What does No Perfect Arbiter conclude, in numbers, about “Four Axioms and an Empty Table: Arrow's Theorem Enumerated for Three Reviewers and Three Options”?

Answer: Chapter 1 enumerates all 262,144 rules that satisfy Pareto and independence for three reviewers and three options and finds that only dictators guarantee transitivity.

Scope of the numbers: Reviewer names and parameters are illustrative, all calculations are generated by the book's programs, and the book is general business analysis, not business advice. Chapter 6 builds a scenario of conflicting kit refusal codes with illustrative rule names, computes deadlock risks and recommends a hybrid rule that vetoes first and then compares grades in written priority order.

中文版

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: 262144

n = 2 reviewers, verdicts strict      :      64 rules
   transitive on every profile: 2
   survivor: reviewer 1 dictates
   survivor: reviewer 2 dictates
n = 2 reviewers, verdicts ties allowed:     729 rules
   transitive on every profile: 2
   survivor: reviewer 1 dictates
   survivor: reviewer 2 dictates
n = 3 reviewers, verdicts strict      : 262,144 rules
   transitive on every profile: 3
   survivor: reviewer 1 dictates
   survivor: reviewer 2 dictates
   survivor: reviewer 3 dictates
only dictators survive Pareto + IIA + ORD (Arrow, small n)
Show the full program
# Chapter 1. p12: exhaustive search of all IIA + Pareto rules (small n).
# By IIA a rule is a separate verdict table for each pair {x, y}: it
# maps the reviewers' x-vs-y votes to a social verdict. Pareto fixes
# the two unanimous rows; every other row is free. We enumerate every
# such rule and keep those whose verdicts are transitive on all
# profiles of strict rankings over 3 options (Arrow's ORD axiom).
# Exact enumeration; nothing is sampled.
import itertools

OPTS = "ABC"
ORDERS = ["".join(p) for p in itertools.permutations(OPTS)]
PAIRS = [("A", "B"), ("B", "C"), ("A", "C")]


def pattern(prof, x, y):
    return tuple(o.index(x) < o.index(y) for o in prof)


def survivors(n, verdicts):
    pats = list(itertools.product((True, False), repeat=n))
    free = [p for p in pats if any(p) and not all(p)]
    profiles = list(itertools.product(ORDERS, repeat=n))
    pp = [[pattern(pr, x, y) for x, y in PAIRS] for pr in profiles]

    def tables():
        for vals in itertools.product(verdicts, repeat=len(free)):
            t = dict(zip(free, vals))
            t[tuple([True] * n)] = 1
            t[tuple([False] * n)] = -1
            yield t
    tabs = list(tables())
    keep = []
    for tab_ab in tabs:
        for tab_bc in tabs:
            need = {}
            ok = True
            for ab, bc, ac in pp:
                a, b = tab_ab[ab], tab_bc[bc]
                # A?B = a, B?C = b; transitivity pins A?C in some cases
                if a >= 0 and b >= 0:
                    req = {1} if a > 0 or b > 0 else {0}
                elif a <= 0 and b <= 0:
                    req = {-1} if a < 0 or b < 0 else {0}
                else:
                    req = {1, 0, -1}
                cur = need.get(ac, {1, 0, -1}) & req
                if not cur:
                    ok = False
                    break
                need[ac] = cur
            if not ok:
                continue
            for tab_ac in tabs:
                if all(tab_ac[k] in v for k, v in need.items()):
                    if check(pp, tab_ab, tab_bc, tab_ac):
                        keep.append((tab_ab, tab_bc, tab_ac))
    return len(tabs) ** 3, keep


def check(pp, t1, t2, t3):
    for ab, bc, ac in pp:
        r = {("A", "B"): t1[ab], ("B", "C"): t2[bc], ("A", "C"): t3[ac]}
        g = dict(r)
        for (x, y), v in r.items():
            g[(y, x)] = -v
        for x, y, z in itertools.permutations(OPTS, 3):
            a, b, c = g[(x, y)], g[(y, z)], g[(x, z)]
            if a >= 0 and b >= 0 and c < 0:
                return False
            if a > 0 and b >= 0 and c <= 0:
                return False
    return True


def who_dictates(rule, n):
    ds = []
    for i in range(n):
        if all(t[p] == (1 if p[i] else -1) for t in rule for p in t):
            ds.append(i + 1)
    return ds


if __name__ == "__main__":
    for n, verdicts, label in ((2, (1, -1), "strict"),
                               (2, (1, 0, -1), "ties allowed"),
                               (3, (1, -1), "strict")):
        total, keep = survivors(n, verdicts)
        ds = [who_dictates(r, n) for r in keep]
        print("n = {} reviewers, verdicts {:<12}: {:>7,} rules".format(
            n, label, total))
        print("   transitive on every profile: {}".format(len(keep)))
        for d in ds:
            print("   survivor: reviewer {} dictates".format(d[0])
                  if d else "   survivor: no dictator")
    print("only dictators survive Pareto + IIA + ORD (Arrow, small n)")

Single source and citation

Fan, Y. (2026). Arrow's Impossibility Theorem and the Aggregation of Multiple Reviewers: Why No Perfect Arbiter Exists When Kit Refusal Codes Conflict (Version 1.0.0), Chapter 1: Four Axioms and an Empty Table: Arrow's Theorem Enumerated for Three Reviewers and Three Options. 5D Library. DOI pending

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

BibTeX
@book{fan2026310,
  author    = {Fan, Yafu},
  title     = {Arrow's Impossibility Theorem and the Aggregation of Multiple Reviewers: Why No Perfect Arbiter Exists When Kit Refusal Codes Conflict},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book