What does Most Conflicts Are Redundancy conclude, in numbers, about “Most Conflicts among a Thousand Rules Are Redundancy”?

Answer: Chapter 1 states and quantifies the claim: in an illustrative library of a thousand rules, true contradictions are only 0.0392 of flagged pairs, 971 rules are redundant after the rulings and just 18 stay binding; even when one rule in ten crosses over, the contradiction share is only 0.2667, although every metric is by then infeasible. The preface corrects the blueprint: the greedy ratio Johnson proved in 1974 is of harmonic order, at most ln n plus one; Quine's paper of 1952 concerns prime implicants, not set cover; and "most conflicts are redundancy" is the author's hypothesis, not a published law.

Scope of the numbers: The rule libraries and values are illustrative; every calculation is generated by the book's programs; the book offers general business method, not legal, compliance or business-decision advice, and adding or deleting a rule must be released by its owner. Marked boxes separate published evidence, runnable Python calculations (19 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.0392, 18, 971

illustrative library1000 rules, 12 metrics, seed 20261113
writer mix: same 0.550, variant 0.440, opposite side 0.010
same-metric pairs41,369
duplicate22,041 share 0.5328
subsumed18,423 share 0.4453
compatible148 share 0.0036
contradiction757 share 0.0183
pairs flagged (numbers differ)19,328
of which true contradictions share 0.0392
binding rules kept (one per side)18
rules redundant once ruled971
metrics infeasible 7 of 12; rules to delete for feasibility 11
audit snapshot 2026-11-13 (report quoted, not re-run):
rule lines 1333 kit + 330 canon; comparable metrics 12
threshold conflicts 3 (high 0, medium 0, low 1, ruled 2)
infeasible metrics 0; duplicates 20; near-synonyms 9
Show the full program
# Chapter 1. p11: in a 1000-rule library most flagged pairs are redundancy
# Model: an illustrative library of machine rules, each a threshold
# (metric, op, value) with op in >=, <=, ==. Twelve metrics, each with
# one canonical value; every new rule restates the canonical rule
# (paraphrase), writes a stricter or looser variant in the same
# direction, or (rarely) writes a rule that crosses the opposite side.
# Writer mix 0.550 / 0.440 / 0.010 is illustrative; fixed seed.
# A naive checker flags every pair on one metric whose numbers differ.
# Exact rational comparison with fractions.Fraction throughout.
# The last block quotes counts from the read-only audit report of the
# production pruner (2026-11-13 snapshot), typed in, not re-run here.

import random
from collections import Counter
from fractions import Fraction as F
from itertools import combinations

SEED = 20261113
N_RULES = 1000
P_OPP = F(1, 100)
P_VAR = F(44, 100)
METRICS = [
    ("tap_px", "lower", F(44), F(4)),
    ("font_px", "lower", F(16), F(1)),
    ("contrast", "lower", F(9, 2), F(1, 2)),
    ("refund_days", "lower", F(7), F(7)),
    ("followups", "upper", F(2), F(1)),
    ("msgs_day", "upper", F(1), F(1)),
    ("pushes_week", "upper", F(4), F(1)),
    ("discount_pct", "upper", F(30), F(5)),
    ("quiet_start", "upper", F(21), F(1)),
    ("settle_day", "exact", F(5), F(1)),
    ("launch_hour", "exact", F(10), F(1)),
    ("resets", "exact", F(0), F(1)),
]


def make_rule(rng, p_opp=P_OPP, p_var=P_VAR):
    name, kind, c, step = METRICS[rng.randrange(len(METRICS))]
    u = F(rng.randrange(1000), 1000)
    if kind == "exact":
        if u < p_opp:
            return (name, "==", c + step * rng.choice([1, 2, 3]))
        return (name, "==", c)
    op = ">=" if kind == "lower" else "<="
    if u < p_opp:
        k = rng.choice([1, 2])
        if kind == "lower":
            return (name, "<=", c - step * k)
        return (name, ">=", c + step * k)
    if u < p_opp + p_var:
        k = rng.choice([-2, -1, 1, 2])
        return (name, op, max(F(0), c + step * k))
    return (name, op, c)


def pair_kind(a, b):
    (oa, va), (ob, vb) = sorted([a, b])
    if (oa, va) == (ob, vb):
        return "duplicate"
    if oa == ob and oa != "==":
        return "subsumed"
    if oa == ob:
        return "contradiction"
    if (oa, ob) == ("<=", ">="):
        return "contradiction" if vb > va else "compatible"
    if oa == "<=":                      # ("<=", "==")
        return "contradiction" if vb > va else "subsumed"
    return "contradiction" if va < vb else "subsumed"   # ("==", ">=")


def classify(rules):
    by = {}
    for name, op, v in rules:
        by.setdefault(name, Counter())[(op, v)] += 1
    tally = Counter()
    for name in sorted(by):
        keys = sorted(by[name].items())
        for (k, n) in keys:
            tally["duplicate"] += n * (n - 1) // 2
        for (ka, na), (kb, nb) in combinations(keys, 2):
            tally[pair_kind(ka, kb)] += na * nb
    return by, tally


def min_delete(cnt):
    vals = sorted({v for (_, v) in cnt})
    best = None
    for t in vals:
        cost = 0
        for (op, v), n in cnt.items():
            if (op == ">=" and v > t) or (op == "<=" and v < t):
                cost += n
            if op == "==" and v != t:
                cost += n
        best = cost if best is None else min(best, cost)
    return best


def kernel_size(cnt):
    ops = {op for (op, _) in cnt}
    return len(ops & {">=", "<="}) + (1 if "==" in ops else 0)


rng = random.Random(20261113)
rules = [make_rule(rng) for _ in range(N_RULES)]
by, tally = classify(rules)
pairs = tally["duplicate"] + tally["subsumed"] + tally["compatible"] \
    + tally["contradiction"]
flagged = pairs - tally["duplicate"]
kern = 0
dele = 0
bad = 0
for name in sorted(by):
    kern += kernel_size(by[name])
    d = min_delete(by[name])
    dele += d
    bad += 1 if d else 0
print("illustrative library: %d rules, %d metrics, seed %d"
      % (N_RULES, len(METRICS), SEED))
print("writer mix: same %.3f, variant %.3f, opposite side %.3f"
      % (1 - P_OPP - P_VAR, P_VAR, P_OPP))
print("same-metric pairs                 %7s" % format(pairs, ","))
for k in ("duplicate", "subsumed", "compatible", "contradiction"):
    print("  %-14s                  %7s   share %.4f"
          % (k, format(tally[k], ","), tally[k] / pairs))
print("pairs flagged (numbers differ)    %7s" % format(flagged, ","))
print("  of which true contradictions    share %.4f"
      % (tally["contradiction"] / flagged))
print("binding rules kept (one per side) %7d" % kern)
print("rules redundant once ruled        %7d" % (N_RULES - kern - dele))
print("metrics infeasible %d of %d; rules to delete for feasibility %d"
      % (bad, len(METRICS), dele))
print("audit snapshot 2026-11-13 (report quoted, not re-run):")
print("  rule lines 1333 kit + 330 canon; comparable metrics 12")
print("  threshold conflicts 3 (high 0, medium 0, low 1, ruled 2)")
print("  infeasible metrics 0; duplicates 20; near-synonyms 9")

Single source and citation

Fan, Y. (2026). Cross-Volume Rule Resolution and Axiom Reduction: Detecting Threshold Conflicts among a Thousand Machine Rules and Finding a Minimal Primitive Set (Version 1.0.0), Chapter 1: Most Conflicts among a Thousand Rules Are Redundancy. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-258 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026258,
  author    = {Fan, Yafu},
  title     = {Cross-Volume Rule Resolution and Axiom Reduction: Detecting Threshold Conflicts among a Thousand Machine Rules and Finding a Minimal Primitive Set},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book