docs/research/2026-11-05-estate-rule-sim/.gitignore

@@ -0,0 +1 @@
+__pycache__/

docs/research/2026-11-05-estate-rule-sim/REPORT.md

@@ -0,0 +1,59 @@
+# Estate-rule sim: report (2026-11-05)
+
+Question: does the unified estate rule (estate votes decide the estate's vote) dampen populism? Spec: `SPEC.md` (written first, four revisions, each before the results it affects). Numbers: `results.md` (235 cells, 40 replicates x 500 motions each, paired draws). Rerun: `python3 -I run.py` (about 11 minutes on 8 jobs; `--quick` for a smoke; `python3 -I test_estatesim.py` for the 41 tests). Output is byte-identical across reruns and across `--jobs` values.
+
+## Answer
+
+**Partly, weakly, and at a merit cost. The claim as stated ("dampens populism") is not established, and it fails in the cells that matter most.**
+
+1. UNI lowers populism sensitivity (PS) against a direct tally in every sincere and strategic cell: by 0.02 to 0.07 on a DIRECT baseline of 0.23 to 0.35 (E1 equal weights: 0.297 to 0.275). Small, but outside the intervals.
+2. It lowers merit tracking (MT) by more: 0.05 to 0.10 (E1: 0.465 to 0.400; with strategic agents and a 20-person Users faction: 0.381 to 0.304). Dampening populism by losing the signal is not what the claim means. PI = PS/MT, appeal sensitivity per unit of merit, is **worse** under UNI at equal weights (E1: 0.689 vs 0.639; E2 faction 20: 0.900 vs 0.849; E5 Users appeal .4: 0.840 vs 0.691) and flat under minds-heavy weights. The pre-registered verdict (SPEC section 8) therefore reads "supported" in 0 of 235 cells in the final run, "fails" in 2 (Users appeal loading b = .4, with and without delegation: MT drops more than .10), "undecided" in 233. Undecided here mostly means PS fell and MT fell too.
+3. UNI passes more motions (0.65 vs 0.60 at equal weights) and passes more *bad popular* motions: BPP (pass rate when merit < -.5 and appeal > .5) is 0.62 vs 0.525 for DIRECT. It blocks fewer good unpopular ones (GBR 0.19 vs 0.23). The cause is the low-threshold categories: at q = .15 an estate casts all its weight For on 15% support, and PS at q = .15 collapses to 0.06 only because nearly everything passes. Per-category tables are in results.md. At q >= .4 UNI is within about .01 of DIRECT. The dampening is concentrated where the threshold was already doing the work.
+4. **Winner-take-all does the opposite of dampening:** PS is above DIRECT by 0.03 to 0.06 in most cells (E1 equal: 0.323 vs 0.297; strategic with faction: 0.360 vs 0.323). Collapsing an estate to one bit at 0.5 amplifies a populist estate's swing; only the UNI threshold change (q instead of .5 inside the estate) makes the difference between the two bloc rules. If "unified estate rule" is read as WTA, the claim is **false** in this model.
+5. A headcount tally (HEAD, reference only) is far worse (PS 0.43 to 0.52, MT collapses to 0.05 once the Users faction mobilizes). Estate structure of any kind does dampen against a mass-mobilized Users roll; the unified rule adds a little on top.
+
+## Strategic agents
+
+With 25% strategic voters (misreporting, abstaining, pivot-seeking turnout) strategy flips about 2.8% of outcomes under DIRECT, WTA and UNI alike and 1% under HEAD, and does not change the ranking of rules. A coordinated Users faction raises PS under DIRECT and WTA (0.291 at no faction to 0.328 at 40) while UNI stays flat at 0.27, so **the UNI-DIRECT gap widens with organized mobilization** (-0.024 to -0.054). This is the strongest point for the claim: UNI's resistance is to turnout-limited organized blocs, not to diffuse appeal. The MT gap also shrinks with faction size (-0.072 to -0.052), because the faction drags DIRECT's merit tracking down toward UNI's. Sweep E2.
+
+## Delegation (E3, E3b, E3c, E3d, E3e, E4, E5b)
+
+- **Delegation barely moves the claim.** dPS UNI-DIRECT is -0.027 with delegation vs -0.050 without in the matched strategic/faction cell; PS under each rule changes by under .01 (DIRECT .313 vs .323). Delegation makes the claim slightly weaker (the gap shrinks), not stronger.
+- **Concentration is real and the cap controls it, but outcomes do not care.** Zipf exponent alpha from 0 to 4 moves the Users top-holder share from 0.045 to 0.19 (no cap) and n_eff from 61 to 26; a cap of .10 pulls that to 0.107, n_eff 44. A cap of .2 does not bind at alpha 1.5 (top share 0.103 with or without it) and binds only near alpha 4 (0.173 vs 0.190). The outcome measures (PS, MT) move by under .005 across the whole alpha x cap grid, because the Users estate's single vote is decided by its resolved majority and delegates are mostly drawn from the same population. Appeal attraction beta (E4) has the same null result. Cap basis (cast weight vs roll) matters only at small c (E3d): a roll-based cap never binds at 10% turnout.
+- **Transitive depth 2, 3, 4, 6 and unlimited are indistinguishable** (E3c; PS and MT differ by under .005 across depths, including with 80% peer edges and delegates turning out at 30%). The votes that die do so on scope overlap, dead ends and absent peers (uncast share 0.50 to 0.85), not on length: a long chain is a chain whose scope intersection was already empty. Depth is a safe parameter to set at the placeholder 3 in this model; it does not need to be tuned. Loops are returned uncast and appear as part of the uncast share.
+- **A delegation network under the posted revocation rule decays.** With two strikes and no renewal, 13% of delegations are alive after 500 motions (E3e), so the rule as posted cannot sustain liquid delegation unless revoked delegators re-delegate. The steady state depends on the renewal rate: 53% live at renew .02, 81% at .1. This is a design finding independent of the populism claim and was the cause of the first run's inert delegation cells.
+- Delegation mostly leaves votes uncast (0.5 uncast with peer edges at the default). Whether delegators who lose a chain should be told is a product question the sim cannot answer.
+
+## Copy-the-ballot (E3f, SPEC section 5b)
+
+Source: Gölz et al. 2018 (introduction) argue, citing Behrens et al. 2014 (LiquidFeedback), that capping weight fails because a delegator can copy the delegate's ballot outside the system. It is an argument, not a measurement; the copy rate is an assumption and is swept (0, .5, 1). Agents: a delegator whose weight sits under an over-cap holder copies that holder's ballot with probability `copy` and votes directly with weight 1.
+
+**Answer: once copying is available the cap does not reduce effective concentration.** Effective concentration counts a copier's weight to the voter it copied. Cap .10 against no cap, paired by replicate, 40 replicates (E3f top table in results.md):
+
+- Without copying the cap works where concentration exists: effective Users top-holder share falls by 0.015 (alpha 1.5), 0.055 (2.5), 0.083 (4.0); below alpha 1.5 the cap does not bind.
+- With full copying (copy = 1) the difference is +0.001 or less in every alpha, intervals about ±0.002: indistinguishable from no cap. At copy = .5 the difference is -0.008 at alpha 4 (under the one-point materiality bar), and under that at lower alpha. Verdict "reduces": 3 of 6 alphas at copy 0, 0 of 6 at .5, 0 of 6 at 1.
+- The formal measure is misleading in the other direction: at copy = 1, alpha 4, cap .10 the formal top share drops from 0.190 to 0.034 (copiers appear as separate ballots), more than the cap achieves without copying (0.107). A cap would look best exactly when it is doing nothing to whose ballot the weight follows. It is also what the source's transparency point predicts: the system sees direct ballots and cannot see the copying.
+- The cap's cost is paid anyway where copying is partial: copiers are 29% of delegated votes at alpha 4, cap .20, copy 1, and 57% at cap .10.
+- Outcomes: dPS UNI-DIRECT stays -0.023 to -0.031 in all 108 cells, within intervals of the copy = 0 values. Copying changes nothing the outcome measures can see, as the cap alone did not (E3).
+- Depth sweep (E3c) and every other experiment ran with copy = 0 and their results.md sections are byte-identical to the previous run.
+
+Limits specific to this result: copying is triggered only when the holder is over the cap (a standing copy habit is not modeled); copiers copy the holder's sincere ballot and are not strategic; the cost of coordination grows with copiers in practice and is a flat probability here; the copy rate has no empirical value. At copy rates well below .5 the cap partly works; where the break-even lies was not mapped. The design question this leaves is not tuning c: a cap bounds the *ledger*, and a ledger-visible cap is evaded by a ballot copy that costs the delegator nothing but a few keystrokes. Whether the system wants delegation visible and capped, or invisible and uncapped, is a product choice for the operator; nothing is ruled here.
+
+## Robustness (E5, E5b)
+
+The sign of the PS effect holds across Users appeal 0.4/0.9/1.4, Users turnout .05/.10/.30 and Minds shared taste .3/.9/1.5. Its size scales with Users appeal loading (-0.025 at .4, -0.067 at 1.4): the rule helps in proportion to how appeal-driven the Users estate is, while its merit loss does not go away (MT gap -0.101 at .4 vs -0.063 at 1.4). If Users are not appeal-driven the rule is nearly all cost.
+
+## Limits and honesty
+
+- Every behavioral parameter is an assumption (SPEC section 4), not data. The populism measure rests on an independent merit/appeal draw that the real system cannot observe; PS is an error rate against a modeled channel, not a measurement of any real vote.
+- Myopic, single-motion strategy; no repeated game, vote trading, or reputation. Delegators are not strategic. Prior work (../2026-10-29-estate-tally-game-theory/) covers some of those on unitary blocs.
+- No Patron/Member inequality inside estates; no real Bifrost data.
+- The verdict rule counts MT loss over .05 as "not supported" and over .10 as "fails". These are my pre-registered thresholds; a different pair would change the verdict column but not the PS/MT numbers beside it.
+- Sources: SPEC section 10 ([V] fetched, [M] from memory). The delegate-cap "a fifth" has no strong precedent found; DAO caps are rare and the Jupiter 5% proposal is the nearest.
+
+## Deviations from the spec text
+
+- Spec rev 3 added renewal (`renew`) and peer edges (`peer`) after the first full run showed (a) revocation had silently emptied every delegation cell at 500 motions and (b) with only delegates delegating onward, depth was inert. The first run's results were discarded. Renewal and peer defaults are my choices, swept in E3c and E3e.
+- Cap basis default is the estate's cast weight, not roll; both are swept.
+- E3f: the falsifier was first printed as means only; the paired interval was added to `run.py` before the final run (no number changed). Its materiality bar (-.01) is mine.
+- Per-category PS tables are printed only for the non-grid experiments (E1, E2, E4, E5).

docs/research/2026-11-05-estate-rule-sim/SPEC.md

@@ -0,0 +1,140 @@
+# Estate-rule sim harness: spec (2026-11-05)
+
+Serves follow-up `heimdall-body:follow_up:chat-mind-20261105T002133411Z-t0`. Prior work: `../2026-10-29-estate-tally-game-theory/` (README.md plus numpy probes in `sims/`). Facts there are cited as "prior §n". This document is written before the code; `estatesim.py` implements it, and where the code had to deviate the deviation is listed at the bottom of `REPORT.md`, not edited in here. Revision 2 (delegation rules) was made before any result was generated. Revision 4 (copy-the-ballot, section 5b) was added after the first reported results and before its own. Revision 3 (renewal, peer edges) was forced by the first full run, whose delegation cells were inert; the first run's results were discarded, not kept.
+
+## 1. Claim under test
+
+> The unified estate rule (an estate's own vote decides the estate's vote) dampens populism relative to a direct tally.
+
+The claim is stated by the operator and has not been tested. The sim is allowed to refute it. Falsifiers are fixed in advance (section 8).
+
+## 2. Rules compared
+
+All rules aggregate the same ballots. After the estate's ballots are resolved (section 5) each live estate e has resolved weighted counts For F_e and Against A_e (abstain excluded). Live = F_e + A_e > 0. Estate weights W_e renormalize over live estates (prior, pass rule and renormalization ruling). Motion threshold q comes from the motion category (prior §5b: Bugs .15, Cosmetics .30, Balance .40, Features/NewContent .50, FundamentalDesign .66). The motion passes iff council For weight / (For + Against weight) >= q; ties at q pass (prior).
+
+| id | name | estate e casts |
+|---|---|---|
+| DIRECT | direct tally | W_e × F_e/(F_e+A_e) For, remainder Against (weighted popular share; prior "prop") |
+| HEAD | headcount tally | reference only: pooled ΣF/Σ(F+A), estate weights ignored |
+| WTA | winner-take-all | all of W_e For if F_e/(F_e+A_e) > .5, all Against if < .5, nothing on an exact tie (prior WTA) |
+| UNI | unified estate rule | all of W_e For iff F_e/(F_e+A_e) >= q, else all Against (prior §9 `bloc-parliament-at-threshold`) |
+
+Ambiguity recorded: "unified estate rule" and "winner-take-all" both describe an estate casting a single vote. They differ only in the internal threshold (.5 vs the category threshold q), and prior §9 shows that is the only difference. UNI is the reading in which the estate's decision applies the same threshold as the council. Every result is reported for both, so the claim can be read either way.
+
+## 3. Populism measure
+
+Definition used (after the ideational definition, Mudde 2004: politics as direct expression of the people's will against the judgment of those who know, applied here to outcomes, not rhetoric): **populism is the degree to which the outcome follows mass appeal that is independent of merit.**
+
+Each motion draws merit m ~ N(0,1) and demagogic appeal d ~ N(0,1), independent. Merit is what informed voters track; appeal is the part of a motion's attractiveness that carries no information (framing, grievance, flattery). Because d is independent of m, outcome dependence on d is by construction an error.
+
+- **PS, populism sensitivity (headline):** P(pass | d > 0) − P(pass | d < 0).
+- **MT, merit tracking (the cost side):** P(pass | m > 0) − P(pass | m < 0). A rule can reduce PS by ignoring everything; MT shows if it did.
+- **PI = PS / MT**, appeal sensitivity per unit of merit sensitivity. Reported with MT; ignored when MT < .05.
+- **BPP, bad-popular pass rate:** P(pass | m < −.5, d > .5). **GBR, good-unpopular block rate:** P(fail | m > .5, d < −.5).
+- Every number is reported pooled over categories and per q, because q moves base rates and compresses PS at the ends (q = .15 passes almost everything).
+
+Measure limits: d and m are drawn, not observed; a real populism measure would need an independent merit label (Bifrost has none). The measure says what the rule does to a modeled appeal channel, no more.
+
+Concentration measures (delegation runs): top-delegate share of the Users estate's resolved weight, Gini of resolved weights over ballot holders, and Kish n_eff = (Σw)²/Σw² per estate. Prior §4 uses Kish n_eff for the same purpose.
+
+## 4. Population and ballots
+
+Sizes follow prior: Minds 8, Members 15, Users roll 300, Patrons 4. Estate weights: `equal` 25/25/25/25 and `minds-heavy` 40/30/20/10 (prior seeds). Member one-each within estate; within-bloc donation or contribution curves (prior §4) are out of scope, so Patron and Member power inequality is not tested.
+
+Voter i of estate e on one motion: u_i = a_e·m + b_e·d + s_e·z_e + σ_e·ε_i, with z_e ~ N(0,1) the estate's shared taste, ε_i ~ N(0,1).
+
+| estate | a (merit) | b (appeal) | s (shared) | σ (noise) | base turnout |
+|---|---|---|---|---|---|
+| Minds | 1.0 | .15 | .9 | .7 | 1.0 |
+| Members | .8 | .4 | .5 | 1.0 | .8 |
+| Users | .4 | .9 | .5 | 1.2 | .10 |
+| Patrons | .7 | .5 | .5 | 1.0 | .8 |
+
+These are assumptions, not data. They encode: Minds are accurate and correlated (ICC of the noise part ≈ .62, between the prior's .44 and .8; prior §3 Kish n_eff calibration from Kohli 2026); Users are mass-appeal-driven, noisy, and mostly absent. The result depends on them, so section 7 sweeps the Users appeal loading b.
+
+Sincere ballot: For if u > .1, Against if u < −.1, otherwise abstain.
+
+**Turnout response (intensity):** voter turns out with p_i = clamp(base_e × (1 + κ(|u_i| − ū_e)), 0, 1), κ = 1, ū_e = .8·sqrt(a²+b²+s²+σ²) the mean |u|. Aggrieved or enthused voters show up. This is the standard mobilization asymmetry behind low-turnout populist surges and is the channel through which d reaches the Users estate even at 10% turnout.
+
+## 5. Delegation (operator's posted rules, revision 2)
+
+Revision 2 (same day, brief `heimdall-body:follow_up:chat-s1938-1941`) replaces depth-2 with transitive chains and sweeps the depth limit. Rules as posted, each with its realization:
+
+1. **Within-estate:** an edge joins two members of the same estate. Minds do not delegate (eight accountable Personas delegating to each other would only reduce n_eff). Delegator shares of the roll: Members .2, Users .5, Patrons .2.
+2. **Scoped:** each edge covers a set of motion categories, each of the five included with probability .6 (never empty).
+3. **Revocable:** a delegator whose final holder's ballot opposes the delegator's strong sincere preference (|u| > .5) takes a strike; at `STRIKES` = 2 the edge is revoked. A revoked delegator re-delegates with probability `renew` per motion (default .1; swept {0, .02, .1, .5}) to a freshly drawn target with a fresh scope and zero strikes. Without renewal (renew = 0) revocation is final and the network decays to nothing over a long horizon (found in the first full run at 500 motions: revocation alone had emptied the network, so every delegation cell had silently become a no-delegation cell). The `live edges` column reports the share of delegators still holding an edge. The strike count is the only delegation memory.
+4. **Direct overrides:** a member who votes directly casts weight 1 and is never forwarded. A delegator with a strike-worthy contradiction turns out regardless of the turnout draw (the delegation-driven turnout response); the motion is then re-resolved, so chains that ran through that member now end at it.
+5. **Transitive chains, depth D:** weight follows edges from the delegator until it reaches a member who votes directly (the final holder). An intermediate member who votes directly ends the chain there. D is the maximum number of edges; swept over {2, 3 (placeholder, default), 4, 6, unlimited}. **Scope is the overlap of all links:** the chain is void when any link's scope excludes the motion's category. **A loop, a chain longer than D, a chain that ends at a member who neither votes nor delegates, or a chain with an out-of-scope link returns the vote uncast** (the delegator counts as an abstainer, not redirected). The `uncast` column in results is the share of delegated votes left uncast.
+6. **Per-final-holder cap c:** a final holder's total resolved weight (own vote plus everything that reached it) is capped at max(1, c × basis). Basis is "cast" (the estate's total resolved weight before capping, default) or "roll" (estate roll size, an alternative swept in E3d). A fifth is read as a fifth of what the estate actually casts, because Users turnout is about 10% and a roll-based fifth (60 of 300) would never bind; E3d shows both. c ∈ {.10, .15, .20, .25, .30} and none. Excess is void, not redistributed.
+7. **Estate rule after resolution:** F_e and A_e are computed from capped resolved weights; section 2 then applies unchanged.
+
+Delegate pool: each delegating estate has 10% of its roll (at least one) as active delegates with turnout `dturn` (default .95; swept {.95, .6, .3}, because when delegates always vote chains never run past one edge and depth is inert), 25% of them populist (a = .2, b = 1.2, σ = .7, otherwise a = .7, b = .5, σ = .7). A delegate delegates onward to another delegate with probability `onward` (.3). A delegator's edge goes to another ordinary delegator with probability `peer` (default .3; swept {.3, .8}) and otherwise to a delegate; peer edges are what make chains longer than two (the first full run, where only delegates delegated onward, made depth 2 to unlimited indistinguishable). Loops arise naturally. Delegator and onward targets are Zipf over a fixed delegate ranking with exponent α, multiplied by (1+β) for populist delegates. α ∈ {0, .5, 1, 1.5, 2.5, 4}, β ∈ {0, 1, 3}. α=0 is uniform choice; larger α is guru formation (Kling et al. 2015 observed super-voters in LiquidFeedback; Gölz et al. 2018 show maximum delegated weight grows with concentration).
+
+Not modeled: vote selling, delegation to non-members, delegators choosing delegates by track record.
+
+## 5b. Copy-the-ballot (revision 4, written before its results)
+
+Serves `heimdall-body:follow_up:chat-s1946-1946`.
+
+**Source.** Gölz, Kahng, Mackenzie, Procaccia 2018 (arXiv 1808.01906, introduction, "Just how can the maximum weight be reduced?"): capping delegated weight is an option, "however, as argued by Behrens et al. [3], delegation is always possible by coordinating outside of the system and copying the desired delegate's ballot. Pushing delegations outside of the system would not alleviate the problem of super-voters, just reduce transparency." [3] is Behrens, Kistner, Nitsche, Swierczek, *The Principles of LiquidFeedback* (Interaktive Demokratie, 2014), not fetched here. What the source is: a one-paragraph argument, quoted second-hand by Gölz et al. to motivate their own voluntary approach. It gives no model, rate or measurement of copying, so the copy rate below is an assumption and is swept, not calibrated. Verified by fetching the ar5iv text of the paper this pass.
+
+**Agents.** A copier is a delegator in a delegating estate (Members, Users, Patrons) with the following behavior, per motion, after the final resolution of section 5 (strikes, direct overrides and the cap already applied):
+
+- Trigger: the delegator's final holder h has raw resolved weight above the cap value (the weight the cap would void). Only delegators whose weight is routed to an over-cap holder consider copying. There is no copying under a holder within the cap, and none when there is no cap. The agent does not know whether its own weight is among the voided excess (the cap voids "excess", not named delegators), so every delegator under an over-cap holder is exposed.
+- Action: with probability `copy` (friction: the effort of reading and re-entering the ballot; swept {0, .5, 1}) the delegator becomes a direct voter casting weight 1 and holder h's ballot (h's sincere ballot, as it stands before any strategic misreport). Direct voters are never forwarded (section 5 rule 4), so the copied weight leaves h's chain and the cap no longer applies to it. Delegators of the copier now end at the copier, who is itself subject to the cap as a final holder.
+- Copiers are not strategic and do not take strikes for the copy (it is voluntary and aligned with h by construction).
+- One round per motion. The decision is not remembered: a copier delegates again next motion, and copies again if the holder is still over cap. Delegators do not copy as a standing policy and do not copy unconditionally; copy-everything-always would remove delegation altogether and is out of scope.
+- Copy requires that h votes directly this motion, which holds by construction (a final holder is a direct voter).
+- Not modeled: the copy being visible to the mechanism (the real system sees only a direct ballot, which is the point of the source's transparency objection), coordination cost that grows with the number of copiers, and delegators choosing to copy a different, trusted voter than their delegate.
+
+**Measures.** Formal concentration is the section 3 measure on the resolved weights (copiers appear as separate weight-1 holders, which is what the mechanism sees). Effective concentration counts each copier's weight to the voter it copied, so it measures whose ballot the weight follows; the cap's job is to limit that. Also reported: copiers as a share of delegated votes. Outcomes (PS, MT, dPS UNI-DIRECT) are reported alongside.
+
+**Experiment E3f.** The delegation cap sweep with copying: alpha {0, .5, 1, 1.5, 2.5, 4} x cap {.10, .15, .20, .25, .30, none} x copy {0, .5, 1}, depth 3, strategic, F = 20, as E3. `copy = 0` reproduces E3 exactly. The depth sweep E3c is unchanged and runs with `copy = 0`; so does every other experiment. Falsifier fixed in advance: the cap "reduces effective concentration once copying is available" if the paired-by-replicate difference (effective Users top-holder share at cap .10 minus no cap) has a 95% interval entirely below -.01 (a drop under one point of share is not called a reduction). Evaluated per alpha and per copy rate by `run.py` and printed at the top of E3f in `results.md`; the cap reduces effective concentration under copying only if this reads "reduces" at `copy = 1`. The first full E3f run printed only means; the interval was added before the final run, and the numbers did not change.
+
+## 6. Strategic and adaptive agents
+
+A fraction ρ = .25 of ballot holders and of absent undelegated roll members are strategic. Each is myopic about the motion at hand and best-responds to everyone else's current ballots over three rounds in random order:
+
+- **Misreporting:** a strategic ballot holder picks among For/Against/Abstain (its whole resolved weight, so a capped delegate misreports the weight it carries) the ballot whose resulting outcome it prefers (pass iff its u > 0); it keeps the sincere ballot on ties of outcome.
+- **Turnout response:** a strategic absent member joins with the sincere ballot iff joining flips the outcome to the one it prefers (the pivot-seeking participant of Palfrey and Rosenthal 1983). Strategic ballot holders may also abstain (Abstain option above).
+- **Coalition shifts:** a coordinated faction of F Users (default F = 20, 6.7% of the roll, sweep {0, 10, 20, 40}) turns out with certainty and votes For iff d − m > 0 (the populist agenda), Against otherwise. It does not best-respond; it models the organized actor that turnout-limited estates attract. Faction members are not delegators.
+
+Strategy is best response per rule: each rule is run separately from the same sincere draws, so a rule that rewards misreporting is not credited with sincere behavior.
+
+Limits: delegators are not strategic (their ballot is their delegate's); single-motion myopia; no repeated-game or reputation effects; no cross-estate vote trading (prior §6 S2 covers logrolling on unitary blocs).
+
+## 7. Experiments
+
+Paired across rules: one set of random draws per motion feeds all rules (common random numbers). Replicates R = 40 (a fresh delegation network per replicate), M = 500 motions each, categories uniform. Seeds are fixed integers; no wall-clock or hash use. Confidence intervals are 1.96 standard errors over replicates; paired differences are taken within replicate.
+
+- **E1 baseline:** sincere, no delegation, no faction. Rules × weight seeds × q.
+- **E2 strategic:** E1 with ρ = .25 strategic agents and faction sweep.
+- **E3 delegation:** concentration α × cap c (36 cells) at depth 3, strategic on, F = 20; **E3b** the same sincere with no faction (isolates delegation).
+- **E3c transitive depth:** depth {2, 3, 4, 6, unlimited} × delegate turnout {.95, .3} × peer share {.3, .8}, α = 1.5, c = .2.
+- **E3e renewal:** renew {0, .02, .1, .5}, depth 3.
+- **E3d cap basis:** cast vs roll × c ∈ {.05, .10, .20, .30}, depth 3, α = 1.5.
+- **E3f copy-the-ballot:** section 5b.
+- **E4 appeal attraction:** β sweep at α = 1.5, c = .2.
+- **E5 robustness:** Users appeal loading b ∈ {.4, .9, 1.4}; Users base turnout {.05, .10, .30}; Minds ICC (s_Minds ∈ {.3, .9, 1.5}). This is the check on the assumed parameters in section 4.
+
+## 8. Pre-registered falsifiers
+
+The claim is **supported** in a cell if the paired difference PS(UNI) − PS(DIRECT) has a CI entirely below 0 and MT(UNI) ≥ MT(DIRECT) − .05. It **fails** if the CI is entirely above 0 or MT(UNI) falls more than .10 below DIRECT's (dampened by not working). Otherwise **undecided**. The summary reports counts of each across cells and lists the failing cells; no cell is dropped. The report states separately whether delegation shrinks or grows the gap.
+
+## 9. Tests (`test_estatesim.py`)
+
+Pin the rules, not the spelling: rule thresholds including ties; chains within depth, over depth (uncast), unlimited, terminated by an intermediate direct vote, looped, dead-ended; scope as overlap of all links; direct override; two-strike revocation; cap void, cap floor, copy-the-ballot (off draws nothing, full copying evades the cap, copied ballot is the holder's, within-cap and no-cap holders see no copying, effective weight follows the copied voter), cap on the final holder, cap basis; determinism (same seed, same bytes); paired draws identical across rules; misreporting never produces an outcome the agent likes less; metrics on hand-built outcome lists.
+
+## 10. Sources
+
+Verified by search this pass [V]; from memory, not fetched [M].
+
+- [V] Mudde 2004, "The Populist Zeitgeist", Government and Opposition 39(4):541–563: ideational (thin-centered) definition, virtuous people against corrupt elite. https://illiberalism.org/cas-mudde-the-populist-zeitgeist (secondary). Mapping to a measure is this document's, not Mudde's.
+- [V] Kling, Kunegis, Hartmann, Strohmaier, Staab 2015, "Voting Behaviour and Power in Online Democracy: A Study of LiquidFeedback in Germany's Pirate Party", ICWSM 9. https://arxiv.org/abs/1503.07723. Super-voters hold high theoretical power; empirically they voted with the majority and did not fully use it.
+- [V] Gölz, Kahng, Mackenzie, Procaccia 2018/2021, "The Fluid Mechanics of Liquid Democracy", WINE 2018, ACM TEAC 2021. https://arxiv.org/abs/1808.01906. Preferential-attachment delegation model; maximum delegated weight; two delegation choices lower it.
+- [V] Gölz et al. 2018 introduction, second-hand citing Behrens, Kistner, Nitsche, Swierczek 2014, "The Principles of LiquidFeedback" [M], for copy-the-ballot as the answer to caps (section 5b).
+- [V] Caragiannis and Micha 2019, "A Contribution to the Critique of Liquid Democracy", IJCAI. https://www.ijcai.org/proceedings/2019/17. Local delegation can do worse than direct voting or a dictator. Rebuttal: Butterworth and Booth 2022, arXiv 2206.13904, disputes the model assumptions.
+- [V] Palfrey and Rosenthal 1983, "A Strategic Calculus of Voting", Public Choice 41(1):7–53; and 1985, "Voter Participation and Strategic Uncertainty", APSR 79(1):62–78. High-turnout equilibria need complete information. Turnout response here is the myopic pivot-seeker, a simplification.
+- [V] Delegate-cap practice: no official cap found for Optimism, Arbitrum or Uniswap; Lido and a Jupiter forum proposal (5%) are the examples surfaced (https://discuss.jup.ag/t/delegated-voting-for-asr/34971/32; https://gov.optimism.io/t/can-delegates-become-too-powerful/2919 discusses mitigation without an adopted cap). Weak evidence. The operator's "a fifth" is a design choice, which is why c is swept.
+- From the repo: `../2026-10-29-swarm-governance-prior-art.md` (Compound 289 concentration, ~17% of voting tokens delegated and clustering on popular delegates across 18 Ethereum DAOs, Frontiers 2025); prior estate research README §3, §5b, §6, §9, §10.
+- [M] Riker and Ordeshook 1968 calculus of voting; Nurmi 1998 referendum paradox; Madison, Federalist 10 (filtering mass sentiment through representatives, the classical form of the dampening claim). Not fetched.

docs/research/2026-11-05-estate-rule-sim/estatesim.py

@@ -0,0 +1,438 @@
+"""Estate-rule simulation core. Pure stdlib. Spec: SPEC.md in this directory.
+
+One replicate = one population (delegation network, strategic flags, faction)
+plus a sequence of motions. Every random draw comes from two Random objects
+seeded from integers, so a (Config, rep) pair is a pure function.
+"""
+import math
+import random
+from dataclasses import dataclass
+
+ESTATES = ("Minds", "Members", "Users", "Patrons")
+ROLL = {"Minds": 8, "Members": 15, "Users": 300, "Patrons": 4}
+BASE = {
+    "Minds": dict(a=1.0, b=.15, s=.9, sigma=.7, turnout=1.0, kappa=0.0),
+    "Members": dict(a=.8, b=.4, s=.5, sigma=1.0, turnout=.8, kappa=1.0),
+    "Users": dict(a=.4, b=.9, s=.5, sigma=1.2, turnout=.10, kappa=1.0),
+    "Patrons": dict(a=.7, b=.5, s=.5, sigma=1.0, turnout=.8, kappa=1.0),
+}
+DELEG_SHARE = {"Minds": 0.0, "Members": .2, "Users": .5, "Patrons": .2}
+WEIGHTS = {"equal": (25, 25, 25, 25), "minds-heavy": (40, 30, 20, 10)}
+CATS = (.15, .30, .40, .50, .66)
+RULES = ("DIRECT", "HEAD", "WTA", "UNI")
+ABSTAIN_BAND = .1
+STRONG = .5          # |u| above which a final holder's opposing ballot is a strike
+STRIKES = 2          # strikes that revoke a delegation for the rest of the replicate
+SCOPE_P = .6
+DELEGATE_FRAC = .1
+POPULIST_DELEGATE_P = .25
+EPS = 1e-9
+
+
+@dataclass(frozen=True)
+class Config:
+    weights: str = "equal"
+    delegation: bool = False
+    alpha: float = 1.0       # Zipf exponent of delegate choice (concentration)
+    beta: float = 0.0        # extra attraction of populist delegates
+    cap: float = None        # per-final-holder cap as a fraction of cap_basis; None = no cap
+    cap_basis: str = "cast"  # "cast": estate weight resolved before capping; "roll": estate roll size
+    depth: int = 3           # max delegation edges a vote may traverse; None = unlimited
+    renew: float = .1        # per-motion probability a revoked delegator picks a new delegate (0: revocation is final)
+    peer: float = .3         # probability a delegator's edge goes to another delegator, not an active delegate
+    dturn: float = .95       # delegates' own turnout; a delegate who stays home passes weight onward
+    onward: float = .3       # probability an active delegate itself delegates onward
+    copy: float = 0.0        # probability a delegator under an over-cap holder copies that holder's ballot instead (SPEC section 5b)
+    rho: float = 0.0         # strategic fraction
+    faction: int = 0         # coordinated Users faction size
+    motions: int = 400
+    overrides: tuple = ()    # ((estate, key, value), ...)
+
+
+# ---------------------------------------------------------------- rules
+
+def passes(rule, F, A, W, q):
+    """Does the motion pass? F, A: per-estate resolved For/Against weight; W: estate weights."""
+    if rule == "HEAD":
+        f, a = sum(F), sum(A)
+        return f + a > 0 and f >= q * (f + a) - EPS
+    fo = tot = 0.0
+    for e in range(len(F)):
+        n = F[e] + A[e]
+        if n <= 0:
+            continue
+        if rule == "DIRECT":
+            fo += W[e] * F[e] / n
+        elif rule == "WTA":
+            if F[e] == A[e]:
+                continue                      # tied estate casts nothing and drops out
+            if F[e] > A[e]:
+                fo += W[e]
+        elif rule == "UNI":
+            if F[e] >= q * n - EPS:
+                fo += W[e]
+        else:
+            raise ValueError(rule)
+        tot += W[e]
+    return tot > 0 and fo >= q * tot - EPS
+
+
+# ---------------------------------------------------------------- population
+
+class Estate:
+    def __init__(self, name, cfg, rng):
+        n = ROLL[name]
+        p = dict(BASE[name])
+        for en, k, v in cfg.overrides:
+            if en == name:
+                p[k] = v
+        self.name, self.n, self.cfg = name, n, cfg
+        self.a = [p["a"]] * n
+        self.b = [p["b"]] * n
+        self.s = p["s"]
+        self.sig = [p["sigma"]] * n
+        self.turn = [p["turnout"]] * n
+        self.kap = [p["kappa"]] * n
+        self.target = [None] * n
+        self.scope = [None] * n
+        self.strikes = [0] * n
+        self.revoked = []
+        self.delegators = []
+        self.pool = None
+        self.rng = random.Random(rng.getrandbits(32))
+        self.is_delegate = [False] * n
+        self.populist = [False] * n
+        self.faction = [False] * n
+        self.strategic = [rng.random() < cfg.rho for _ in range(n)]
+        ids = list(range(n))
+        rng.shuffle(ids)
+        rest = ids
+        share = DELEG_SHARE[name]
+        if cfg.delegation and share > 0:
+            nd = max(1, round(DELEGATE_FRAC * n))
+            delegates, rest = ids[:nd], ids[nd:]
+            for d in delegates:
+                self.is_delegate[d] = True
+                self.populist[d] = rng.random() < POPULIST_DELEGATE_P
+                if self.populist[d]:
+                    self.a[d], self.b[d], self.sig[d] = .2, 1.2, .7
+                else:
+                    self.a[d], self.b[d], self.sig[d] = .7, .5, .7
+                self.turn[d], self.kap[d] = cfg.dturn, 0.0
+            wts = [(k + 1) ** -cfg.alpha * ((1 + cfg.beta) if self.populist[d] else 1.0)
+                   for k, d in enumerate(delegates)]
+            self.pool = (delegates, wts)
+            nde = min(len(rest), round(share * n))
+            delegators, rest = rest[:nde], rest[nde:]
+            self.delegators = delegators
+            for i in delegators:
+                self.target[i] = self._pick(i, rng)
+                self.scope[i] = self._scope(rng)
+            if len(delegates) > 1:
+                for k, d in enumerate(delegates):
+                    if rng.random() < cfg.onward:
+                        others = [(x, w) for x, w in zip(delegates, wts) if x != d]
+                        self.target[d] = rng.choices([x for x, _ in others], [w for _, w in others])[0]
+                        self.scope[d] = self._scope(rng)
+        if name == "Users":
+            for i in rest[:cfg.faction]:
+                self.faction[i] = True
+        self.ubar = [.8 * math.sqrt(self.a[i] ** 2 + self.b[i] ** 2 + self.s ** 2 + self.sig[i] ** 2)
+                     for i in range(n)]
+
+    def _pick(self, i, rng):
+        """A new delegation target for delegator i: a peer delegator, or an active delegate by Zipf rank."""
+        if len(self.delegators) > 1 and rng.random() < self.cfg.peer:
+            return rng.choice([x for x in self.delegators if x != i])
+        return rng.choices(*self.pool)[0]
+
+    @staticmethod
+    def _scope(rng):
+        sc = frozenset(c for c in range(len(CATS)) if rng.random() < SCOPE_P)
+        return sc or frozenset((rng.randrange(len(CATS)),))
+
+    def chain(self, cat, voting):
+        """Final holder of every non-voting node's weight this motion.
+
+        Follows delegation edges until a node that votes directly. The chain is
+        void (vote uncast) when any link's scope excludes cat (the usable scope
+        is the overlap of all links), it loops, it exceeds cfg.depth edges, or it
+        ends at a node with no edge. Returns (dest, uncast): dest maps node ->
+        final holder, uncast counts non-voting nodes that hold an edge but are void.
+        """
+        D = self.cfg.depth
+        res = {}                      # node -> (holder, edges) or None for void
+        for i in range(self.n):
+            if voting[i] or self.target[i] is None or i in res:
+                continue
+            path, seen, cur = [], set(), i
+            out = None
+            while True:
+                if voting[cur]:
+                    out = (cur, 0)
+                    break
+                if cur in res:
+                    out = res[cur]
+                    break
+                if cur in seen or self.target[cur] is None or cat not in self.scope[cur]:
+                    break                          # loop, dead end or out of scope
+                seen.add(cur)
+                path.append(cur)
+                cur = self.target[cur]
+            for node in reversed(path):            # void propagates upstream; distances add
+                out = (out[0], out[1] + 1) if out else None
+                res[node] = out
+        dest, uncast = {}, 0
+        for i, r in res.items():
+            if voting[i] or self.target[i] is None:
+                continue
+            if r is not None and (D is None or r[1] <= D):
+                dest[i] = r[0]
+            else:
+                uncast += 1
+        return dest, uncast
+
+    def resolve(self, cat, voting):
+        dest, uncast = self.chain(cat, voting)
+        w = {}
+        for i in range(self.n):
+            if voting[i]:
+                w[i] = w.get(i, 0.0) + 1.0
+        for i, h in dest.items():
+            w[h] = w.get(h, 0.0) + 1.0
+        self.last_raw, self.last_cv = dict(w), None
+        if self.cfg.cap is not None:
+            base = self.n if self.cfg.cap_basis == "roll" else sum(w.values())
+            cv = self.last_cv = max(1.0, self.cfg.cap * base)
+            for t in w:
+                if w[t] > cv:
+                    w[t] = cv                          # excess is void, not redistributed
+        self.last_uncast = uncast
+        return w, dest
+
+    def copy_step(self, cat, voting, sb, dest):
+        """Copy-the-ballot (SPEC section 5b), run once on the final resolution.
+
+        Each delegator whose final holder is over the cap copies that holder's
+        ballot with probability cfg.copy: it becomes a direct voter (weight 1,
+        own cap exposure only) casting the holder's ballot. Mutates voting and sb.
+        Returns (copiers {delegator: holder}, w, dest) re-resolved, or None when
+        nobody copies. Draws from self.rng only when copying is on and a holder is over cap.
+        """
+        raw, cv = self.last_raw, self.last_cv
+        if not self.cfg.copy or cv is None:
+            return None
+        copiers = {}
+        for i in sorted(dest):
+            h = dest[i]
+            if raw[h] > cv + EPS and self.rng.random() < self.cfg.copy:
+                copiers[i] = h
+        if not copiers:
+            return None
+        for i, h in copiers.items():
+            voting[i] = True
+            sb[i] = sb[h]
+        w, dest = self.resolve(cat, voting)
+        return copiers, w, dest
+
+    @staticmethod
+    def effective(w, copiers):
+        """Weight by whose ballot it follows: a copier's weight counts to the voter it copied."""
+        eff = dict(w)
+        for c, h in copiers.items():
+            eff[h] = eff.get(h, 0.0) + eff.pop(c, 0.0)
+        return eff
+
+    def motion(self, cat, m, d, rng, z):
+        """Draw this estate's motion state; returns dict with resolved holders and joiners."""
+        n = self.n
+        if self.revoked:
+            keep = []
+            for i in self.revoked:
+                if self.rng.random() < self.cfg.renew:
+                    self.target[i] = self._pick(i, self.rng)
+                    self.scope[i] = self._scope(self.rng)
+                    self.strikes[i] = 0
+                else:
+                    keep.append(i)
+            self.revoked = keep
+        u = [self.a[i] * m + self.b[i] * d + self.s * z + self.sig[i] * rng.gauss(0, 1) for i in range(n)]
+        un = [rng.random() for _ in range(n)]
+        agenda = d - m > 0
+        voting, sb = [False] * n, [0] * n
+        for i in range(n):
+            if self.kap[i]:
+                p = self.turn[i] * (1 + self.kap[i] * (abs(u[i]) - self.ubar[i]))
+                p = min(1.0, max(0.0, p))
+            else:
+                p = self.turn[i]
+            voting[i] = un[i] < p
+            sb[i] = 1 if u[i] > ABSTAIN_BAND else (-1 if u[i] < -ABSTAIN_BAND else 0)
+            if self.faction[i]:
+                voting[i] = True
+                sb[i] = 1 if agenda else -1
+        w, dest = self.resolve(cat, voting)
+        forced = False
+        for i, dd in dest.items():
+            if abs(u[i]) > STRONG and sb[dd] * u[i] < 0:
+                voting[i] = True
+                forced = True
+                self.strikes[i] += 1
+                if self.strikes[i] >= STRIKES:
+                    self.target[i] = None              # revoked until renewed (cfg.renew)
+                    self.revoked.append(i)
+        if forced:
+            w, dest = self.resolve(cat, voting)
+        copiers = {}
+        cs = self.copy_step(cat, voting, sb, dest)
+        if cs:
+            copiers, w, dest = cs
+        holders = [(t, sb[t], w[t]) for t in w]
+        joiners = [(i, sb[i]) for i in range(n)
+                   if not voting[i] and i not in dest and sb[i] != 0]
+        return dict(u=u, holders=holders, joiners=joiners, weights=sorted(w.values()),
+                copiers=copiers, eff_weights=sorted(self.effective(w, copiers).values()),
+                uncast=self.last_uncast, delegated=len(dest) + self.last_uncast,
+                live=sum(1 for i in self.delegators if self.target[i] is not None) / max(1, len(self.delegators)))
+
+
+def concentration(weights):
+    """(top share, gini, kish n_eff, total) of resolved holder weights."""
+    tot = sum(weights)
+    if not weights or tot <= 0:
+        return (0.0, 0.0, 0.0, 0.0)
+    ws = sorted(weights)
+    n = len(ws)
+    cum = sum((k + 1) * x for k, x in enumerate(ws))
+    gini = (2 * cum) / (n * tot) - (n + 1) / n
+    neff = tot * tot / sum(x * x for x in ws)
+    return (ws[-1] / tot, gini, neff, tot)
+
+
+# ---------------------------------------------------------------- one motion
+
+def strategize(rule, W, q, F, A, agents, order_seed):
+    """Myopic best response of strategic agents, three rounds. agents: dicts with
+    e, w, sincere, cur, pref(want pass), opts. Mutates F, A, agent['cur']."""
+    rng = random.Random(order_seed)
+    for _ in range(3):
+        order = list(range(len(agents)))
+        rng.shuffle(order)
+        changed = False
+        for k in order:
+            ag = agents[k]
+            e, w = ag["e"], ag["w"]
+            _move(F, A, e, ag["cur"], 0, w)
+            pick = ag["sincere"]
+            for o in ag["opts"]:
+                _move(F, A, e, 0, o, w)
+                ok = passes(rule, F, A, W, q) == ag["pref"]
+                _move(F, A, e, o, 0, w)
+                if ok:
+                    pick = o
+                    break
+            _move(F, A, e, 0, pick, w)
+            if pick != ag["cur"]:
+                changed = True
+                ag["cur"] = pick
+        if not changed:
+            break
+
+
+def _move(F, A, e, old, new, w):
+    if old == 1:
+        F[e] -= w
+    elif old == -1:
+        A[e] -= w
+    if new == 1:
+        F[e] += w
+    elif new == -1:
+        A[e] += w
+
+
+def run_replicate(cfg, rep, base_seed=20261105):
+    """Returns (records, conc). records[k] = (cat_idx, m, d, strat_bits, sincere_bits)."""
+    pop_rng = random.Random(base_seed * 1_000_003 + rep)
+    mot_rng = random.Random(base_seed * 7_919 + rep + 17)
+    estates = [Estate(nm, cfg, pop_rng) for nm in ESTATES]
+    W = WEIGHTS[cfg.weights]
+    records, conc = [], []
+    for _ in range(cfg.motions):
+        ci = mot_rng.randrange(len(CATS))
+        q = CATS[ci]
+        m, d = mot_rng.gauss(0, 1), mot_rng.gauss(0, 1)
+        zs = [mot_rng.gauss(0, 1) for _ in ESTATES]
+        sseed = mot_rng.getrandbits(32)
+        data = [est.motion(ci, m, d, mot_rng, zs[k]) for k, est in enumerate(estates)]
+        F0, A0 = [0.0] * 4, [0.0] * 4
+        for e, dt in enumerate(data):
+            for _, b, w in dt["holders"]:
+                _move(F0, A0, e, 0, b, w)
+        conc.append(concentration(data[2]["weights"]) + (data[2]["uncast"], data[2]["delegated"], data[2]["live"])
+                    + concentration(data[2]["eff_weights"])[:3:2] + (len(data[2]["copiers"]),))
+        sinc, strat = [], []
+        for rule in RULES:
+            sinc.append(passes(rule, F0, A0, W, q))
+            if cfg.rho <= 0:
+                strat.append(sinc[-1])
+                continue
+            F, A = list(F0), list(A0)
+            agents = []
+            for e, (est, dt) in enumerate(zip(estates, data)):
+                for t, b, w in dt["holders"]:
+                    if est.strategic[t] and not est.faction[t] and t not in dt["copiers"]:
+                        opts = [x for x in (1, -1, 0) if x != b]
+                        agents.append(dict(e=e, w=w, sincere=b, cur=b, pref=dt["u"][t] > 0, opts=[b] + opts))
+                for i, b in dt["joiners"]:
+                    if est.strategic[i]:
+                        agents.append(dict(e=e, w=1.0, sincere=0, cur=0, pref=dt["u"][i] > 0, opts=[0, b]))
+            # opts[0] is the sincere option (for joiners: stay out), evaluated first
+            strategize(rule, W, q, F, A, agents, sseed)
+            strat.append(passes(rule, F, A, W, q))
+        records.append((ci, m, d, tuple(strat), tuple(sinc)))
+    return records, conc
+
+
+# ---------------------------------------------------------------- metrics
+
+def _mean(xs):
+    return sum(xs) / len(xs) if xs else float("nan")
+
+
+def rep_metrics(records, rule_idx, which=3, cats=None):
+    """PS, MT, BPP, GBR, pass rate for one replicate and rule. which: 3 strategic, 4 sincere."""
+    rows = [(m, d, rec[which][rule_idx]) for rec in records
+            for (ci, m, d) in [rec[:3]] if cats is None or ci in cats]
+    def diff(sel_pos, sel_neg):
+        p = [o for (m, d, o) in rows if sel_pos(m, d)]
+        n = [o for (m, d, o) in rows if sel_neg(m, d)]
+        return _mean(p) - _mean(n) if p and n else float("nan")
+    ps = diff(lambda m, d: d > 0, lambda m, d: d < 0)
+    mt = diff(lambda m, d: m > 0, lambda m, d: m < 0)
+    bad = [o for (m, d, o) in rows if m < -.5 and d > .5]
+    good = [o for (m, d, o) in rows if m > .5 and d < -.5]
+    return dict(PS=ps, MT=mt, BPP=_mean(bad) if bad else float("nan"),
+                GBR=1 - _mean(good) if good else float("nan"),
+                PASS=_mean([o for (_, _, o) in rows]) if rows else float("nan"))
+
+
+def mean_ci(xs):
+    xs = [x for x in xs if x == x]
+    if not xs:
+        return (float("nan"), float("nan"))
+    mu = _mean(xs)
+    if len(xs) < 2:
+        return (mu, float("nan"))
+    var = sum((x - mu) ** 2 for x in xs) / (len(xs) - 1)
+    return (mu, 1.96 * math.sqrt(var / len(xs)))
+
+
+def verdict(dps, dmt):
+    """SPEC section 8. dps, dmt: (mean, ci) of PS(UNI)-PS(DIRECT) and MT(UNI)-MT(DIRECT)."""
+    if dps[0] != dps[0]:
+        return "n/a"
+    if (dps[0] - dps[1] > 0) or dmt[0] < -.10:
+        return "fails"
+    if dps[0] + dps[1] < 0 and dmt[0] >= -.05:
+        return "supported"
+    return "undecided"

docs/research/2026-11-05-estate-rule-sim/results.md

@@ -0,0 +1,802 @@
+# Estate-rule sim results (full: 40 replicates x 500 motions per cell)
+
+Generated by `run.py`; spec in SPEC.md. +/- is a 95% interval over replicates. PS populism sensitivity, MT merit tracking, BPP bad-popular pass rate, GBR good-unpopular block rate (SPEC section 3).
+
+## E1 baseline (sincere, no delegation, no faction)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| equal | -0.022 ±0.007 | -0.066 ±0.007 | 0.026 ±0.007 | 0.297 ±0.014 | 0.323 ±0.015 | 0.275 ±0.012 | 0.038 | 30.5 | 0.00 | 0.00 | undecided |
+| minds-heavy | -0.036 ±0.007 | -0.081 ±0.007 | 0.001 ±0.007 | 0.235 ±0.012 | 0.237 ±0.014 | 0.199 ±0.014 | 0.038 | 30.5 | 0.00 | 0.00 | undecided |
+
+### E1 / equal
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.297 ±0.014 | 0.465 ±0.011 | 0.639 | 0.525 ±0.017 | 0.227 ±0.017 | 0.596 ±0.006 | 0.297 ±0.014 | 0.000 ±0.000 |
+| HEAD | 0.427 ±0.010 | 0.364 ±0.011 | 1.173 | 0.686 ±0.021 | 0.409 ±0.017 | 0.592 ±0.006 | 0.427 ±0.010 | 0.000 ±0.000 |
+| WTA | 0.323 ±0.015 | 0.485 ±0.012 | 0.667 | 0.535 ±0.018 | 0.226 ±0.018 | 0.593 ±0.006 | 0.323 ±0.015 | 0.000 ±0.000 |
+| UNI | 0.275 ±0.012 | 0.400 ±0.010 | 0.689 | 0.622 ±0.019 | 0.190 ±0.019 | 0.652 ±0.006 | 0.275 ±0.012 | 0.000 ±0.000 |
+
+UNI-DIRECT: dPS -0.022 ±0.007, dMT -0.066 ±0.007; WTA-DIRECT: dPS 0.026 ±0.007, dMT 0.019 ±0.008; UNI-WTA: dPS -0.048 ±0.009, dMT -0.085 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.22 ±0.02 | 0.30 ±0.02 | 0.27 ±0.03 | 0.13 ±0.01 |
+| 0.3 | 0.29 ±0.03 | 0.41 ±0.03 | 0.31 ±0.03 | 0.27 ±0.03 |
+| 0.4 | 0.33 ±0.02 | 0.48 ±0.02 | 0.33 ±0.03 | 0.32 ±0.02 |
+| 0.5 | 0.33 ±0.03 | 0.50 ±0.03 | 0.35 ±0.03 | 0.33 ±0.03 |
+| 0.66 | 0.32 ±0.03 | 0.44 ±0.03 | 0.35 ±0.03 | 0.32 ±0.03 |
+
+### E1 / minds-heavy
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.235 ±0.012 | 0.494 ±0.011 | 0.476 | 0.434 ±0.017 | 0.183 ±0.018 | 0.593 ±0.006 | 0.235 ±0.012 | 0.000 ±0.000 |
+| HEAD | 0.427 ±0.010 | 0.364 ±0.011 | 1.173 | 0.686 ±0.021 | 0.409 ±0.017 | 0.592 ±0.006 | 0.427 ±0.010 | 0.000 ±0.000 |
+| WTA | 0.237 ±0.014 | 0.502 ±0.012 | 0.471 | 0.436 ±0.016 | 0.179 ±0.018 | 0.586 ±0.007 | 0.237 ±0.014 | 0.000 ±0.000 |
+| UNI | 0.199 ±0.014 | 0.413 ±0.011 | 0.481 | 0.531 ±0.016 | 0.158 ±0.017 | 0.646 ±0.006 | 0.199 ±0.014 | 0.000 ±0.000 |
+
+UNI-DIRECT: dPS -0.036 ±0.007, dMT -0.081 ±0.007; WTA-DIRECT: dPS 0.001 ±0.007, dMT 0.008 ±0.008; UNI-WTA: dPS -0.038 ±0.008, dMT -0.089 ±0.008; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.30 ±0.02 | 0.28 ±0.03 | 0.16 ±0.01 |
+| 0.3 | 0.21 ±0.03 | 0.41 ±0.03 | 0.20 ±0.03 | 0.17 ±0.03 |
+| 0.4 | 0.24 ±0.02 | 0.48 ±0.02 | 0.19 ±0.02 | 0.18 ±0.03 |
+| 0.5 | 0.25 ±0.03 | 0.50 ±0.03 | 0.30 ±0.03 | 0.29 ±0.03 |
+| 0.66 | 0.24 ±0.03 | 0.44 ±0.03 | 0.20 ±0.03 | 0.18 ±0.03 |
+
+## E2 strategic agents (rho=.25) and Users faction size
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| faction=0 | -0.024 ±0.009 | -0.072 ±0.009 | 0.033 ±0.009 | 0.291 ±0.013 | 0.324 ±0.014 | 0.267 ±0.012 | 0.038 | 30.5 | 0.00 | 0.00 | undecided |
+| faction=10 | -0.041 ±0.008 | -0.086 ±0.009 | 0.042 ±0.008 | 0.316 ±0.013 | 0.358 ±0.013 | 0.275 ±0.011 | 0.028 | 39.5 | 0.00 | 0.00 | undecided |
+| faction=20 | -0.050 ±0.008 | -0.077 ±0.009 | 0.037 ±0.009 | 0.323 ±0.013 | 0.360 ±0.013 | 0.274 ±0.011 | 0.022 | 48.5 | 0.00 | 0.00 | undecided |
+| faction=40 | -0.054 ±0.007 | -0.052 ±0.008 | 0.011 ±0.009 | 0.328 ±0.012 | 0.339 ±0.013 | 0.274 ±0.011 | 0.015 | 66.4 | 0.00 | 0.00 | undecided |
+
+### E2 / faction=0
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.291 ±0.013 | 0.459 ±0.011 | 0.634 | 0.524 ±0.017 | 0.226 ±0.019 | 0.599 ±0.007 | 0.297 ±0.014 | 0.026 ±0.004 |
+| HEAD | 0.418 ±0.011 | 0.358 ±0.011 | 1.168 | 0.690 ±0.022 | 0.403 ±0.018 | 0.597 ±0.006 | 0.427 ±0.010 | 0.012 ±0.002 |
+| WTA | 0.324 ±0.014 | 0.483 ±0.012 | 0.671 | 0.540 ±0.019 | 0.224 ±0.017 | 0.596 ±0.006 | 0.323 ±0.015 | 0.025 ±0.004 |
+| UNI | 0.267 ±0.012 | 0.387 ±0.011 | 0.689 | 0.630 ±0.019 | 0.193 ±0.019 | 0.659 ±0.005 | 0.275 ±0.012 | 0.028 ±0.004 |
+
+UNI-DIRECT: dPS -0.024 ±0.009, dMT -0.072 ±0.009; WTA-DIRECT: dPS 0.033 ±0.009, dMT 0.024 ±0.008; UNI-WTA: dPS -0.058 ±0.011, dMT -0.096 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.20 ±0.02 | 0.27 ±0.02 | 0.26 ±0.03 | 0.11 ±0.01 |
+| 0.3 | 0.27 ±0.03 | 0.40 ±0.03 | 0.32 ±0.03 | 0.25 ±0.03 |
+| 0.4 | 0.32 ±0.02 | 0.48 ±0.02 | 0.34 ±0.03 | 0.32 ±0.02 |
+| 0.5 | 0.33 ±0.03 | 0.49 ±0.03 | 0.34 ±0.02 | 0.32 ±0.02 |
+| 0.66 | 0.31 ±0.03 | 0.44 ±0.03 | 0.35 ±0.03 | 0.31 ±0.03 |
+
+### E2 / faction=10
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.316 ±0.013 | 0.413 ±0.013 | 0.765 | 0.564 ±0.018 | 0.253 ±0.021 | 0.607 ±0.007 | 0.319 ±0.013 | 0.027 ±0.004 |
+| HEAD | 0.488 ±0.010 | 0.192 ±0.013 | 2.550 | 0.815 ±0.020 | 0.517 ±0.017 | 0.614 ±0.007 | 0.502 ±0.010 | 0.014 ±0.001 |
+| WTA | 0.358 ±0.013 | 0.426 ±0.012 | 0.842 | 0.595 ±0.020 | 0.245 ±0.019 | 0.607 ±0.006 | 0.358 ±0.014 | 0.027 ±0.004 |
+| UNI | 0.275 ±0.011 | 0.328 ±0.011 | 0.838 | 0.656 ±0.018 | 0.205 ±0.021 | 0.672 ±0.005 | 0.282 ±0.012 | 0.027 ±0.004 |
+
+UNI-DIRECT: dPS -0.041 ±0.008, dMT -0.086 ±0.009; WTA-DIRECT: dPS 0.042 ±0.008, dMT 0.012 ±0.009; UNI-WTA: dPS -0.084 ±0.010, dMT -0.098 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.22 ±0.02 | 0.30 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.47 ±0.03 | 0.35 ±0.03 | 0.27 ±0.03 |
+| 0.4 | 0.35 ±0.02 | 0.58 ±0.02 | 0.37 ±0.03 | 0.34 ±0.02 |
+| 0.5 | 0.37 ±0.03 | 0.62 ±0.03 | 0.38 ±0.02 | 0.36 ±0.02 |
+| 0.66 | 0.34 ±0.03 | 0.53 ±0.02 | 0.39 ±0.03 | 0.32 ±0.03 |
+
+### E2 / faction=20
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.323 ±0.013 | 0.381 ±0.013 | 0.849 | 0.588 ±0.019 | 0.264 ±0.021 | 0.612 ±0.007 | 0.326 ±0.013 | 0.028 ±0.004 |
+| HEAD | 0.524 ±0.010 | 0.048 ±0.013 | n/a | 0.890 ±0.015 | 0.621 ±0.019 | 0.615 ±0.006 | 0.537 ±0.010 | 0.010 ±0.001 |
+| WTA | 0.360 ±0.013 | 0.381 ±0.012 | 0.944 | 0.612 ±0.019 | 0.250 ±0.018 | 0.618 ±0.006 | 0.362 ±0.014 | 0.028 ±0.004 |
+| UNI | 0.274 ±0.011 | 0.304 ±0.011 | 0.900 | 0.665 ±0.019 | 0.210 ±0.021 | 0.676 ±0.005 | 0.279 ±0.012 | 0.028 ±0.004 |
+
+UNI-DIRECT: dPS -0.050 ±0.008, dMT -0.077 ±0.009; WTA-DIRECT: dPS 0.037 ±0.009, dMT 0.000 ±0.010; UNI-WTA: dPS -0.086 ±0.009, dMT -0.077 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.19 ±0.02 | 0.23 ±0.02 | 0.28 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.36 ±0.03 | 0.27 ±0.03 |
+| 0.4 | 0.37 ±0.03 | 0.64 ±0.02 | 0.37 ±0.03 | 0.35 ±0.02 |
+| 0.5 | 0.40 ±0.02 | 0.70 ±0.02 | 0.38 ±0.02 | 0.36 ±0.02 |
+| 0.66 | 0.34 ±0.03 | 0.56 ±0.02 | 0.39 ±0.03 | 0.32 ±0.03 |
+
+### E2 / faction=40
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.328 ±0.012 | 0.341 ±0.014 | 0.961 | 0.609 ±0.019 | 0.279 ±0.023 | 0.620 ±0.006 | 0.330 ±0.012 | 0.029 ±0.004 |
+| HEAD | 0.546 ±0.012 | -0.141 ±0.014 | n/a | 0.960 ±0.007 | 0.761 ±0.018 | 0.603 ±0.006 | 0.551 ±0.012 | 0.007 ±0.001 |
+| WTA | 0.339 ±0.013 | 0.338 ±0.012 | 1.004 | 0.618 ±0.020 | 0.253 ±0.018 | 0.630 ±0.006 | 0.340 ±0.013 | 0.028 ±0.004 |
+| UNI | 0.274 ±0.011 | 0.290 ±0.011 | 0.945 | 0.667 ±0.019 | 0.212 ±0.021 | 0.678 ±0.004 | 0.280 ±0.011 | 0.029 ±0.004 |
+
+UNI-DIRECT: dPS -0.054 ±0.007, dMT -0.052 ±0.008; WTA-DIRECT: dPS 0.011 ±0.009, dMT -0.003 ±0.009; UNI-WTA: dPS -0.066 ±0.009, dMT -0.048 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.16 ±0.02 | 0.29 ±0.02 | 0.21 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.31 ±0.03 | 0.56 ±0.02 | 0.36 ±0.03 | 0.28 ±0.03 |
+| 0.4 | 0.38 ±0.02 | 0.62 ±0.02 | 0.36 ±0.03 | 0.34 ±0.03 |
+| 0.5 | 0.42 ±0.02 | 0.66 ±0.02 | 0.37 ±0.02 | 0.35 ±0.02 |
+| 0.66 | 0.35 ±0.03 | 0.58 ±0.03 | 0.39 ±0.03 | 0.33 ±0.03 |
+
+## E3 delegation: concentration alpha x per-delegate cap (depth 3, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| alpha=0.0 cap=0.1 | -0.026 ±0.007 | -0.093 ±0.009 | 0.054 ±0.009 | 0.311 ±0.014 | 0.365 ±0.014 | 0.286 ±0.010 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.15 | -0.025 ±0.007 | -0.093 ±0.009 | 0.052 ±0.009 | 0.312 ±0.014 | 0.364 ±0.014 | 0.286 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.2 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.010 | 0.312 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.25 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.009 | 0.313 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.3 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.009 | 0.313 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=None | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.009 | 0.315 ±0.014 | 0.367 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.1 | -0.028 ±0.008 | -0.092 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.015 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.15 | -0.028 ±0.008 | -0.094 ±0.008 | 0.048 ±0.010 | 0.313 ±0.014 | 0.361 ±0.014 | 0.286 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.2 | -0.028 ±0.008 | -0.094 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.25 | -0.028 ±0.008 | -0.095 ±0.008 | 0.048 ±0.010 | 0.314 ±0.014 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.3 | -0.029 ±0.009 | -0.094 ±0.008 | 0.048 ±0.010 | 0.314 ±0.015 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=None | -0.028 ±0.009 | -0.092 ±0.008 | 0.050 ±0.010 | 0.315 ±0.015 | 0.365 ±0.015 | 0.287 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.1 | -0.028 ±0.007 | -0.092 ±0.008 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.284 ±0.010 | 0.066 | 53.8 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.15 | -0.027 ±0.007 | -0.093 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.2 | -0.028 ±0.007 | -0.093 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.25 | -0.027 ±0.007 | -0.094 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.3 | -0.028 ±0.008 | -0.094 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.363 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=None | -0.027 ±0.008 | -0.092 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.288 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.5 cap=0.1 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.010 | 0.312 ±0.014 | 0.365 ±0.014 | 0.286 ±0.010 | 0.088 | 46.8 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.15 | -0.026 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.287 ±0.010 | 0.100 | 43.5 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.2 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.25 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.3 | -0.028 ±0.008 | -0.092 ±0.008 | 0.049 ±0.010 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=None | -0.027 ±0.009 | -0.090 ±0.009 | 0.051 ±0.009 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=2.5 cap=0.1 | -0.029 ±0.007 | -0.095 ±0.009 | 0.052 ±0.010 | 0.313 ±0.014 | 0.365 ±0.014 | 0.284 ±0.011 | 0.102 | 43.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.15 | -0.028 ±0.008 | -0.096 ±0.008 | 0.049 ±0.009 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.011 | 0.135 | 34.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.2 | -0.030 ±0.008 | -0.095 ±0.008 | 0.046 ±0.009 | 0.315 ±0.014 | 0.361 ±0.015 | 0.285 ±0.011 | 0.151 | 31.9 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.25 | -0.031 ±0.008 | -0.096 ±0.008 | 0.046 ±0.009 | 0.316 ±0.014 | 0.361 ±0.014 | 0.285 ±0.011 | 0.156 | 31.3 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.3 | -0.031 ±0.008 | -0.096 ±0.008 | 0.045 ±0.009 | 0.316 ±0.014 | 0.361 ±0.014 | 0.284 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=None | -0.030 ±0.008 | -0.094 ±0.008 | 0.047 ±0.008 | 0.317 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.1 | -0.025 ±0.008 | -0.095 ±0.008 | 0.058 ±0.010 | 0.311 ±0.014 | 0.369 ±0.014 | 0.286 ±0.010 | 0.107 | 44.0 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.15 | -0.026 ±0.008 | -0.095 ±0.008 | 0.054 ±0.010 | 0.312 ±0.014 | 0.367 ±0.014 | 0.287 ±0.010 | 0.147 | 32.5 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.2 | -0.027 ±0.008 | -0.093 ±0.008 | 0.052 ±0.010 | 0.313 ±0.013 | 0.365 ±0.014 | 0.286 ±0.011 | 0.173 | 27.8 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.25 | -0.026 ±0.008 | -0.092 ±0.008 | 0.052 ±0.010 | 0.313 ±0.013 | 0.365 ±0.014 | 0.287 ±0.011 | 0.185 | 26.4 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.3 | -0.028 ±0.008 | -0.091 ±0.008 | 0.050 ±0.010 | 0.314 ±0.013 | 0.364 ±0.014 | 0.286 ±0.011 | 0.189 | 26.2 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=None | -0.027 ±0.008 | -0.089 ±0.009 | 0.051 ±0.010 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.190 | 26.1 | 0.51 | 0.81 | undecided |
+
+## E3b same grid, no faction, sincere (isolates delegation)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| alpha=0.0 cap=0.1 | -0.016 ±0.009 | -0.076 ±0.008 | 0.027 ±0.009 | 0.300 ±0.015 | 0.327 ±0.015 | 0.285 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.15 | -0.015 ±0.008 | -0.076 ±0.008 | 0.027 ±0.009 | 0.300 ±0.015 | 0.327 ±0.015 | 0.285 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.2 | -0.015 ±0.009 | -0.077 ±0.009 | 0.028 ±0.009 | 0.301 ±0.015 | 0.329 ±0.015 | 0.285 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.25 | -0.015 ±0.009 | -0.077 ±0.008 | 0.029 ±0.009 | 0.300 ±0.015 | 0.330 ±0.015 | 0.286 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.3 | -0.015 ±0.009 | -0.077 ±0.009 | 0.029 ±0.009 | 0.300 ±0.015 | 0.330 ±0.015 | 0.286 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=None | -0.015 ±0.009 | -0.074 ±0.008 | 0.028 ±0.009 | 0.303 ±0.016 | 0.331 ±0.016 | 0.288 ±0.013 | 0.055 | 46.8 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.1 | -0.016 ±0.008 | -0.076 ±0.009 | 0.030 ±0.009 | 0.300 ±0.015 | 0.330 ±0.015 | 0.284 ±0.013 | 0.059 | 45.6 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.15 | -0.016 ±0.008 | -0.075 ±0.009 | 0.030 ±0.009 | 0.301 ±0.014 | 0.330 ±0.015 | 0.284 ±0.013 | 0.059 | 45.5 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.2 | -0.017 ±0.008 | -0.076 ±0.009 | 0.030 ±0.009 | 0.301 ±0.015 | 0.331 ±0.015 | 0.284 ±0.013 | 0.059 | 45.5 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.25 | -0.017 ±0.008 | -0.077 ±0.009 | 0.031 ±0.009 | 0.301 ±0.015 | 0.332 ±0.015 | 0.285 ±0.013 | 0.059 | 45.5 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.3 | -0.016 ±0.008 | -0.077 ±0.009 | 0.031 ±0.009 | 0.301 ±0.015 | 0.332 ±0.015 | 0.285 ±0.013 | 0.059 | 45.5 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=None | -0.015 ±0.007 | -0.074 ±0.009 | 0.031 ±0.008 | 0.302 ±0.015 | 0.333 ±0.015 | 0.287 ±0.013 | 0.059 | 45.5 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.1 | -0.015 ±0.008 | -0.074 ±0.007 | 0.031 ±0.009 | 0.300 ±0.014 | 0.331 ±0.015 | 0.285 ±0.013 | 0.077 | 41.1 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.15 | -0.016 ±0.008 | -0.074 ±0.007 | 0.030 ±0.009 | 0.301 ±0.014 | 0.331 ±0.015 | 0.285 ±0.013 | 0.082 | 40.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.2 | -0.016 ±0.009 | -0.075 ±0.008 | 0.031 ±0.009 | 0.302 ±0.014 | 0.332 ±0.015 | 0.285 ±0.013 | 0.082 | 40.2 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.25 | -0.016 ±0.009 | -0.076 ±0.008 | 0.032 ±0.009 | 0.301 ±0.014 | 0.333 ±0.015 | 0.286 ±0.013 | 0.082 | 40.2 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.3 | -0.016 ±0.009 | -0.075 ±0.008 | 0.032 ±0.009 | 0.302 ±0.014 | 0.333 ±0.015 | 0.286 ±0.013 | 0.082 | 40.2 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=None | -0.016 ±0.008 | -0.072 ±0.007 | 0.031 ±0.009 | 0.304 ±0.015 | 0.335 ±0.016 | 0.288 ±0.013 | 0.082 | 40.2 | 0.51 | 0.81 | undecided |
+| alpha=1.5 cap=0.1 | -0.016 ±0.008 | -0.075 ±0.007 | 0.030 ±0.009 | 0.300 ±0.015 | 0.331 ±0.015 | 0.284 ±0.013 | 0.096 | 36.9 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.15 | -0.016 ±0.008 | -0.075 ±0.007 | 0.031 ±0.009 | 0.300 ±0.014 | 0.331 ±0.015 | 0.285 ±0.013 | 0.116 | 33.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.2 | -0.016 ±0.008 | -0.075 ±0.007 | 0.033 ±0.009 | 0.300 ±0.015 | 0.333 ±0.015 | 0.284 ±0.013 | 0.123 | 32.2 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.25 | -0.015 ±0.008 | -0.076 ±0.007 | 0.033 ±0.009 | 0.300 ±0.015 | 0.334 ±0.016 | 0.285 ±0.013 | 0.124 | 32.0 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.3 | -0.015 ±0.008 | -0.076 ±0.007 | 0.033 ±0.009 | 0.300 ±0.015 | 0.334 ±0.016 | 0.285 ±0.013 | 0.124 | 32.0 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=None | -0.014 ±0.008 | -0.073 ±0.007 | 0.033 ±0.009 | 0.302 ±0.015 | 0.335 ±0.016 | 0.288 ±0.013 | 0.124 | 32.0 | 0.50 | 0.81 | undecided |
+| alpha=2.5 cap=0.1 | -0.014 ±0.008 | -0.078 ±0.008 | 0.031 ±0.010 | 0.298 ±0.015 | 0.329 ±0.015 | 0.284 ±0.013 | 0.108 | 35.6 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.15 | -0.014 ±0.009 | -0.077 ±0.008 | 0.033 ±0.009 | 0.298 ±0.015 | 0.331 ±0.016 | 0.284 ±0.013 | 0.147 | 27.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.2 | -0.015 ±0.009 | -0.077 ±0.008 | 0.032 ±0.010 | 0.299 ±0.014 | 0.331 ±0.015 | 0.284 ±0.013 | 0.172 | 24.2 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.25 | -0.015 ±0.009 | -0.077 ±0.008 | 0.032 ±0.010 | 0.300 ±0.015 | 0.332 ±0.016 | 0.285 ±0.013 | 0.185 | 23.1 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.3 | -0.015 ±0.009 | -0.077 ±0.007 | 0.032 ±0.010 | 0.300 ±0.015 | 0.332 ±0.016 | 0.285 ±0.013 | 0.189 | 22.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=None | -0.015 ±0.009 | -0.074 ±0.007 | 0.031 ±0.009 | 0.302 ±0.015 | 0.333 ±0.016 | 0.287 ±0.013 | 0.191 | 22.7 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.1 | -0.012 ±0.008 | -0.080 ±0.008 | 0.034 ±0.010 | 0.295 ±0.014 | 0.329 ±0.016 | 0.284 ±0.013 | 0.114 | 36.2 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.15 | -0.014 ±0.008 | -0.080 ±0.007 | 0.034 ±0.010 | 0.297 ±0.014 | 0.330 ±0.015 | 0.282 ±0.013 | 0.158 | 26.8 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.2 | -0.016 ±0.007 | -0.078 ±0.008 | 0.033 ±0.009 | 0.299 ±0.014 | 0.332 ±0.015 | 0.283 ±0.013 | 0.192 | 21.9 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.25 | -0.015 ±0.008 | -0.078 ±0.007 | 0.034 ±0.009 | 0.300 ±0.014 | 0.333 ±0.015 | 0.285 ±0.012 | 0.213 | 19.8 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.3 | -0.015 ±0.008 | -0.075 ±0.007 | 0.033 ±0.009 | 0.300 ±0.014 | 0.334 ±0.016 | 0.285 ±0.012 | 0.224 | 19.1 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=None | -0.015 ±0.008 | -0.072 ±0.007 | 0.033 ±0.009 | 0.302 ±0.014 | 0.335 ±0.016 | 0.288 ±0.012 | 0.230 | 18.9 | 0.51 | 0.81 | undecided |
+
+## E3c transitive depth x delegate turnout x peer-delegation share (alpha=1.5, cap=.2, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| depth=2 dturn=0.95 peer=0.3 | -0.029 ±0.007 | -0.092 ±0.009 | 0.048 ±0.009 | 0.314 ±0.013 | 0.362 ±0.014 | 0.284 ±0.011 | 0.096 | 45.4 | 0.55 | 0.82 | undecided |
+| depth=2 dturn=0.95 peer=0.8 | -0.028 ±0.008 | -0.093 ±0.008 | 0.057 ±0.008 | 0.314 ±0.015 | 0.371 ±0.014 | 0.286 ±0.011 | 0.046 | 63.4 | 0.83 | 0.93 | undecided |
+| depth=2 dturn=0.3 peer=0.3 | -0.037 ±0.007 | -0.088 ±0.008 | 0.051 ±0.008 | 0.312 ±0.013 | 0.362 ±0.013 | 0.275 ±0.012 | 0.107 | 37.1 | 0.77 | 0.90 | undecided |
+| depth=2 dturn=0.3 peer=0.8 | -0.034 ±0.008 | -0.088 ±0.008 | 0.055 ±0.008 | 0.314 ±0.014 | 0.369 ±0.013 | 0.280 ±0.012 | 0.064 | 45.0 | 0.85 | 0.94 | undecided |
+| depth=3 dturn=0.95 peer=0.3 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| depth=3 dturn=0.95 peer=0.8 | -0.028 ±0.007 | -0.094 ±0.009 | 0.056 ±0.007 | 0.314 ±0.015 | 0.369 ±0.014 | 0.286 ±0.012 | 0.051 | 61.6 | 0.81 | 0.92 | undecided |
+| depth=3 dturn=0.3 peer=0.3 | -0.033 ±0.007 | -0.090 ±0.009 | 0.056 ±0.008 | 0.308 ±0.013 | 0.364 ±0.012 | 0.275 ±0.012 | 0.109 | 36.7 | 0.76 | 0.90 | undecided |
+| depth=3 dturn=0.3 peer=0.8 | -0.034 ±0.008 | -0.089 ±0.008 | 0.057 ±0.008 | 0.313 ±0.014 | 0.370 ±0.012 | 0.279 ±0.013 | 0.070 | 43.7 | 0.84 | 0.93 | undecided |
+| depth=4 dturn=0.95 peer=0.3 | -0.027 ±0.007 | -0.091 ±0.009 | 0.050 ±0.010 | 0.312 ±0.014 | 0.362 ±0.015 | 0.286 ±0.011 | 0.103 | 42.9 | 0.50 | 0.81 | undecided |
+| depth=4 dturn=0.95 peer=0.8 | -0.028 ±0.008 | -0.091 ±0.008 | 0.056 ±0.008 | 0.314 ±0.015 | 0.370 ±0.014 | 0.286 ±0.011 | 0.052 | 61.1 | 0.81 | 0.92 | undecided |
+| depth=4 dturn=0.3 peer=0.3 | -0.037 ±0.007 | -0.090 ±0.008 | 0.050 ±0.008 | 0.313 ±0.013 | 0.363 ±0.012 | 0.275 ±0.012 | 0.110 | 36.6 | 0.76 | 0.90 | undecided |
+| depth=4 dturn=0.3 peer=0.8 | -0.035 ±0.009 | -0.090 ±0.007 | 0.056 ±0.007 | 0.313 ±0.014 | 0.369 ±0.013 | 0.278 ±0.013 | 0.072 | 43.3 | 0.83 | 0.93 | undecided |
+| depth=6 dturn=0.95 peer=0.3 | -0.029 ±0.007 | -0.094 ±0.009 | 0.049 ±0.010 | 0.313 ±0.014 | 0.363 ±0.015 | 0.284 ±0.011 | 0.103 | 42.9 | 0.50 | 0.81 | undecided |
+| depth=6 dturn=0.95 peer=0.8 | -0.027 ±0.008 | -0.092 ±0.008 | 0.057 ±0.007 | 0.313 ±0.015 | 0.370 ±0.014 | 0.285 ±0.011 | 0.053 | 60.9 | 0.81 | 0.92 | undecided |
+| depth=6 dturn=0.3 peer=0.3 | -0.037 ±0.007 | -0.089 ±0.008 | 0.049 ±0.008 | 0.312 ±0.013 | 0.362 ±0.012 | 0.275 ±0.012 | 0.110 | 36.5 | 0.76 | 0.90 | undecided |
+| depth=6 dturn=0.3 peer=0.8 | -0.035 ±0.008 | -0.087 ±0.008 | 0.058 ±0.008 | 0.316 ±0.014 | 0.374 ±0.013 | 0.281 ±0.012 | 0.073 | 43.2 | 0.83 | 0.93 | undecided |
+| depth=None dturn=0.95 peer=0.3 | -0.030 ±0.007 | -0.093 ±0.009 | 0.048 ±0.010 | 0.314 ±0.014 | 0.363 ±0.015 | 0.285 ±0.011 | 0.103 | 42.9 | 0.50 | 0.81 | undecided |
+| depth=None dturn=0.95 peer=0.8 | -0.027 ±0.008 | -0.092 ±0.008 | 0.056 ±0.007 | 0.313 ±0.015 | 0.369 ±0.015 | 0.286 ±0.012 | 0.053 | 61.0 | 0.81 | 0.92 | undecided |
+| depth=None dturn=0.3 peer=0.3 | -0.036 ±0.007 | -0.090 ±0.009 | 0.051 ±0.008 | 0.312 ±0.013 | 0.362 ±0.012 | 0.276 ±0.012 | 0.110 | 36.5 | 0.76 | 0.90 | undecided |
+| depth=None dturn=0.3 peer=0.8 | -0.033 ±0.008 | -0.088 ±0.008 | 0.057 ±0.007 | 0.314 ±0.014 | 0.372 ±0.013 | 0.281 ±0.013 | 0.073 | 43.1 | 0.83 | 0.93 | undecided |
+
+## E3f copy-the-ballot: alpha x cap x copy rate (depth 3, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| alpha=0.0 cap=0.1 copy=0.0 | -0.026 ±0.007 | -0.093 ±0.009 | 0.054 ±0.009 | 0.311 ±0.014 | 0.365 ±0.014 | 0.286 ±0.010 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.15 copy=0.0 | -0.025 ±0.007 | -0.093 ±0.009 | 0.052 ±0.009 | 0.312 ±0.014 | 0.364 ±0.014 | 0.286 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.2 copy=0.0 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.010 | 0.312 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.25 copy=0.0 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.009 | 0.313 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.3 copy=0.0 | -0.026 ±0.007 | -0.095 ±0.009 | 0.052 ±0.009 | 0.313 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=None copy=0.0 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.009 | 0.315 ±0.014 | 0.367 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.1 copy=0.5 | -0.028 ±0.007 | -0.091 ±0.009 | 0.049 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.286 ±0.011 | 0.045 | 61.3 | 0.52 | 0.81 | undecided |
+| alpha=0.0 cap=0.15 copy=0.5 | -0.028 ±0.007 | -0.091 ±0.009 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.286 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.2 copy=0.5 | -0.027 ±0.007 | -0.093 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.364 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.25 copy=0.5 | -0.026 ±0.008 | -0.092 ±0.009 | 0.051 ±0.009 | 0.313 ±0.014 | 0.364 ±0.014 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.3 copy=0.5 | -0.026 ±0.008 | -0.094 ±0.009 | 0.053 ±0.009 | 0.313 ±0.015 | 0.366 ±0.015 | 0.287 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=None copy=0.5 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.009 | 0.315 ±0.014 | 0.367 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.1 copy=1.0 | -0.026 ±0.007 | -0.093 ±0.009 | 0.051 ±0.009 | 0.314 ±0.015 | 0.365 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.52 | 0.81 | undecided |
+| alpha=0.0 cap=0.15 copy=1.0 | -0.027 ±0.007 | -0.091 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.015 | 0.288 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.2 copy=1.0 | -0.026 ±0.007 | -0.092 ±0.009 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.25 copy=1.0 | -0.025 ±0.008 | -0.091 ±0.009 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=0.3 copy=1.0 | -0.025 ±0.008 | -0.093 ±0.009 | 0.053 ±0.008 | 0.313 ±0.015 | 0.367 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.0 cap=None copy=1.0 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.009 | 0.315 ±0.014 | 0.367 ±0.015 | 0.289 ±0.011 | 0.045 | 61.3 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.1 copy=0.0 | -0.028 ±0.008 | -0.092 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.015 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.15 copy=0.0 | -0.028 ±0.008 | -0.094 ±0.008 | 0.048 ±0.010 | 0.313 ±0.014 | 0.361 ±0.014 | 0.286 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.2 copy=0.0 | -0.028 ±0.008 | -0.094 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.25 copy=0.0 | -0.028 ±0.008 | -0.095 ±0.008 | 0.048 ±0.010 | 0.314 ±0.014 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.3 copy=0.0 | -0.029 ±0.009 | -0.094 ±0.008 | 0.048 ±0.010 | 0.314 ±0.015 | 0.362 ±0.014 | 0.285 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=None copy=0.0 | -0.028 ±0.009 | -0.092 ±0.008 | 0.050 ±0.010 | 0.315 ±0.015 | 0.365 ±0.015 | 0.287 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.1 copy=0.5 | -0.027 ±0.008 | -0.092 ±0.008 | 0.049 ±0.009 | 0.313 ±0.014 | 0.362 ±0.015 | 0.286 ±0.011 | 0.049 | 59.8 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.15 copy=0.5 | -0.028 ±0.008 | -0.092 ±0.009 | 0.048 ±0.010 | 0.314 ±0.014 | 0.362 ±0.015 | 0.286 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.2 copy=0.5 | -0.027 ±0.008 | -0.094 ±0.009 | 0.048 ±0.009 | 0.315 ±0.014 | 0.362 ±0.014 | 0.287 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.25 copy=0.5 | -0.025 ±0.009 | -0.096 ±0.009 | 0.050 ±0.010 | 0.311 ±0.015 | 0.361 ±0.015 | 0.286 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.3 copy=0.5 | -0.028 ±0.009 | -0.094 ±0.009 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.015 | 0.286 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=None copy=0.5 | -0.028 ±0.009 | -0.092 ±0.008 | 0.050 ±0.010 | 0.315 ±0.015 | 0.365 ±0.015 | 0.287 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.1 copy=1.0 | -0.024 ±0.008 | -0.093 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.362 ±0.015 | 0.288 ±0.011 | 0.049 | 59.8 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.15 copy=1.0 | -0.026 ±0.008 | -0.092 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.363 ±0.015 | 0.288 ±0.012 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.2 copy=1.0 | -0.025 ±0.008 | -0.093 ±0.008 | 0.048 ±0.009 | 0.315 ±0.014 | 0.363 ±0.015 | 0.289 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.25 copy=1.0 | -0.024 ±0.009 | -0.094 ±0.009 | 0.050 ±0.009 | 0.311 ±0.015 | 0.362 ±0.015 | 0.288 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=0.3 copy=1.0 | -0.026 ±0.009 | -0.092 ±0.008 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.015 | 0.288 ±0.012 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=0.5 cap=None copy=1.0 | -0.028 ±0.009 | -0.092 ±0.008 | 0.050 ±0.010 | 0.315 ±0.015 | 0.365 ±0.015 | 0.287 ±0.011 | 0.049 | 59.7 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.1 copy=0.0 | -0.028 ±0.007 | -0.092 ±0.008 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.284 ±0.010 | 0.066 | 53.8 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.15 copy=0.0 | -0.027 ±0.007 | -0.093 ±0.008 | 0.049 ±0.010 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.2 copy=0.0 | -0.028 ±0.007 | -0.093 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.25 copy=0.0 | -0.027 ±0.007 | -0.094 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.362 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.3 copy=0.0 | -0.028 ±0.008 | -0.094 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.363 ±0.014 | 0.285 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=None copy=0.0 | -0.027 ±0.008 | -0.092 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.288 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.1 copy=0.5 | -0.030 ±0.008 | -0.089 ±0.010 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.284 ±0.011 | 0.063 | 55.2 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.15 copy=0.5 | -0.030 ±0.008 | -0.093 ±0.009 | 0.047 ±0.009 | 0.315 ±0.014 | 0.362 ±0.014 | 0.285 ±0.011 | 0.068 | 53.4 | 0.52 | 0.81 | undecided |
+| alpha=1.0 cap=0.2 copy=0.5 | -0.027 ±0.007 | -0.093 ±0.009 | 0.047 ±0.009 | 0.315 ±0.014 | 0.362 ±0.014 | 0.288 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.25 copy=0.5 | -0.026 ±0.008 | -0.093 ±0.009 | 0.049 ±0.009 | 0.313 ±0.014 | 0.362 ±0.015 | 0.286 ±0.011 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.3 copy=0.5 | -0.026 ±0.007 | -0.093 ±0.009 | 0.050 ±0.009 | 0.313 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=None copy=0.5 | -0.027 ±0.008 | -0.092 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.288 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.1 copy=1.0 | -0.027 ±0.008 | -0.090 ±0.009 | 0.050 ±0.008 | 0.315 ±0.014 | 0.365 ±0.015 | 0.287 ±0.011 | 0.061 | 56.5 | 0.52 | 0.81 | undecided |
+| alpha=1.0 cap=0.15 copy=1.0 | -0.027 ±0.008 | -0.093 ±0.009 | 0.048 ±0.009 | 0.315 ±0.014 | 0.362 ±0.014 | 0.287 ±0.011 | 0.068 | 53.5 | 0.52 | 0.81 | undecided |
+| alpha=1.0 cap=0.2 copy=1.0 | -0.025 ±0.008 | -0.093 ±0.009 | 0.049 ±0.008 | 0.315 ±0.014 | 0.363 ±0.014 | 0.290 ±0.011 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.25 copy=1.0 | -0.025 ±0.008 | -0.092 ±0.009 | 0.050 ±0.009 | 0.313 ±0.014 | 0.363 ±0.015 | 0.288 ±0.011 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=0.3 copy=1.0 | -0.024 ±0.007 | -0.092 ±0.009 | 0.050 ±0.008 | 0.313 ±0.014 | 0.364 ±0.014 | 0.289 ±0.011 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.0 cap=None copy=1.0 | -0.027 ±0.008 | -0.092 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.288 ±0.010 | 0.068 | 53.3 | 0.51 | 0.81 | undecided |
+| alpha=1.5 cap=0.1 copy=0.0 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.010 | 0.312 ±0.014 | 0.365 ±0.014 | 0.286 ±0.010 | 0.088 | 46.8 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.15 copy=0.0 | -0.026 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.287 ±0.010 | 0.100 | 43.5 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.2 copy=0.0 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.25 copy=0.0 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.3 copy=0.0 | -0.028 ±0.008 | -0.092 ±0.008 | 0.049 ±0.010 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=None copy=0.0 | -0.027 ±0.009 | -0.090 ±0.009 | 0.051 ±0.009 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.1 copy=0.5 | -0.028 ±0.008 | -0.089 ±0.009 | 0.048 ±0.008 | 0.315 ±0.014 | 0.362 ±0.014 | 0.286 ±0.011 | 0.072 | 53.9 | 0.54 | 0.81 | undecided |
+| alpha=1.5 cap=0.15 copy=0.5 | -0.027 ±0.008 | -0.092 ±0.008 | 0.048 ±0.008 | 0.314 ±0.014 | 0.362 ±0.015 | 0.287 ±0.012 | 0.091 | 46.4 | 0.52 | 0.81 | undecided |
+| alpha=1.5 cap=0.2 copy=0.5 | -0.027 ±0.008 | -0.093 ±0.008 | 0.047 ±0.009 | 0.315 ±0.014 | 0.363 ±0.015 | 0.288 ±0.011 | 0.100 | 44.0 | 0.51 | 0.81 | undecided |
+| alpha=1.5 cap=0.25 copy=0.5 | -0.026 ±0.009 | -0.091 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.288 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.3 copy=0.5 | -0.026 ±0.009 | -0.092 ±0.009 | 0.049 ±0.010 | 0.314 ±0.015 | 0.363 ±0.014 | 0.288 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=None copy=0.5 | -0.027 ±0.009 | -0.090 ±0.009 | 0.051 ±0.009 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.1 copy=1.0 | -0.026 ±0.008 | -0.090 ±0.008 | 0.047 ±0.008 | 0.315 ±0.014 | 0.363 ±0.015 | 0.290 ±0.011 | 0.062 | 61.5 | 0.58 | 0.81 | undecided |
+| alpha=1.5 cap=0.15 copy=1.0 | -0.025 ±0.008 | -0.092 ±0.008 | 0.050 ±0.008 | 0.313 ±0.014 | 0.363 ±0.015 | 0.288 ±0.012 | 0.087 | 49.1 | 0.53 | 0.81 | undecided |
+| alpha=1.5 cap=0.2 copy=1.0 | -0.026 ±0.008 | -0.092 ±0.008 | 0.048 ±0.009 | 0.315 ±0.014 | 0.364 ±0.015 | 0.290 ±0.011 | 0.099 | 44.4 | 0.52 | 0.81 | undecided |
+| alpha=1.5 cap=0.25 copy=1.0 | -0.024 ±0.009 | -0.091 ±0.009 | 0.051 ±0.010 | 0.314 ±0.014 | 0.364 ±0.014 | 0.289 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=0.3 copy=1.0 | -0.023 ±0.008 | -0.091 ±0.008 | 0.050 ±0.009 | 0.313 ±0.014 | 0.364 ±0.014 | 0.290 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=1.5 cap=None copy=1.0 | -0.027 ±0.009 | -0.090 ±0.009 | 0.051 ±0.009 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| alpha=2.5 cap=0.1 copy=0.0 | -0.029 ±0.007 | -0.095 ±0.009 | 0.052 ±0.010 | 0.313 ±0.014 | 0.365 ±0.014 | 0.284 ±0.011 | 0.102 | 43.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.15 copy=0.0 | -0.028 ±0.008 | -0.096 ±0.008 | 0.049 ±0.009 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.011 | 0.135 | 34.8 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.2 copy=0.0 | -0.030 ±0.008 | -0.095 ±0.008 | 0.046 ±0.009 | 0.315 ±0.014 | 0.361 ±0.015 | 0.285 ±0.011 | 0.151 | 31.9 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.25 copy=0.0 | -0.031 ±0.008 | -0.096 ±0.008 | 0.046 ±0.009 | 0.316 ±0.014 | 0.361 ±0.014 | 0.285 ±0.011 | 0.156 | 31.3 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.3 copy=0.0 | -0.031 ±0.008 | -0.096 ±0.008 | 0.045 ±0.009 | 0.316 ±0.014 | 0.361 ±0.014 | 0.284 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=None copy=0.0 | -0.030 ±0.008 | -0.094 ±0.008 | 0.047 ±0.008 | 0.317 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.1 copy=0.5 | -0.027 ±0.007 | -0.089 ±0.009 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.287 ±0.011 | 0.080 | 55.2 | 0.59 | 0.81 | undecided |
+| alpha=2.5 cap=0.15 copy=0.5 | -0.025 ±0.008 | -0.090 ±0.008 | 0.049 ±0.008 | 0.312 ±0.015 | 0.361 ±0.014 | 0.287 ±0.011 | 0.102 | 46.4 | 0.57 | 0.81 | undecided |
+| alpha=2.5 cap=0.2 copy=0.5 | -0.026 ±0.007 | -0.091 ±0.008 | 0.050 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.288 ±0.011 | 0.131 | 37.3 | 0.54 | 0.81 | undecided |
+| alpha=2.5 cap=0.25 copy=0.5 | -0.026 ±0.008 | -0.091 ±0.010 | 0.048 ±0.008 | 0.314 ±0.014 | 0.362 ±0.014 | 0.287 ±0.011 | 0.150 | 32.6 | 0.52 | 0.81 | undecided |
+| alpha=2.5 cap=0.3 copy=0.5 | -0.027 ±0.008 | -0.090 ±0.009 | 0.048 ±0.008 | 0.314 ±0.014 | 0.362 ±0.014 | 0.287 ±0.011 | 0.156 | 31.5 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=None copy=0.5 | -0.030 ±0.008 | -0.094 ±0.008 | 0.047 ±0.008 | 0.317 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=2.5 cap=0.1 copy=1.0 | -0.026 ±0.008 | -0.089 ±0.009 | 0.049 ±0.009 | 0.314 ±0.014 | 0.363 ±0.014 | 0.289 ±0.011 | 0.047 | 77.9 | 0.71 | 0.81 | undecided |
+| alpha=2.5 cap=0.15 copy=1.0 | -0.024 ±0.008 | -0.091 ±0.008 | 0.050 ±0.008 | 0.312 ±0.015 | 0.362 ±0.014 | 0.288 ±0.012 | 0.072 | 65.4 | 0.65 | 0.81 | undecided |
+| alpha=2.5 cap=0.2 copy=1.0 | -0.024 ±0.008 | -0.091 ±0.008 | 0.051 ±0.008 | 0.314 ±0.014 | 0.366 ±0.014 | 0.290 ±0.012 | 0.114 | 46.9 | 0.57 | 0.81 | undecided |
+| alpha=2.5 cap=0.25 copy=1.0 | -0.024 ±0.008 | -0.090 ±0.009 | 0.049 ±0.008 | 0.314 ±0.014 | 0.363 ±0.014 | 0.290 ±0.011 | 0.144 | 35.9 | 0.53 | 0.81 | undecided |
+| alpha=2.5 cap=0.3 copy=1.0 | -0.024 ±0.008 | -0.090 ±0.008 | 0.049 ±0.008 | 0.313 ±0.013 | 0.362 ±0.014 | 0.289 ±0.011 | 0.154 | 32.4 | 0.52 | 0.81 | undecided |
+| alpha=2.5 cap=None copy=1.0 | -0.030 ±0.008 | -0.094 ±0.008 | 0.047 ±0.008 | 0.317 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.158 | 31.2 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.1 copy=0.0 | -0.025 ±0.008 | -0.095 ±0.008 | 0.058 ±0.010 | 0.311 ±0.014 | 0.369 ±0.014 | 0.286 ±0.010 | 0.107 | 44.0 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.15 copy=0.0 | -0.026 ±0.008 | -0.095 ±0.008 | 0.054 ±0.010 | 0.312 ±0.014 | 0.367 ±0.014 | 0.287 ±0.010 | 0.147 | 32.5 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.2 copy=0.0 | -0.027 ±0.008 | -0.093 ±0.008 | 0.052 ±0.010 | 0.313 ±0.013 | 0.365 ±0.014 | 0.286 ±0.011 | 0.173 | 27.8 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.25 copy=0.0 | -0.026 ±0.008 | -0.092 ±0.008 | 0.052 ±0.010 | 0.313 ±0.013 | 0.365 ±0.014 | 0.287 ±0.011 | 0.185 | 26.4 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.3 copy=0.0 | -0.028 ±0.008 | -0.091 ±0.008 | 0.050 ±0.010 | 0.314 ±0.013 | 0.364 ±0.014 | 0.286 ±0.011 | 0.189 | 26.2 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=None copy=0.0 | -0.027 ±0.008 | -0.089 ±0.009 | 0.051 ±0.010 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.190 | 26.1 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.1 copy=0.5 | -0.026 ±0.008 | -0.094 ±0.009 | 0.049 ±0.009 | 0.312 ±0.014 | 0.361 ±0.014 | 0.286 ±0.011 | 0.085 | 56.1 | 0.62 | 0.81 | undecided |
+| alpha=4.0 cap=0.15 copy=0.5 | -0.028 ±0.008 | -0.089 ±0.008 | 0.046 ±0.009 | 0.315 ±0.015 | 0.361 ±0.014 | 0.287 ±0.011 | 0.105 | 47.9 | 0.60 | 0.81 | undecided |
+| alpha=4.0 cap=0.2 copy=0.5 | -0.028 ±0.008 | -0.092 ±0.008 | 0.048 ±0.010 | 0.315 ±0.014 | 0.363 ±0.014 | 0.287 ±0.011 | 0.133 | 38.5 | 0.57 | 0.81 | undecided |
+| alpha=4.0 cap=0.25 copy=0.5 | -0.028 ±0.007 | -0.091 ±0.008 | 0.047 ±0.009 | 0.315 ±0.013 | 0.363 ±0.014 | 0.288 ±0.011 | 0.163 | 30.6 | 0.54 | 0.81 | undecided |
+| alpha=4.0 cap=0.3 copy=0.5 | -0.026 ±0.008 | -0.092 ±0.009 | 0.048 ±0.009 | 0.314 ±0.014 | 0.362 ±0.013 | 0.288 ±0.011 | 0.180 | 27.4 | 0.52 | 0.81 | undecided |
+| alpha=4.0 cap=None copy=0.5 | -0.027 ±0.008 | -0.089 ±0.009 | 0.051 ±0.010 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.190 | 26.1 | 0.51 | 0.81 | undecided |
+| alpha=4.0 cap=0.1 copy=1.0 | -0.025 ±0.008 | -0.095 ±0.009 | 0.047 ±0.009 | 0.314 ±0.014 | 0.361 ±0.014 | 0.289 ±0.011 | 0.034 | 89.0 | 0.80 | 0.81 | undecided |
+| alpha=4.0 cap=0.15 copy=1.0 | -0.026 ±0.008 | -0.090 ±0.008 | 0.048 ±0.009 | 0.315 ±0.015 | 0.363 ±0.014 | 0.289 ±0.011 | 0.050 | 80.8 | 0.75 | 0.81 | undecided |
+| alpha=4.0 cap=0.2 copy=1.0 | -0.026 ±0.008 | -0.091 ±0.008 | 0.049 ±0.009 | 0.314 ±0.014 | 0.364 ±0.014 | 0.289 ±0.011 | 0.094 | 61.4 | 0.65 | 0.81 | undecided |
+| alpha=4.0 cap=0.25 copy=1.0 | -0.026 ±0.007 | -0.090 ±0.008 | 0.047 ±0.008 | 0.315 ±0.013 | 0.363 ±0.014 | 0.289 ±0.011 | 0.144 | 41.7 | 0.57 | 0.81 | undecided |
+| alpha=4.0 cap=0.3 copy=1.0 | -0.025 ±0.008 | -0.091 ±0.008 | 0.048 ±0.009 | 0.315 ±0.014 | 0.362 ±0.014 | 0.290 ±0.011 | 0.173 | 31.6 | 0.53 | 0.81 | undecided |
+| alpha=4.0 cap=None copy=1.0 | -0.027 ±0.008 | -0.089 ±0.009 | 0.051 ±0.010 | 0.315 ±0.014 | 0.366 ±0.014 | 0.288 ±0.011 | 0.190 | 26.1 | 0.51 | 0.81 | undecided |
+
+**Does the cap reduce effective concentration? Effective Users top-holder share at cap 0.1 minus no cap, paired by replicate; 'reduces' iff the 95% interval is entirely below -0.01.**
+
+| alpha | copy | effective top share, cap - none | verdict | formal top share, cap - none |
+|---|---|---|---|---|
+| 0.0 | 0.0 | -0.000 ±0.000 | does not reduce | -0.000 |
+| 0.0 | 0.5 | -0.000 ±0.000 | does not reduce | -0.000 |
+| 0.0 | 1.0 | -0.000 ±0.000 | does not reduce | -0.000 |
+| 0.5 | 0.0 | -0.000 ±0.000 | does not reduce | -0.000 |
+| 0.5 | 0.5 | 0.000 ±0.000 | does not reduce | -0.000 |
+| 0.5 | 1.0 | 0.000 ±0.000 | does not reduce | -0.000 |
+| 1.0 | 0.0 | -0.002 ±0.000 | does not reduce | -0.002 |
+| 1.0 | 0.5 | 0.001 ±0.001 | does not reduce | -0.005 |
+| 1.0 | 1.0 | 0.001 ±0.001 | does not reduce | -0.007 |
+| 1.5 | 0.0 | -0.015 ±0.001 | reduces | -0.015 |
+| 1.5 | 0.5 | -0.000 ±0.002 | does not reduce | -0.031 |
+| 1.5 | 1.0 | 0.000 ±0.002 | does not reduce | -0.041 |
+| 2.5 | 0.0 | -0.055 ±0.003 | reduces | -0.055 |
+| 2.5 | 0.5 | -0.003 ±0.002 | does not reduce | -0.078 |
+| 2.5 | 1.0 | 0.001 ±0.002 | does not reduce | -0.111 |
+| 4.0 | 0.0 | -0.083 ±0.003 | reduces | -0.083 |
+| 4.0 | 0.5 | -0.008 ±0.002 | does not reduce | -0.105 |
+| 4.0 | 1.0 | 0.001 ±0.002 | does not reduce | -0.156 |
+
+Reading, computed from the rows above: the cap reduces effective concentration in 3 of 6 alpha values at copy rate 0.0; 0 of 6 alpha values at copy rate 0.5; 0 of 6 alpha values at copy rate 1.0. Where it reduces at copy 0 and not at copy 1, the formal top share falls (last column) while the weight follows the same voters through their copiers, so the cap moves weight from the holder's ledger to its followers' ballots without changing whose ballot it is.
+
+**Users top-holder share, formal (copiers are separate weight-1 ballots)**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.0 | 0.5 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.0 | 1.0 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.5 | 0.0 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 0.5 | 0.5 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 0.5 | 1.0 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 1.0 | 0.0 | 0.066 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.0 | 0.5 | 0.063 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.0 | 1.0 | 0.061 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.5 | 0.0 | 0.088 | 0.100 | 0.103 | 0.103 | 0.103 | 0.103 |
+| 1.5 | 0.5 | 0.072 | 0.091 | 0.100 | 0.103 | 0.103 | 0.103 |
+| 1.5 | 1.0 | 0.062 | 0.087 | 0.099 | 0.103 | 0.103 | 0.103 |
+| 2.5 | 0.0 | 0.102 | 0.135 | 0.151 | 0.156 | 0.158 | 0.158 |
+| 2.5 | 0.5 | 0.080 | 0.102 | 0.131 | 0.150 | 0.156 | 0.158 |
+| 2.5 | 1.0 | 0.047 | 0.072 | 0.114 | 0.144 | 0.154 | 0.158 |
+| 4.0 | 0.0 | 0.107 | 0.147 | 0.173 | 0.185 | 0.189 | 0.190 |
+| 4.0 | 0.5 | 0.085 | 0.105 | 0.133 | 0.163 | 0.180 | 0.190 |
+| 4.0 | 1.0 | 0.034 | 0.050 | 0.094 | 0.144 | 0.173 | 0.190 |
+
+**Users top-holder share, effective (copiers counted to the voter they copied)**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.0 | 0.5 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.0 | 1.0 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 | 0.045 |
+| 0.5 | 0.0 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 0.5 | 0.5 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 0.5 | 1.0 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 | 0.049 |
+| 1.0 | 0.0 | 0.066 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.0 | 0.5 | 0.069 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.0 | 1.0 | 0.069 | 0.068 | 0.068 | 0.068 | 0.068 | 0.068 |
+| 1.5 | 0.0 | 0.088 | 0.100 | 0.103 | 0.103 | 0.103 | 0.103 |
+| 1.5 | 0.5 | 0.102 | 0.102 | 0.101 | 0.103 | 0.103 | 0.103 |
+| 1.5 | 1.0 | 0.103 | 0.102 | 0.101 | 0.103 | 0.103 | 0.103 |
+| 2.5 | 0.0 | 0.102 | 0.135 | 0.151 | 0.156 | 0.158 | 0.158 |
+| 2.5 | 0.5 | 0.155 | 0.159 | 0.159 | 0.159 | 0.158 | 0.158 |
+| 2.5 | 1.0 | 0.159 | 0.160 | 0.159 | 0.159 | 0.158 | 0.158 |
+| 4.0 | 0.0 | 0.107 | 0.147 | 0.173 | 0.185 | 0.189 | 0.190 |
+| 4.0 | 0.5 | 0.182 | 0.191 | 0.191 | 0.192 | 0.190 | 0.190 |
+| 4.0 | 1.0 | 0.191 | 0.192 | 0.191 | 0.192 | 0.190 | 0.190 |
+
+**Users n_eff, effective**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 |
+| 0.0 | 0.5 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 |
+| 0.0 | 1.0 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 | 61.3 |
+| 0.5 | 0.0 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 |
+| 0.5 | 0.5 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 |
+| 0.5 | 1.0 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 | 59.7 |
+| 1.0 | 0.0 | 53.8 | 53.3 | 53.3 | 53.3 | 53.3 | 53.3 |
+| 1.0 | 0.5 | 53.1 | 53.3 | 53.3 | 53.3 | 53.3 | 53.3 |
+| 1.0 | 1.0 | 53.1 | 53.3 | 53.3 | 53.3 | 53.3 | 53.3 |
+| 1.5 | 0.0 | 46.8 | 43.5 | 43.1 | 43.1 | 43.1 | 43.1 |
+| 1.5 | 0.5 | 43.2 | 43.4 | 43.6 | 43.1 | 43.1 | 43.1 |
+| 1.5 | 1.0 | 43.1 | 43.4 | 43.6 | 43.1 | 43.1 | 43.1 |
+| 2.5 | 0.0 | 43.8 | 34.8 | 31.9 | 31.3 | 31.2 | 31.2 |
+| 2.5 | 0.5 | 31.5 | 30.9 | 31.0 | 31.0 | 31.2 | 31.2 |
+| 2.5 | 1.0 | 30.9 | 30.9 | 31.0 | 31.0 | 31.2 | 31.2 |
+| 4.0 | 0.0 | 44.0 | 32.5 | 27.8 | 26.4 | 26.2 | 26.1 |
+| 4.0 | 0.5 | 27.0 | 25.9 | 26.0 | 25.9 | 26.1 | 26.1 |
+| 4.0 | 1.0 | 26.0 | 25.8 | 26.0 | 25.9 | 26.1 | 26.1 |
+
+**copiers as a share of delegated votes**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 0.0 | 0.5 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 0.0 | 1.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 0.5 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 0.5 | 0.5 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 0.5 | 1.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.0 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.0 | 0.5 | 0.01 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.0 | 1.0 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.5 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.5 | 0.5 | 0.07 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 1.5 | 1.0 | 0.14 | 0.04 | 0.01 | 0.00 | 0.00 | 0.00 |
+| 2.5 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 2.5 | 0.5 | 0.17 | 0.12 | 0.06 | 0.02 | 0.01 | 0.00 |
+| 2.5 | 1.0 | 0.40 | 0.28 | 0.12 | 0.04 | 0.01 | 0.00 |
+| 4.0 | 0.0 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
+| 4.0 | 0.5 | 0.22 | 0.20 | 0.13 | 0.06 | 0.02 | 0.00 |
+| 4.0 | 1.0 | 0.57 | 0.49 | 0.29 | 0.12 | 0.04 | 0.00 |
+
+**dPS UNI-DIRECT**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | -0.026 ±0.007 | -0.025 ±0.007 | -0.026 ±0.007 | -0.026 ±0.007 | -0.026 ±0.007 | -0.026 ±0.008 |
+| 0.0 | 0.5 | -0.028 ±0.007 | -0.028 ±0.007 | -0.027 ±0.007 | -0.026 ±0.008 | -0.026 ±0.008 | -0.026 ±0.008 |
+| 0.0 | 1.0 | -0.026 ±0.007 | -0.027 ±0.007 | -0.026 ±0.007 | -0.025 ±0.008 | -0.025 ±0.008 | -0.026 ±0.008 |
+| 0.5 | 0.0 | -0.028 ±0.008 | -0.028 ±0.008 | -0.028 ±0.008 | -0.028 ±0.008 | -0.029 ±0.009 | -0.028 ±0.009 |
+| 0.5 | 0.5 | -0.027 ±0.008 | -0.028 ±0.008 | -0.027 ±0.008 | -0.025 ±0.009 | -0.028 ±0.009 | -0.028 ±0.009 |
+| 0.5 | 1.0 | -0.024 ±0.008 | -0.026 ±0.008 | -0.025 ±0.008 | -0.024 ±0.009 | -0.026 ±0.009 | -0.028 ±0.009 |
+| 1.0 | 0.0 | -0.028 ±0.007 | -0.027 ±0.007 | -0.028 ±0.007 | -0.027 ±0.007 | -0.028 ±0.008 | -0.027 ±0.008 |
+| 1.0 | 0.5 | -0.030 ±0.008 | -0.030 ±0.008 | -0.027 ±0.007 | -0.026 ±0.008 | -0.026 ±0.007 | -0.027 ±0.008 |
+| 1.0 | 1.0 | -0.027 ±0.008 | -0.027 ±0.008 | -0.025 ±0.008 | -0.025 ±0.008 | -0.024 ±0.007 | -0.027 ±0.008 |
+| 1.5 | 0.0 | -0.026 ±0.008 | -0.026 ±0.008 | -0.027 ±0.008 | -0.027 ±0.008 | -0.028 ±0.008 | -0.027 ±0.009 |
+| 1.5 | 0.5 | -0.028 ±0.008 | -0.027 ±0.008 | -0.027 ±0.008 | -0.026 ±0.009 | -0.026 ±0.009 | -0.027 ±0.009 |
+| 1.5 | 1.0 | -0.026 ±0.008 | -0.025 ±0.008 | -0.026 ±0.008 | -0.024 ±0.009 | -0.023 ±0.008 | -0.027 ±0.009 |
+| 2.5 | 0.0 | -0.029 ±0.007 | -0.028 ±0.008 | -0.030 ±0.008 | -0.031 ±0.008 | -0.031 ±0.008 | -0.030 ±0.008 |
+| 2.5 | 0.5 | -0.027 ±0.007 | -0.025 ±0.008 | -0.026 ±0.007 | -0.026 ±0.008 | -0.027 ±0.008 | -0.030 ±0.008 |
+| 2.5 | 1.0 | -0.026 ±0.008 | -0.024 ±0.008 | -0.024 ±0.008 | -0.024 ±0.008 | -0.024 ±0.008 | -0.030 ±0.008 |
+| 4.0 | 0.0 | -0.025 ±0.008 | -0.026 ±0.008 | -0.027 ±0.008 | -0.026 ±0.008 | -0.028 ±0.008 | -0.027 ±0.008 |
+| 4.0 | 0.5 | -0.026 ±0.008 | -0.028 ±0.008 | -0.028 ±0.008 | -0.028 ±0.007 | -0.026 ±0.008 | -0.027 ±0.008 |
+| 4.0 | 1.0 | -0.025 ±0.008 | -0.026 ±0.008 | -0.026 ±0.008 | -0.026 ±0.007 | -0.025 ±0.008 | -0.027 ±0.008 |
+
+**PS UNI**
+
+| alpha | copy | 0.1 | 0.15 | 0.2 | 0.25 | 0.3 | none |
+|---|---|---|---|---|---|---|---|
+| 0.0 | 0.0 | 0.286 ±0.010 | 0.286 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.289 ±0.011 |
+| 0.0 | 0.5 | 0.286 ±0.011 | 0.286 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.289 ±0.011 |
+| 0.0 | 1.0 | 0.289 ±0.011 | 0.288 ±0.011 | 0.289 ±0.011 | 0.289 ±0.011 | 0.289 ±0.011 | 0.289 ±0.011 |
+| 0.5 | 0.0 | 0.285 ±0.011 | 0.286 ±0.011 | 0.285 ±0.011 | 0.285 ±0.011 | 0.285 ±0.011 | 0.287 ±0.011 |
+| 0.5 | 0.5 | 0.286 ±0.011 | 0.286 ±0.011 | 0.287 ±0.011 | 0.286 ±0.011 | 0.286 ±0.011 | 0.287 ±0.011 |
+| 0.5 | 1.0 | 0.288 ±0.011 | 0.288 ±0.012 | 0.289 ±0.011 | 0.288 ±0.011 | 0.288 ±0.012 | 0.287 ±0.011 |
+| 1.0 | 0.0 | 0.284 ±0.010 | 0.285 ±0.010 | 0.285 ±0.010 | 0.285 ±0.010 | 0.285 ±0.010 | 0.288 ±0.010 |
+| 1.0 | 0.5 | 0.284 ±0.011 | 0.285 ±0.011 | 0.288 ±0.010 | 0.286 ±0.011 | 0.287 ±0.011 | 0.288 ±0.010 |
+| 1.0 | 1.0 | 0.287 ±0.011 | 0.287 ±0.011 | 0.290 ±0.011 | 0.288 ±0.011 | 0.289 ±0.011 | 0.288 ±0.010 |
+| 1.5 | 0.0 | 0.286 ±0.010 | 0.287 ±0.010 | 0.286 ±0.010 | 0.286 ±0.010 | 0.286 ±0.010 | 0.288 ±0.011 |
+| 1.5 | 0.5 | 0.286 ±0.011 | 0.287 ±0.012 | 0.288 ±0.011 | 0.288 ±0.011 | 0.288 ±0.010 | 0.288 ±0.011 |
+| 1.5 | 1.0 | 0.290 ±0.011 | 0.288 ±0.012 | 0.290 ±0.011 | 0.289 ±0.011 | 0.290 ±0.011 | 0.288 ±0.011 |
+| 2.5 | 0.0 | 0.284 ±0.011 | 0.286 ±0.011 | 0.285 ±0.011 | 0.285 ±0.011 | 0.284 ±0.011 | 0.287 ±0.011 |
+| 2.5 | 0.5 | 0.287 ±0.011 | 0.287 ±0.011 | 0.288 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 |
+| 2.5 | 1.0 | 0.289 ±0.011 | 0.288 ±0.012 | 0.290 ±0.012 | 0.290 ±0.011 | 0.289 ±0.011 | 0.287 ±0.011 |
+| 4.0 | 0.0 | 0.286 ±0.010 | 0.287 ±0.010 | 0.286 ±0.011 | 0.287 ±0.011 | 0.286 ±0.011 | 0.288 ±0.011 |
+| 4.0 | 0.5 | 0.286 ±0.011 | 0.287 ±0.011 | 0.287 ±0.011 | 0.288 ±0.011 | 0.288 ±0.011 | 0.288 ±0.011 |
+| 4.0 | 1.0 | 0.289 ±0.011 | 0.289 ±0.011 | 0.289 ±0.011 | 0.289 ±0.011 | 0.290 ±0.011 | 0.288 ±0.011 |
+
+## E3e revocation renewal: how fast revoked delegators re-delegate (alpha=1.5, cap=.2, depth 3, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| renew=0.0 | -0.031 ±0.008 | -0.095 ±0.008 | 0.049 ±0.009 | 0.320 ±0.015 | 0.370 ±0.013 | 0.289 ±0.011 | 0.026 | 71.1 | 0.66 | 0.13 | undecided |
+| renew=0.02 | -0.028 ±0.007 | -0.092 ±0.008 | 0.049 ±0.009 | 0.315 ±0.013 | 0.364 ±0.015 | 0.287 ±0.010 | 0.069 | 56.4 | 0.59 | 0.53 | undecided |
+| renew=0.1 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| renew=0.5 | -0.026 ±0.007 | -0.092 ±0.008 | 0.047 ±0.009 | 0.312 ±0.014 | 0.358 ±0.014 | 0.285 ±0.011 | 0.115 | 38.8 | 0.48 | 0.95 | undecided |
+
+## E3d cap basis: share of cast weight vs share of roll (alpha=1.5, depth=3, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| basis=cast cap=0.05 | -0.027 ±0.008 | -0.094 ±0.009 | 0.055 ±0.010 | 0.311 ±0.014 | 0.366 ±0.014 | 0.284 ±0.010 | 0.053 | 58.3 | 0.50 | 0.81 | undecided |
+| basis=cast cap=0.1 | -0.026 ±0.008 | -0.092 ±0.009 | 0.053 ±0.010 | 0.312 ±0.014 | 0.365 ±0.014 | 0.286 ±0.010 | 0.088 | 46.8 | 0.50 | 0.81 | undecided |
+| basis=cast cap=0.2 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| basis=cast cap=0.3 | -0.028 ±0.008 | -0.092 ±0.008 | 0.049 ±0.010 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| basis=roll cap=0.05 | -0.027 ±0.008 | -0.091 ±0.009 | 0.051 ±0.010 | 0.312 ±0.014 | 0.363 ±0.014 | 0.285 ±0.010 | 0.098 | 44.0 | 0.50 | 0.81 | undecided |
+| basis=roll cap=0.1 | -0.027 ±0.008 | -0.091 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| basis=roll cap=0.2 | -0.027 ±0.008 | -0.092 ±0.008 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| basis=roll cap=0.3 | -0.027 ±0.008 | -0.091 ±0.009 | 0.051 ±0.009 | 0.314 ±0.014 | 0.365 ±0.014 | 0.287 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+
+## E4 appeal attraction beta (alpha=1.5, cap=.2, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| beta=0.0 | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| beta=1.0 | -0.029 ±0.008 | -0.091 ±0.009 | 0.048 ±0.009 | 0.314 ±0.014 | 0.363 ±0.014 | 0.286 ±0.011 | 0.106 | 42.3 | 0.51 | 0.81 | undecided |
+| beta=3.0 | -0.028 ±0.007 | -0.092 ±0.008 | 0.050 ±0.009 | 0.315 ±0.014 | 0.365 ±0.014 | 0.287 ±0.011 | 0.110 | 41.1 | 0.50 | 0.81 | undecided |
+
+### E4 / beta=0.0
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.313 ±0.014 | 0.428 ±0.013 | 0.731 | 0.555 ±0.019 | 0.250 ±0.022 | 0.603 ±0.006 | 0.323 ±0.015 | 0.022 ±0.003 |
+| HEAD | 0.496 ±0.008 | 0.181 ±0.013 | 2.736 | 0.826 ±0.018 | 0.545 ±0.019 | 0.609 ±0.006 | 0.503 ±0.008 | 0.008 ±0.001 |
+| WTA | 0.363 ±0.014 | 0.443 ±0.014 | 0.820 | 0.587 ±0.019 | 0.259 ±0.022 | 0.598 ±0.006 | 0.368 ±0.015 | 0.022 ±0.003 |
+| UNI | 0.286 ±0.010 | 0.336 ±0.014 | 0.850 | 0.671 ±0.023 | 0.219 ±0.021 | 0.668 ±0.006 | 0.293 ±0.012 | 0.020 ±0.003 |
+
+UNI-DIRECT: dPS -0.027 ±0.008, dMT -0.092 ±0.009; WTA-DIRECT: dPS 0.050 ±0.010, dMT 0.015 ±0.008; UNI-WTA: dPS -0.078 ±0.011, dMT -0.107 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.23 ±0.02 | 0.29 ±0.03 | 0.05 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.36 ±0.03 | 0.29 ±0.02 |
+| 0.4 | 0.35 ±0.03 | 0.59 ±0.02 | 0.37 ±0.03 | 0.36 ±0.03 |
+| 0.5 | 0.36 ±0.03 | 0.61 ±0.03 | 0.39 ±0.03 | 0.36 ±0.02 |
+| 0.66 | 0.33 ±0.03 | 0.54 ±0.02 | 0.40 ±0.03 | 0.35 ±0.03 |
+
+### E4 / beta=1.0
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.314 ±0.014 | 0.427 ±0.013 | 0.737 | 0.558 ±0.019 | 0.249 ±0.021 | 0.604 ±0.006 | 0.322 ±0.014 | 0.021 ±0.003 |
+| HEAD | 0.502 ±0.008 | 0.178 ±0.014 | 2.827 | 0.831 ±0.017 | 0.553 ±0.020 | 0.610 ±0.007 | 0.508 ±0.008 | 0.008 ±0.001 |
+| WTA | 0.363 ±0.014 | 0.442 ±0.014 | 0.821 | 0.587 ±0.019 | 0.259 ±0.022 | 0.598 ±0.006 | 0.368 ±0.015 | 0.022 ±0.003 |
+| UNI | 0.286 ±0.011 | 0.336 ±0.014 | 0.851 | 0.672 ±0.023 | 0.218 ±0.020 | 0.668 ±0.005 | 0.292 ±0.012 | 0.019 ±0.003 |
+
+UNI-DIRECT: dPS -0.029 ±0.008, dMT -0.091 ±0.009; WTA-DIRECT: dPS 0.048 ±0.009, dMT 0.015 ±0.007; UNI-WTA: dPS -0.077 ±0.011, dMT -0.106 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.24 ±0.01 | 0.28 ±0.03 | 0.05 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.36 ±0.03 | 0.29 ±0.02 |
+| 0.4 | 0.36 ±0.03 | 0.60 ±0.02 | 0.38 ±0.03 | 0.36 ±0.03 |
+| 0.5 | 0.37 ±0.03 | 0.63 ±0.03 | 0.39 ±0.03 | 0.36 ±0.03 |
+| 0.66 | 0.33 ±0.03 | 0.55 ±0.02 | 0.40 ±0.03 | 0.34 ±0.03 |
+
+### E4 / beta=3.0
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.315 ±0.014 | 0.426 ±0.012 | 0.738 | 0.561 ±0.019 | 0.250 ±0.021 | 0.605 ±0.006 | 0.322 ±0.015 | 0.021 ±0.003 |
+| HEAD | 0.502 ±0.008 | 0.177 ±0.013 | 2.833 | 0.836 ±0.017 | 0.550 ±0.020 | 0.611 ±0.007 | 0.507 ±0.009 | 0.007 ±0.001 |
+| WTA | 0.365 ±0.014 | 0.441 ±0.013 | 0.828 | 0.588 ±0.019 | 0.261 ±0.021 | 0.599 ±0.006 | 0.370 ±0.015 | 0.024 ±0.003 |
+| UNI | 0.287 ±0.011 | 0.334 ±0.013 | 0.857 | 0.675 ±0.023 | 0.222 ±0.020 | 0.668 ±0.006 | 0.294 ±0.012 | 0.020 ±0.003 |
+
+UNI-DIRECT: dPS -0.028 ±0.007, dMT -0.092 ±0.008; WTA-DIRECT: dPS 0.050 ±0.009, dMT 0.014 ±0.007; UNI-WTA: dPS -0.078 ±0.011, dMT -0.106 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.23 ±0.02 | 0.29 ±0.03 | 0.05 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.36 ±0.03 | 0.29 ±0.02 |
+| 0.4 | 0.36 ±0.03 | 0.60 ±0.03 | 0.38 ±0.03 | 0.36 ±0.03 |
+| 0.5 | 0.37 ±0.03 | 0.63 ±0.03 | 0.40 ±0.03 | 0.37 ±0.02 |
+| 0.66 | 0.33 ±0.03 | 0.55 ±0.02 | 0.39 ±0.03 | 0.34 ±0.03 |
+
+## E5 robustness to assumed parameters (no delegation, strategic, faction 20)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| users appeal b=.4 | -0.025 ±0.010 | -0.101 ±0.008 | 0.057 ±0.009 | 0.281 ±0.013 | 0.338 ±0.014 | 0.256 ±0.011 | 0.021 | 48.0 | 0.00 | 0.00 | fails |
+| users appeal b=.9 (default) | -0.050 ±0.008 | -0.077 ±0.009 | 0.037 ±0.009 | 0.323 ±0.013 | 0.360 ±0.013 | 0.274 ±0.011 | 0.022 | 48.5 | 0.00 | 0.00 | undecided |
+| users appeal b=1.4 | -0.067 ±0.007 | -0.063 ±0.009 | 0.021 ±0.009 | 0.347 ±0.012 | 0.368 ±0.013 | 0.280 ±0.011 | 0.023 | 49.7 | 0.00 | 0.00 | undecided |
+| users turnout .05 | -0.051 ±0.008 | -0.057 ±0.008 | 0.017 ±0.009 | 0.325 ±0.012 | 0.341 ±0.013 | 0.274 ±0.011 | 0.030 | 34.3 | 0.00 | 0.00 | undecided |
+| users turnout .30 | -0.036 ±0.009 | -0.077 ±0.008 | 0.042 ±0.010 | 0.314 ±0.014 | 0.356 ±0.014 | 0.279 ±0.012 | 0.010 | 104.3 | 0.00 | 0.00 | undecided |
+| minds shared s=.3 | -0.056 ±0.008 | -0.079 ±0.009 | 0.027 ±0.009 | 0.322 ±0.013 | 0.349 ±0.012 | 0.266 ±0.011 | 0.022 | 48.5 | 0.00 | 0.00 | undecided |
+| minds shared s=1.5 | -0.043 ±0.009 | -0.074 ±0.008 | 0.045 ±0.008 | 0.322 ±0.013 | 0.367 ±0.013 | 0.279 ±0.011 | 0.022 | 48.5 | 0.00 | 0.00 | undecided |
+
+### E5 / users appeal b=.4
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.281 ±0.013 | 0.406 ±0.012 | 0.691 | 0.529 ±0.016 | 0.228 ±0.018 | 0.612 ±0.006 | 0.284 ±0.014 | 0.028 ±0.004 |
+| HEAD | 0.409 ±0.010 | 0.095 ±0.012 | 4.295 | 0.788 ±0.018 | 0.472 ±0.022 | 0.632 ±0.006 | 0.420 ±0.011 | 0.010 ±0.002 |
+| WTA | 0.338 ±0.014 | 0.388 ±0.011 | 0.869 | 0.585 ±0.020 | 0.241 ±0.018 | 0.617 ±0.006 | 0.337 ±0.015 | 0.028 ±0.004 |
+| UNI | 0.256 ±0.011 | 0.305 ±0.011 | 0.840 | 0.652 ±0.018 | 0.202 ±0.021 | 0.679 ±0.005 | 0.261 ±0.012 | 0.027 ±0.004 |
+
+UNI-DIRECT: dPS -0.025 ±0.010, dMT -0.101 ±0.008; WTA-DIRECT: dPS 0.057 ±0.009, dMT -0.017 ±0.008; UNI-WTA: dPS -0.082 ±0.010, dMT -0.084 ±0.009; claim (UNI vs DIRECT): **fails**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.17 ±0.02 | 0.14 ±0.01 | 0.24 ±0.02 | 0.04 ±0.01 |
+| 0.3 | 0.26 ±0.03 | 0.37 ±0.03 | 0.34 ±0.03 | 0.25 ±0.03 |
+| 0.4 | 0.32 ±0.03 | 0.52 ±0.03 | 0.36 ±0.02 | 0.33 ±0.02 |
+| 0.5 | 0.33 ±0.03 | 0.57 ±0.02 | 0.36 ±0.02 | 0.34 ±0.02 |
+| 0.66 | 0.30 ±0.03 | 0.43 ±0.02 | 0.38 ±0.03 | 0.31 ±0.03 |
+
+### E5 / users appeal b=.9 (default)
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.323 ±0.013 | 0.381 ±0.013 | 0.849 | 0.588 ±0.019 | 0.264 ±0.021 | 0.612 ±0.007 | 0.326 ±0.013 | 0.028 ±0.004 |
+| HEAD | 0.524 ±0.010 | 0.048 ±0.013 | n/a | 0.890 ±0.015 | 0.621 ±0.019 | 0.615 ±0.006 | 0.537 ±0.010 | 0.010 ±0.001 |
+| WTA | 0.360 ±0.013 | 0.381 ±0.012 | 0.944 | 0.612 ±0.019 | 0.250 ±0.018 | 0.618 ±0.006 | 0.362 ±0.014 | 0.028 ±0.004 |
+| UNI | 0.274 ±0.011 | 0.304 ±0.011 | 0.900 | 0.665 ±0.019 | 0.210 ±0.021 | 0.676 ±0.005 | 0.279 ±0.012 | 0.028 ±0.004 |
+
+UNI-DIRECT: dPS -0.050 ±0.008, dMT -0.077 ±0.009; WTA-DIRECT: dPS 0.037 ±0.009, dMT 0.000 ±0.010; UNI-WTA: dPS -0.086 ±0.009, dMT -0.077 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.19 ±0.02 | 0.23 ±0.02 | 0.28 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.36 ±0.03 | 0.27 ±0.03 |
+| 0.4 | 0.37 ±0.03 | 0.64 ±0.02 | 0.37 ±0.03 | 0.35 ±0.02 |
+| 0.5 | 0.40 ±0.02 | 0.70 ±0.02 | 0.38 ±0.02 | 0.36 ±0.02 |
+| 0.66 | 0.34 ±0.03 | 0.56 ±0.02 | 0.39 ±0.03 | 0.32 ±0.03 |
+
+### E5 / users appeal b=1.4
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.347 ±0.012 | 0.364 ±0.013 | 0.953 | 0.615 ±0.019 | 0.287 ±0.021 | 0.613 ±0.006 | 0.353 ±0.012 | 0.028 ±0.004 |
+| HEAD | 0.590 ±0.011 | 0.013 ±0.013 | n/a | 0.940 ±0.012 | 0.715 ±0.019 | 0.603 ±0.006 | 0.600 ±0.011 | 0.008 ±0.001 |
+| WTA | 0.368 ±0.013 | 0.375 ±0.012 | 0.981 | 0.616 ±0.020 | 0.252 ±0.018 | 0.618 ±0.006 | 0.370 ±0.014 | 0.027 ±0.004 |
+| UNI | 0.280 ±0.011 | 0.301 ±0.012 | 0.930 | 0.664 ±0.019 | 0.211 ±0.020 | 0.675 ±0.005 | 0.285 ±0.012 | 0.029 ±0.004 |
+
+UNI-DIRECT: dPS -0.067 ±0.007, dMT -0.063 ±0.009; WTA-DIRECT: dPS 0.021 ±0.009, dMT 0.010 ±0.009; UNI-WTA: dPS -0.088 ±0.009, dMT -0.074 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.20 ±0.02 | 0.29 ±0.02 | 0.29 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.33 ±0.03 | 0.57 ±0.02 | 0.37 ±0.03 | 0.28 ±0.03 |
+| 0.4 | 0.39 ±0.02 | 0.70 ±0.02 | 0.38 ±0.03 | 0.35 ±0.02 |
+| 0.5 | 0.43 ±0.02 | 0.76 ±0.02 | 0.38 ±0.02 | 0.37 ±0.02 |
+| 0.66 | 0.37 ±0.03 | 0.62 ±0.02 | 0.40 ±0.03 | 0.33 ±0.03 |
+
+### E5 / users turnout .05
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.325 ±0.012 | 0.350 ±0.013 | 0.928 | 0.605 ±0.020 | 0.271 ±0.020 | 0.619 ±0.006 | 0.331 ±0.012 | 0.028 ±0.004 |
+| HEAD | 0.497 ±0.012 | 0.001 ±0.014 | n/a | 0.891 ±0.017 | 0.604 ±0.019 | 0.622 ±0.006 | 0.509 ±0.012 | 0.012 ±0.002 |
+| WTA | 0.341 ±0.013 | 0.345 ±0.012 | 0.990 | 0.617 ±0.020 | 0.251 ±0.017 | 0.629 ±0.006 | 0.343 ±0.013 | 0.028 ±0.004 |
+| UNI | 0.274 ±0.011 | 0.293 ±0.012 | 0.934 | 0.665 ±0.019 | 0.212 ±0.020 | 0.678 ±0.005 | 0.279 ±0.011 | 0.029 ±0.004 |
+
+UNI-DIRECT: dPS -0.051 ±0.008, dMT -0.057 ±0.008; WTA-DIRECT: dPS 0.017 ±0.009, dMT -0.005 ±0.009; UNI-WTA: dPS -0.068 ±0.009, dMT -0.052 ±0.010; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.17 ±0.02 | 0.21 ±0.02 | 0.22 ±0.01 | 0.06 ±0.01 |
+| 0.3 | 0.31 ±0.03 | 0.46 ±0.03 | 0.36 ±0.03 | 0.28 ±0.03 |
+| 0.4 | 0.38 ±0.02 | 0.61 ±0.02 | 0.37 ±0.03 | 0.34 ±0.02 |
+| 0.5 | 0.41 ±0.03 | 0.69 ±0.02 | 0.37 ±0.02 | 0.35 ±0.02 |
+| 0.66 | 0.35 ±0.03 | 0.52 ±0.03 | 0.39 ±0.03 | 0.33 ±0.03 |
+
+### E5 / users turnout .30
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.314 ±0.014 | 0.424 ±0.012 | 0.740 | 0.563 ±0.019 | 0.247 ±0.022 | 0.606 ±0.007 | 0.315 ±0.013 | 0.028 ±0.004 |
+| HEAD | 0.550 ±0.007 | 0.140 ±0.014 | 3.937 | 0.868 ±0.016 | 0.638 ±0.020 | 0.598 ±0.007 | 0.556 ±0.007 | 0.005 ±0.001 |
+| WTA | 0.356 ±0.014 | 0.442 ±0.011 | 0.805 | 0.584 ±0.020 | 0.238 ±0.018 | 0.604 ±0.006 | 0.356 ±0.014 | 0.025 ±0.004 |
+| UNI | 0.279 ±0.012 | 0.347 ±0.011 | 0.803 | 0.652 ±0.019 | 0.206 ±0.021 | 0.667 ±0.005 | 0.285 ±0.013 | 0.025 ±0.003 |
+
+UNI-DIRECT: dPS -0.036 ±0.009, dMT -0.077 ±0.008; WTA-DIRECT: dPS 0.042 ±0.010, dMT 0.018 ±0.008; UNI-WTA: dPS -0.078 ±0.011, dMT -0.095 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.30 ±0.02 | 0.30 ±0.02 | 0.07 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.54 ±0.03 | 0.35 ±0.03 | 0.28 ±0.03 |
+| 0.4 | 0.35 ±0.03 | 0.63 ±0.02 | 0.37 ±0.03 | 0.34 ±0.02 |
+| 0.5 | 0.37 ±0.03 | 0.67 ±0.02 | 0.37 ±0.02 | 0.35 ±0.02 |
+| 0.66 | 0.33 ±0.03 | 0.59 ±0.02 | 0.39 ±0.03 | 0.33 ±0.03 |
+
+### E5 / minds shared s=.3
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.322 ±0.013 | 0.427 ±0.012 | 0.755 | 0.564 ±0.021 | 0.225 ±0.019 | 0.610 ±0.006 | 0.326 ±0.013 | 0.028 ±0.004 |
+| HEAD | 0.524 ±0.011 | 0.069 ±0.014 | 7.608 | 0.882 ±0.017 | 0.601 ±0.021 | 0.616 ±0.006 | 0.537 ±0.010 | 0.010 ±0.001 |
+| WTA | 0.349 ±0.012 | 0.446 ±0.012 | 0.782 | 0.571 ±0.022 | 0.195 ±0.017 | 0.612 ±0.006 | 0.350 ±0.013 | 0.028 ±0.004 |
+| UNI | 0.266 ±0.011 | 0.348 ±0.010 | 0.766 | 0.644 ±0.022 | 0.181 ±0.020 | 0.674 ±0.005 | 0.271 ±0.011 | 0.028 ±0.004 |
+
+UNI-DIRECT: dPS -0.056 ±0.008, dMT -0.079 ±0.009; WTA-DIRECT: dPS 0.027 ±0.009, dMT 0.019 ±0.009; UNI-WTA: dPS -0.082 ±0.009, dMT -0.098 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.21 ±0.02 | 0.23 ±0.01 | 0.32 ±0.02 | 0.06 ±0.01 |
+| 0.3 | 0.31 ±0.03 | 0.49 ±0.03 | 0.34 ±0.03 | 0.26 ±0.03 |
+| 0.4 | 0.37 ±0.02 | 0.64 ±0.03 | 0.36 ±0.03 | 0.34 ±0.02 |
+| 0.5 | 0.37 ±0.03 | 0.70 ±0.02 | 0.36 ±0.03 | 0.35 ±0.02 |
+| 0.66 | 0.34 ±0.03 | 0.55 ±0.02 | 0.37 ±0.03 | 0.31 ±0.03 |
+
+### E5 / minds shared s=1.5
+
+| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |
+|---|---|---|---|---|---|---|---|---|
+| DIRECT | 0.322 ±0.013 | 0.343 ±0.012 | 0.940 | 0.607 ±0.017 | 0.290 ±0.021 | 0.615 ±0.006 | 0.327 ±0.012 | 0.029 ±0.004 |
+| HEAD | 0.524 ±0.011 | 0.032 ±0.013 | n/a | 0.896 ±0.015 | 0.636 ±0.018 | 0.614 ±0.006 | 0.536 ±0.011 | 0.010 ±0.001 |
+| WTA | 0.367 ±0.013 | 0.335 ±0.012 | 1.096 | 0.645 ±0.018 | 0.288 ±0.020 | 0.623 ±0.007 | 0.369 ±0.014 | 0.028 ±0.004 |
+| UNI | 0.279 ±0.011 | 0.268 ±0.011 | 1.041 | 0.694 ±0.020 | 0.237 ±0.023 | 0.681 ±0.005 | 0.285 ±0.011 | 0.027 ±0.004 |
+
+UNI-DIRECT: dPS -0.043 ±0.009, dMT -0.074 ±0.008; WTA-DIRECT: dPS 0.045 ±0.008, dMT -0.008 ±0.011; UNI-WTA: dPS -0.088 ±0.010, dMT -0.067 ±0.009; claim (UNI vs DIRECT): **undecided**
+
+PS by category threshold:
+
+| q | DIRECT | HEAD | WTA | UNI |
+|---|---|---|---|---|
+| 0.15 | 0.18 ±0.02 | 0.23 ±0.02 | 0.26 ±0.02 | 0.05 ±0.01 |
+| 0.3 | 0.30 ±0.03 | 0.49 ±0.03 | 0.37 ±0.03 | 0.27 ±0.03 |
+| 0.4 | 0.37 ±0.02 | 0.64 ±0.03 | 0.39 ±0.02 | 0.35 ±0.02 |
+| 0.5 | 0.40 ±0.02 | 0.70 ±0.02 | 0.40 ±0.02 | 0.37 ±0.02 |
+| 0.66 | 0.34 ±0.03 | 0.56 ±0.02 | 0.41 ±0.03 | 0.33 ±0.03 |
+
+## E5b same, with delegation (alpha=1.5, cap=.2)
+
+| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+| users appeal b=.4 | -0.023 ±0.007 | -0.105 ±0.008 | 0.050 ±0.009 | 0.283 ±0.014 | 0.332 ±0.014 | 0.260 ±0.011 | 0.099 | 44.4 | 0.50 | 0.78 | fails |
+| users appeal b=.9 (default) | -0.027 ±0.008 | -0.092 ±0.009 | 0.050 ±0.010 | 0.313 ±0.014 | 0.363 ±0.014 | 0.286 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| users appeal b=1.4 | -0.036 ±0.008 | -0.085 ±0.008 | 0.045 ±0.009 | 0.335 ±0.014 | 0.381 ±0.013 | 0.300 ±0.011 | 0.098 | 45.5 | 0.55 | 0.83 | undecided |
+| users turnout .05 | -0.028 ±0.007 | -0.096 ±0.009 | 0.053 ±0.009 | 0.313 ±0.013 | 0.366 ±0.014 | 0.285 ±0.011 | 0.109 | 37.1 | 0.62 | 0.84 | undecided |
+| users turnout .30 | -0.026 ±0.008 | -0.079 ±0.009 | 0.044 ±0.010 | 0.315 ±0.014 | 0.359 ±0.014 | 0.288 ±0.012 | 0.070 | 80.9 | 0.30 | 0.80 | undecided |
+| minds shared s=.3 | -0.035 ±0.008 | -0.093 ±0.008 | 0.041 ±0.009 | 0.312 ±0.013 | 0.353 ±0.013 | 0.277 ±0.011 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+| minds shared s=1.5 | -0.020 ±0.008 | -0.081 ±0.008 | 0.055 ±0.010 | 0.312 ±0.013 | 0.367 ±0.014 | 0.292 ±0.010 | 0.103 | 43.1 | 0.50 | 0.81 | undecided |
+
+## Claim tally over all cells (SPEC section 8)
+
+supported 0, fails 2, undecided 233, n/a 0
+
+Failing cells:
+
+- E5 users appeal b=.4
+- E5b users appeal b=.4
+

docs/research/2026-11-05-estate-rule-sim/run.py

@@ -0,0 +1,256 @@
+"""One-command rerun: python3 -I run.py [--quick] [--out results.md] [--jobs N]
+
+Writes a deterministic markdown results file (no timestamps). See SPEC.md section 7.
+"""
+import argparse
+import os
+import sys
+from multiprocessing import Pool
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import estatesim as E  # noqa: E402
+
+REPS, MOTIONS = 40, 500
+QUICK_REPS, QUICK_MOTIONS = 4, 100
+METRICS = ("PS", "MT", "BPP", "GBR", "PASS")
+PAIRS = (("UNI", "DIRECT"), ("WTA", "DIRECT"), ("UNI", "WTA"))
+
+
+def _job(args):
+    cfg, rep = args
+    return E.run_replicate(cfg, rep)
+
+
+def evaluate(cfg_list, reps, jobs):
+    """Run every (cfg, rep); returns list of per-config result dicts."""
+    tasks = [(cfg, r) for cfg in cfg_list for r in range(reps)]
+    if jobs > 1:
+        with Pool(jobs) as p:
+            out = p.map(_job, tasks, chunksize=2)
+    else:
+        out = [_job(t) for t in tasks]
+    res = []
+    for k, cfg in enumerate(cfg_list):
+        chunk = out[k * reps:(k + 1) * reps]
+        res.append(summarize(cfg, chunk))
+    return res
+
+
+def summarize(cfg, chunk):
+    recs = [c[0] for c in chunk]
+    per = {}   # rule -> metric -> list over reps (strategic) ; plus sincere PS
+    for ri, rule in enumerate(E.RULES):
+        per[rule] = {m: [] for m in METRICS}
+        per[rule]["PS_sincere"] = []
+        per[rule]["FLIP"] = []
+        for rec in recs:
+            mm = E.rep_metrics(rec, ri)
+            for m in METRICS:
+                per[rule][m].append(mm[m])
+            per[rule]["PS_sincere"].append(E.rep_metrics(rec, ri, which=4)["PS"])
+            per[rule]["FLIP"].append(sum(1 for r in rec if r[3][ri] != r[4][ri]) / len(rec))
+    percat = {}
+    for ci in range(len(E.CATS)):
+        for ri, rule in enumerate(E.RULES):
+            percat[(ci, rule)] = [E.rep_metrics(rec, ri, cats={ci})["PS"] for rec in recs]
+    paired = {}
+    for a, b in PAIRS:
+        for m in ("PS", "MT"):
+            paired[(a, b, m)] = E.mean_ci([x - y for x, y in zip(per[a][m], per[b][m])])
+    conc = {}
+    allc = [c for ch in chunk for c in ch[1]]
+    for k, nm in enumerate(("top_share", "gini", "n_eff", "weight")):
+        conc[nm] = sum(c[k] for c in allc) / len(allc)
+    dl = sum(c[5] for c in allc)
+    conc["eff_top"] = sum(c[7] for c in allc) / len(allc)             # top share counting copiers to the voter they copied
+    conc["eff_neff"] = sum(c[8] for c in allc) / len(allc)
+    conc["copied"] = sum(c[9] for c in allc) / dl if dl else 0.0       # copiers as a share of delegated votes
+    conc["eff_top_reps"] = [sum(c[7] for c in ch[1]) / len(ch[1]) for ch in chunk]   # per replicate, for paired contrasts
+    conc["live"] = sum(c[6] for c in allc) / len(allc)                # share of delegators still holding an edge
+    conc["uncast"] = sum(c[4] for c in allc) / dl if dl else 0.0       # share of delegated votes left uncast
+    return dict(cfg=cfg, per=per, percat=percat, paired=paired, conc=conc,
+                verdict=E.verdict(paired[("UNI", "DIRECT", "PS")], paired[("UNI", "DIRECT", "MT")]))
+
+
+def f(x, ci=None, d=3):
+    if x != x:
+        return "n/a"
+    s = f"{x:.{d}f}"
+    return s + (f" ±{ci:.{d}f}" if ci is not None and ci == ci else "")
+
+
+def rule_table(r):
+    lines = ["| rule | PS | MT | PI=PS/MT | BPP | GBR | pass | PS sincere | outcome flipped by strategy |",
+             "|---|---|---|---|---|---|---|---|---|"]
+    for rule in E.RULES:
+        p = r["per"][rule]
+        ps, mt = E.mean_ci(p["PS"]), E.mean_ci(p["MT"])
+        pi = ps[0] / mt[0] if mt[0] >= .05 else float("nan")
+        lines.append(f"| {rule} | {f(*ps)} | {f(*mt)} | {f(pi)} | {f(*E.mean_ci(p['BPP']))} | "
+                     f"{f(*E.mean_ci(p['GBR']))} | {f(*E.mean_ci(p['PASS']))} | "
+                     f"{f(*E.mean_ci(p['PS_sincere']))} | {f(*E.mean_ci(p['FLIP']))} |")
+    return lines
+
+
+def pair_line(r):
+    pr = r["paired"]
+    parts = []
+    for a, b in PAIRS:
+        parts.append(f"{a}-{b}: dPS {f(*pr[(a, b, 'PS')])}, dMT {f(*pr[(a, b, 'MT')])}")
+    return "; ".join(parts) + f"; claim (UNI vs DIRECT): **{r['verdict']}**"
+
+
+def percat_table(r):
+    lines = ["| q | " + " | ".join(E.RULES) + " |", "|---|" + "---|" * len(E.RULES)]
+    for ci, q in enumerate(E.CATS):
+        lines.append(f"| {q} | " + " | ".join(f(*E.mean_ci(r["percat"][(ci, ru)]), d=2) for ru in E.RULES) + " |")
+    return lines
+
+
+def experiments(quick):
+    X = []
+    if quick:
+        alphas, caps, facs, betas = (0.0, 1.5), (.2, None), (0, 20), (0.0, 3.0)
+    else:
+        alphas, caps, facs, betas = (0.0, .5, 1.0, 1.5, 2.5, 4.0), (.10, .15, .20, .25, .30, None), (0, 10, 20, 40), (0.0, 1.0, 3.0)
+    X.append(("E1 baseline (sincere, no delegation, no faction)",
+              [(w, E.Config(weights=w)) for w in ("equal", "minds-heavy")], True))
+    X.append(("E2 strategic agents (rho=.25) and Users faction size",
+              [(f"faction={k}", E.Config(rho=.25, faction=k)) for k in facs], True))
+    X.append(("E3 delegation: concentration alpha x per-delegate cap (depth 3, strategic, faction 20)",
+              [(f"alpha={a} cap={c}", E.Config(delegation=True, alpha=a, cap=c, rho=.25, faction=20))
+               for a in alphas for c in caps], False))
+    X.append(("E3b same grid, no faction, sincere (isolates delegation)",
+              [(f"alpha={a} cap={c}", E.Config(delegation=True, alpha=a, cap=c))
+               for a in alphas for c in caps], False))
+    depths = (2, None) if quick else (2, 3, 4, 6, None)
+    X.append(("E3c transitive depth x delegate turnout x peer-delegation share (alpha=1.5, cap=.2, strategic, faction 20)",
+              [(f"depth={d} dturn={t} peer={p}", E.Config(delegation=True, alpha=1.5, depth=d, dturn=t, peer=p, cap=.2, rho=.25, faction=20))
+               for d in depths for t in (.95, .3) for p in (.3, .8)], False))
+    copies = (0.0, 1.0) if quick else (0.0, .5, 1.0)
+    X.append(("E3f copy-the-ballot: alpha x cap x copy rate (depth 3, strategic, faction 20)",
+              [(f"alpha={a} cap={c} copy={p}", E.Config(delegation=True, alpha=a, cap=c, copy=p, rho=.25, faction=20))
+               for a in alphas for p in copies for c in caps], "copy"))
+    X.append(("E3e revocation renewal: how fast revoked delegators re-delegate (alpha=1.5, cap=.2, depth 3, strategic, faction 20)",
+              [(f"renew={n}", E.Config(delegation=True, alpha=1.5, cap=.2, renew=n, rho=.25, faction=20))
+               for n in (0.0, .02, .1, .5)], False))
+    X.append(("E3d cap basis: share of cast weight vs share of roll (alpha=1.5, depth=3, strategic, faction 20)",
+              [(f"basis={bs} cap={c}", E.Config(delegation=True, alpha=1.5, cap=c, cap_basis=bs, rho=.25, faction=20))
+               for bs in ("cast", "roll") for c in ((.1, .2) if quick else (.05, .1, .2, .3))], False))
+    X.append(("E4 appeal attraction beta (alpha=1.5, cap=.2, strategic, faction 20)",
+              [(f"beta={b}", E.Config(delegation=True, alpha=1.5, cap=.2, beta=b, rho=.25, faction=20))
+               for b in betas], True))
+    rob = [("users appeal b=.4", (("Users", "b", .4),)), ("users appeal b=.9 (default)", ()),
+           ("users appeal b=1.4", (("Users", "b", 1.4),)),
+           ("users turnout .05", (("Users", "turnout", .05),)), ("users turnout .30", (("Users", "turnout", .30),)),
+           ("minds shared s=.3", (("Minds", "s", .3),)), ("minds shared s=1.5", (("Minds", "s", 1.5),))]
+    X.append(("E5 robustness to assumed parameters (no delegation, strategic, faction 20)",
+              [(nm, E.Config(rho=.25, faction=20, overrides=ov)) for nm, ov in rob], True))
+    X.append(("E5b same, with delegation (alpha=1.5, cap=.2)",
+              [(nm, E.Config(delegation=True, alpha=1.5, cap=.2, rho=.25, faction=20, overrides=ov))
+               for nm, ov in rob], False))
+    return X
+
+
+def copy_tables(cells, res):
+    """Pivots for E3f: rows (alpha, copy), columns cap. Effective = copiers counted to the voter they copied."""
+    caps = []
+    for _, c in cells:
+        if c.cap not in caps:
+            caps.append(c.cap)
+    rows = {}
+    for (_, c), r in zip(cells, res):
+        rows.setdefault((c.alpha, c.copy), {})[c.cap] = r
+    hdr = ["| alpha | copy | " + " | ".join("none" if c is None else f"{c}" for c in caps) + " |",
+           "|---|---|" + "---|" * len(caps)]
+    L = []
+    for title, get in (
+            ("Users top-holder share, formal (copiers are separate weight-1 ballots)", lambda r: f"{r['conc']['top_share']:.3f}"),
+            ("Users top-holder share, effective (copiers counted to the voter they copied)", lambda r: f"{r['conc']['eff_top']:.3f}"),
+            ("Users n_eff, effective", lambda r: f"{r['conc']['eff_neff']:.1f}"),
+            ("copiers as a share of delegated votes", lambda r: f"{r['conc']['copied']:.2f}"),
+            ("dPS UNI-DIRECT", lambda r: f(*r["paired"][("UNI", "DIRECT", "PS")])),
+            ("PS UNI", lambda r: f(*E.mean_ci(r["per"]["UNI"]["PS"])))):
+        L += [f"**{title}**", ""] + hdr
+        for (a, p), byc in rows.items():
+            L.append(f"| {a} | {p} | " + " | ".join(get(byc[c]) for c in caps) + " |")
+        L.append("")
+    return L
+
+
+CAP_MATERIAL = .01   # effective top-share drop below this is not called a reduction (SPEC section 5b)
+
+
+def copy_reading(cells, res):
+    """SPEC section 5b falsifier, computed: does the tightest cap reduce effective Users top-holder share?
+
+    Paired by replicate (same population draw): top share at cap c minus top share with no cap.
+    "reduces" iff the 95% interval lies entirely below -CAP_MATERIAL; "does not reduce" otherwise.
+    """
+    by = {(c.alpha, c.copy, c.cap): r for (_, c), r in zip(cells, res)}
+    tight = min(c.cap for _, c in cells if c.cap is not None)
+    tally = {}
+    L = [f"**Does the cap reduce effective concentration? Effective Users top-holder share at cap {tight} minus no cap, "
+         f"paired by replicate; 'reduces' iff the 95% interval is entirely below -{CAP_MATERIAL}.**", "",
+         "| alpha | copy | effective top share, cap - none | verdict | formal top share, cap - none |", "|---|---|---|---|---|"]
+    for (a, p, c) in by:
+        if c != tight:
+            continue
+        r, n = by[(a, p, c)], by[(a, p, None)]
+        d = E.mean_ci([x - y for x, y in zip(r["conc"]["eff_top_reps"], n["conc"]["eff_top_reps"])])
+        v = "reduces" if d[0] + d[1] < -CAP_MATERIAL else "does not reduce"
+        L.append(f"| {a} | {p} | {f(*d)} | {v} | {r['conc']['top_share'] - n['conc']['top_share']:+.3f} |")
+        tally.setdefault(p, []).append(v == "reduces")
+    L += ["", "Reading, computed from the rows above: the cap reduces effective concentration in " + "; ".join(
+        f"{sum(t)} of {len(t)} alpha values at copy rate {p}" for p, t in tally.items()) +
+        ". Where it reduces at copy 0 and not at copy 1, the formal top share falls (last column) while the weight follows "
+        "the same voters through their copiers, so the cap moves weight from the holder's ledger to its followers' ballots "
+        "without changing whose ballot it is."]
+    return L + [""]
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    ap.add_argument("--out", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "results.md"))
+    ap.add_argument("--jobs", type=int, default=min(os.cpu_count() or 1, 16))
+    a = ap.parse_args(argv)
+    reps, motions = (QUICK_REPS, QUICK_MOTIONS) if a.quick else (REPS, MOTIONS)
+    L = [f"# Estate-rule sim results ({'quick' if a.quick else 'full'}: {reps} replicates x {motions} motions per cell)",
+         "", "Generated by `run.py`; spec in SPEC.md. +/- is a 95% interval over replicates. PS populism sensitivity, "
+         "MT merit tracking, BPP bad-popular pass rate, GBR good-unpopular block rate (SPEC section 3).", ""]
+    tally = {"supported": 0, "fails": 0, "undecided": 0, "n/a": 0}
+    failing = []
+    for title, cells, detail in experiments(a.quick):
+        cfgs = [E.Config(**{**c.__dict__, "motions": motions}) for _, c in cells]
+        res = evaluate(cfgs, reps, a.jobs)
+        L += [f"## {title}", ""]
+        summ = ["| cell | dPS UNI-DIRECT | dMT UNI-DIRECT | dPS WTA-DIRECT | PS DIRECT | PS WTA | PS UNI | Users top share | Users n_eff | uncast | live edges | claim |",
+                "|---|---|---|---|---|---|---|---|---|---|---|---|"]
+        for (name, _), r in zip(cells, res):
+            tally[r["verdict"]] += 1
+            if r["verdict"] == "fails":
+                failing.append(f"{title.split(' ')[0]} {name}")
+            pr, pe = r["paired"], r["per"]
+            summ.append(f"| {name} | {f(*pr[('UNI','DIRECT','PS')])} | {f(*pr[('UNI','DIRECT','MT')])} | "
+                        f"{f(*pr[('WTA','DIRECT','PS')])} | {f(*E.mean_ci(pe['DIRECT']['PS']))} | "
+                        f"{f(*E.mean_ci(pe['WTA']['PS']))} | {f(*E.mean_ci(pe['UNI']['PS']))} | "
+                        f"{r['conc']['top_share']:.3f} | {r['conc']['n_eff']:.1f} | {r['conc']['uncast']:.2f} | {r['conc']['live']:.2f} | {r['verdict']} |")
+        L += summ + [""]
+        if detail == "copy":
+            L += copy_reading(cells, res) + copy_tables(cells, res)
+        elif detail:
+            for (name, _), r in zip(cells, res):
+                L += [f"### {title.split(' ')[0]} / {name}", ""] + rule_table(r) + [""]
+                L += [pair_line(r), "", "PS by category threshold:", ""] + percat_table(r) + [""]
+    L += ["## Claim tally over all cells (SPEC section 8)", "",
+          f"supported {tally['supported']}, fails {tally['fails']}, undecided {tally['undecided']}, n/a {tally['n/a']}", ""]
+    if failing:
+        L += ["Failing cells:", ""] + [f"- {x}" for x in failing] + [""]
+    with open(a.out, "w") as fh:
+        fh.write("\n".join(L) + "\n")
+    print(f"wrote {a.out}: {tally}")
+
+
+if __name__ == "__main__":
+    main()

docs/research/2026-11-05-estate-rule-sim/test_estatesim.py

@@ -0,0 +1,377 @@
+"""python3 -I test_estatesim.py"""
+import os
+import random
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import estatesim as E  # noqa: E402
+
+W = (25, 25, 25, 25)
+
+
+def est(cap=None, name="Users"):
+    cfg = E.Config(delegation=True, cap=cap)
+    e = E.Estate(name, cfg, random.Random(1))
+    e.target = [None] * e.n
+    e.scope = [None] * e.n
+    return e
+
+
+def edge(e, i, t, scope=(0, 1, 2, 3, 4)):
+    e.target[i], e.scope[i] = t, frozenset(scope)
+
+
+class RuleTests(unittest.TestCase):
+    def test_threshold_tie_passes(self):
+        # one live estate, exactly q For
+        self.assertTrue(E.passes("DIRECT", [.5, 0, 0, 0], [.5, 0, 0, 0], W, .5))
+        self.assertFalse(E.passes("DIRECT", [.4, 0, 0, 0], [.6, 0, 0, 0], W, .5))
+
+    def test_wta_tie_drops_estate_out(self):
+        # Minds tie drops out; Members 3-1 For decides alone
+        self.assertTrue(E.passes("WTA", [4, 3, 0, 0], [4, 1, 0, 0], W, .66))
+        # tied estate alone casts nothing: nothing passes
+        self.assertFalse(E.passes("WTA", [4, 0, 0, 0], [4, 0, 0, 0], W, .15))
+
+    def test_uni_uses_category_threshold_inside_estate(self):
+        # 40% For inside each estate: UNI at q=.3 casts all For, WTA casts all Against
+        F, A = [4, 4, 4, 4], [6, 6, 6, 6]
+        self.assertTrue(E.passes("UNI", F, A, W, .3))
+        self.assertFalse(E.passes("WTA", F, A, W, .3))
+        self.assertFalse(E.passes("UNI", F, A, W, .5))
+
+    def test_uni_two_of_four_blocs_at_half(self):
+        self.assertTrue(E.passes("UNI", [9, 9, 1, 1], [1, 1, 9, 9], W, .5))   # 50% of weight
+        self.assertFalse(E.passes("UNI", [9, 1, 1, 1], [1, 9, 9, 9], W, .5))
+
+    def test_renormalizes_over_live_estates(self):
+        self.assertTrue(E.passes("UNI", [5, 0, 0, 0], [1, 0, 0, 0], W, .66))   # empty estates not counted
+        self.assertFalse(E.passes("DIRECT", [0] * 4, [0] * 4, W, .15))
+
+    def test_head_ignores_estate_weights(self):
+        self.assertTrue(E.passes("HEAD", [1, 0, 9, 0], [9, 0, 0, 0], W, .5))
+        self.assertFalse(E.passes("DIRECT", [1, 0, 9, 0], [9, 0, 0, 0], W, .6))
+
+
+class DelegationTests(unittest.TestCase):
+    def setUp(self):
+        self.e = est()
+        self.n = self.e.n
+
+    def voting(self, ids):
+        v = [False] * self.n
+        for i in ids:
+            v[i] = True
+        return v
+
+    def test_delegated_weight_goes_to_delegate(self):
+        edge(self.e, 1, 0)
+        w, dest = self.e.resolve(0, self.voting([0]))
+        self.assertEqual(w, {0: 2.0})
+        self.assertEqual(dest, {1: 0})
+
+    def test_direct_vote_overrides_delegation(self):
+        edge(self.e, 1, 0)
+        w, dest = self.e.resolve(0, self.voting([0, 1]))
+        self.assertEqual(w, {0: 1.0, 1: 1.0})
+        self.assertEqual(dest, {})
+
+    def test_scope_out_of_category_is_ignored(self):
+        edge(self.e, 1, 0, scope=(2,))
+        w, _ = self.e.resolve(0, self.voting([0]))
+        self.assertEqual(w, {0: 1.0})
+        w, _ = self.e.resolve(2, self.voting([0]))
+        self.assertEqual(w, {0: 2.0})
+
+    def chain_estate(self, depth, n_links):
+        e = est()
+        e.cfg = E.Config(delegation=True, depth=depth)
+        for k in range(1, n_links + 1):                   # n_links -> ... -> 1 -> 0
+            edge(e, k, k - 1)
+        return e
+
+    def test_chain_within_depth_reaches_holder(self):
+        e = self.chain_estate(2, 2)                        # 2 -> 1 -> 0, two edges
+        w, dest = e.resolve(0, self.voting([0]))
+        self.assertEqual(w, {0: 3.0})
+        self.assertEqual(dest, {1: 0, 2: 0})
+
+    def test_over_depth_is_uncast_not_redirected(self):
+        e = self.chain_estate(2, 3)                        # 3 needs three edges
+        w, dest = e.resolve(0, self.voting([0]))
+        self.assertNotIn(3, dest)
+        self.assertEqual(w, {0: 3.0})
+        self.assertEqual(e.last_uncast, 1)
+
+    def test_unlimited_depth_follows_long_chain(self):
+        e = self.chain_estate(None, 9)
+        w, _ = e.resolve(0, self.voting([0]))
+        self.assertEqual(w, {0: 10.0})
+
+    def test_intermediate_direct_vote_terminates_chain(self):
+        e = self.chain_estate(None, 3)                     # 3 -> 2 -> 1 -> 0 ; 1 votes itself
+        w, dest = e.resolve(0, self.voting([0, 1]))
+        self.assertEqual(w, {0: 1.0, 1: 3.0})
+        self.assertEqual(dest, {2: 1, 3: 1})
+
+    def test_loop_is_uncast(self):
+        e = est()
+        e.cfg = E.Config(delegation=True, depth=None)
+        edge(e, 1, 2)
+        edge(e, 2, 1)
+        edge(e, 3, 1)                                      # feeds the loop: also void
+        w, dest = e.resolve(0, self.voting([0]))
+        self.assertEqual((w, dest), ({0: 1.0}, {}))
+        self.assertEqual(e.last_uncast, 3)
+
+    def test_scope_is_overlap_of_all_links(self):
+        e = est()
+        e.cfg = E.Config(delegation=True, depth=None)
+        edge(e, 2, 1, scope=(0, 1))                        # 2 -> 1 -> 0
+        edge(e, 1, 0, scope=(1, 2))
+        for cat, expect in ((0, {}), (1, {2: 0, 1: 0}), (2, {1: 0})):
+            _, dest = e.resolve(cat, self.voting([0]))
+            self.assertEqual(dest, expect, cat)
+
+    def test_dead_end_is_uncast(self):
+        e = est()
+        edge(e, 2, 1)                                      # 1 does not vote and delegates nowhere
+        w, dest = e.resolve(0, self.voting([0]))
+        self.assertEqual((w, dest), ({0: 1.0}, {}))
+        self.assertEqual(e.last_uncast, 1)
+
+    def test_cap_voids_excess_and_floors_at_one(self):
+        e = est(cap=.5)                                    # cast weight 12, cap 6
+        for i in range(1, 11):
+            edge(e, i, 0)
+        voting = [i in (0, 20) for i in range(e.n)]
+        w, _ = e.resolve(0, voting)
+        self.assertEqual(w, {0: 6.0, 20: 1.0})             # 11 delegated+own capped to 6, excess void
+        e = est(cap=.001, name="Patrons")                  # below one voter: floor is 1
+        w, _ = e.resolve(0, [i == 0 for i in range(e.n)])
+        self.assertEqual(w, {0: 1.0})
+
+    def test_cap_applies_to_final_holder_not_each_link(self):
+        e = est(cap=.4)
+        e.cfg = E.Config(delegation=True, depth=None, cap=.4)
+        for i in range(1, 6):
+            edge(e, i, 6)                                  # five delegators to 6 ...
+        edge(e, 6, 0)                                      # ... who delegates to 0
+        w, _ = e.resolve(0, self.voting([0, 20]))          # 0 holds 1+6, cast 8 -> cap 3.2
+        self.assertEqual(w[0], 3.2)
+
+    def test_cap_basis_roll(self):
+        e = est()
+        e.cfg = E.Config(delegation=True, cap=.1, cap_basis="roll")   # 300 * .1 = 30
+        for i in range(1, 41):
+            edge(e, i, 0)
+        w, _ = e.resolve(0, self.voting([0]))
+        self.assertEqual(w, {0: 30.0})
+
+    def contradicting_estate(self):
+        e = est()
+        edge(e, 1, 0)
+        e.turn[0], e.kap[0], e.a[0], e.b[0], e.sig[0] = 1.0, 0.0, 1.0, 0.0, .01
+        e.turn[1], e.kap[1], e.a[1], e.b[1], e.sig[1] = 0.0, 0.0, -3.0, 0.0, .01
+        return e
+
+    def test_contradiction_forces_direct_vote_then_revokes_at_second_strike(self):
+        e = self.contradicting_estate()
+        dt = e.motion(0, 1.0, 0.0, random.Random(1), 0.0)
+        self.assertIn(1, [t for t, _, _ in dt["holders"]])          # overrides this motion
+        self.assertEqual(e.target[1], 0)                            # one strike: still delegated
+        self.assertEqual(e.strikes[1], 1)
+        e.motion(0, 1.0, 0.0, random.Random(2), 0.0)
+        self.assertIsNone(e.target[1])                              # second strike revokes
+        e.motion(0, 1.0, 0.0, random.Random(3), 0.0)
+        self.assertEqual(e.strikes[1], 2)                           # revoked: no further strikes while unrenewed
+        self.assertIsNone(e.target[1])
+
+    def test_renewal_restores_an_edge_with_fresh_strikes(self):
+        e = self.contradicting_estate()
+        e.cfg = E.Config(delegation=True, renew=1.0, peer=0.0)
+        e.pool, e.delegators = ([0], [1.0]), [1]
+        e.target[1], e.revoked, e.strikes[1] = None, [1], 2
+        e.motion(0, 0.0, 0.0, random.Random(1), 0.0)
+        self.assertEqual((e.target[1], e.strikes[1], e.revoked), (0, 0, []))
+
+    def test_direct_voters_never_forwarded(self):
+        edge(self.e, 1, 0)
+        w, _ = self.e.resolve(0, self.voting([0, 1]))
+        self.assertNotIn(2, w)
+        self.assertEqual(sum(w.values()), 2.0)
+
+
+class CopyTests(unittest.TestCase):
+    """SPEC section 5b: copy-the-ballot."""
+
+    def setup(self, copy, cap=.2, followers=10):
+        e = est(cap)
+        e.cfg = E.Config(delegation=True, cap=cap, copy=copy)
+        for k in range(1, followers + 1):
+            edge(e, k, 0)
+        voting = [False] * e.n
+        voting[0] = True
+        sb = [0] * e.n
+        sb[0] = 1
+        w, dest = e.resolve(0, voting)
+        return e, voting, sb, w, dest
+
+    def test_off_by_default_draws_nothing(self):
+        e, v, sb, w, dest = self.setup(0.0)
+        state = e.rng.getstate()
+        self.assertIsNone(e.copy_step(0, v, sb, dest))
+        self.assertEqual(e.rng.getstate(), state)
+        self.assertEqual(w[0], 2.2)                        # cap .2 of 11 cast weight; excess void
+
+    def test_full_copying_evades_the_cap(self):
+        e, v, sb, w, dest = self.setup(1.0)
+        copiers, w2, _ = e.copy_step(0, v, sb, dest)
+        self.assertEqual(len(copiers), 10)
+        self.assertEqual(w2[0], 1.0)                        # the holder keeps only its own vote
+        self.assertTrue(all(w2[c] == 1.0 and sb[c] == 1 and v[c] for c in copiers))
+        self.assertEqual(sum(w2.values()), 11.0)            # nothing voided
+        self.assertEqual(e.effective(w2, copiers), {0: 11.0})
+
+    def test_copiers_cast_the_holders_ballot_not_their_own(self):
+        e, v, sb, w, dest = self.setup(1.0)
+        sb[0] = -1
+        copiers, w2, _ = e.copy_step(0, v, sb, dest)
+        self.assertTrue(all(sb[c] == -1 for c in copiers))
+
+    def test_no_copying_under_a_holder_within_the_cap(self):
+        e, v, sb, w, dest = self.setup(1.0, cap=1.0, followers=3)   # cap 4.0 of 4 cast, raw 4.0: not over
+        self.assertIsNone(e.copy_step(0, v, sb, dest))
+
+    def test_no_copying_without_a_cap(self):
+        e, v, sb, w, dest = self.setup(1.0, cap=None)
+        self.assertIsNone(e.copy_step(0, v, sb, dest))
+
+    def test_partial_copy_rate_is_between(self):
+        e, v, sb, w, dest = self.setup(.5, followers=40)
+        copiers, w2, _ = e.copy_step(0, v, sb, dest)
+        self.assertTrue(8 <= len(copiers) <= 32)
+        self.assertEqual(e.effective(w2, copiers)[0], sum(w2.values()) - sum(
+            x for t, x in w2.items() if t != 0 and t not in copiers))
+
+    def test_followers_of_a_copier_are_counted_through_it(self):
+        e, v, sb, w, dest = self.setup(1.0, followers=10)
+        edge(e, 20, 5)                                      # 20 delegates to 5, who delegates to 0
+        w, dest = e.resolve(0, v)
+        copiers, w2, dest2 = e.copy_step(0, v, sb, dest)
+        self.assertEqual(sum(w2.values()), 12.0)            # all twelve ballots are cast, none void
+        self.assertEqual(e.effective(w2, copiers), {0: 12.0})
+
+    def test_copying_run_is_deterministic_and_leaves_paired_draws(self):
+        cfg = E.Config(delegation=True, alpha=4.0, cap=.1, copy=.5, rho=.25, faction=10, motions=30)
+        self.assertEqual(E.run_replicate(cfg, 2), E.run_replicate(cfg, 2))
+        a, _ = E.run_replicate(E.Config(motions=30), 2)
+        b, _ = E.run_replicate(cfg, 2)
+        self.assertEqual([r[:3] for r in a], [r[:3] for r in b])
+
+    def test_copy_off_matches_the_no_copy_config_byte_for_byte(self):
+        base = dict(delegation=True, alpha=2.5, cap=.15, rho=.25, faction=20, motions=40)
+        self.assertEqual(E.run_replicate(E.Config(**base), 4), E.run_replicate(E.Config(copy=0.0, **base), 4))
+
+    def test_effective_concentration_exceeds_capped_formal_weight(self):
+        cfg = E.Config(delegation=True, alpha=4.0, cap=.1, copy=1.0, motions=60)
+        _, conc = E.run_replicate(cfg, 0)
+        self.assertGreater(sum(c[7] for c in conc), sum(c[0] for c in conc))
+        self.assertGreater(sum(c[9] for c in conc), 0)
+        _, conc = E.run_replicate(E.Config(delegation=True, alpha=4.0, cap=.1, motions=60), 0)
+        self.assertEqual(sum(c[9] for c in conc), 0)
+        self.assertAlmostEqual(sum(c[7] for c in conc), sum(c[0] for c in conc))
+
+
+class StrategyTests(unittest.TestCase):
+    def test_deviation_never_makes_agent_worse_off(self):
+        rng = random.Random(3)
+        for _ in range(300):
+            q = rng.choice(E.CATS)
+            F = [float(rng.randrange(0, 6)) for _ in range(4)]
+            A = [float(rng.randrange(0, 6)) for _ in range(4)]
+            rule = rng.choice(E.RULES)
+            e = rng.randrange(4)
+            for b in (1, -1):
+                F0, A0 = list(F), list(A)
+                E._move(F0, A0, e, 0, b, 1.0)
+                pref = b == 1
+                ag = dict(e=e, w=1.0, sincere=b, cur=b, pref=pref, opts=[b] + [x for x in (1, -1, 0) if x != b])
+                sincere_ok = E.passes(rule, F0, A0, W, q) == pref
+                E.strategize(rule, W, q, F0, A0, [ag], 7)
+                if sincere_ok:
+                    self.assertTrue(E.passes(rule, F0, A0, W, q) == pref)
+
+    def test_strategic_joiner_joins_only_when_pivotal(self):
+        F, A = [3.0, 0, 0, 0], [3.0, 0, 0, 0]               # tie, q=.5 passes under UNI already
+        ag = dict(e=0, w=1.0, sincere=0, cur=0, pref=True, opts=[0, 1])
+        E.strategize("UNI", W, .5, F, A, [ag], 1)
+        self.assertEqual(ag["cur"], 0)                      # already passes: stays home
+        F, A = [2.0, 0, 0, 0], [3.0, 0, 0, 0]               # 40% For: fails at .5, joining makes 3/6
+        ag = dict(e=0, w=1.0, sincere=0, cur=0, pref=True, opts=[0, 1])
+        E.strategize("UNI", W, .5, F, A, [ag], 1)
+        self.assertEqual(ag["cur"], 1)
+
+    def test_faction_votes_agenda_regardless_of_preference(self):
+        cfg = E.Config(faction=20)
+        e = E.Estate("Users", cfg, random.Random(2))
+        self.assertEqual(sum(e.faction), 20)
+        dt = e.motion(0, -2.0, 2.0, random.Random(9), 0.0)  # d - m > 0: faction votes For
+        ballots = {t: b for t, b, _ in dt["holders"]}
+        for i in range(e.n):
+            if e.faction[i]:
+                self.assertEqual(ballots[i], 1)
+
+
+class HarnessTests(unittest.TestCase):
+    CFG = E.Config(delegation=True, alpha=1.5, cap=.2, rho=.25, faction=10, motions=30)
+
+    def test_deterministic(self):
+        self.assertEqual(E.run_replicate(self.CFG, 3), E.run_replicate(self.CFG, 3))
+
+    def test_draws_paired_across_rules_and_configs(self):
+        a, _ = E.run_replicate(E.Config(motions=30), 1)
+        b, _ = E.run_replicate(self.CFG, 1)
+        self.assertEqual([r[:3] for r in a], [r[:3] for r in b])    # same (category, merit, appeal)
+
+    def test_sincere_run_has_no_strategy_flips(self):
+        r, _ = E.run_replicate(E.Config(motions=60), 0)
+        self.assertTrue(all(x[3] == x[4] for x in r))
+
+    def test_metrics_on_known_outcomes(self):
+        # outcome == (d > 0): PS = 1, MT ~ 0 (independent), BPP = 1, GBR = 1 - 0 = 1
+        rng = random.Random(1)
+        recs = []
+        for _ in range(4000):
+            m, d = rng.gauss(0, 1), rng.gauss(0, 1)
+            recs.append((0, m, d, (d > 0,) * 4, (d > 0,) * 4))
+        mm = E.rep_metrics(recs, 0)
+        self.assertEqual(mm["PS"], 1.0)
+        self.assertLess(abs(mm["MT"]), .1)
+        self.assertEqual(mm["BPP"], 1.0)
+        self.assertEqual(mm["GBR"], 1.0)
+        # outcome == (m > 0): PS ~ 0, MT = 1, BPP = 0, GBR = 0
+        recs = [(0, m, d, (m > 0,) * 4, (m > 0,) * 4) for (_, m, d, _, _) in recs]
+        mm = E.rep_metrics(recs, 0)
+        self.assertEqual(mm["MT"], 1.0)
+        self.assertEqual(mm["BPP"], 0.0)
+        self.assertEqual(mm["GBR"], 0.0)
+        self.assertLess(abs(mm["PS"]), .1)
+
+    def test_concentration(self):
+        top, gini, neff, tot = E.concentration([1, 1, 1, 1])
+        self.assertEqual((top, round(gini, 9), neff, tot), (.25, 0.0, 4.0, 4))
+        top, gini, neff, _ = E.concentration([1, 1, 1, 97])
+        self.assertGreater(gini, .7)
+        self.assertLess(neff, 1.1)
+
+    def test_verdict_rules(self):
+        self.assertEqual(E.verdict((-.1, .02), (0.0, .02)), "supported")
+        self.assertEqual(E.verdict((.1, .02), (0.0, .02)), "fails")
+        self.assertEqual(E.verdict((-.1, .02), (-.12, .02)), "fails")     # dampened by not working
+        self.assertEqual(E.verdict((-.01, .05), (0.0, .02)), "undecided")
+
+
+if __name__ == "__main__":
+    unittest.main()