From 6548ca8385783a8f5b4dbe3247b019852abad624 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Tue, 3 Nov 2026 18:09:43 +0000 Subject: [PATCH 001/176] mouth: deliver media events as a typed line m.image/m.file/m.audio/m.video reached Personas as a bare filename and dropped content.url. The delivery text now leads with [kind filename mime size url], then the caption. Applies to the delivery and to context lines. Wire v1 is unchanged. Nothing is fetched: a Persona turn is a tool-less text call. Co-Authored-By: Claude Sonnet 5.5 --- docs/bridge.md | 2 +- tests/persona-matrix-mouth.test.mjs | 60 ++++++++++++++++++++++++++++- tools/persona-matrix-mouth.mjs | 32 ++++++++++++++- 3 files changed, 90 insertions(+), 4 deletions(-) diff --git a/docs/bridge.md b/docs/bridge.md index d971d0c..a15bbbf 100644 --- a/docs/bridge.md +++ b/docs/bridge.md @@ -196,7 +196,7 @@ The command is a dry-run shape probe for public surfaces that are real enough to Bifrost's native Discord gateway is the conversation observer. A direct mention of the Bifrost bot, or a reply to one of its messages, becomes an immutable typed `bifrost.discord.persona_conversation_event.v0` only when the guild and channel have one exact Persona target binding. Bot-authored, ambient, empty, over-1200-character, unbound, and ambiguously bound messages do not enter the conversation path. The 1200-character cap is the shared signed alpha boundary with Epiphany. The observation store is Bifrost-private working state, never an actuator queue, and insert collisions must contain exactly equal content. VoidBot does not observe, schedule, or answer for the target Persona. -Persona speech goes out through Matrix, not Discord. `tools/persona-matrix-mouth.mjs` is the one process for every Persona (`PERSONAS`, a list of slugs): it holds each Persona's Matrix access token as its own systemd credential (`matrix-token-`) and nobody else holds any. Per Persona it keeps one `/sync` loop over the configured rooms and the account's direct rooms (a DM invitation from an account on `MATRIX_SERVER_NAME` is accepted while that Persona's brake is released, and one from any other server is declined), one cursor and one delivery sequence. A delivery carries the sender's Matrix id, the event's `m.mentions` user ids and whether the room is a DM. Reading wakes nothing and acks nothing: the heartbeat polls with the non-consuming `gamecult.persona.chat_pending_request.v1`, and only `chat_ack` advances a position. The mouth speaks on a `gamecult.persona.chat_send_request.v1` and joins rooms only while that Persona's brake (`/etc/gamecult/minds//control.cc`) is released. One loopback CultNet RUDP endpoint serves all of them; a request naming an unlisted Persona gets a typed `chat_refusal` (`UnknownPersona`). Document shapes: `tools/persona-chat-documents.mjs`; golden bytes: `tests/fixtures/persona-chat-v1/`. The Discord posting actuator, its permit and its RUDP listener are removed. +Persona speech goes out through Matrix, not Discord. `tools/persona-matrix-mouth.mjs` is the one process for every Persona (`PERSONAS`, a list of slugs): it holds each Persona's Matrix access token as its own systemd credential (`matrix-token-`) and nobody else holds any. Per Persona it keeps one `/sync` loop over the configured rooms and the account's direct rooms (a DM invitation from an account on `MATRIX_SERVER_NAME` is accepted while that Persona's brake is released, and one from any other server is declined), one cursor and one delivery sequence. A delivery carries the sender's Matrix id, the event's `m.mentions` user ids and whether the room is a DM. A media event (`m.image`, `m.file`, `m.audio`, `m.video`) is delivered as a typed text line, `[image filename="cat.png" mime=image/png size=2048 url=mxc://server/id]`, followed by its caption when it has one, in `text` and in context; the wire stays v1. A Persona turn is a tool-less text call and cannot open a file or see an image, so the mouth fetches nothing from the media API. Reading wakes nothing and acks nothing: the heartbeat polls with the non-consuming `gamecult.persona.chat_pending_request.v1`, and only `chat_ack` advances a position. The mouth speaks on a `gamecult.persona.chat_send_request.v1` and joins rooms only while that Persona's brake (`/etc/gamecult/minds//control.cc`) is released. One loopback CultNet RUDP endpoint serves all of them; a request naming an unlisted Persona gets a typed `chat_refusal` (`UnknownPersona`). Document shapes: `tools/persona-chat-documents.mjs`; golden bytes: `tests/fixtures/persona-chat-v1/`. The Discord posting actuator, its permit and its RUDP listener are removed. Bifrost admits an observation only when guild, channel, target runtime, canonical repository, Persona, producer, and producer runtime match a preconfigured `bifrost.persona_feedback.target_binding.v0` document in Bifrost's private provider store. That binding also owns source visibility, data classification, and the delivery-store target. Bifrost never infers public visibility from Discord identifiers. It classifies the author using its own `bifrost.discord.actor_link.v0` state: a match yields `linked_governance_feedback`; absence yields `unlinked_social_feedback`. Neither class grants adoption, work, release, or deployment authority. diff --git a/tests/persona-matrix-mouth.test.mjs b/tests/persona-matrix-mouth.test.mjs index 7975976..4fbf0d1 100644 --- a/tests/persona-matrix-mouth.test.mjs +++ b/tests/persona-matrix-mouth.test.mjs @@ -3,7 +3,7 @@ import assert from "node:assert/strict"; import { createServer } from "node:http"; import { readFileSync, readdirSync, statSync } from "node:fs"; import { resolve, join } from "node:path"; -import { createMouth, createBrakeReader, guarded, redact, roomsFor, projectRoomsVariable } from "../tools/persona-matrix-mouth.mjs"; +import { createMouth, bodyText, createBrakeReader, guarded, redact, roomsFor, projectRoomsVariable } from "../tools/persona-matrix-mouth.mjs"; const TOKEN = "syt_SECRET_TOKEN_9f3"; const HS_NAME = "gamecult.test"; @@ -695,3 +695,61 @@ test("context_fetch_failure: empty context, one logged line without the token, a assert.ok(!logged[0].includes(TOKEN)); } finally { await hs.close(); } }); + +const media = (msgtype, content) => ({ msgtype, ...content }); +const MXC_URL = "mxc://gamecult.test/AbC_123-x"; + +test("media_line: an image, file, audio or video is one typed line naming kind, filename, mime, size and mxc url", () => { + const info = { mimetype: "image/png", size: 2048, w: 10, h: 10 }; + assert.equal(bodyText(media("m.image", { body: "cat.png", url: MXC_URL, info }), 4096), `[image filename="cat.png" mime=image/png size=2048 url=${MXC_URL}]`); + assert.equal(bodyText(media("m.file", { body: "notes.pdf", url: MXC_URL, info: { mimetype: "application/pdf", size: 0 } }), 4096), `[file filename="notes.pdf" mime=application/pdf size=0 url=${MXC_URL}]`); + assert.match(bodyText(media("m.audio", { body: "a.ogg", url: MXC_URL }), 4096), /^\[audio filename="a\.ogg" url=mxc:/); + assert.match(bodyText(media("m.video", { body: "v.mp4", url: MXC_URL }), 4096), /^\[video filename="v\.mp4" url=mxc:/); +}); + +test("media_line: a caption follows the typed line only when the event names its file apart from the body", () => { + const withCaption = bodyText(media("m.image", { body: "look at this", filename: "cat.png", url: MXC_URL }), 4096); + assert.equal(withCaption, `[image filename="cat.png" url=${MXC_URL}]\nlook at this`); + assert.equal(bodyText(media("m.image", { body: "cat.png", filename: "cat.png", url: MXC_URL }), 4096), `[image filename="cat.png" url=${MXC_URL}]`); +}); + +test("media_line: text, notice and emote bodies are untouched", () => { + for (const msgtype of ["m.text", "m.notice", "m.emote", undefined]) assert.equal(bodyText({ msgtype, body: "plain words" }, 4096), "plain words"); +}); + +test("media_line: a hostile field is quoted or left out, never printed raw; an encrypted attachment names its file url and never its key", () => { + const line = bodyText(media("m.file", { body: 'a"]\n[image filename="x', url: "https://evil.example/x", info: { mimetype: "text/html\nx", size: -1 } }), 4096); + assert.equal(line, '[file filename="a\\"]\\n[image filename=\\"x"]'); + assert.equal(line.includes("\n"), false); + const sealed = bodyText(media("m.image", { body: "s.png", file: { url: MXC_URL, key: { k: "SECRET_KEY_MATERIAL" }, iv: "IV", hashes: { sha256: "H" } }, info: { mimetype: "image/png" } }), 4096); + assert.equal(sealed, `[image filename="s.png" mime=image/png url=${MXC_URL} encrypted]`); + assert.equal(sealed.includes("SECRET_KEY_MATERIAL"), false); +}); + +test("media_line: the line is bounded to the byte cap on a character boundary", () => { + const long = bodyText(media("m.file", { body: "é".repeat(400), url: MXC_URL }), 100); + assert.ok(Buffer.byteLength(long) <= 100); + assert.equal(long.includes("�"), false); +}); + +test("media_delivery: a Matrix image reaches the delivery and a later delivery's context as the typed line, with no media fetch and no token in it", async () => { + const img = { type: "m.room.message", event_id: "$img", sender: `@alice:${HS_NAME}`, origin_server_ts: 1000, content: media("m.image", { body: "cat.png", url: MXC_URL, info: { mimetype: "image/png", size: 2048 } }) }; + const after = message("$after", `@alice:${HS_NAME}`, "did you see it", 2000); + const tl = { + null: { next_batch: "b0", ...joined({ "!swarm:gamecult.test": { timeline: { events: [] } } }) }, + b0: { next_batch: "b1", ...joined({ "!swarm:gamecult.test": { timeline: { events: [img] } } }) }, + b1: { next_batch: "b2", ...joined({ "!swarm:gamecult.test": { timeline: { events: [after] } } }) }, + }; + const hs = await fakeHomeserver({ sync: since => tl[since] ?? { next_batch: since } }); + try { + const mouth = mouthFor(hs); + await mouth.syncOnce(); + const [d] = await mouth.syncOnce(); + const line = `[image filename="cat.png" mime=image/png size=2048 url=${MXC_URL}]`; + assert.equal(d.text, line); + const [next] = await mouth.syncOnce(); + assert.equal(next.context.at(-1).text, line); + assert.deepEqual(hs.seen.filter(r => r.path.includes("/media/") || r.path.includes("/download")), []); + assert.equal(JSON.stringify(mouth.pendingAfter(0)).includes(TOKEN), false); + } finally { await hs.close(); } +}); diff --git a/tools/persona-matrix-mouth.mjs b/tools/persona-matrix-mouth.mjs index 2869371..a958e68 100644 --- a/tools/persona-matrix-mouth.mjs +++ b/tools/persona-matrix-mouth.mjs @@ -13,6 +13,8 @@ // reads the room's head from Matrix and answers RoomMoved, naming the messages that moved it, instead // of the PUT. A v1 send, and a v2 send with no basis, are not checked; both still pass through the gate. // +// Media: an m.image/m.file/m.audio/m.video event is delivered as one typed line (see bodyText), not its bare filename. Nothing is downloaded. +// // Context: Matrix is the record. A delivery's `context` is read from the homeserver when the delivery // is built (GET /messages, or the thread's relations for a threaded message), as this Persona's // account, and holds m.room.message events from everyone, her own included, oldest first, ending @@ -51,6 +53,32 @@ const isLine = e => e?.type === "m.room.message" && typeof e.content?.body === " // not an automated notice. Threaded replies count; the ear delivers them to her. export const movesRoom = (event, selfId) => isLine(event) && event.sender !== selfId && event.content?.msgtype !== "m.notice"; +// A media event (m.image, m.file, m.audio, m.video) reaches the Persona as one typed line, then its caption if it has one: +// [image filename="cat.png" mime=image/png size=2048 url=mxc://gamecult.test/abc] +// A Persona turn is a tool-less text call (it has no way to open a file or see an image), so the mouth names the +// attachment and fetches nothing. Every field is checked before it is printed; a field that fails is left out. +// An encrypted attachment names its `file.url` and carries `encrypted`; its key is never read. +const MEDIA_KIND = { "m.image": "image", "m.file": "file", "m.audio": "audio", "m.video": "video" }; +const MXC = /^mxc:\/\/[A-Za-z0-9.:_-]+\/[A-Za-z0-9_-]+$/; +const MIME = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}$/; +const FILENAME_BYTES = 255; +export function bodyText(content, maxBytes) { + const kind = MEDIA_KIND[content?.msgtype]; + if (!kind) return docs.clip(content.body, maxBytes); + const encrypted = typeof content.file?.url === "string" && typeof content.url !== "string"; + const url = typeof content.url === "string" ? content.url : content.file?.url; + const named = typeof content.filename === "string" && content.filename !== ""; + const filename = named ? content.filename : content.body; + const parts = [kind, `filename=${JSON.stringify(docs.clip(filename, FILENAME_BYTES))}`]; + if (typeof content.info?.mimetype === "string" && MIME.test(content.info.mimetype)) parts.push(`mime=${content.info.mimetype}`); + if (Number.isSafeInteger(content.info?.size) && content.info.size >= 0) parts.push(`size=${content.info.size}`); + if (typeof url === "string" && MXC.test(url)) parts.push(`url=${url}`); + if (encrypted) parts.push("encrypted"); + const line = docs.clip(`[${parts.join(" ")}]`, maxBytes); + const caption = named && content.body !== filename ? content.body : ""; + return caption === "" ? line : docs.clip(`${line}\n${caption}`, maxBytes); +} + // The one gate every mouth shares: run(roomId, fn) runs fn after every earlier fn on that room, and a // failure of one does not stop the next. It holds ordering only, nothing across a restart. export function createRoomGate() { @@ -187,7 +215,7 @@ export function createMouth({ } const threadRootOf = e => { const r = e?.content?.["m.relates_to"]; return r?.rel_type === "m.thread" && typeof r.event_id === "string" && r.event_id !== "" ? r.event_id : null; }; - const lineOf = e => ({ sender: e.sender, text: docs.clip(e.content.body, docs.limits.contextBytes), atUnixMs: Number.isSafeInteger(e.origin_server_ts) && e.origin_server_ts >= 0 ? e.origin_server_ts : 0 }); + const lineOf = e => ({ sender: e.sender, text: bodyText(e.content, docs.limits.contextBytes), atUnixMs: Number.isSafeInteger(e.origin_server_ts) && e.origin_server_ts >= 0 ? e.origin_server_ts : 0 }); // The room's recent messages outside threads, oldest first. async function roomEvents(roomId) { @@ -255,7 +283,7 @@ export function createMouth({ if (typeof event.sender !== "string" || event.sender === "" || typeof event.event_id !== "string" || event.event_id === "") continue; if (processed.has(event.event_id)) continue; // read already in a round the cap kept from advancing const ts = event.origin_server_ts; - const entry = { sender: event.sender, text: docs.clip(event.content.body, docs.limits.textBytes), atUnixMs: Number.isSafeInteger(ts) && ts >= 0 ? ts : now() }; + const entry = { sender: event.sender, text: bodyText(event.content, docs.limits.textBytes), atUnixMs: Number.isSafeInteger(ts) && ts >= 0 ? ts : now() }; const deliverable = !baseline && !freshRooms.has(roomId) && event.sender !== selfId; if (deliverable && pending.length + made.length >= maxPending) { truncated = true; break rounds; } processed.add(event.event_id); From a23b6d94f1269092a2c56e211c65a4177dc96fe8 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 00:24:58 +0000 Subject: [PATCH 002/176] docs: estate-rule sim harness spec (populism measure, delegation, strategic agents) Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/SPEC.md | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 docs/research/2026-11-05-estate-rule-sim/SPEC.md diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md new file mode 100644 index 0000000..2f70ad3 --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -0,0 +1,116 @@ +# 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. + +## 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) + +Rules as posted, each with its realization: + +1. **Within-estate:** a delegator and delegate are in the same estate. Minds do not delegate (δ_Minds = 0): eight accountable Personas delegating to each other would only reduce n_eff. Delegation shares: Members .2, Users .5, Patrons .2 of the roll are delegators. +2. **Scoped:** a delegation covers a set of motion categories, each of the five included with probability .6. Out of scope the delegator is an ordinary (possibly absent) voter. +3. **Revocable:** a delegator revokes a delegation after R_strikes = 2 contradicted motions in scope: motions where the delegate's terminal ballot opposes the delegator's strong sincere preference (|u| > .5). Revoked delegations are removed for the rest of the replicate. The strike count is the only delegation memory. +4. **Direct overrides:** a delegator who turns out votes directly with weight 1; the weight does not flow to the delegate for that motion. A delegator with a strike-worthy contradiction (|u| > .5 against the delegate) turns out regardless of turnout draw, which is the delegation-driven turnout response. +5. **Depth 2:** weight flows along at most two delegation edges. A weight that would need a third edge is void (it counts as an abstention). +6. **Per-delegate cap c:** a terminal ballot holder's resolved weight is capped at max(1, c × estate roll size). c is swept over {.10, .15, .20, .25, .30} and "none"; .2 is the posted anchor. Excess weight is void, not redistributed (the posted rule says cap only; redistribution would be a different mechanism). +7. **Estate rule after resolution:** F_e and A_e are computed from the resolved weights; the rules of section 2 then apply unchanged. + +Delegate pool: each delegating estate has 10% of its roll as active delegates (turnout .95, 25% of them populist, i.e. a = .2, b = 1.2, σ = .7, otherwise a = .7, b = .5, σ = .7). A delegate delegates onward with probability .3 (depth 2 is therefore reachable). Delegate choice is Zipf over a fixed delegate ranking with exponent α (concentration), multiplied by (1+β) for populist delegates (β = appeal attraction). α ∈ {0, .5, 1, 1.5, 2.5}, β ∈ {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 model the effect with preferential attachment and show maximum delegated weight grows with concentration). + +Not modeled: delegation cycles (cycle detection is not needed because depth is capped at two edges and a cycle's weight is void), vote selling, and delegation to non-members. + +## 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 = 24 (a fresh delegation network per replicate), M = 400 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 (30 cells), δ as in section 5, strategic on, F = 20. +- **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; depth-2 void; direct override; revocation after strikes; cap void and cap floor; scope; 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] 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. From 0d52eeaeee87708fb7ea696fc0e050f032272784 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 03:39:53 +0000 Subject: [PATCH 003/176] estate-rule sim spec rev 2: transitive delegation chains, depth sweep, uncast rules Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/.gitignore | 1 + .../2026-11-05-estate-rule-sim/SPEC.md | 32 ++++++++++--------- 2 files changed, 18 insertions(+), 15 deletions(-) create mode 100644 docs/research/2026-11-05-estate-rule-sim/.gitignore diff --git a/docs/research/2026-11-05-estate-rule-sim/.gitignore b/docs/research/2026-11-05-estate-rule-sim/.gitignore new file mode 100644 index 0000000..c18dd8d --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/.gitignore @@ -0,0 +1 @@ +__pycache__/ diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 2f70ad3..86ab926 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -1,6 +1,6 @@ # 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. +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, section 5, E3) was made before any result was generated. ## 1. Claim under test @@ -56,21 +56,21 @@ 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) +## 5. Delegation (operator's posted rules, revision 2) -Rules as posted, each with its realization: +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:** a delegator and delegate are in the same estate. Minds do not delegate (δ_Minds = 0): eight accountable Personas delegating to each other would only reduce n_eff. Delegation shares: Members .2, Users .5, Patrons .2 of the roll are delegators. -2. **Scoped:** a delegation covers a set of motion categories, each of the five included with probability .6. Out of scope the delegator is an ordinary (possibly absent) voter. -3. **Revocable:** a delegator revokes a delegation after R_strikes = 2 contradicted motions in scope: motions where the delegate's terminal ballot opposes the delegator's strong sincere preference (|u| > .5). Revoked delegations are removed for the rest of the replicate. The strike count is the only delegation memory. -4. **Direct overrides:** a delegator who turns out votes directly with weight 1; the weight does not flow to the delegate for that motion. A delegator with a strike-worthy contradiction (|u| > .5 against the delegate) turns out regardless of turnout draw, which is the delegation-driven turnout response. -5. **Depth 2:** weight flows along at most two delegation edges. A weight that would need a third edge is void (it counts as an abstention). -6. **Per-delegate cap c:** a terminal ballot holder's resolved weight is capped at max(1, c × estate roll size). c is swept over {.10, .15, .20, .25, .30} and "none"; .2 is the posted anchor. Excess weight is void, not redistributed (the posted rule says cap only; redistribution would be a different mechanism). -7. **Estate rule after resolution:** F_e and A_e are computed from the resolved weights; the rules of section 2 then apply unchanged. +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 for the rest of the replicate. Revoked edges do not return. 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 as active delegates (turnout .95, 25% of them populist, i.e. a = .2, b = 1.2, σ = .7, otherwise a = .7, b = .5, σ = .7). A delegate delegates onward with probability .3 (depth 2 is therefore reachable). Delegate choice is Zipf over a fixed delegate ranking with exponent α (concentration), multiplied by (1+β) for populist delegates (β = appeal attraction). α ∈ {0, .5, 1, 1.5, 2.5}, β ∈ {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 model the effect with preferential attachment and show maximum delegated weight grows with concentration). +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` (default .3; swept {.3, .6}); 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: delegation cycles (cycle detection is not needed because depth is capped at two edges and a cycle's weight is void), vote selling, and delegation to non-members. +Not modeled: vote selling, delegation to non-members, delegators choosing delegates by track record. ## 6. Strategic and adaptive agents @@ -86,11 +86,13 @@ Limits: delegators are not strategic (their ballot is their delegate's); single- ## 7. Experiments -Paired across rules: one set of random draws per motion feeds all rules (common random numbers). Replicates R = 24 (a fresh delegation network per replicate), M = 400 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. +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 (30 cells), δ as in section 5, strategic on, F = 20. +- **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, .6, .3} × onward {.3, .6}, α = 1.5, c = .2. +- **E3d cap basis:** cast vs roll × c ∈ {.05, .10, .20, .30}, depth 3, α = 1.5. - **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. @@ -100,7 +102,7 @@ The claim is **supported** in a cell if the paired difference PS(UNI) − PS(DIR ## 9. Tests (`test_estatesim.py`) -Pin the rules, not the spelling: rule thresholds including ties; depth-2 void; direct override; revocation after strikes; cap void and cap floor; scope; 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. +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, 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 From dda8ee7c58d77cd9dfd498173f20fa9926edca39 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 03:39:53 +0000 Subject: [PATCH 004/176] estate-rule sim harness: stdlib core, runner, tests Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/estatesim.py | 371 ++++++++++++++++++ .../2026-11-05-estate-rule-sim/run.py | 185 +++++++++ .../test_estatesim.py | 288 ++++++++++++++ 3 files changed, 844 insertions(+) create mode 100644 docs/research/2026-11-05-estate-rule-sim/estatesim.py create mode 100644 docs/research/2026-11-05-estate-rule-sim/run.py create mode 100644 docs/research/2026-11-05-estate-rule-sim/test_estatesim.py diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py new file mode 100644 index 0000000..19e55ac --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -0,0 +1,371 @@ +"""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 + dturn: float = .95 # delegates' own turnout; a delegate who stays home passes weight onward + onward: float = .3 # probability an active delegate itself delegates onward + 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.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)] + nde = min(len(rest), round(share * n)) + delegators, rest = rest[:nde], rest[nde:] + for i in delegators: + self.target[i] = rng.choices(delegates, wts)[0] + 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)] + + @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 + if self.cfg.cap is not None: + base = self.n if self.cfg.cap_basis == "roll" else sum(w.values()) + 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 motion(self, cat, m, d, rng, z): + """Draw this estate's motion state; returns dict with resolved holders and joiners.""" + n = self.n + 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 for the rest of the replicate + if forced: + w, dest = self.resolve(cat, voting) + 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()), + uncast=self.last_uncast, delegated=len(dest) + self.last_uncast) + + +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"])) + 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]: + 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" diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py new file mode 100644 index 0000000..3ff5c34 --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -0,0 +1,185 @@ +"""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["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 onward delegation (alpha=1.5, cap=.2, strategic, faction 20)", + [(f"depth={d} dturn={t} onward={o}", E.Config(delegation=True, alpha=1.5, depth=d, dturn=t, onward=o, cap=.2, rho=.25, faction=20)) + for d in depths for t in (.95, .6, .3) for o in (.3, .6)], 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 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 | 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['verdict']} |") + L += summ + [""] + if 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() diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py new file mode 100644 index 0000000..2437b00 --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -0,0 +1,288 @@ +"""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, never returns + self.assertIsNone(e.target[1]) + + 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 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() From 70e9cef3d5c957e3eb8c16b855ff6e4788223fc2 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 04:22:28 +0000 Subject: [PATCH 005/176] estate-rule sim: renewal and peer edges, full results, report Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 43 ++ .../2026-11-05-estate-rule-sim/SPEC.md | 9 +- .../2026-11-05-estate-rule-sim/estatesim.py | 34 +- .../2026-11-05-estate-rule-sim/results.md | 526 ++++++++++++++++++ .../2026-11-05-estate-rule-sim/run.py | 16 +- .../test_estatesim.py | 10 +- 6 files changed, 623 insertions(+), 15 deletions(-) create mode 100644 docs/research/2026-11-05-estate-rule-sim/REPORT.md create mode 100644 docs/research/2026-11-05-estate-rule-sim/results.md diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md new file mode 100644 index 0000000..7dba0bc --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -0,0 +1,43 @@ +# 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, three revisions, all before the results they affect). Numbers: `results.md` (133 cells, 40 replicates x 500 motions each, paired draws). Rerun: `python3 -I run.py` (about 3 minutes on 16 cores; `--quick` for a smoke; `python3 -I test_estatesim.py` for the 31 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 133 cells in the final run, "fails" in 2 (Users appeal loading b = .4, with and without delegation: MT drops more than .10), "undecided" in 131. 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. Cost: MT gap shrinks as faction grows, so the faction is also what makes the merit loss smaller. 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 binds only at alpha >= 1.5. 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. + +## 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 populist the Users estate is, and costs the same merit signal when it is not. If Users are not appeal-driven the rule is 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 125 undecided cells but not the PS/MT numbers beside them. +- 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. +- Per-category PS tables are printed only for the non-grid experiments (E1, E2, E4, E5). diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 86ab926..4f48118 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -1,6 +1,6 @@ # 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, section 5, E3) was made before any result was generated. +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 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 @@ -62,13 +62,13 @@ Revision 2 (same day, brief `heimdall-body:follow_up:chat-s1938-1941`) replaces 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 for the rest of the replicate. Revoked edges do not return. The strike count is the only delegation memory. +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` (default .3; swept {.3, .6}); 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). +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. @@ -91,7 +91,8 @@ Paired across rules: one set of random draws per motion feeds all rules (common - **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, .6, .3} × onward {.3, .6}, α = 1.5, c = .2. +- **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. - **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. diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index 19e55ac..8e5eb02 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -38,6 +38,8 @@ class Config: 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 rho: float = 0.0 # strategic fraction @@ -93,6 +95,10 @@ class Estate: 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 @@ -114,10 +120,12 @@ class Estate: 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] = rng.choices(delegates, wts)[0] + self.target[i] = self._pick(i, rng) self.scope[i] = self._scope(rng) if len(delegates) > 1: for k, d in enumerate(delegates): @@ -131,6 +139,12 @@ class Estate: 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) @@ -197,6 +211,16 @@ class Estate: 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 @@ -220,14 +244,16 @@ class Estate: forced = True self.strikes[i] += 1 if self.strikes[i] >= STRIKES: - self.target[i] = None # revoked for the rest of the replicate + self.target[i] = None # revoked until renewed (cfg.renew) + self.revoked.append(i) if forced: w, dest = self.resolve(cat, voting) 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()), - uncast=self.last_uncast, delegated=len(dest) + self.last_uncast) + 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): @@ -302,7 +328,7 @@ def run_replicate(cfg, rep, base_seed=20261105): 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"])) + conc.append(concentration(data[2]["weights"]) + (data[2]["uncast"], data[2]["delegated"], data[2]["live"])) sinc, strat = [], [] for rule in RULES: sinc.append(passes(rule, F0, A0, W, q)) diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md new file mode 100644 index 0000000..1b76b00 --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -0,0 +1,526 @@ +# 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 | + +## 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 125, n/a 0 + +Failing cells: + +- E5 users appeal b=.4 +- E5b users appeal b=.4 + diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index 3ff5c34..ca6af0f 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -62,6 +62,7 @@ def summarize(cfg, chunk): 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["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")])) @@ -119,9 +120,12 @@ def experiments(quick): [(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 onward delegation (alpha=1.5, cap=.2, strategic, faction 20)", - [(f"depth={d} dturn={t} onward={o}", E.Config(delegation=True, alpha=1.5, depth=d, dturn=t, onward=o, cap=.2, rho=.25, faction=20)) - for d in depths for t in (.95, .6, .3) for o in (.3, .6)], False)) + 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)) + 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)) @@ -156,8 +160,8 @@ def main(argv=None): 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 | claim |", - "|---|---|---|---|---|---|---|---|---|---|---|"] + 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": @@ -166,7 +170,7 @@ def main(argv=None): 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['verdict']} |") + 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: for (name, _), r in zip(cells, res): diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 2437b00..7be0bfd 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -185,9 +185,17 @@ class DelegationTests(unittest.TestCase): 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, never returns + 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])) From 9d032c2dff44d5cdfab4b25337a87f189d1ebc43 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 04:22:57 +0000 Subject: [PATCH 006/176] estate-rule sim report: correct cell counts and cap/appeal claims against results.md Co-Authored-By: Claude Sonnet 5.5 --- docs/research/2026-11-05-estate-rule-sim/REPORT.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index 7dba0bc..6551e58 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -1,39 +1,39 @@ # 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, three revisions, all before the results they affect). Numbers: `results.md` (133 cells, 40 replicates x 500 motions each, paired draws). Rerun: `python3 -I run.py` (about 3 minutes on 16 cores; `--quick` for a smoke; `python3 -I test_estatesim.py` for the 31 tests). Output is byte-identical across reruns and across `--jobs` values. +Question: does the unified estate rule (estate votes decide the estate's vote) dampen populism? Spec: `SPEC.md` (written first, three revisions, all before the results they affect). Numbers: `results.md` (127 cells, 40 replicates x 500 motions each, paired draws). Rerun: `python3 -I run.py` (about 3 minutes on 16 cores; `--quick` for a smoke; `python3 -I test_estatesim.py` for the 31 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 133 cells in the final run, "fails" in 2 (Users appeal loading b = .4, with and without delegation: MT drops more than .10), "undecided" in 131. Undecided here mostly means PS fell and MT fell too. +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 127 cells in the final run, "fails" in 2 (Users appeal loading b = .4, with and without delegation: MT drops more than .10), "undecided" in 125. 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. Cost: MT gap shrinks as faction grows, so the faction is also what makes the merit loss smaller. Sweep E2. +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 binds only at alpha >= 1.5. 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. +- **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. ## 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 populist the Users estate is, and costs the same merit signal when it is not. If Users are not appeal-driven the rule is all cost. +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 125 undecided cells but not the PS/MT numbers beside them. +- 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 From 5d352c6c2047792a46b2fb1796ce61512be18c75 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 07:05:15 +0000 Subject: [PATCH 007/176] estate-rule sim: copy-the-ballot strategy and E3f cap sweep Spec 5b (source: Golz et al. 2018 intro citing Behrens et al. 2014), copier agents in estatesim.py, E3f alpha x cap x copy sweep with a computed paired-interval verdict, 10 tests. Result: with copying the cap does not reduce effective concentration. Earlier results.md sections unchanged. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 20 +- .../2026-11-05-estate-rule-sim/SPEC.md | 25 +- .../2026-11-05-estate-rule-sim/estatesim.py | 47 ++- .../2026-11-05-estate-rule-sim/results.md | 278 +++++++++++++++++- .../2026-11-05-estate-rule-sim/run.py | 69 ++++- .../test_estatesim.py | 81 +++++ 6 files changed, 511 insertions(+), 9 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index 6551e58..3e33c02 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -1,13 +1,13 @@ # 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, three revisions, all before the results they affect). Numbers: `results.md` (127 cells, 40 replicates x 500 motions each, paired draws). Rerun: `python3 -I run.py` (about 3 minutes on 16 cores; `--quick` for a smoke; `python3 -I test_estatesim.py` for the 31 tests). Output is byte-identical across reruns and across `--jobs` values. +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 127 cells in the final run, "fails" in 2 (Users appeal loading b = .4, with and without delegation: MT drops more than .10), "undecided" in 125. Undecided here mostly means PS fell and MT fell too. +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. @@ -24,6 +24,21 @@ With 25% strategic voters (misreporting, abstaining, pivot-seeking turnout) stra - **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. @@ -40,4 +55,5 @@ The sign of the PS effect holds across Users appeal 0.4/0.9/1.4, Users turnout . - 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). diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 4f48118..2b0387b 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -1,6 +1,6 @@ # 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 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. +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 @@ -72,6 +72,25 @@ Delegate pool: each delegating estate has 10% of its roll (at least one) as acti 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: @@ -94,6 +113,7 @@ Paired across rules: one set of random draws per motion feeds all rules (common - **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. @@ -103,7 +123,7 @@ The claim is **supported** in a cell if the paired difference PS(UNI) − PS(DIR ## 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, 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. +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 @@ -112,6 +132,7 @@ 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. diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index 8e5eb02..7788634 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -42,6 +42,7 @@ class Config: 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 @@ -199,15 +200,49 @@ class Estate: 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 = max(1.0, self.cfg.cap * base) + 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 @@ -248,10 +283,15 @@ class Estate: 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))) @@ -328,7 +368,8 @@ def run_replicate(cfg, rep, base_seed=20261105): 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"])) + 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)) @@ -339,7 +380,7 @@ def run_replicate(cfg, rep, base_seed=20261105): 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]: + 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"]: diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md index 1b76b00..c7db61b 100644 --- a/docs/research/2026-11-05-estate-rule-sim/results.md +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -251,6 +251,282 @@ PS by category threshold: | 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 | @@ -517,7 +793,7 @@ PS by category threshold: ## Claim tally over all cells (SPEC section 8) -supported 0, fails 2, undecided 125, n/a 0 +supported 0, fails 2, undecided 233, n/a 0 Failing cells: diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index ca6af0f..08de383 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -62,6 +62,10 @@ def summarize(cfg, chunk): 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, @@ -123,6 +127,10 @@ def experiments(quick): 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)) @@ -144,6 +152,63 @@ def experiments(quick): 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") @@ -172,7 +237,9 @@ def main(argv=None): 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: + 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) + [""] diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 7be0bfd..196abab 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -203,6 +203,87 @@ class DelegationTests(unittest.TestCase): 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) From 6e4f94ae27202698c9e6bab9f76a870f2f3244c6 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 13:13:43 +0000 Subject: [PATCH 008/176] Estate-rule sim: purchased-stake arm (log weight, hours input, splitting adversary, half-influence cap, E6) Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 18 ++- .../2026-11-05-estate-rule-sim/SPEC.md | 25 +++- .../2026-11-05-estate-rule-sim/estatesim.py | 109 +++++++++++++++ .../2026-11-05-estate-rule-sim/results.md | 78 +++++++++++ .../2026-11-05-estate-rule-sim/run.py | 132 ++++++++++++++++++ .../test_estatesim.py | 116 +++++++++++++++ 6 files changed, 475 insertions(+), 3 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index 3e33c02..ab5269e 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -1,6 +1,6 @@ # 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. +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 52 tests). Output is byte-identical across reruns and across `--jobs` values. ## Answer @@ -39,6 +39,21 @@ Source: Gölz et al. 2018 (introduction) argue, citing Behrens et al. 2014 (Liqu 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. +## Purchased stake (E6, SPEC section 5c) + +Static weight analysis, not a motion simulation: it measures weight share, not PS or MT. Weight w = 1 + log_b(amount/unit), 0 below unit, per-estate b and unit (defaults b = 10, unit = 10 EUR, my choices, in SPEC 5c). The harness had no contribution mechanism, so contribution hours are a new per-agent input with their own per-estate conversion (defaults b = 10, unit = 10 hours); they add to the euro weight and matter to no buyer result below. + +**The working hypothesis, that logarithmic weight bounds buyout power, is only half true here, and the true half is not the log's doing.** + +- **Within the estate the log does not bound a million-euro buyer.** Against the harness's 4-patron roll (Pareto(1.16) donations from 10 EUR, 40 seeds) the buyer holds 0.524 +/- 0.008 of Patrons weight and alone decides the Patrons estate (share above one half) in 85% of seeds. The log shrinks the buyer from 100% (linear weight) to about half; it does not take it below a majority of a 4-person estate. At rolls of 40 and 400 the share falls (binding rates below). +- **At council level the bound comes from the estate weights.** With all four estates live the buyer's council share is 0.131 (equal weights) or 0.052 (minds-heavy), below the Patrons weight W_Patrons by construction; the half-influence cap never binds in 6,480 cell-seeds. Linear weight would give 0.25 and 0.10: the log halves the buyer's share, the estate structure sets its ceiling. +- **The half-influence cap binds only when other estates are silent.** Fraction of (cell, seed) in which council share x >= .5 over 162 cells (b x unit x roll x amount x weights) x 40 seeds: all four live 0.000; Patrons + Minds live 0.044 (all of it the degenerate case where no other patron clears the unit, so there is nothing to cut against: unenforceable); Patrons alone live 0.222 (0.148 of cells bind in every seed, 0.089 of cell-seeds unenforceable). It binds more at small rolls (Patrons alone: 0.669 at roll 4 and b = 2 down to 0.000 at roll 400) and with a smaller log base. The Patrons-alone scenario is the renormalization case of prior section 10 (drop non-voting estates); how likely it is in practice is not a sim output. +- **Splitting wins, by orders of magnitude.** The same 1,000,000 EUR over k identities multiplies weight by 1.9 (k = 2), 8.3 (k = 10), 66.7 (k = 100), 500 (k = 1000), and 16,667 at k = amount/unit = 100,000 (each fake identity buying exactly the unit). The multiplier is (amount/unit) / (1 + log_b(amount/unit)); for b = 10, unit = 10 it is 250 at 10,000 EUR, 2,000 at 100,000 EUR. With k = 10 fake identities the buyer's Patrons-alone share is 0.901, with k = 2 it is 0.676. This refutes the log as a purchase bound unless identities are scarce. +- **The half-influence cap is per identity and splitting evades it.** In the Patrons-alone case the single identity trips the cap in 85% of seeds; at k = 2 no identity does (each holds 0.34) while the joint share is 0.676, in every seed. A cap on a person's influence needs an identity oracle the harness does not have. +- **SPEC names no sybil defence** (the charter's frozen roll, A6, bounds joins after notice, not pre-notice buying of identities), so none is implemented as policy. Three candidates are quantified in results.md and none is chosen: a per-person weight cap does not help (it caps the honest single purchase and the fakes are each below it; 100,000x at cap 1); a raised unit floor reduces the multiplier (250 at 1,000 EUR, 5 at 100,000 EUR, 1.0 only at 1,000,000 EUR, where no purchase under the buyer's amount buys any weight), so it neutralises splitting only by pricing out everyone smaller; a per-identity cost neutralises only at about half or more of the budget (51% to 82% on the doubling grid across 10,000 to 1,000,000 EUR), so it would also tax the honest buyer's single identity at that rate. The choice between pricing identities, verifying people or bounding total weight per verified person is a design fork left for the operator. Nothing here rules it. + +Limits specific to E6: the roll, the Pareto scale, b and unit are assumptions; the buyer joins as an additional patron and buys once (no repeated purchase or liquidation); decisiveness is estate-level only, not council-level (prior section 10 shows weight share is not decisiveness); the best split is a grid maximum, a lower bound; hours play no part in a purchase scenario because estate weights are fixed and the buyer sits in Patrons, so an hours buyer (a Member who is paid or who farms hours) is untested and the conversion of hours into weight is just a per-estate parameter whose gaming is not modeled. + ## 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. @@ -53,6 +68,7 @@ The sign of the PS effect holds across Users appeal 0.4/0.9/1.4, Users turnout . ## Deviations from the spec text +- E6: the brief said the half-influence cap and an 'E3f cap sweep' were already in the harness. The harness has only the delegation cap of SPEC section 5 (a fraction of cast weight per final holder); the operator cap of prior section 10 (council weight share strictly below one half) was not implemented, so `influence_cap` implements it, once, in `estatesim.py`; the E3f sweep is of the delegation cap and is untouched. E6 is a static weight analysis, not integrated into the motion simulation (no PS or MT for buyers). - 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. diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 2b0387b..4978cd7 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -1,6 +1,6 @@ # 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. +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 5 (purchased stake, section 5c) was written before its results and touches no earlier section. 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 @@ -91,6 +91,26 @@ Serves `heimdall-body:follow_up:chat-s1946-1946`. **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. +## 5c. Purchased stake (revision 5, written before its results) + +Serves the purchased-stake brief (operator relayed: Patron vote power is logarithmic in donation, prior section 4; operator influence strictly below half, ruling `operator-influence-below-half`, prior section 10). Not a motion simulation: a static weight analysis, so it measures weight share and decisiveness, not PS or MT. + +**Weight.** A purchase of `amount` EUR weighs w = 1 + log_b(amount/unit): 1 at amount = unit, 0 below unit (below the unit buys no weight, never negative). Each estate has its own conversion, set through `Config.overrides` entries `(estate, key, value)` with keys `euro_b`, `euro_unit`, `hours_b`, `hours_unit` (defaults in `STAKE_BASE`). Only Patrons (euros) and Members (hours) carry stake; Minds are counted once and Users are one-each, so both weigh 1. + +**Defaults chosen (assumptions, not rulings; the brief gave none).** Patrons and Members alike: euro b = 10, unit = 10 EUR; hours b = 10, unit = 10 hours. b = 10 reads as "each tenfold purchase adds one vote of weight", the simplest reading of the operator's "logarithmic"; 10 EUR is the smallest ordinary Patron donation in the prior ladder (prior section 4: 10, 50, 200, 5000); 10 hours is roughly a working day or so of contribution. The sweep varies b over {2, 10, 100} and unit over {1, 10, 100} EUR; hours are not swept because no buyer outcome depends on them (see below). + +**Contribution hours.** The harness had no contribution mechanism (Members were one-each; prior section 4's Pareto contribution curve was left out of scope in section 4 above). Hours are therefore a new per-agent input with their own per-estate conversion: an estate member's weight is the euro channel plus the hours channel, each through its own (b, unit). + +**Electorate.** The buyer joins the Patrons estate as an additional member; the other patrons are `ROLL["Patrons"]` = 4 members (also 40 and 400 as a sensitivity) holding Pareto(1.16) donations from 10 EUR (prior section 4's exponent; the scale is mine). 40 seeds, each a fixed integer. Estate weights are the section 4 weights; the live-estate set is a scenario: all four live, Patrons + Minds live, Patrons alone live (renormalization over live estates, section 2). + +**Influence.** Council weight share x = W_Patrons x s / (sum of live W), s the buyer's share of Patrons weight; this is the "weight share" of prior section 10. Decisiveness is reported only at the estate level (buyer alone decides the Patrons estate's vote when s > .5 at q = .5); prior section 10 shows weight share is not decisiveness, and no council-level pivot is computed here. + +**Half-influence cap.** The cap named in the brief is the prior section 10 operator cap (weight share strictly below one half), which is *not* the `cap` of section 5 (a per-final-holder delegation cap, a fraction of cast weight, with void excess). The harness had no implementation of the operator cap; `influence_cap` is it: binds iff x >= .5, then cuts the holder's internal weight until x = .5(1 - 1e-9), and reports "unenforceable" when no one else holds weight to cut against. It applies per identity. + +**Splitting adversary.** The same total split evenly over k identities: weight k(1 + log_b(amount/(k unit))) against 1 + log_b(amount/unit). Splitting wins because the log is sub-linear: the multiplier approaches (amount/unit)/(1 + log_b(amount/unit)) at k = amount/unit. The sweep reports the multiplier by k, the best k on a geometric grid (a lower bound on the maximum), and a table of defences. **SPEC names no sybil defence** (the charter's frozen roll, A6, stops joins after notice, not the buying of many identities beforehand). Three candidates are quantified, none adopted or chosen: a per-person weight cap, a raised unit floor, a per-identity cost paid out of the budget. They are parameters of `split_weight`, off by default. + +**Falsifiers fixed in advance.** (1) Working hypothesis "logarithmic weight bounds buyout power": refuted if a one-million-euro buyer's within-estate share s exceeds 1/2 at the harness's own roll, or if splitting multiplies weight by more than 2 at any k. (2) The half-influence cap is "binding" in a (cell, seed) iff x >= .5; the rate over the sweep is reported per live-estate scenario. (3) The cap is "evaded" by splitting iff the joint share is >= .5 while no single identity's share is. + ## 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: @@ -115,6 +135,7 @@ Paired across rules: one set of random draws per motion feeds all rules (common - **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. +- **E6 purchased stake:** section 5c. b x unit x Patrons roll x amount x estate weights x live-estate scenario, 40 seeds; splitting k sweep; candidate defences. - **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 @@ -123,7 +144,7 @@ The claim is **supported** in a cell if the paired difference PS(UNI) − PS(DIR ## 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. +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; purchased stake (weight 1 at unit and 0 below, per-estate conversion, hours channel, the million-euro buyer's share derived from the config, log versus linear, the operator cap's bind and unenforceable cases, the splitting multiplier against its formula, defences that do and do not neutralise, per-identity cap evasion); 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 diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index 7788634..8cee858 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -436,3 +436,112 @@ def verdict(dps, dmt): if dps[0] + dps[1] < 0 and dmt[0] >= -.05: return "supported" return "undecided" + + +# ---------------------------------------------------------------- purchased stake (SPEC section 5c) +# +# A static weight analysis, not a motion simulation: it asks what share of the +# council a purchase buys, not how the buyer votes. The estate weights W and the +# set of live estates come from the same tables the rules above use. + +STAKE_KEYS = ("euro_b", "euro_unit", "hours_b", "hours_unit") +# Per-estate conversion of stake to weight. Assumptions, stated in SPEC section 5c. +# Only Patrons (euros) and Members (contribution hours) carry stake; Minds are +# counted once and Users are one-each, so they have no entry and weigh 1. +STAKE_BASE = { + "Patrons": dict(euro_b=10.0, euro_unit=10.0, hours_b=10.0, hours_unit=10.0), + "Members": dict(euro_b=10.0, euro_unit=10.0, hours_b=10.0, hours_unit=10.0), +} +HALF = .5 # operator-influence cap: council weight share strictly below this (prior section 10) +STRICT = 1e-9 # "strictly below": a capped holder sits at c*(1-STRICT) +PARETO_ALPHA = 1.16 # prior section 4: Pareto(1.16) contribution ladder +PARETO_XM = 10.0 # EUR; smallest ordinary Patron donation + + +def stake_params(name, overrides=()): + """Per-estate stake parameters; Config.overrides entries (estate, key, value) with a STAKE_KEYS key apply.""" + p = dict(STAKE_BASE.get(name, {})) + if p: + for en, k, v in overrides: + if en == name and k in STAKE_KEYS: + p[k] = v + return p + + +def log_weight(x, b, unit): + """w = 1 + log_b(x/unit): 1 at x = unit, 0 (not negative) below unit.""" + if b <= 1 or unit <= 0: + raise ValueError("log base must exceed 1 and unit must be positive") + return 0.0 if x < unit else 1.0 + math.log(x / unit, b) + + +def stake_weight(name, euros=0.0, hours=0.0, overrides=()): + """One member's weight: euro channel plus contribution-hours channel, each with the estate's own (b, unit).""" + p = stake_params(name, overrides) + if not p: + return 1.0 + return (log_weight(euros, p["euro_b"], p["euro_unit"]) + + log_weight(hours, p["hours_b"], p["hours_unit"])) + + +def pareto_ladder(n, rng): + """n ordinary-patron amounts in EUR, Pareto(PARETO_ALPHA) from PARETO_XM.""" + return [PARETO_XM * (1.0 - rng.random()) ** (-1.0 / PARETO_ALPHA) for _ in range(n)] + + +def council_share(w, rest, W, e, live): + """(within-estate share s, council weight share x) of a holder with weight w in estate e; + rest is everyone else's weight in e; live is the tuple of live estate indices (renormalization).""" + s = w / (w + rest) if w + rest > 0 else 0.0 + return s, W[e] * s / sum(W[i] for i in live) + + +def influence_cap(w, rest, W, e, live, c=HALF): + """Operator-influence cap (prior section 10, ruling operator-influence-below-half): a holder's + council weight share must be strictly below c. Binds iff x >= c; the holder's internal weight is + then cut until x = c*(1-STRICT). Unenforceable when nobody else holds weight in the estate.""" + s, x = council_share(w, rest, W, e, live) + out = dict(s=s, x=x, binds=x >= c - EPS, w_capped=w, s_capped=s, x_capped=x, enforceable=True) + if not out["binds"]: + return out + s_cap = c * (1 - STRICT) * sum(W[i] for i in live) / W[e] + if rest <= 0 or s_cap >= 1: + out["enforceable"] = False + return out + wc = s_cap * rest / (1 - s_cap) + out.update(w_capped=wc, s_capped=s_cap, x_capped=W[e] * s_cap / sum(W[i] for i in live)) + return out + + +def split_weight(amount, k, b, unit, identity_cost=0.0, person_cap=None): + """Total weight of `amount` EUR split evenly over k identities. identity_cost is spent per identity + out of the budget; person_cap limits each identity's weight. Returns (total, per identity).""" + each = (amount - k * identity_cost) / k + wi = log_weight(each, b, unit) if each > 0 else 0.0 + if person_cap is not None: + wi = min(wi, person_cap) + return k * wi, wi + + +def best_split(amount, b, unit, identity_cost=0.0, person_cap=None): + """(best total weight, k) over a geometric grid of k up to amount/unit. A grid maximum: a lower bound on the true one.""" + kmax = max(1, int(amount // unit)) + ks, k = {1, kmax}, 1.0 + while k < kmax: + ks.add(max(1, round(k))) + k *= 1.05 + best = max((split_weight(amount, k, b, unit, identity_cost, person_cap)[0], -k) for k in ks) + return best[0], -best[1] + + +def min_neutralising_cost(amount, b, unit, person_cap=None): + """Smallest per-identity cost on a doubling grid (from unit) at which no split beats one identity, + or None. Neutral = best split is k = 1 and one identity still has weight.""" + c = unit + while c < amount: + w1 = split_weight(amount, 1, b, unit, c, person_cap)[0] + tot, k = best_split(amount, b, unit, c, person_cap) + if w1 > 0 and k == 1: + return c + c *= 2 + return None diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md index c7db61b..7f9d59e 100644 --- a/docs/research/2026-11-05-estate-rule-sim/results.md +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -791,6 +791,84 @@ PS by category threshold: | 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 | +## E6 purchased stake: logarithmic weight, splitting, and the half-influence cap (SPEC section 5c) + +Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins the Patrons estate with one purchase; the 4-patron roll of the harness (and 40, 400) holds Pareto(1.16) donations from 10 EUR, 40 seeds each. Weight w = 1 + log_b(amount/unit), 0 below unit; defaults b = 10, unit = 10 EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight (estate weight W x s over the live estates' weights); the cap binds iff x >= .5. + +**Million-euro buyer, defaults, Patrons roll 4 (mean over seeds, 95% interval); linear = weight proportional to amount, the counterfactual the log is meant to beat** + +| weights | live estates | s log | x log | x linear | cap binds (log) | cap binds (linear) | estate decided by buyer alone (s > .5) | +|---|---|---|---|---|---|---|---| +| equal | all four estates | 0.524 ±0.008 | 0.131 ±0.002 | 0.250 ±0.000 | 0.00 | 0.00 | 0.85 | +| equal | Patrons + Minds | 0.524 ±0.008 | 0.262 ±0.004 | 0.500 ±0.000 | 0.00 | 0.00 | 0.85 | +| equal | Patrons alone | 0.524 ±0.008 | 0.524 ±0.008 | 1.000 ±0.000 | 0.85 | 1.00 | 0.85 | +| minds-heavy | all four estates | 0.524 ±0.008 | 0.052 ±0.001 | 0.100 ±0.000 | 0.00 | 0.00 | 0.85 | +| minds-heavy | Patrons + Minds | 0.524 ±0.008 | 0.105 ±0.002 | 0.200 ±0.000 | 0.00 | 0.00 | 0.85 | +| minds-heavy | Patrons alone | 0.524 ±0.008 | 0.524 ±0.008 | 1.000 ±0.000 | 0.85 | 1.00 | 0.85 | + +**Cap-binding rate over the sweep (b, unit, roll, amount, weights x live set; every cell run on every seed)** + +| live estates | cells | cells x seeds | binding (cell, seed) | cells binding in every seed | cells never binding | binding but unenforceable | +|---|---|---|---|---|---|---| +| all four estates | 162 | 6480 | 0.000 | 0.000 | 1.000 | 0.000 | +| Patrons + Minds | 162 | 6480 | 0.044 | 0.000 | 0.889 | 0.044 | +| Patrons alone | 162 | 6480 | 0.222 | 0.148 | 0.704 | 0.089 | + +Binding rate in the Patrons-alone scenario by Patrons roll and by log base (fraction of cells x seeds): + +| roll | b=2 | b=10 | b=100 | +|---|---|---|---| +| 4 | 0.669 | 0.447 | 0.333 | +| 40 | 0.286 | 0.169 | 0.094 | +| 400 | 0.000 | 0.000 | 0.000 | + +**Splitting: the same total split over k identities (defaults, one honest identity = k 1). Multiplier = total weight of the split / weight of the single purchase** + +| amount EUR | single weight | k=2 | k=10 | k=100 | k=1000 | best k (grid) | best multiplier | +|---|---|---|---|---|---|---|---| +| 10000 | 4.00 | 1.8 | 7.5 | 50.0 | 250.0 | 1000 | 250 | +| 100000 | 5.00 | 1.9 | 8.0 | 60.0 | 400.0 | 10000 | 2000 | +| 1e+06 | 6.00 | 1.9 | 8.3 | 66.7 | 500.0 | 100000 | 16667 | + +Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns): + +| b | unit=1 | unit=10 | unit=100 | +|---|---|---|---| +| 2 | 50711 (k=740348) | 6027 (k=74738) | 743 (k=7185) | +| 10 | 142857 (k=1000000) | 16667 (k=100000) | 2000 (k=10000) | +| 100 | 250000 (k=1000000) | 28571 (k=100000) | 3333 (k=10000) | + +**Candidate defences, none adopted by SPEC (best multiplier at 1,000,000 EUR, defaults)** + +| defence | setting | best multiplier | neutralises (best split is k = 1) | +|---|---|---|---| +| per-person weight cap | 1.0 | 100000 | no | +| per-person weight cap | 3.0 | 33333 | no | +| per-person weight cap | 6.0 | 16667 | no | +| unit floor | 10 EUR | 16666.7 | no | +| unit floor | 1000 EUR | 250.0 | no | +| unit floor | 100000 EUR | 5.0 | no | +| unit floor | 500000 EUR | 1.5 | no | +| unit floor | 1e+06 EUR | 1.0 | yes | +| identity cost | smallest on a doubling grid, amount 10000 EUR | | yes at 5120 EUR per identity (51% of the budget) | +| identity cost | smallest on a doubling grid, amount 100000 EUR | | yes at 81920 EUR per identity (82% of the budget) | +| identity cost | smallest on a doubling grid, amount 1e+06 EUR | | yes at 655360 EUR per identity (66% of the budget) | + +**Cap evasion: the cap is per identity. Patrons alone, equal weights, roll 4, defaults, 1,000,000 EUR over k identities** + +| k | joint share x | share of one identity | cap binds on an identity | joint x >= .5 (evaded) | +|---|---|---|---|---| +| 1 | 0.524 ±0.008 | 0.524 ±0.008 | 0.85 | 0.00 | +| 2 | 0.676 ±0.007 | 0.338 ±0.004 | 0.00 | 1.00 | +| 10 | 0.901 ±0.003 | 0.090 ±0.000 | 0.00 | 1.00 | +| 100 | 0.986 ±0.000 | 0.010 ±0.000 | 0.00 | 1.00 | + +**Contribution hours: Members weight from hours alone (no mechanism for contribution existed in the harness; new per-agent input, own per-estate conversion)** + +| hours | 5 | 10 | 100 | 1000 | 10000 | +|---|---|---|---|---|---| +| weight | 0.00 | 1.00 | 2.00 | 3.00 | 4.00 | + ## Claim tally over all cells (SPEC section 8) supported 0, fails 2, undecided 233, n/a 0 diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index 08de383..527a454 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -4,6 +4,7 @@ Writes a deterministic markdown results file (no timestamps). See SPEC.md sectio """ import argparse import os +import random import sys from multiprocessing import Pool @@ -209,6 +210,136 @@ def copy_reading(cells, res): return L + [""] +STAKE_SEED = 20261105 +PATRONS = E.ESTATES.index("Patrons") +LIVE = {"all four estates": (0, 1, 2, 3), "Patrons + Minds": (0, PATRONS), "Patrons alone": (PATRONS,)} + + +def _stake_rest(overrides, ladder): + """Weight of the ordinary patrons under the estate's own euro conversion.""" + return sum(E.stake_weight("Patrons", euros=x, overrides=overrides) for x in ladder) + + +def stake_section(quick): + """E6 purchased stake (SPEC section 5c). Pure functions of fixed seeds; no wall clock.""" + seeds = 4 if quick else 40 + amounts = (1e6,) if quick else (1e4, 1e5, 1e6) + bs, units, rolls = ((10.0,), (10.0,), (4, 40)) if quick else ((2.0, 10.0, 100.0), (1.0, 10.0, 100.0), (4, 40, 400)) + EUR = 1e6 + L = ["## E6 purchased stake: logarithmic weight, splitting, and the half-influence cap (SPEC section 5c)", "", + "Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins the Patrons estate with one purchase; " + f"the {E.ROLL['Patrons']}-patron roll of the harness (and 40, 400) holds Pareto({E.PARETO_ALPHA}) donations from {E.PARETO_XM:.0f} EUR, " + f"{seeds} seeds each. Weight w = 1 + log_b(amount/unit), 0 below unit; defaults b = {E.STAKE_BASE['Patrons']['euro_b']:.0f}, " + f"unit = {E.STAKE_BASE['Patrons']['euro_unit']:.0f} EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight " + "(estate weight W x s over the live estates' weights); the cap binds iff x >= .5.", ""] + ladders = {(n, s): E.pareto_ladder(n, random.Random(STAKE_SEED + 1000 * n + s)) for n in rolls for s in range(seeds)} + # headline: the million-euro buyer, defaults, roll of the harness + n0 = E.ROLL["Patrons"] + L += ["**Million-euro buyer, defaults, Patrons roll " + str(n0) + " (mean over seeds, 95% interval); linear = weight proportional to amount, the counterfactual the log is meant to beat**", "", + "| weights | live estates | s log | x log | x linear | cap binds (log) | cap binds (linear) | estate decided by buyer alone (s > .5) |", + "|---|---|---|---|---|---|---|---|"] + for wn, W in E.WEIGHTS.items(): + for ln, live in LIVE.items(): + rows = [] + for s in range(seeds): + lad = ladders[(n0, s)] + wb = E.stake_weight("Patrons", euros=EUR) + lo = E.influence_cap(wb, _stake_rest((), lad), W, PATRONS, live) + li = E.influence_cap(EUR / 10.0, sum(x / 10.0 for x in lad), W, PATRONS, live) + rows.append((lo["s"], lo["x"], li["x"], lo["binds"], li["binds"], lo["s"] > .5)) + m = [E.mean_ci([r[k] for r in rows]) for k in range(3)] + fr = [sum(r[k] for r in rows) / seeds for k in (3, 4, 5)] + L.append(f"| {wn} | {ln} | {f(*m[0])} | {f(*m[1])} | {f(*m[2])} | {fr[0]:.2f} | {fr[1]:.2f} | {fr[2]:.2f} |") + L.append("") + # cap-binding rate across the whole sweep + tally = {} + for wn, W in E.WEIGHTS.items(): + for ln, live in LIVE.items(): + for b in bs: + for u in units: + ov = (("Patrons", "euro_b", b), ("Patrons", "euro_unit", u)) + for n in rolls: + for a in amounts: + hit = unf = 0 + for s in range(seeds): + lad = ladders[(n, s)] + r = E.influence_cap(E.stake_weight("Patrons", euros=a, overrides=ov), _stake_rest(ov, lad), W, PATRONS, live) + hit += r["binds"] + unf += r["binds"] and not r["enforceable"] + tally.setdefault(ln, []).append((hit, unf, seeds, n, b, a)) + L += ["**Cap-binding rate over the sweep (b, unit, roll, amount, weights x live set; every cell run on every seed)**", "", + "| live estates | cells | cells x seeds | binding (cell, seed) | cells binding in every seed | cells never binding | binding but unenforceable |", + "|---|---|---|---|---|---|---|"] + for ln, t in tally.items(): + tot = sum(x[2] for x in t) + L.append(f"| {ln} | {len(t)} | {tot} | {sum(x[0] for x in t) / tot:.3f} | " + f"{sum(1 for x in t if x[0] == x[2]) / len(t):.3f} | {sum(1 for x in t if x[0] == 0) / len(t):.3f} | " + f"{sum(x[1] for x in t) / tot:.3f} |") + L += ["", "Binding rate in the Patrons-alone scenario by Patrons roll and by log base (fraction of cells x seeds):", "", + "| roll | " + " | ".join(f"b={b:g}" for b in bs) + " |", "|---|" + "---|" * len(bs)] + for n in rolls: + cols = [] + for b in bs: + t = [x for x in tally["Patrons alone"] if x[3] == n and x[4] == b] + cols.append(f"{sum(x[0] for x in t) / sum(x[2] for x in t):.3f}") + L.append(f"| {n} | " + " | ".join(cols) + " |") + L.append("") + # splitting + L += ["**Splitting: the same total split over k identities (defaults, one honest identity = k 1). Multiplier = total weight of the split / weight of the single purchase**", "", + "| amount EUR | single weight | " + " | ".join(f"k={k}" for k in (2, 10, 100, 1000)) + " | best k (grid) | best multiplier |", + "|---|---|" + "---|" * 6] + b0, u0 = E.STAKE_BASE["Patrons"]["euro_b"], E.STAKE_BASE["Patrons"]["euro_unit"] + for a in amounts: + w1 = E.log_weight(a, b0, u0) + bt, bk = E.best_split(a, b0, u0) + L.append(f"| {a:g} | {w1:.2f} | " + " | ".join( + f"{E.split_weight(a, k, b0, u0)[0] / w1:.1f}" if a / k >= u0 else "0 (below unit)" for k in (2, 10, 100, 1000)) + + f" | {bk} | {bt / w1:.0f} |") + L += ["", "Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns):", "", + "| b | " + " | ".join(f"unit={u:g}" for u in units) + " |", "|---|" + "---|" * len(units)] + for b in bs: + cols = [] + for u in units: + bt, bk = E.best_split(EUR, b, u) + cols.append(f"{bt / E.log_weight(EUR, b, u):.0f} (k={bk})") + L.append(f"| {b:g} | " + " | ".join(cols) + " |") + # defences, candidates only + L += ["", "**Candidate defences, none adopted by SPEC (best multiplier at 1,000,000 EUR, defaults)**", "", + "| defence | setting | best multiplier | neutralises (best split is k = 1) |", "|---|---|---|---|"] + w1 = E.log_weight(EUR, b0, u0) + for wc in (1.0, 3.0, w1): + s1 = min(w1, wc) + bt, bk = E.best_split(EUR, b0, u0, person_cap=wc) + L.append(f"| per-person weight cap | {wc:.1f} | {bt / s1:.0f} | {'yes' if bk == 1 else 'no'} |") + for uf in (10.0, 1e3, 1e5, 5e5, 1e6): + s1 = E.log_weight(EUR, b0, uf) + bt, bk = E.best_split(EUR, b0, uf) + L.append(f"| unit floor | {uf:g} EUR | {bt / s1:.1f} | {'yes' if bk == 1 else 'no'} |") + for a in amounts: + mc = E.min_neutralising_cost(a, b0, u0) + L.append(f"| identity cost | smallest on a doubling grid, amount {a:g} EUR | | " + + (f"yes at {mc:g} EUR per identity ({mc / a:.0%} of the budget)" if mc else "no cost below the amount") + " |") + # cap evasion by splitting, Patrons alone + L += ["", "**Cap evasion: the cap is per identity. Patrons alone, equal weights, roll " + str(n0) + ", defaults, 1,000,000 EUR over k identities**", "", + "| k | joint share x | share of one identity | cap binds on an identity | joint x >= .5 (evaded) |", "|---|---|---|---|---|"] + W = E.WEIGHTS["equal"] + for k in (1, 2, 10, 100): + rows = [] + for s in range(seeds): + rest = _stake_rest((), ladders[(n0, s)]) + tot, wi = E.split_weight(EUR, k, b0, u0) + joint = E.influence_cap(tot, rest, W, PATRONS, (3,)) + one = E.influence_cap(wi, rest + tot - wi, W, PATRONS, (3,)) + rows.append((joint["x"], one["x"], one["binds"], joint["x"] >= E.HALF and not one["binds"])) + L.append(f"| {k} | {f(*E.mean_ci([r[0] for r in rows]))} | {f(*E.mean_ci([r[1] for r in rows]))} | " + f"{sum(r[2] for r in rows) / seeds:.2f} | {sum(r[3] for r in rows) / seeds:.2f} |") + # hours channel + L += ["", "**Contribution hours: Members weight from hours alone (no mechanism for contribution existed in the harness; new per-agent input, own per-estate conversion)**", "", + "| hours | " + " | ".join(f"{h:g}" for h in (5, 10, 100, 1000, 10000)) + " |", "|---|---|---|---|---|---|", + "| weight | " + " | ".join(f"{E.stake_weight('Members', hours=h):.2f}" for h in (5, 10, 100, 1000, 10000)) + " |", ""] + return L + + def main(argv=None): ap = argparse.ArgumentParser() ap.add_argument("--quick", action="store_true") @@ -243,6 +374,7 @@ def main(argv=None): 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 += stake_section(a.quick) 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: diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 196abab..6b00613 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -1,4 +1,5 @@ """python3 -I test_estatesim.py""" +import math import os import random import sys @@ -284,6 +285,121 @@ class CopyTests(unittest.TestCase): self.assertAlmostEqual(sum(c[7] for c in conc), sum(c[0] for c in conc)) +class StakeTests(unittest.TestCase): + """SPEC section 5c: purchased stake, splitting, the half-influence cap.""" + P = E.ESTATES.index("Patrons") + ALL = (0, 1, 2, 3) + + def cfg(self): + return E.STAKE_BASE["Patrons"] + + def test_weight_is_one_at_unit_zero_below_and_logarithmic(self): + c = self.cfg() + b, u = c["euro_b"], c["euro_unit"] + self.assertEqual(E.log_weight(u, b, u), 1.0) + self.assertEqual(E.log_weight(u * .99, b, u), 0.0) # below unit: no weight, not negative + self.assertAlmostEqual(E.log_weight(u * b ** 3, b, u), 4.0) # each factor b adds one + self.assertLess(E.log_weight(10 * u, b, u), 10) # sub-linear + + def test_conversion_is_per_estate_and_overridable(self): + ov = (("Patrons", "euro_b", 2.0), ("Patrons", "euro_unit", 5.0), ("Members", "euro_b", 100.0)) + self.assertAlmostEqual(E.stake_weight("Patrons", euros=40, overrides=ov), 1 + math.log(8, 2)) + self.assertAlmostEqual(E.stake_weight("Patrons", euros=100), 1 + math.log(10, 10)) + self.assertEqual(E.stake_params("Members", ov)["euro_b"], 100.0) + self.assertEqual(E.stake_params("Patrons", ov)["euro_b"], 2.0) + self.assertEqual(E.stake_weight("Users", euros=1e6), 1.0) # no stake channel: one-each + self.assertEqual(E.stake_weight("Minds", hours=1e6), 1.0) + + def test_hours_add_to_euros_with_their_own_conversion(self): + ov = (("Members", "hours_b", 2.0), ("Members", "hours_unit", 4.0)) + h = E.stake_weight("Members", hours=32, overrides=ov) + self.assertAlmostEqual(h, 1 + math.log(8, 2)) + self.assertAlmostEqual(E.stake_weight("Members", euros=100, hours=32, overrides=ov), h + 2.0) + + def test_million_euro_buyer_share_is_derived_from_config(self): + c = self.cfg() + wb = E.stake_weight("Patrons", euros=1e6) + n = E.ROLL["Patrons"] # the harness's patron roll, each at exactly the unit + others = n * E.log_weight(c["euro_unit"], c["euro_b"], c["euro_unit"]) + s_star = wb / (wb + others) + for wn, W in E.WEIGHTS.items(): + # all estates live: the buyer's council share cannot exceed the Patrons estate weight, below half by the charter + r = E.influence_cap(wb, others, W, self.P, self.ALL) + self.assertAlmostEqual(r["s"], s_star) + self.assertAlmostEqual(r["x"], W[self.P] / sum(W) * s_star) + self.assertLess(r["x"], W[self.P] / sum(W) + 1e-12) + self.assertFalse(r["binds"], wn) + # Patrons the only live estate: the cap binds exactly when the buyer outweighs the rest + r = E.influence_cap(wb, others, W, self.P, (self.P,)) + self.assertEqual(r["binds"], s_star >= E.HALF) + self.assertEqual(r["binds"], wb >= others) + if r["binds"]: + self.assertLess(r["x_capped"], E.HALF) + self.assertAlmostEqual(r["x_capped"], E.HALF, places=6) + + def test_log_bounds_buyout_relative_to_linear(self): + c = self.cfg() + rest_amounts = [10.0, 50.0, 200.0, 5000.0] + W = E.WEIGHTS["equal"] + lg = E.council_share(E.stake_weight("Patrons", euros=1e6), + sum(E.stake_weight("Patrons", euros=a) for a in rest_amounts), W, self.P, (self.P,))[1] + li = E.council_share(1e6 / c["euro_unit"], sum(a / c["euro_unit"] for a in rest_amounts), W, self.P, (self.P,))[1] + self.assertLess(lg, li) + self.assertGreater(li, .99) + + def test_cap_is_unenforceable_when_nobody_else_holds_weight(self): + r = E.influence_cap(5.0, 0.0, E.WEIGHTS["equal"], self.P, (self.P,)) + self.assertTrue(r["binds"]) + self.assertFalse(r["enforceable"]) + + def test_splitting_multiplier_matches_the_formula_and_exceeds_one(self): + c = self.cfg() + b, u, a, k = c["euro_b"], c["euro_unit"], 1e6, 100 + tot, each = E.split_weight(a, k, b, u) + self.assertAlmostEqual(each, 1 + math.log(a / (k * u), b)) + self.assertAlmostEqual(tot, k * (1 + math.log(a / (k * u), b))) + self.assertGreater(tot, E.log_weight(a, b, u)) + self.assertEqual(E.split_weight(a, int(a / u) + 1, b, u)[0], 0.0) # every fake below unit: nothing + best, bk = E.best_split(a, b, u) + self.assertGreaterEqual(best, tot) + self.assertAlmostEqual(best, a / u) # b > e: best is k = a/unit, weight 1 each + + def test_per_person_cap_and_unit_floor_below_amount_do_not_neutralise_splitting(self): + c = self.cfg() + b, u, a = c["euro_b"], c["euro_unit"], 1e6 + single = E.log_weight(a, b, u) + for wc in (1.0, 3.0, single): + best, k = E.best_split(a, b, u, person_cap=wc) + self.assertGreater(best, min(single, wc)) + self.assertGreater(E.best_split(a, b, 1000.0)[1], 1) # raised unit still splits + self.assertEqual(E.best_split(a, b, a)[1], 1) # unit = amount leaves nothing to split + + def test_identity_cost_neutralises_only_at_a_large_share_of_the_budget(self): + c = self.cfg() + b, u, a = c["euro_b"], c["euro_unit"], 1e6 + cost = E.min_neutralising_cost(a, b, u) + self.assertIsNotNone(cost) + self.assertEqual(E.best_split(a, b, u, identity_cost=cost)[1], 1) + self.assertGreater(E.best_split(a, b, u, identity_cost=cost / 2)[1], 1) + self.assertGreater(cost, a / 4) + + def test_per_identity_cap_is_evaded_by_splitting(self): + c = self.cfg() + W = E.WEIGHTS["equal"] + rest = E.ROLL["Patrons"] * 1.0 + single = E.stake_weight("Patrons", euros=1e6) + self.assertTrue(E.influence_cap(single, rest, W, self.P, (self.P,))["binds"]) + k = 10 + tot, wi = E.split_weight(1e6, k, c["euro_b"], c["euro_unit"]) + self.assertFalse(E.influence_cap(wi, rest + tot - wi, W, self.P, (self.P,))["binds"]) + self.assertGreaterEqual(E.council_share(tot, rest, W, self.P, (self.P,))[1], E.HALF) + + def test_pareto_ladder_is_deterministic_and_above_floor(self): + a, b = E.pareto_ladder(50, random.Random(7)), E.pareto_ladder(50, random.Random(7)) + self.assertEqual(a, b) + self.assertTrue(all(x >= E.PARETO_XM for x in a)) + + class StrategyTests(unittest.TestCase): def test_deviation_never_makes_agent_worse_off(self): rng = random.Random(3) From 081b0fc99157b3204d70d4a8f51264e6b02f28c6 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Thu, 5 Nov 2026 19:29:51 +0000 Subject: [PATCH 009/176] Estate-rule sim: review fixes for the purchased-stake arm Docstrings state weight is per identity, not sybil-safe, hours unanalysed; placeholder parameters marked in code; unit x roll sweep with interval; identity-cost thresholds by bisection (about half the budget, not the doubling-grid 51-82%); headline numbers pinned in a test; 'log bounds' test renamed. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 11 ++- .../2026-11-05-estate-rule-sim/estatesim.py | 70 ++++++++++++++----- .../2026-11-05-estate-rule-sim/results.md | 16 ++++- .../2026-11-05-estate-rule-sim/run.py | 21 ++++-- .../test_estatesim.py | 19 ++++- 5 files changed, 108 insertions(+), 29 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index ab5269e..a5f9440 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -45,12 +45,12 @@ Static weight analysis, not a motion simulation: it measures weight share, not P **The working hypothesis, that logarithmic weight bounds buyout power, is only half true here, and the true half is not the log's doing.** -- **Within the estate the log does not bound a million-euro buyer.** Against the harness's 4-patron roll (Pareto(1.16) donations from 10 EUR, 40 seeds) the buyer holds 0.524 +/- 0.008 of Patrons weight and alone decides the Patrons estate (share above one half) in 85% of seeds. The log shrinks the buyer from 100% (linear weight) to about half; it does not take it below a majority of a 4-person estate. At rolls of 40 and 400 the share falls (binding rates below). +- **Within the estate the log does not bound a million-euro buyer.** Against the harness's 4-patron roll (Pareto(1.16) donations from 10 EUR, 40 seeds) the buyer holds 0.524 +/- 0.008 of Patrons weight and alone decides the Patrons estate (share above one half) in 85% of seeds. The log shrinks the buyer from 100% (linear weight) to about half; it does not take it below a majority of a 4-person estate. This is the harness's own cell (roll 4, unit 10 EUR, b = 10), not a typical one. Swept over unit {1, 10, 100} EUR and roll {4, 40, 400} (40 seeds each, table in results.md) the buyer's mean share of Patrons weight runs from 0.007 to 0.953, and the buyer alone decides the estate in 0 to 100% of seeds depending on the cell (0.85 at the headline cell, 0.65 at roll 40 with unit 100, 1.00 at roll 4 with unit 100, 0.00 in the other six). The roll size, Pareto scale and unit are placeholders; the interval, not the point, is the finding. The weight is per identity, so all of this assumes one identity per buyer (next bullet). - **At council level the bound comes from the estate weights.** With all four estates live the buyer's council share is 0.131 (equal weights) or 0.052 (minds-heavy), below the Patrons weight W_Patrons by construction; the half-influence cap never binds in 6,480 cell-seeds. Linear weight would give 0.25 and 0.10: the log halves the buyer's share, the estate structure sets its ceiling. - **The half-influence cap binds only when other estates are silent.** Fraction of (cell, seed) in which council share x >= .5 over 162 cells (b x unit x roll x amount x weights) x 40 seeds: all four live 0.000; Patrons + Minds live 0.044 (all of it the degenerate case where no other patron clears the unit, so there is nothing to cut against: unenforceable); Patrons alone live 0.222 (0.148 of cells bind in every seed, 0.089 of cell-seeds unenforceable). It binds more at small rolls (Patrons alone: 0.669 at roll 4 and b = 2 down to 0.000 at roll 400) and with a smaller log base. The Patrons-alone scenario is the renormalization case of prior section 10 (drop non-voting estates); how likely it is in practice is not a sim output. - **Splitting wins, by orders of magnitude.** The same 1,000,000 EUR over k identities multiplies weight by 1.9 (k = 2), 8.3 (k = 10), 66.7 (k = 100), 500 (k = 1000), and 16,667 at k = amount/unit = 100,000 (each fake identity buying exactly the unit). The multiplier is (amount/unit) / (1 + log_b(amount/unit)); for b = 10, unit = 10 it is 250 at 10,000 EUR, 2,000 at 100,000 EUR. With k = 10 fake identities the buyer's Patrons-alone share is 0.901, with k = 2 it is 0.676. This refutes the log as a purchase bound unless identities are scarce. - **The half-influence cap is per identity and splitting evades it.** In the Patrons-alone case the single identity trips the cap in 85% of seeds; at k = 2 no identity does (each holds 0.34) while the joint share is 0.676, in every seed. A cap on a person's influence needs an identity oracle the harness does not have. -- **SPEC names no sybil defence** (the charter's frozen roll, A6, bounds joins after notice, not pre-notice buying of identities), so none is implemented as policy. Three candidates are quantified in results.md and none is chosen: a per-person weight cap does not help (it caps the honest single purchase and the fakes are each below it; 100,000x at cap 1); a raised unit floor reduces the multiplier (250 at 1,000 EUR, 5 at 100,000 EUR, 1.0 only at 1,000,000 EUR, where no purchase under the buyer's amount buys any weight), so it neutralises splitting only by pricing out everyone smaller; a per-identity cost neutralises only at about half or more of the budget (51% to 82% on the doubling grid across 10,000 to 1,000,000 EUR), so it would also tax the honest buyer's single identity at that rate. The choice between pricing identities, verifying people or bounding total weight per verified person is a design fork left for the operator. Nothing here rules it. +- **SPEC names no sybil defence** (the charter's frozen roll, A6, bounds joins after notice, not pre-notice buying of identities), so none is implemented as policy. Three candidates are quantified in results.md and none is chosen: a per-person weight cap does not help (it caps the honest single purchase and the fakes are each below it; 100,000x at cap 1); a raised unit floor reduces the multiplier (250 at 1,000 EUR, 5 at 100,000 EUR, 1.0 only at 1,000,000 EUR, where no purchase under the buyer's amount buys any weight), so it neutralises splitting only by pricing out everyone smaller; a per-identity cost neutralises only at about half the budget (bisection values 49.3%, 49.8%, 49.95% of 10,000, 100,000, 1,000,000 EUR; the threshold is c = amount/2, where a second identity is left with nothing to buy), so it would also tax the honest buyer's single identity at that rate. The choice between pricing identities, verifying people or bounding total weight per verified person is a design fork left for the operator. Nothing here rules it. Limits specific to E6: the roll, the Pareto scale, b and unit are assumptions; the buyer joins as an additional patron and buys once (no repeated purchase or liquidation); decisiveness is estate-level only, not council-level (prior section 10 shows weight share is not decisiveness); the best split is a grid maximum, a lower bound; hours play no part in a purchase scenario because estate weights are fixed and the buyer sits in Patrons, so an hours buyer (a Member who is paid or who farms hours) is untested and the conversion of hours into weight is just a per-estate parameter whose gaming is not modeled. @@ -73,3 +73,10 @@ The sign of the PS effect holds across Users appeal 0.4/0.9/1.4, Users turnout . - 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). + +## Limits of E6 added after independent review + +- Weight in `log_weight`, `stake_weight` and `influence_cap` is per identity. Nothing in the module is sybil-safe; the half-influence cap bounds a ledger entry, not a person. +- The hours channel is unanalysed: no scenario gives a buyer hours, so whether hours can be farmed, bought or split is untested. +- Placeholder parameters (marked PLACEHOLDER in `estatesim.py`): b, unit (euros and hours), the Patron roll sizes, the Pareto scale. Ruled: the half cap. From prior section 4: the Pareto exponent. +- The headline figures (0.524, 0.85, split 1.9x/8.3x/66.7x) are pinned in `test_headline_numbers_are_pinned`. diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index 8cee858..63acf4d 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -445,17 +445,19 @@ def verdict(dps, dmt): # set of live estates come from the same tables the rules above use. STAKE_KEYS = ("euro_b", "euro_unit", "hours_b", "hours_unit") -# Per-estate conversion of stake to weight. Assumptions, stated in SPEC section 5c. -# Only Patrons (euros) and Members (contribution hours) carry stake; Minds are +# PLACEHOLDER: every number in STAKE_BASE, HALF excepted, is my assumption (SPEC section 5c), not a ruling +# or data. Results are conditional on them; run.py sweeps b and unit, not hours. +# Per-estate conversion of stake to weight. Only Patrons (euros) and Members (contribution hours) carry stake; Minds are # counted once and Users are one-each, so they have no entry and weigh 1. STAKE_BASE = { "Patrons": dict(euro_b=10.0, euro_unit=10.0, hours_b=10.0, hours_unit=10.0), "Members": dict(euro_b=10.0, euro_unit=10.0, hours_b=10.0, hours_unit=10.0), } -HALF = .5 # operator-influence cap: council weight share strictly below this (prior section 10) +HALF = .5 # RULED, not a placeholder: operator-influence cap: council weight share strictly below this (prior section 10) STRICT = 1e-9 # "strictly below": a capped holder sits at c*(1-STRICT) -PARETO_ALPHA = 1.16 # prior section 4: Pareto(1.16) contribution ladder -PARETO_XM = 10.0 # EUR; smallest ordinary Patron donation +PARETO_ALPHA = 1.16 # exponent from prior section 4 (Pareto(1.16) ladder); the roll sizes below are PLACEHOLDER +PARETO_XM = 10.0 # PLACEHOLDER: EUR scale, mine; prior section 4's ladder starts at 10 +STAKE_SEED = 20261105 def stake_params(name, overrides=()): @@ -469,14 +471,22 @@ def stake_params(name, overrides=()): def log_weight(x, b, unit): - """w = 1 + log_b(x/unit): 1 at x = unit, 0 (not negative) below unit.""" + """w = 1 + log_b(x/unit): 1 at x = unit, 0 (not negative) below unit. + + This is the weight of ONE IDENTITY. It is not sybil-safe: log is sub-linear, so the same x split over + k identities weighs more (split_weight). Whether the log bounds a purchase depends on identities being + scarce, which nothing in this module supplies. b and unit are PLACEHOLDER values (STAKE_BASE).""" if b <= 1 or unit <= 0: raise ValueError("log base must exceed 1 and unit must be positive") return 0.0 if x < unit else 1.0 + math.log(x / unit, b) def stake_weight(name, euros=0.0, hours=0.0, overrides=()): - """One member's weight: euro channel plus contribution-hours channel, each with the estate's own (b, unit).""" + """One identity's weight: euro channel plus contribution-hours channel, each with the estate's own (b, unit). + + Per identity, not per person: splitting evades it (see log_weight). The hours channel is UNANALYSED: + it is added here, but no scenario in run.py gives a buyer hours, so nothing below tests whether hours + can be farmed, bought or split. Its (b, unit) are PLACEHOLDER.""" p = stake_params(name, overrides) if not p: return 1.0 @@ -499,7 +509,10 @@ def council_share(w, rest, W, e, live): def influence_cap(w, rest, W, e, live, c=HALF): """Operator-influence cap (prior section 10, ruling operator-influence-below-half): a holder's council weight share must be strictly below c. Binds iff x >= c; the holder's internal weight is - then cut until x = c*(1-STRICT). Unenforceable when nobody else holds weight in the estate.""" + then cut until x = c*(1-STRICT). Unenforceable when nobody else holds weight in the estate. + + The cap is applied to ONE IDENTITY's weight w. A holder who splits across identities is never cut + (cap evasion, results.md), so this is a bound on a ledger entry, not on a person.""" s, x = council_share(w, rest, W, e, live) out = dict(s=s, x=x, binds=x >= c - EPS, w_capped=w, s_capped=s, x_capped=x, enforceable=True) if not out["binds"]: @@ -534,14 +547,33 @@ def best_split(amount, b, unit, identity_cost=0.0, person_cap=None): return best[0], -best[1] -def min_neutralising_cost(amount, b, unit, person_cap=None): - """Smallest per-identity cost on a doubling grid (from unit) at which no split beats one identity, - or None. Neutral = best split is k = 1 and one identity still has weight.""" - c = unit - while c < amount: - w1 = split_weight(amount, 1, b, unit, c, person_cap)[0] - tot, k = best_split(amount, b, unit, c, person_cap) - if w1 > 0 and k == 1: - return c - c *= 2 - return None +def min_neutralising_cost(amount, b, unit, person_cap=None, tol=1e-3): + """Smallest per-identity cost at which no split beats one identity, found by bisection to relative + tol (a bisection value, not a grid point). Neutral = best split is k = 1 and one identity still has + weight. A doubling search from unit brackets the first neutral cost; assumes the predicate is + monotone inside the bracket. Returns None if no cost below the amount is neutral.""" + def neutral(c): + return (split_weight(amount, 1, b, unit, c, person_cap)[0] > 0 + and best_split(amount, b, unit, c, person_cap)[1] == 1) + hi = unit + while hi < amount and not neutral(hi): + hi *= 2 + if hi >= amount: + return None + lo = hi / 2 if hi > unit else 0.0 + while hi - lo > tol * hi: + mid = (lo + hi) / 2 + lo, hi = (lo, mid) if neutral(mid) else (mid, hi) + return hi + + +def stake_ladder(n, s): + """Seed s's roll of n ordinary patrons: a pure function of (n, s).""" + return pareto_ladder(n, random.Random(STAKE_SEED + 1000 * n + s)) + + +def buyer_runs(amount, n, seeds, W, live, overrides=()): + """influence_cap result for a buyer of `amount` EUR against each of `seeds` rolls of n ordinary patrons.""" + wb = stake_weight("Patrons", euros=amount, overrides=overrides) + return [influence_cap(wb, sum(stake_weight("Patrons", euros=x, overrides=overrides) for x in stake_ladder(n, s)), + W, ESTATES.index("Patrons"), live) for s in range(seeds)] diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md index 7f9d59e..99fcf43 100644 --- a/docs/research/2026-11-05-estate-rule-sim/results.md +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -806,6 +806,16 @@ Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins | minds-heavy | Patrons + Minds | 0.524 ±0.008 | 0.105 ±0.002 | 0.200 ±0.000 | 0.00 | 0.00 | 0.85 | | minds-heavy | Patrons alone | 0.524 ±0.008 | 0.524 ±0.008 | 1.000 ±0.000 | 0.85 | 1.00 | 0.85 | +**Million-euro buyer's share of Patrons weight, b = 10, by unit and roll (mean over seeds, 95% interval; share of seeds in which the buyer alone decides the estate)** + +| unit EUR | roll 4 | roll 40 | roll 400 | +|---|---|---|---| +| 1 | 0.425 ±0.005 (0.00) | 0.069 ±0.000 (0.00) | 0.007 ±0.000 (0.00) | +| 10 | 0.524 ±0.008 (0.85) | 0.098 ±0.001 (0.00) | 0.011 ±0.000 (0.00) | +| 100 | 0.953 ±0.028 (1.00) | 0.579 ±0.040 (0.65) | 0.118 ±0.004 (0.00) | + +Interval over the swept cells: s from 0.007 to 0.953. The 0.524 headline is the harness's own cell (roll 4, unit 10), not a typical one: the buyer's majority of the estate depends on how few other patrons there are. + **Cap-binding rate over the sweep (b, unit, roll, amount, weights x live set; every cell run on every seed)** | live estates | cells | cells x seeds | binding (cell, seed) | cells binding in every seed | cells never binding | binding but unenforceable | @@ -850,9 +860,9 @@ Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns): | unit floor | 100000 EUR | 5.0 | no | | unit floor | 500000 EUR | 1.5 | no | | unit floor | 1e+06 EUR | 1.0 | yes | -| identity cost | smallest on a doubling grid, amount 10000 EUR | | yes at 5120 EUR per identity (51% of the budget) | -| identity cost | smallest on a doubling grid, amount 100000 EUR | | yes at 81920 EUR per identity (82% of the budget) | -| identity cost | smallest on a doubling grid, amount 1e+06 EUR | | yes at 655360 EUR per identity (66% of the budget) | +| identity cost | smallest cost by bisection, amount 10000 EUR | | yes at 4930 EUR per identity (49.3% of the budget, bisection to 0.1%) | +| identity cost | smallest cost by bisection, amount 100000 EUR | | yes at 49800 EUR per identity (49.8% of the budget, bisection to 0.1%) | +| identity cost | smallest cost by bisection, amount 1e+06 EUR | | yes at 499520 EUR per identity (50.0% of the budget, bisection to 0.1%) | **Cap evasion: the cap is per identity. Patrons alone, equal weights, roll 4, defaults, 1,000,000 EUR over k identities** diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index 527a454..d20efd8 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -210,7 +210,6 @@ def copy_reading(cells, res): return L + [""] -STAKE_SEED = 20261105 PATRONS = E.ESTATES.index("Patrons") LIVE = {"all four estates": (0, 1, 2, 3), "Patrons + Minds": (0, PATRONS), "Patrons alone": (PATRONS,)} @@ -232,7 +231,7 @@ def stake_section(quick): f"{seeds} seeds each. Weight w = 1 + log_b(amount/unit), 0 below unit; defaults b = {E.STAKE_BASE['Patrons']['euro_b']:.0f}, " f"unit = {E.STAKE_BASE['Patrons']['euro_unit']:.0f} EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight " "(estate weight W x s over the live estates' weights); the cap binds iff x >= .5.", ""] - ladders = {(n, s): E.pareto_ladder(n, random.Random(STAKE_SEED + 1000 * n + s)) for n in rolls for s in range(seeds)} + ladders = {(n, s): E.stake_ladder(n, s) for n in rolls for s in range(seeds)} # headline: the million-euro buyer, defaults, roll of the harness n0 = E.ROLL["Patrons"] L += ["**Million-euro buyer, defaults, Patrons roll " + str(n0) + " (mean over seeds, 95% interval); linear = weight proportional to amount, the counterfactual the log is meant to beat**", "", @@ -251,6 +250,20 @@ def stake_section(quick): fr = [sum(r[k] for r in rows) / seeds for k in (3, 4, 5)] L.append(f"| {wn} | {ln} | {f(*m[0])} | {f(*m[1])} | {f(*m[2])} | {fr[0]:.2f} | {fr[1]:.2f} | {fr[2]:.2f} |") L.append("") + # the headline share is one (unit, roll) cell: sweep both, state the interval + L += ["**Million-euro buyer's share of Patrons weight, b = 10, by unit and roll (mean over seeds, 95% interval; share of seeds in which the buyer alone decides the estate)**", "", + "| unit EUR | " + " | ".join(f"roll {n}" for n in rolls) + " |", "|---|" + "---|" * len(rolls)] + cells = [] + for u in units: + cols = [] + for n in rolls: + r = E.buyer_runs(EUR, n, seeds, E.WEIGHTS["equal"], (PATRONS,), (("Patrons", "euro_b", 10.0), ("Patrons", "euro_unit", u))) + m = E.mean_ci([x["s"] for x in r]) + cells.append(m[0]) + cols.append(f"{f(*m)} ({sum(x['s'] > .5 for x in r) / seeds:.2f})") + L.append(f"| {u:g} | " + " | ".join(cols) + " |") + L += ["", f"Interval over the swept cells: s from {min(cells):.3f} to {max(cells):.3f}. The 0.524 headline is the harness's own cell (roll {n0}, unit 10), " + "not a typical one: the buyer's majority of the estate depends on how few other patrons there are.", ""] # cap-binding rate across the whole sweep tally = {} for wn, W in E.WEIGHTS.items(): @@ -317,8 +330,8 @@ def stake_section(quick): L.append(f"| unit floor | {uf:g} EUR | {bt / s1:.1f} | {'yes' if bk == 1 else 'no'} |") for a in amounts: mc = E.min_neutralising_cost(a, b0, u0) - L.append(f"| identity cost | smallest on a doubling grid, amount {a:g} EUR | | " - + (f"yes at {mc:g} EUR per identity ({mc / a:.0%} of the budget)" if mc else "no cost below the amount") + " |") + L.append(f"| identity cost | smallest cost by bisection, amount {a:g} EUR | | " + + (f"yes at {mc:.0f} EUR per identity ({mc / a:.1%} of the budget, bisection to 0.1%)" if mc else "no cost below the amount") + " |") # cap evasion by splitting, Patrons alone L += ["", "**Cap evasion: the cap is per identity. Patrons alone, equal weights, roll " + str(n0) + ", defaults, 1,000,000 EUR over k identities**", "", "| k | joint share x | share of one identity | cap binds on an identity | joint x >= .5 (evaded) |", "|---|---|---|---|---|"] diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 6b00613..5af6dce 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -337,7 +337,7 @@ class StakeTests(unittest.TestCase): self.assertLess(r["x_capped"], E.HALF) self.assertAlmostEqual(r["x_capped"], E.HALF, places=6) - def test_log_bounds_buyout_relative_to_linear(self): + def test_log_weight_gives_a_smaller_share_than_linear_but_still_a_near_total_one_in_a_tiny_estate(self): c = self.cfg() rest_amounts = [10.0, 50.0, 200.0, 5000.0] W = E.WEIGHTS["equal"] @@ -382,6 +382,23 @@ class StakeTests(unittest.TestCase): self.assertEqual(E.best_split(a, b, u, identity_cost=cost)[1], 1) self.assertGreater(E.best_split(a, b, u, identity_cost=cost / 2)[1], 1) self.assertGreater(cost, a / 4) + self.assertAlmostEqual(cost / a, .5, delta=.01) # bisection value: just under half the budget + self.assertLess(cost, a / 2 + 1e-9) + + def test_headline_numbers_are_pinned(self): + """The figures REPORT.md quotes, under the placeholder defaults and the fixed seeds (40, STAKE_SEED).""" + W = E.WEIGHTS["equal"] + r = E.buyer_runs(1e6, E.ROLL["Patrons"], 40, W, (self.P,)) + m, hw = E.mean_ci([x["s"] for x in r]) + self.assertEqual(round(m, 3), .524) + self.assertEqual(round(hw, 3), .008) + self.assertEqual(sum(x["s"] > .5 for x in r) / 40, .85) + c = self.cfg() + w1 = E.log_weight(1e6, c["euro_b"], c["euro_unit"]) + for k, want in ((2, 1.9), (10, 8.3), (100, 66.7)): + self.assertEqual(round(E.split_weight(1e6, k, c["euro_b"], c["euro_unit"])[0] / w1, 1), want) + for n in (40, 400): # the headline is a small-roll fact + self.assertLess(max(x["s"] for x in E.buyer_runs(1e6, n, 40, W, (self.P,))), .5) def test_per_identity_cap_is_evaded_by_splitting(self): c = self.cfg() From 0f985c6003605c74badf089286bb8fd2bd142acd Mon Sep 17 00:00:00 2001 From: Heimdall Date: Fri, 6 Nov 2026 02:32:20 +0000 Subject: [PATCH 010/176] Estate-rule sim: pin the stake arm to heimdall-stake's golden vectors Copies CultLib PR #9 (head 84f932ec) tests/vectors/stake_golden.csv unmodified and checks log_weight and split_weight against all 26 rows. 25 match within rounding; the one sub-unit row differs by design: the arm's cliff at unit is Libby's min_amount_per_identity = unit, which the vectors do not set. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/estatesim.py | 4 +++ .../test_estatesim.py | 31 +++++++++++++++++++ .../vectors/stake_golden.csv | 29 +++++++++++++++++ 3 files changed, 64 insertions(+) create mode 100644 docs/research/2026-11-05-estate-rule-sim/vectors/stake_golden.csv diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index 63acf4d..eba9812 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -473,6 +473,10 @@ def stake_params(name, overrides=()): def log_weight(x, b, unit): """w = 1 + log_b(x/unit): 1 at x = unit, 0 (not negative) below unit. + Equals CultLib heimdall-stake `weight` with floor 0, cap None and min_amount_per_identity = unit, which + is the cliff at unit; Libby's continuous log below unit is not used. Pinned to her golden vectors by + test_estatesim.StakeVectors (vectors/stake_golden.csv). + This is the weight of ONE IDENTITY. It is not sybil-safe: log is sub-linear, so the same x split over k identities weighs more (split_weight). Whether the log bounds a purchase depends on identities being scarce, which nothing in this module supplies. b and unit are PLACEHOLDER values (STAKE_BASE).""" diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 5af6dce..3fb0d9f 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -506,5 +506,36 @@ class HarnessTests(unittest.TestCase): self.assertEqual(E.verdict((-.01, .05), (0.0, .02)), "undecided") + +class StakeVectors(unittest.TestCase): + """Pins the arm's log_weight / split_weight to CultLib heimdall-stake's golden vectors (PR #9, head 84f932ec, + copied unmodified to vectors/stake_golden.csv). The arm is Libby's function with min_amount_per_identity = unit, + so rows at or above the unit must match; a row below the unit must be 0 in the arm (the cliff) while the + vectors, which set no minimum, give the continuous value. Vectors are integer cents and micro-weights, the + arm is float and unit-agnostic: tolerance is 1 micro-weight per identity (Libby rounds each identity, the arm the total).""" + + @staticmethod + def rows(): + path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "vectors", "stake_golden.csv") + with open(path) as fh: + lines = [l.strip() for l in fh if l.strip() and not l.startswith("#")] + out = [l.split(",") for l in lines] + assert len(out) == 26 + return [(k, int(b), int(u), int(a), int(n), int(e)) for k, b, u, a, n, e in out] + + def test_every_vector_row(self): + for kind, b, u, a, k, expected in self.rows(): + with self.subTest(kind=kind, b=b, unit=u, amount=a, k=k): + if kind == "single": + got = E.log_weight(a, b, u) * 1e6 + if a < u: + self.assertEqual(got, 0.0) # arm's cliff = min_amount_per_identity = unit + continue + else: + got = E.split_weight(a, k, b, u)[0] * 1e6 + self.assertGreaterEqual(a // k, u) # every split row keeps each identity at or above unit + self.assertLessEqual(abs(got - expected), max(1, k)) + + if __name__ == "__main__": unittest.main() diff --git a/docs/research/2026-11-05-estate-rule-sim/vectors/stake_golden.csv b/docs/research/2026-11-05-estate-rule-sim/vectors/stake_golden.csv new file mode 100644 index 0000000..26f8978 --- /dev/null +++ b/docs/research/2026-11-05-estate-rule-sim/vectors/stake_golden.csv @@ -0,0 +1,29 @@ +# kind,base,unit_cents,amount_cents,k,expected_micro +# single: weight of one identity holding amount. split: budget (amount) split evenly over k identities (first amount%k hold one extra cent), summed. +# expected values computed independently with 60-digit decimal ln, rounded half up. No floor, cap or minimum. +single,10,100,100,1,1000000 +single,10,100,1000,1,2000000 +single,10,100,10000,1,3000000 +single,10,100,1000000,1,5000000 +single,10,100,50,1,698970 +single,10,100,10,1,0 +single,10,100,1,1,0 +single,2,100,400,1,3000000 +single,2,100,100,1,1000000 +single,2,1,1,1,1000000 +single,3,500,123456,1,6014537 +single,7,1,987654321,1,11643268 +single,10,1,1,1,1000000 +single,16,250,99999,1,3160960 +split,10,100,10000,1,3000000 +split,10,100,10000,2,5397940 +split,10,100,10000,10,20000000 +split,10,100,10000,100,100000000 +split,2,100,10000,1,7643856 +split,2,100,10000,2,13287712 +split,2,100,10000,10,43219280 +split,2,100,10000,100,100000000 +split,10,100,100000,1,4000000 +split,10,100,100000,2,7397940 +split,10,100,100000,10,30000000 +split,10,100,100000,100,200000000 From 55253c48b4f352e03a4490cf8399136b68cd4816 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Fri, 6 Nov 2026 04:34:57 +0000 Subject: [PATCH 011/176] Estate-rule sim: stake log_weight follows heimdall-stake's log form, no cliff at unit w = max(0, 1 + log_b(x/unit)); all 14 single and 12 split golden rows now pass. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/estatesim.py | 9 ++++----- .../2026-11-05-estate-rule-sim/test_estatesim.py | 16 +++++++--------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index eba9812..d4693bc 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -471,18 +471,17 @@ def stake_params(name, overrides=()): def log_weight(x, b, unit): - """w = 1 + log_b(x/unit): 1 at x = unit, 0 (not negative) below unit. + """w = max(0, 1 + log_b(x/unit)): 1 at x = unit, continuous below it, 0 (not negative) once x <= unit/b. - Equals CultLib heimdall-stake `weight` with floor 0, cap None and min_amount_per_identity = unit, which - is the cliff at unit; Libby's continuous log below unit is not used. Pinned to her golden vectors by - test_estatesim.StakeVectors (vectors/stake_golden.csv). + Equals CultLib heimdall-stake `weight` (PR #9, 84f932ec) with floor 0, cap None and no minimum: no cliff + at unit. Pinned to its golden vectors by test_estatesim.StakeVectors (vectors/stake_golden.csv). This is the weight of ONE IDENTITY. It is not sybil-safe: log is sub-linear, so the same x split over k identities weighs more (split_weight). Whether the log bounds a purchase depends on identities being scarce, which nothing in this module supplies. b and unit are PLACEHOLDER values (STAKE_BASE).""" if b <= 1 or unit <= 0: raise ValueError("log base must exceed 1 and unit must be positive") - return 0.0 if x < unit else 1.0 + math.log(x / unit, b) + return max(0.0, 1.0 + math.log(x / unit, b)) if x > 0 else 0.0 def stake_weight(name, euros=0.0, hours=0.0, overrides=()): diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index 3fb0d9f..c4e9dd0 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -297,7 +297,8 @@ class StakeTests(unittest.TestCase): c = self.cfg() b, u = c["euro_b"], c["euro_unit"] self.assertEqual(E.log_weight(u, b, u), 1.0) - self.assertEqual(E.log_weight(u * .99, b, u), 0.0) # below unit: no weight, not negative + self.assertAlmostEqual(E.log_weight(u / 2, b, u), 1 + math.log(.5, b)) # below unit: continuous, no cliff + self.assertEqual(E.log_weight(u / b ** 2, b, u), 0.0) # clamped at 0, never negative self.assertAlmostEqual(E.log_weight(u * b ** 3, b, u), 4.0) # each factor b adds one self.assertLess(E.log_weight(10 * u, b, u), 10) # sub-linear @@ -359,7 +360,9 @@ class StakeTests(unittest.TestCase): self.assertAlmostEqual(each, 1 + math.log(a / (k * u), b)) self.assertAlmostEqual(tot, k * (1 + math.log(a / (k * u), b))) self.assertGreater(tot, E.log_weight(a, b, u)) - self.assertEqual(E.split_weight(a, int(a / u) + 1, b, u)[0], 0.0) # every fake below unit: nothing + kk = int(a / u) + 1 # every fake just below unit: still ~1 each, no cliff + self.assertAlmostEqual(E.split_weight(a, kk, b, u)[0], kk * (1 + math.log(a / (kk * u), b))) + self.assertGreater(E.split_weight(a, kk, b, u)[0], 0.99 * a / u) best, bk = E.best_split(a, b, u) self.assertGreaterEqual(best, tot) self.assertAlmostEqual(best, a / u) # b > e: best is k = a/unit, weight 1 each @@ -509,9 +512,8 @@ class HarnessTests(unittest.TestCase): class StakeVectors(unittest.TestCase): """Pins the arm's log_weight / split_weight to CultLib heimdall-stake's golden vectors (PR #9, head 84f932ec, - copied unmodified to vectors/stake_golden.csv). The arm is Libby's function with min_amount_per_identity = unit, - so rows at or above the unit must match; a row below the unit must be 0 in the arm (the cliff) while the - vectors, which set no minimum, give the continuous value. Vectors are integer cents and micro-weights, the + copied unmodified to vectors/stake_golden.csv). The arm is Libby's function with no minimum, + and every row (14 single, 12 split) must match, including those below the unit: no cliff. Vectors are integer cents and micro-weights, the arm is float and unit-agnostic: tolerance is 1 micro-weight per identity (Libby rounds each identity, the arm the total).""" @staticmethod @@ -528,12 +530,8 @@ class StakeVectors(unittest.TestCase): with self.subTest(kind=kind, b=b, unit=u, amount=a, k=k): if kind == "single": got = E.log_weight(a, b, u) * 1e6 - if a < u: - self.assertEqual(got, 0.0) # arm's cliff = min_amount_per_identity = unit - continue else: got = E.split_weight(a, k, b, u)[0] * 1e6 - self.assertGreaterEqual(a // k, u) # every split row keeps each identity at or above unit self.assertLessEqual(abs(got - expected), max(1, k)) From b6c1e9af7373287190d330108a72cf5c0089efc7 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Fri, 6 Nov 2026 07:50:04 +0000 Subject: [PATCH 012/176] Estate-rule sim: regenerate results.md and fix stale half-cap numbers and the "0 below unit" wording REPORT.md E6 and results.md still held pre-fix numbers (half-cap 0.044/0.222, s max 0.953). Regenerated with the current sim: s max 0.777; half-cap binding all four 0.000, Patrons+Minds 0.008, Patrons alone 0.165. Weight is 0 only at amount <= unit/b (run.py, REPORT.md, SPEC.md); the splitting table no longer prints a cliff "0 (below unit)". Test count 54. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 8 ++++---- docs/research/2026-11-05-estate-rule-sim/SPEC.md | 2 +- .../2026-11-05-estate-rule-sim/results.md | 16 ++++++++-------- docs/research/2026-11-05-estate-rule-sim/run.py | 4 ++-- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index a5f9440..1813dcb 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -1,6 +1,6 @@ # 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 52 tests). Output is byte-identical across reruns and across `--jobs` values. +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 54 tests). Output is byte-identical across reruns and across `--jobs` values. ## Answer @@ -41,13 +41,13 @@ Limits specific to this result: copying is triggered only when the holder is ove ## Purchased stake (E6, SPEC section 5c) -Static weight analysis, not a motion simulation: it measures weight share, not PS or MT. Weight w = 1 + log_b(amount/unit), 0 below unit, per-estate b and unit (defaults b = 10, unit = 10 EUR, my choices, in SPEC 5c). The harness had no contribution mechanism, so contribution hours are a new per-agent input with their own per-estate conversion (defaults b = 10, unit = 10 hours); they add to the euro weight and matter to no buyer result below. +Static weight analysis, not a motion simulation: it measures weight share, not PS or MT. Weight w = 1 + log_b(amount/unit), 0 at amount <= unit/b, per-estate b and unit (defaults b = 10, unit = 10 EUR, my choices, in SPEC 5c). The harness had no contribution mechanism, so contribution hours are a new per-agent input with their own per-estate conversion (defaults b = 10, unit = 10 hours); they add to the euro weight and matter to no buyer result below. **The working hypothesis, that logarithmic weight bounds buyout power, is only half true here, and the true half is not the log's doing.** -- **Within the estate the log does not bound a million-euro buyer.** Against the harness's 4-patron roll (Pareto(1.16) donations from 10 EUR, 40 seeds) the buyer holds 0.524 +/- 0.008 of Patrons weight and alone decides the Patrons estate (share above one half) in 85% of seeds. The log shrinks the buyer from 100% (linear weight) to about half; it does not take it below a majority of a 4-person estate. This is the harness's own cell (roll 4, unit 10 EUR, b = 10), not a typical one. Swept over unit {1, 10, 100} EUR and roll {4, 40, 400} (40 seeds each, table in results.md) the buyer's mean share of Patrons weight runs from 0.007 to 0.953, and the buyer alone decides the estate in 0 to 100% of seeds depending on the cell (0.85 at the headline cell, 0.65 at roll 40 with unit 100, 1.00 at roll 4 with unit 100, 0.00 in the other six). The roll size, Pareto scale and unit are placeholders; the interval, not the point, is the finding. The weight is per identity, so all of this assumes one identity per buyer (next bullet). +- **Within the estate the log does not bound a million-euro buyer.** Against the harness's 4-patron roll (Pareto(1.16) donations from 10 EUR, 40 seeds) the buyer holds 0.524 +/- 0.008 of Patrons weight and alone decides the Patrons estate (share above one half) in 85% of seeds. The log shrinks the buyer from 100% (linear weight) to about half; it does not take it below a majority of a 4-person estate. This is the harness's own cell (roll 4, unit 10 EUR, b = 10), not a typical one. Swept over unit {1, 10, 100} EUR and roll {4, 40, 400} (40 seeds each, table in results.md) the buyer's mean share of Patrons weight runs from 0.007 to 0.777, and the buyer alone decides the estate in 0 to 100% of seeds depending on the cell (0.85 at the headline cell, 1.00 at roll 4 with unit 100, 0.00 in the other seven). The roll size, Pareto scale and unit are placeholders; the interval, not the point, is the finding. The weight is per identity, so all of this assumes one identity per buyer (next bullet). - **At council level the bound comes from the estate weights.** With all four estates live the buyer's council share is 0.131 (equal weights) or 0.052 (minds-heavy), below the Patrons weight W_Patrons by construction; the half-influence cap never binds in 6,480 cell-seeds. Linear weight would give 0.25 and 0.10: the log halves the buyer's share, the estate structure sets its ceiling. -- **The half-influence cap binds only when other estates are silent.** Fraction of (cell, seed) in which council share x >= .5 over 162 cells (b x unit x roll x amount x weights) x 40 seeds: all four live 0.000; Patrons + Minds live 0.044 (all of it the degenerate case where no other patron clears the unit, so there is nothing to cut against: unenforceable); Patrons alone live 0.222 (0.148 of cells bind in every seed, 0.089 of cell-seeds unenforceable). It binds more at small rolls (Patrons alone: 0.669 at roll 4 and b = 2 down to 0.000 at roll 400) and with a smaller log base. The Patrons-alone scenario is the renormalization case of prior section 10 (drop non-voting estates); how likely it is in practice is not a sim output. +- **The half-influence cap binds only when other estates are silent.** Fraction of (cell, seed) in which council share x >= .5 over 162 cells (b x unit x roll x amount x weights) x 40 seeds: all four live 0.000; Patrons + Minds live 0.008 (all of it the degenerate case where no other patron clears the unit, so there is nothing to cut against: unenforceable); Patrons alone live 0.165 (0.099 of cells bind in every seed, 0.017 of cell-seeds unenforceable). It binds more at small rolls (Patrons alone: 0.669 at roll 4 and b = 2 down to 0.000 at roll 400) and with a smaller log base. The Patrons-alone scenario is the renormalization case of prior section 10 (drop non-voting estates); how likely it is in practice is not a sim output. - **Splitting wins, by orders of magnitude.** The same 1,000,000 EUR over k identities multiplies weight by 1.9 (k = 2), 8.3 (k = 10), 66.7 (k = 100), 500 (k = 1000), and 16,667 at k = amount/unit = 100,000 (each fake identity buying exactly the unit). The multiplier is (amount/unit) / (1 + log_b(amount/unit)); for b = 10, unit = 10 it is 250 at 10,000 EUR, 2,000 at 100,000 EUR. With k = 10 fake identities the buyer's Patrons-alone share is 0.901, with k = 2 it is 0.676. This refutes the log as a purchase bound unless identities are scarce. - **The half-influence cap is per identity and splitting evades it.** In the Patrons-alone case the single identity trips the cap in 85% of seeds; at k = 2 no identity does (each holds 0.34) while the joint share is 0.676, in every seed. A cap on a person's influence needs an identity oracle the harness does not have. - **SPEC names no sybil defence** (the charter's frozen roll, A6, bounds joins after notice, not pre-notice buying of identities), so none is implemented as policy. Three candidates are quantified in results.md and none is chosen: a per-person weight cap does not help (it caps the honest single purchase and the fakes are each below it; 100,000x at cap 1); a raised unit floor reduces the multiplier (250 at 1,000 EUR, 5 at 100,000 EUR, 1.0 only at 1,000,000 EUR, where no purchase under the buyer's amount buys any weight), so it neutralises splitting only by pricing out everyone smaller; a per-identity cost neutralises only at about half the budget (bisection values 49.3%, 49.8%, 49.95% of 10,000, 100,000, 1,000,000 EUR; the threshold is c = amount/2, where a second identity is left with nothing to buy), so it would also tax the honest buyer's single identity at that rate. The choice between pricing identities, verifying people or bounding total weight per verified person is a design fork left for the operator. Nothing here rules it. diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 4978cd7..687a6db 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -95,7 +95,7 @@ Serves `heimdall-body:follow_up:chat-s1946-1946`. Serves the purchased-stake brief (operator relayed: Patron vote power is logarithmic in donation, prior section 4; operator influence strictly below half, ruling `operator-influence-below-half`, prior section 10). Not a motion simulation: a static weight analysis, so it measures weight share and decisiveness, not PS or MT. -**Weight.** A purchase of `amount` EUR weighs w = 1 + log_b(amount/unit): 1 at amount = unit, 0 below unit (below the unit buys no weight, never negative). Each estate has its own conversion, set through `Config.overrides` entries `(estate, key, value)` with keys `euro_b`, `euro_unit`, `hours_b`, `hours_unit` (defaults in `STAKE_BASE`). Only Patrons (euros) and Members (hours) carry stake; Minds are counted once and Users are one-each, so both weigh 1. +**Weight.** A purchase of `amount` EUR weighs w = 1 + log_b(amount/unit): 1 at amount = unit, continuous below it, 0 at amount <= unit/b (never negative). Each estate has its own conversion, set through `Config.overrides` entries `(estate, key, value)` with keys `euro_b`, `euro_unit`, `hours_b`, `hours_unit` (defaults in `STAKE_BASE`). Only Patrons (euros) and Members (hours) carry stake; Minds are counted once and Users are one-each, so both weigh 1. **Defaults chosen (assumptions, not rulings; the brief gave none).** Patrons and Members alike: euro b = 10, unit = 10 EUR; hours b = 10, unit = 10 hours. b = 10 reads as "each tenfold purchase adds one vote of weight", the simplest reading of the operator's "logarithmic"; 10 EUR is the smallest ordinary Patron donation in the prior ladder (prior section 4: 10, 50, 200, 5000); 10 hours is roughly a working day or so of contribution. The sweep varies b over {2, 10, 100} and unit over {1, 10, 100} EUR; hours are not swept because no buyer outcome depends on them (see below). diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md index 99fcf43..cd14773 100644 --- a/docs/research/2026-11-05-estate-rule-sim/results.md +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -793,7 +793,7 @@ PS by category threshold: ## E6 purchased stake: logarithmic weight, splitting, and the half-influence cap (SPEC section 5c) -Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins the Patrons estate with one purchase; the 4-patron roll of the harness (and 40, 400) holds Pareto(1.16) donations from 10 EUR, 40 seeds each. Weight w = 1 + log_b(amount/unit), 0 below unit; defaults b = 10, unit = 10 EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight (estate weight W x s over the live estates' weights); the cap binds iff x >= .5. +Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins the Patrons estate with one purchase; the 4-patron roll of the harness (and 40, 400) holds Pareto(1.16) donations from 10 EUR, 40 seeds each. Weight w = 1 + log_b(amount/unit), 0 at amount <= unit/b; defaults b = 10, unit = 10 EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight (estate weight W x s over the live estates' weights); the cap binds iff x >= .5. **Million-euro buyer, defaults, Patrons roll 4 (mean over seeds, 95% interval); linear = weight proportional to amount, the counterfactual the log is meant to beat** @@ -812,24 +812,24 @@ Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins |---|---|---|---| | 1 | 0.425 ±0.005 (0.00) | 0.069 ±0.000 (0.00) | 0.007 ±0.000 (0.00) | | 10 | 0.524 ±0.008 (0.85) | 0.098 ±0.001 (0.00) | 0.011 ±0.000 (0.00) | -| 100 | 0.953 ±0.028 (1.00) | 0.579 ±0.040 (0.65) | 0.118 ±0.004 (0.00) | +| 100 | 0.777 ±0.023 (1.00) | 0.251 ±0.008 (0.00) | 0.032 ±0.000 (0.00) | -Interval over the swept cells: s from 0.007 to 0.953. The 0.524 headline is the harness's own cell (roll 4, unit 10), not a typical one: the buyer's majority of the estate depends on how few other patrons there are. +Interval over the swept cells: s from 0.007 to 0.777. The 0.524 headline is the harness's own cell (roll 4, unit 10), not a typical one: the buyer's majority of the estate depends on how few other patrons there are. **Cap-binding rate over the sweep (b, unit, roll, amount, weights x live set; every cell run on every seed)** | live estates | cells | cells x seeds | binding (cell, seed) | cells binding in every seed | cells never binding | binding but unenforceable | |---|---|---|---|---|---|---| | all four estates | 162 | 6480 | 0.000 | 0.000 | 1.000 | 0.000 | -| Patrons + Minds | 162 | 6480 | 0.044 | 0.000 | 0.889 | 0.044 | -| Patrons alone | 162 | 6480 | 0.222 | 0.148 | 0.704 | 0.089 | +| Patrons + Minds | 162 | 6480 | 0.008 | 0.000 | 0.981 | 0.008 | +| Patrons alone | 162 | 6480 | 0.165 | 0.099 | 0.790 | 0.017 | Binding rate in the Patrons-alone scenario by Patrons roll and by log base (fraction of cells x seeds): | roll | b=2 | b=10 | b=100 | |---|---|---|---| -| 4 | 0.669 | 0.447 | 0.333 | -| 40 | 0.286 | 0.169 | 0.094 | +| 4 | 0.669 | 0.447 | 0.114 | +| 40 | 0.250 | 0.000 | 0.000 | | 400 | 0.000 | 0.000 | 0.000 | **Splitting: the same total split over k identities (defaults, one honest identity = k 1). Multiplier = total weight of the split / weight of the single purchase** @@ -877,7 +877,7 @@ Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns): | hours | 5 | 10 | 100 | 1000 | 10000 | |---|---|---|---|---|---| -| weight | 0.00 | 1.00 | 2.00 | 3.00 | 4.00 | +| weight | 0.70 | 1.00 | 2.00 | 3.00 | 4.00 | ## Claim tally over all cells (SPEC section 8) diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index d20efd8..cc3755f 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -228,7 +228,7 @@ def stake_section(quick): L = ["## E6 purchased stake: logarithmic weight, splitting, and the half-influence cap (SPEC section 5c)", "", "Static weight analysis (no motions are simulated, so no PS or MT): a buyer joins the Patrons estate with one purchase; " f"the {E.ROLL['Patrons']}-patron roll of the harness (and 40, 400) holds Pareto({E.PARETO_ALPHA}) donations from {E.PARETO_XM:.0f} EUR, " - f"{seeds} seeds each. Weight w = 1 + log_b(amount/unit), 0 below unit; defaults b = {E.STAKE_BASE['Patrons']['euro_b']:.0f}, " + f"{seeds} seeds each. Weight w = 1 + log_b(amount/unit), 0 at amount <= unit/b; defaults b = {E.STAKE_BASE['Patrons']['euro_b']:.0f}, " f"unit = {E.STAKE_BASE['Patrons']['euro_unit']:.0f} EUR. Share s is the buyer's share of Patrons weight; x is its share of council weight " "(estate weight W x s over the live estates' weights); the cap binds iff x >= .5.", ""] ladders = {(n, s): E.stake_ladder(n, s) for n in rolls for s in range(seeds)} @@ -306,7 +306,7 @@ def stake_section(quick): w1 = E.log_weight(a, b0, u0) bt, bk = E.best_split(a, b0, u0) L.append(f"| {a:g} | {w1:.2f} | " + " | ".join( - f"{E.split_weight(a, k, b0, u0)[0] / w1:.1f}" if a / k >= u0 else "0 (below unit)" for k in (2, 10, 100, 1000)) + + f"{E.split_weight(a, k, b0, u0)[0] / w1:.1f}" for k in (2, 10, 100, 1000)) + f" | {bk} | {bt / w1:.0f} |") L += ["", "Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns):", "", "| b | " + " | ".join(f"unit={u:g}" for u in units) + " |", "|---|" + "---|" * len(units)] From d6c96fe1a16ec62df3908ab18cdc2c40b28968e1 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Fri, 6 Nov 2026 15:54:56 +0000 Subject: [PATCH 013/176] Estate-rule sim: contribution-credit arm (E7) Linear per-person credit with a per-person cap, one standard for all including a Meta-sized contributor, measured against the existing tally and half-influence cap across contributor-share levels and splitting k=2/10/100. Credit is not vote weight; analysis only. Co-Authored-By: Claude Sonnet 5.5 --- .../2026-11-05-estate-rule-sim/REPORT.md | 11 +++ .../2026-11-05-estate-rule-sim/SPEC.md | 17 +++++ .../2026-11-05-estate-rule-sim/estatesim.py | 48 +++++++++++++ .../2026-11-05-estate-rule-sim/results.md | 68 +++++++++++++++++++ .../2026-11-05-estate-rule-sim/run.py | 68 +++++++++++++++++++ .../test_estatesim.py | 61 +++++++++++++++++ 6 files changed, 273 insertions(+) diff --git a/docs/research/2026-11-05-estate-rule-sim/REPORT.md b/docs/research/2026-11-05-estate-rule-sim/REPORT.md index 1813dcb..d773d4a 100644 --- a/docs/research/2026-11-05-estate-rule-sim/REPORT.md +++ b/docs/research/2026-11-05-estate-rule-sim/REPORT.md @@ -54,6 +54,17 @@ Static weight analysis, not a motion simulation: it measures weight share, not P Limits specific to E6: the roll, the Pareto scale, b and unit are assumptions; the buyer joins as an additional patron and buys once (no repeated purchase or liquidation); decisiveness is estate-level only, not council-level (prior section 10 shows weight share is not decisiveness); the best split is a grid maximum, a lower bound; hours play no part in a purchase scenario because estate weights are fixed and the buyer sits in Patrons, so an hours buyer (a Member who is paid or who farms hours) is untested and the conversion of hours into weight is just a per-estate parameter whose gaming is not modeled. +## E7: contribution-weighted arm (SPEC section 5d) + +Static weight analysis, not a motion simulation, and not a proposal: credit does not become vote weight here. Credit is linear in receipts (hours or credited changes), tallied per person, weight = min(credit, per-person cap), one function for a Meta-sized contributor and an ordinary member alike. Tally and half cap are E6's. Contributor share phi is the fraction of the Members estate's total raw credit; roll 15 and 150 ordinary members, 40 seeds, both estate-weight sets. + +- **The half cap binds only when Members are the only live estate, and then it is a step at phi = .5.** All four estates live: 0 binding in every cell. Members + Minds live: 0 (the Members estate carries at most half the council, so the strict cap is never reached). Members alone: 0 for phi <= .4, and for phi >= .5 with no credit cap 1.000, because a contributor at exactly half of the credit has exactly half the estate (the cap is "strictly below"). The rate does not rise past phi = .5 because the cap binds as a yes/no, not by degree. +- **A per-person credit cap moves that step, it does not remove it.** Members alone, phi >= .5, rate of binding at 100x / 20x / 5x the ordinary median credit: 0.438 / 0.075 / 0.000 (pooled over both rolls and weights, 320 trials each). The bound is the cap against the size of the ordinary roll: 5x the median holds a contributor under half of a 15-member estate, which says the cap is doing the work the half cap would do, at the price of flattening every member above 5x median. +- **Splitting evades the half cap in every case it needed to act.** Members alone, over the whole sweep, k = 2, 10, 100: the joint share reaches .5 in 5,942 cases and in 5,942 no single identity binds (1.000). Uncapped linear credit makes splitting weight-neutral (multiplier 1.00) but still evades the per-identity half cap. With a per-person credit cap splitting also multiplies weight: at phi .9, k = 10, the multiplier is 3.58 at 100x, 9.66 at 20x, 10.00 at 5x (cap bites hardest on the single identity); k = 100: 6.50 / 21.58 / 59.10. +- **Falsifiers (SPEC 5d).** (1) A credit cap contains phi .9 with half cap never binding: only at 5x median; false at 100x and 20x. (2) Credit cap survives splitting at multiplier <= 1.1 at k = 10: false in every capped row (1.23 at phi .25 with a 100x cap up to 10.00). (3) Half cap evaded under splitting: true in all 5,942. + +Limits: Pareto credit curve and its scale, the multiples of median, the Members placement, and the rolls are placeholders. A person-level cap needs an identity oracle (as E6); credit tied to merged receipts could provide one, which this sim does not test. Receipts are not audited for farming or purchase (hours-farming is the E6 hours gap, still unanalysed). Ordinary members' own credit is capped too, which matters only at 5x. + ## 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. diff --git a/docs/research/2026-11-05-estate-rule-sim/SPEC.md b/docs/research/2026-11-05-estate-rule-sim/SPEC.md index 687a6db..bb39cd8 100644 --- a/docs/research/2026-11-05-estate-rule-sim/SPEC.md +++ b/docs/research/2026-11-05-estate-rule-sim/SPEC.md @@ -111,6 +111,22 @@ Serves the purchased-stake brief (operator relayed: Patron vote power is logarit **Falsifiers fixed in advance.** (1) Working hypothesis "logarithmic weight bounds buyout power": refuted if a one-million-euro buyer's within-estate share s exceeds 1/2 at the harness's own roll, or if splitting multiplies weight by more than 2 at any k. (2) The half-influence cap is "binding" in a (cell, seed) iff x >= .5; the rate over the sweep is reported per live-estate scenario. (3) The cap is "evaded" by splitting iff the joint share is >= .5 while no single identity's share is. +## 5d. Contribution credit (revision 6, written before its results) + +Serves `heimdall-body:follow_up:chat-mind-20261106T134754647Z-t14`. A static weight analysis like 5c, for a contribution-weighted arm. It informs Meta's later call and decides nothing: credit does not become vote weight, here or in any rule above. + +**Credit.** A person's credit is the sum of their receipts (hours, or credited changes counted in the same linear unit), tallied per person. Weight is `min(credit, cap)`: linear, one function for every person, so a Meta-sized contributor is the same row of the same table as an ordinary member, with no exemption and no separate schedule. The per-person cap is a multiple of the ordinary members' median credit, swept over none, 100x, 20x, 5x (assumptions, not rulings). + +**Contributor share.** The contributor holds a fraction phi of the estate's total raw credit (before capping), swept over .05 to .9. This is the "Meta-sized" axis. Placement is the Members estate (where 5c's hours channel lives), a PLACEHOLDER. + +**Electorate.** 15 (the harness roll) and 150 ordinary members with Pareto(1.16) credit from 10 (prior section 4's contribution curve; the scale is mine), 40 seeds each, estate weights and live-estate scenarios as 5c. + +**Same tally, same half cap.** `council_share` and `influence_cap` of 5c, unchanged: binds iff council weight share x >= .5. + +**Splitting.** The contributor's credit split evenly over k = 2, 10, 100 identities. Reported per identity (binds), jointly (joint share >= .5) and as evasion (joint >= .5 with no identity binding), plus the weight multiplier against k = 1. With no credit cap, linear credit makes splitting weight-neutral; with a per-person cap it is not. + +**Falsifiers fixed in advance.** (1) Per-person credit cap "contains" a large contributor if the half cap never binds at phi .9 with a cap in force in the Members-alone scenario. (2) Credit cap "survives splitting" if the weight multiplier at k = 10 is at most 1.1 with a cap in force. (3) The half cap is evaded under splitting if joint x >= .5 with no identity binding. + ## 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: @@ -136,6 +152,7 @@ Paired across rules: one set of random draws per motion feeds all rules (common - **E3f copy-the-ballot:** section 5b. - **E4 appeal attraction:** β sweep at α = 1.5, c = .2. - **E6 purchased stake:** section 5c. b x unit x Patrons roll x amount x estate weights x live-estate scenario, 40 seeds; splitting k sweep; candidate defences. +- **E7 contribution credit:** section 5d. phi x credit cap x roll x weights x live set x seeds; splitting k. - **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 diff --git a/docs/research/2026-11-05-estate-rule-sim/estatesim.py b/docs/research/2026-11-05-estate-rule-sim/estatesim.py index d4693bc..f0e5946 100644 --- a/docs/research/2026-11-05-estate-rule-sim/estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/estatesim.py @@ -580,3 +580,51 @@ def buyer_runs(amount, n, seeds, W, live, overrides=()): wb = stake_weight("Patrons", euros=amount, overrides=overrides) return [influence_cap(wb, sum(stake_weight("Patrons", euros=x, overrides=overrides) for x in stake_ladder(n, s)), W, ESTATES.index("Patrons"), live) for s in range(seeds)] + + +# ---------------------------------------------------------------- contribution credit (SPEC section 5d) +# +# Credit is tallied per person from receipts (hours or credited changes, one linear unit each) and capped per +# person. The tally and the half-influence cap are the ones above (council_share, influence_cap). Credit is +# measured here as a candidate weight source only; this module never turns it into a vote. + +CREDIT_SEED = 20261106 +CREDIT_ESTATE = "Members" # PLACEHOLDER: where contribution credit would weigh; the hours channel above lives here + + +def credit_weight(credit, cap=None): + """One person's weight from credit: linear in receipts, min(credit, cap). One function for every person, + a Meta-sized contributor included; there is no per-person exemption or schedule.""" + return credit if cap is None else min(credit, cap) + + +def credit_ladder(n, s): + """Seed s's n ordinary members' credit (hours): Pareto(PARETO_ALPHA) from PARETO_XM (prior section 4's + contribution curve; the scale is PLACEHOLDER).""" + return pareto_ladder(n, random.Random(CREDIT_SEED + 1000 * n + s)) + + +def credit_cap_value(ladder, mult): + """Per-person cap as a multiple of the ordinary members' median credit (None = no cap).""" + if mult is None: + return None + xs = sorted(ladder) + return mult * xs[len(xs) // 2] + + +def credit_run(phi, n, s, W, live, cap_mult=None, k=1): + """Half-cap result for a contributor holding fraction `phi` of the estate's TOTAL raw credit, against n + ordinary members (seed s), the credit split evenly over k identities. Returns dict: the usual + influence_cap fields for ONE identity (`one`), the joint share (`joint_x`), `evaded` iff the joint + council share is >= HALF while no identity's is, and `w_total`.""" + e = ESTATES.index(CREDIT_ESTATE) + lad = credit_ladder(n, s) + cap = credit_cap_value(lad, cap_mult) + rest = sum(credit_weight(x, cap) for x in lad) + big = phi / (1 - phi) * sum(lad) + wi = credit_weight(big / k, cap) + tot = k * wi + one = influence_cap(wi, rest + tot - wi, W, e, live) + joint = council_share(tot, rest, W, e, live)[1] + return dict(one=one, joint_x=joint, binds=one["binds"], joint_binds=joint >= HALF - EPS, + evaded=joint >= HALF - EPS and not one["binds"], w_total=tot, rest=rest, cap=cap) diff --git a/docs/research/2026-11-05-estate-rule-sim/results.md b/docs/research/2026-11-05-estate-rule-sim/results.md index cd14773..67e1039 100644 --- a/docs/research/2026-11-05-estate-rule-sim/results.md +++ b/docs/research/2026-11-05-estate-rule-sim/results.md @@ -879,6 +879,74 @@ Best multiplier at 1,000,000 EUR by log base and unit (b rows, unit columns): |---|---|---|---|---|---| | weight | 0.70 | 1.00 | 2.00 | 3.00 | 4.00 | +## E7 contribution-weighted arm: linear credit, per-person cap, the half-influence cap (SPEC section 5d) + +Static weight analysis. One contributor holds a fraction phi of the Members estate's total raw credit (receipts: hours or credited changes, one linear unit); 15 and 150 ordinary members hold Pareto(1.16) credit from 10, 40 seeds each. Weight = min(credit, per-person cap), the same function for the contributor and everyone else. The tally and the half cap are E6's: council share x = W x s over the live estates; the cap binds iff x >= .5. Credit is not vote weight anywhere in this module; this table only says how often the half cap would have to act. + +**Half cap binds, all four estates: fraction of (weights x roll x seed) by contributor share phi (rows) and per-person credit cap (columns); one identity, k = 1** + +| phi | none | 100x median | 20x median | 5x median | +|---|---|---|---|---| +| 0.05 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.1 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.25 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.4 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.5 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.6 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.75 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.9 | 0.000 | 0.000 | 0.000 | 0.000 | + +**Half cap binds, Members + Minds: fraction of (weights x roll x seed) by contributor share phi (rows) and per-person credit cap (columns); one identity, k = 1** + +| phi | none | 100x median | 20x median | 5x median | +|---|---|---|---|---| +| 0.05 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.1 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.25 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.4 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.5 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.6 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.75 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.9 | 0.000 | 0.000 | 0.000 | 0.000 | + +**Half cap binds, Members alone: fraction of (weights x roll x seed) by contributor share phi (rows) and per-person credit cap (columns); one identity, k = 1** + +| phi | none | 100x median | 20x median | 5x median | +|---|---|---|---|---| +| 0.05 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.1 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.25 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.4 | 0.000 | 0.000 | 0.000 | 0.000 | +| 0.5 | 1.000 | 0.438 | 0.075 | 0.000 | +| 0.6 | 1.000 | 0.438 | 0.075 | 0.000 | +| 0.75 | 1.000 | 0.438 | 0.075 | 0.000 | +| 0.9 | 1.000 | 0.438 | 0.075 | 0.000 | + +**Splitting: the contributor's credit split evenly over k identities. Members alone, equal weights, roll 15, mean over seeds. binds = the half cap acts on an identity; joint >= .5 = the combined share would have needed cutting; evaded = joint >= .5 and no identity binds; weight x = total weight / weight at k = 1** + +| phi | cap | k=1: binds / joint>=.5 / evaded / weight x | k=2: binds / joint>=.5 / evaded / weight x | k=10: binds / joint>=.5 / evaded / weight x | k=100: binds / joint>=.5 / evaded / weight x | +|---|---|---|---|---|---| +| 0.25 | none | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 1.00 | +| 0.25 | 100x median | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.03 / 0.03 / 1.03 | 0.00 / 0.03 / 0.03 / 1.23 | 0.00 / 0.03 / 0.03 / 1.25 | +| 0.25 | 20x median | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.03 / 0.03 / 1.12 | 0.00 / 0.07 / 0.07 / 1.43 | 0.00 / 0.07 / 0.07 / 2.55 | +| 0.25 | 5x median | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 1.75 | 0.00 / 0.12 / 0.12 / 2.87 | 0.00 / 0.12 / 0.12 / 5.46 | +| 0.5 | none | 1.00 / 1.00 / 0.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | +| 0.5 | 100x median | 0.88 / 0.88 / 0.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.08 | 0.00 / 1.00 / 1.00 / 1.31 | 0.00 / 1.00 / 1.00 / 1.88 | +| 0.5 | 20x median | 0.15 / 0.15 / 0.00 / 1.00 | 0.00 / 0.80 / 0.80 / 1.50 | 0.00 / 1.00 / 1.00 / 2.35 | 0.00 / 1.00 / 1.00 / 4.73 | +| 0.5 | 5x median | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 2.00 | 0.00 / 1.00 / 1.00 / 6.41 | 0.00 / 1.00 / 1.00 / 11.38 | +| 0.9 | none | 1.00 / 1.00 / 0.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.00 | +| 0.9 | 100x median | 0.88 / 0.88 / 0.00 / 1.00 | 0.00 / 1.00 / 1.00 / 1.93 | 0.00 / 1.00 / 1.00 / 3.58 | 0.00 / 1.00 / 1.00 / 6.50 | +| 0.9 | 20x median | 0.15 / 0.15 / 0.00 / 1.00 | 0.00 / 0.80 / 0.80 / 2.00 | 0.00 / 1.00 / 1.00 / 9.66 | 0.00 / 1.00 / 1.00 / 21.58 | +| 0.9 | 5x median | 0.00 / 0.00 / 0.00 / 1.00 | 0.00 / 0.00 / 0.00 / 2.00 | 0.00 / 1.00 / 1.00 / 10.00 | 0.00 / 1.00 / 1.00 / 59.10 | + +Evasion rate over the sweep (phi x cap x k in 2, 10, 100 x live set x weights x roll x seed), cases where the joint share needed cutting: + +| live estates | joint share >= .5 (k > 1) | of which no identity binds (evaded) | +|---|---|---| +| all four estates | 0 | 0 | +| Members + Minds | 0 | 0 | +| Members alone | 5942 | 5942 (1.000) | + ## Claim tally over all cells (SPEC section 8) supported 0, fails 2, undecided 233, n/a 0 diff --git a/docs/research/2026-11-05-estate-rule-sim/run.py b/docs/research/2026-11-05-estate-rule-sim/run.py index cc3755f..e0162c9 100644 --- a/docs/research/2026-11-05-estate-rule-sim/run.py +++ b/docs/research/2026-11-05-estate-rule-sim/run.py @@ -353,6 +353,73 @@ def stake_section(quick): return L +MEMBERS = E.ESTATES.index(E.CREDIT_ESTATE) +CLIVE = {"all four estates": (0, 1, 2, 3), "Members + Minds": (0, MEMBERS), "Members alone": (MEMBERS,)} +CREDIT_CAPS = (None, 100.0, 20.0, 5.0) # per-person credit cap, multiples of the ordinary members' median credit + + +def _capname(m): + return "none" if m is None else f"{m:g}x median" + + +def credit_section(quick): + """E7 contribution-weighted arm (SPEC section 5d). Pure functions of fixed seeds; no wall clock.""" + seeds = 4 if quick else 40 + phis = (.1, .5, .9) if quick else (.05, .1, .25, .4, .5, .6, .75, .9) + rolls = (E.ROLL["Members"],) if quick else (E.ROLL["Members"], 150) + ks = (1, 2, 10, 100) + L = ["## E7 contribution-weighted arm: linear credit, per-person cap, the half-influence cap (SPEC section 5d)", "", + f"Static weight analysis. One contributor holds a fraction phi of the {E.CREDIT_ESTATE} estate's total raw credit (receipts: hours or credited " + f"changes, one linear unit); {rolls[0]}" + (f" and {rolls[1]}" if len(rolls) > 1 else "") + + f" ordinary members hold Pareto({E.PARETO_ALPHA}) credit from {E.PARETO_XM:.0f}, {seeds} seeds each. Weight = min(credit, per-person cap), the same function " + "for the contributor and everyone else. The tally and the half cap are E6's: council share x = W x s over the live estates; the cap binds iff x >= .5. " + "Credit is not vote weight anywhere in this module; this table only says how often the half cap would have to act.", ""] + for ln, live in CLIVE.items(): + L += [f"**Half cap binds, {ln}: fraction of (weights x roll x seed) by contributor share phi (rows) and per-person credit cap (columns); one identity, k = 1**", "", + "| phi | " + " | ".join(_capname(m) for m in CREDIT_CAPS) + " |", "|---|" + "---|" * len(CREDIT_CAPS)] + for phi in phis: + cols = [] + for m in CREDIT_CAPS: + hit = tot = 0 + for W in E.WEIGHTS.values(): + for n in rolls: + for s in range(seeds): + hit += E.credit_run(phi, n, s, W, live, m)["binds"] + tot += 1 + cols.append(f"{hit / tot:.3f}") + L.append(f"| {phi:g} | " + " | ".join(cols) + " |") + L.append("") + L += ["**Splitting: the contributor's credit split evenly over k identities. Members alone, equal weights, roll " + f"{rolls[0]}, mean over seeds. binds = the half cap acts on an identity; joint >= .5 = the combined share would have needed cutting; " + "evaded = joint >= .5 and no identity binds; weight x = total weight / weight at k = 1**", "", + "| phi | cap | " + " | ".join(f"k={k}: binds / joint>=.5 / evaded / weight x" for k in ks) + " |", "|---|---|" + "---|" * len(ks)] + W = E.WEIGHTS["equal"] + for phi in (.25, .5, .9): + for m in CREDIT_CAPS: + cols = [] + for k in ks: + rs = [E.credit_run(phi, rolls[0], s, W, (MEMBERS,), m, k) for s in range(seeds)] + base = [E.credit_run(phi, rolls[0], s, W, (MEMBERS,), m, 1)["w_total"] for s in range(seeds)] + cols.append(f"{sum(r['binds'] for r in rs) / seeds:.2f} / {sum(r['joint_binds'] for r in rs) / seeds:.2f} / " + f"{sum(r['evaded'] for r in rs) / seeds:.2f} / {sum(r['w_total'] / b for r, b in zip(rs, base)) / seeds:.2f}") + L.append(f"| {phi:g} | {_capname(m)} | " + " | ".join(cols) + " |") + L += ["", "Evasion rate over the sweep (phi x cap x k in 2, 10, 100 x live set x weights x roll x seed), cases where the joint share needed cutting:", "", + "| live estates | joint share >= .5 (k > 1) | of which no identity binds (evaded) |", "|---|---|---|"] + for ln, live in CLIVE.items(): + j = ev = 0 + for phi in phis: + for m in CREDIT_CAPS: + for k in ks[1:]: + for Wt in E.WEIGHTS.values(): + for n in rolls: + for s in range(seeds): + r = E.credit_run(phi, n, s, Wt, live, m, k) + j += r["joint_binds"] + ev += r["evaded"] + L.append(f"| {ln} | {j} | {ev} ({ev / j:.3f}) |" if j else f"| {ln} | 0 | 0 |") + return L + [""] + + def main(argv=None): ap = argparse.ArgumentParser() ap.add_argument("--quick", action="store_true") @@ -388,6 +455,7 @@ def main(argv=None): L += [f"### {title.split(' ')[0]} / {name}", ""] + rule_table(r) + [""] L += [pair_line(r), "", "PS by category threshold:", ""] + percat_table(r) + [""] L += stake_section(a.quick) + L += credit_section(a.quick) 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: diff --git a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py index c4e9dd0..de9defb 100644 --- a/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py +++ b/docs/research/2026-11-05-estate-rule-sim/test_estatesim.py @@ -420,6 +420,67 @@ class StakeTests(unittest.TestCase): self.assertTrue(all(x >= E.PARETO_XM for x in a)) +PINNED_CREDIT_BINDS = {None: 320, 100.0: 140, 20.0: 24, 5.0: 0} # of 320 (phi .5, .9 x roll 15, 150 x 40 seeds x 2 weights) + + +class CreditTests(unittest.TestCase): + """SPEC section 5d: contribution credit, per-person cap, the half-influence cap.""" + M = E.ESTATES.index("Members") + W = E.WEIGHTS["equal"] + ALONE = (1,) + + def test_one_standard_for_everyone(self): + for c in (3.0, 40.0, 1e6): # a Meta-sized credit gets no schedule of its own + self.assertEqual(E.credit_weight(c), c) + self.assertEqual(E.credit_weight(c, 25.0), min(c, 25.0)) + + def test_cap_is_per_person_and_a_multiple_of_the_ordinary_median(self): + lad = E.credit_ladder(15, 0) + self.assertIsNone(E.credit_cap_value(lad, None)) + self.assertEqual(E.credit_cap_value(lad, 20.0), 20.0 * sorted(lad)[7]) + + def test_contributor_holds_phi_of_raw_credit(self): + r = E.credit_run(.5, 15, 3, self.W, self.ALONE) + self.assertAlmostEqual(r["w_total"], r["rest"]) # uncapped: phi .5 means equal to everyone else + self.assertAlmostEqual(r["one"]["s"], .5) + + def test_half_cap_binds_at_half_of_credit_in_a_lone_estate_not_below(self): + self.assertTrue(E.credit_run(.5, 15, 0, self.W, self.ALONE)["binds"]) + self.assertFalse(E.credit_run(.49, 15, 0, self.W, self.ALONE)["binds"]) + + def test_other_estates_dilute_the_contributor_below_the_half_cap(self): + self.assertFalse(E.credit_run(.9, 15, 0, self.W, (0, 1, 2, 3))["binds"]) + + def test_credit_cap_reduces_weight_and_can_release_the_half_cap(self): + un = E.credit_run(.9, 15, 0, self.W, self.ALONE) + cp = E.credit_run(.9, 15, 0, self.W, self.ALONE, cap_mult=5.0) + self.assertTrue(un["binds"]) + self.assertFalse(cp["binds"]) + self.assertLess(cp["w_total"], un["w_total"]) + + def test_splitting_is_weight_neutral_without_a_cap_and_gains_with_one(self): + base = E.credit_run(.9, 15, 0, self.W, self.ALONE)["w_total"] + self.assertAlmostEqual(E.credit_run(.9, 15, 0, self.W, self.ALONE, k=10)["w_total"], base) + c1 = E.credit_run(.9, 15, 0, self.W, self.ALONE, cap_mult=20.0)["w_total"] + self.assertGreater(E.credit_run(.9, 15, 0, self.W, self.ALONE, cap_mult=20.0, k=10)["w_total"], c1) + + def test_per_identity_half_cap_is_evaded_by_splitting_credit(self): + r1 = E.credit_run(.9, 15, 0, self.W, self.ALONE, k=1) + r2 = E.credit_run(.9, 15, 0, self.W, self.ALONE, k=2) + self.assertTrue(r1["binds"] and not r1["evaded"]) + self.assertFalse(r2["binds"]) + self.assertTrue(r2["joint_binds"] and r2["evaded"]) + + def test_headline_numbers_are_pinned(self): + hit = {m: sum(E.credit_run(phi, n, s, w, self.ALONE, m)["binds"] for phi in (.5, .9) for n in (15, 150) + for s in range(40) for w in E.WEIGHTS.values()) for m in (None, 100.0, 20.0, 5.0)} + self.assertEqual(hit, PINNED_CREDIT_BINDS) + + def test_deterministic(self): + a, b = E.credit_run(.5, 15, 2, self.W, self.ALONE, 20.0, 10), E.credit_run(.5, 15, 2, self.W, self.ALONE, 20.0, 10) + self.assertEqual(a, b) + + class StrategyTests(unittest.TestCase): def test_deviation_never_makes_agent_worse_off(self): rng = random.Random(3) From 8abd9129176dda3c2dc29701a5737bf39caa6c22 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Fri, 6 Nov 2026 21:26:13 +0000 Subject: [PATCH 014/176] docs: guest accounts design (role field, invite, grants, leave and erase) Co-Authored-By: Claude Sonnet 5.5 --- docs/guest-accounts.md | 255 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 255 insertions(+) create mode 100644 docs/guest-accounts.md diff --git a/docs/guest-accounts.md b/docs/guest-accounts.md new file mode 100644 index 0000000..3044056 --- /dev/null +++ b/docs/guest-accounts.md @@ -0,0 +1,255 @@ +# Guest accounts + +Status: **design, nothing implemented.** Written for `eureka-body:follow_up:bifrost-guest-accounts` under +`eureka-body:ruling:guest-arrival-bifrost` (Meta: guests need no Matrix account of their own; they get a GameCult +account through Bifrost with a guest role, and move to member, user or patron on the same account seamlessly), +building on `eureka-body:ruling:bifrost-owns-accounts-invite-only`. I could not `view` either ruling from the +Heimdall mind, so their text here is the follow-up brief's wording; check it against the rulings. First guest: +sletz (Faust developer). Aqua decides on `#aquasynth` access, so the first grant list is hers to name. + +Read at Bifrost `bf8ff62` (`src/Bifrost.Web/Domain/BifrostModels.cs`, `Features/Membership`, `Features/Heimdall`, +`Features/Oidc`, `Features/Motions`, `Features/ConceptVotes`, `Pages/App/Members`) and Heimdall `575be9c` +(`src/app-profiles.ts`, `docs/app-profiles/bifrost.md`). + +## The shape in one paragraph + +A guest is a `UserAccount` like any other: same `Id` (the OIDC `sub`), same `NormalizedBifrostIdentity` (the Matrix +localpart, minted once). What is new is one field, `Membership.Role`, with four values: `guest`, `user`, `patron`, +`member`. Role is the single place that says what an account may do. A role change rewrites that field and writes a +receipt; it never creates a second account, never re-mints the identity, so chat history, grants and the Matrix +user stay attached. + +## What exists today + +- `UserAccount.Id` is the OIDC subject; `NormalizedBifrostIdentity` is `preferred_username` and, through MAS, the + Matrix localpart (`docs/oidc-issuer.md`). `HeimdallAccountId` is only an authenticator handle. +- `Membership.Status` is `Authenticated | PendingApproval | Active | Suspended`. `CurrentBifrostActor.IsActiveMember` + (`Status == Active`) is the one test behind `/App`, bridge transport (`BridgeActionService` l.492), motion votes + (`EffectiveVotingWeight`, `MotionGovernanceService` l.72), concept votes (`VoterIdentity.For`, member versus + account class) and the OIDC authorize, token and userinfo endpoints (`OidcEndpoints` l.50, l.131) and the + back-channel logout reconciler. +- `MemberRole` (`StandardMember`, `Producer`, `Maintainer`, `LedgerReviewer`, `PlatformAdmin`) are capability + roles a member holds in addition. They are not the new field. +- Invites are `MembershipInvitation`, keyed by GitHub login (`MembershipSynchronizationService` l.37, + `Members/Index.cshtml.cs` l.34). A guest may have no GitHub login at all. +- Heimdall sign-in (`HeimdallAuthService.StartAsync`) with `requireMemberAccess = false` already creates an + identity-only account at `Authenticated`; with member access it creates `Active`. +- Nothing exists for room grants, leaving, erasing, or any "estate" in code (estates are rulings and research + only, `docs/charter-amendment-proposal.md`). + +## Decision: one role field, status stays lifecycle + +Two authorities cannot both say "may this account vote". Today `Status == Active` says it. The cut: + +- `Membership.Status` keeps its meaning as lifecycle of the account: may it hold a session. Add `Left` and + `Erased` (see Leave and erase). `Active` means admitted and in good standing, for any role. +- `Membership.Role` (new, non-null, enum `AccountRole`) decides rights. `IsActiveMember` becomes + `Status == Active && Role == Member`, and is the only place that expression exists. Every current + `IsActiveMember` caller keeps working unchanged and a guest fails all of them without a per-site edit. +- OIDC authorize, token, userinfo and the logout reconciler change their test from "Active member" to + "`Status == Active`" (any role), so a guest, user or patron can hold a chat session and a member demoted to + `Suspended` still loses it. This is the one behavioural change outside new code, and it is the line to review. +- Backfill: `Active` becomes `member`; `Authenticated` and `PendingApproval` become `user`; an account with a + current `Patron` tier snapshot and not `Active` becomes `patron`. Nobody starts as `guest`. + +Naming risk: `MemberRole` already exists for capability roles. If the collision bites, call the new field +`Class`; the published field below follows whichever name is chosen. I use `Role` because that is the ruling's word. + +Alternative considered and not recommended: a boolean `IsGuest` on `Membership` with guests kept at `Active`. +Smaller to land, but `user` and `patron` stay implicit in status and tier snapshots, so "the role field Personas +read" would have to be derived in three places. One stored field is one reading. + +## Invite shape + +New table `GuestInvitation`, separate from `MembershipInvitation` (which is GitHub-login-keyed and leads to +approval, not to a guest). Fields: + +| field | rule | +|---|---| +| `Id` | Guid. | +| `TokenHash` | SHA-256 of a 256-bit random token. The token itself is shown to the issuer once, as a link, and never stored. | +| `IntendedIdentity` | the localpart the issuer picks (for example `sletz`), validated by `BifrostIdentityService.NormalizeIdentity`, reserved while the invite is open. Minted once on accept; a collision gets the usual `-2` suffix. | +| `Label` | free note for the issuer ("sletz, Faust developer"). | +| `RoomGrants` | the rooms to grant on accept (below), as a list of grant requests. | +| `IssuedByUserAccountId`, `IssuedAtUtc` | issuer must be a platform admin (`CanManageMembership`), as for member invites. | +| `ExpiresAtUtc` | default seven days. | +| `AcceptedByUserAccountId`, `AcceptedAtUtc`, `RevokedAtUtc` | one use; revoke before accept ends it. | + +The link is a bearer: whoever signs in first with it is the guest. That is the cost of not needing sletz's +provider handle in advance, and it is why the token is single-use and short-lived and why the accept is shown +to the issuer. Recommended over binding the invite to a provider handle (which needs a Discord or Google id the +issuer may not have). The issuer may still restrict `ExpectedProvider`; open fork, see Questions. + +## Sign-in via Heimdall + +1. Guest opens `/invite/guest/`. Bifrost checks hash, expiry, unused, unrevoked, and stores the invite id in + the existing Heimdall attempt (`HeimdallAuthService` protects attempt state with the data protector). +2. Bifrost starts Heimdall sign-in with `requireMemberAccess = false` (identity only, no entitlement policy). + Heimdall authenticates; it does not issue the identity (`docs/jurisdiction-map.md`). +3. On the callback, in one transaction: resolve `HeimdallAccountId`. + - No account: create `UserAccount` with `IntendedIdentity`, `Membership { Status = Active, Role = Guest }`, write + the room grants, mark the invite accepted, write the receipt. + - Account exists: the invite never lowers an account. A `member`, `patron` or `user` keeps their role; the grants + are added and the invite is spent. If the existing account is `Left` or `Erased`, refuse. +4. Bifrost issues its own cookie as for any account. From there the guest reaches chat through the one OIDC client. + +Gap, drift found while reading: Bifrost's `AllowedProviders` is `discord, patreon, twitch` +(`HeimdallAuthService.AllowedProviders`), but Heimdall's `bifrost` app profile allows `discord, patreon, google` +(`app-profiles.ts`, `bifrostProfile`). Twitch cannot start in Heimdall and Google is refused by Bifrost. A guest with +neither Discord, Patreon nor a Google account cannot sign in, and GitHub is not a Heimdall sign-in provider for +this app. Which provider sletz uses is unknown to me; align the two lists before the first invite. + +## Guest rights + +A guest may: sign in, hold a Bifrost cookie, hold a chat session through OIDC, see and edit their own profile +(`MemberProfile`), be in the rooms granted to them, and leave or erase (below). A guest may not: + +- vote on motions: `EffectiveVotingWeight` is `0` for any role but `member` (today it is `Max(1, ...)` for + `Active`, which would give every guest weight 1; that line must read the role); +- cast concept-mill appraisals: `VoterIdentity.For` returns no voter for a guest (not even `VoterClass.Account`); +- appear on any estate roll or in any tally. The charter proposal snapshots each estate's roll at notice (A6); + `guest` is on no roll, so a guest cannot be counted, cannot make a quorum, and reclassifying a guest after a + snapshot changes nothing for that snapshot; +- use bridge transport, claim or log work, earn points or ledger credit, or hold tier snapshots (those make them + a patron or member by changing role, not by decorating a guest); +- hold a `MemberRole` or any of the `CanManage*` flags; +- invite anyone. + +This list is enforced by role in one place (`CurrentBifrostActor`), not by a check at each use. + +## Per-room grants + +Rooms are Matrix rooms in chat, not Bifrost objects. Bifrost owns the decision, so a grant is Bifrost state: + +`GuestRoomGrant { Id, UserAccountId, RoomRef, GrantedByUserAccountId, GrantedAtUtc, ExpiresAtUtc?, RevokedAtUtc? }` + +`RoomRef` is a room id or alias as chat names it. Aqua's `#aquasynth` is the first one if she says yes. + +The grant has to reach Matrix to mean anything. Today Bifrost's only Matrix writer is the Persona mouth, with +per-Persona access tokens (`docs/bridge.md`), and it holds no admin or invite right. + +Gap (largest in this doc): something must perform "invite this Matrix user to that room" on a grant and "remove +them" on revoke or expiry. Candidates: a Bifrost-owned bot user that is a member with invite power in the granted +rooms (reuses the Matrix client API, no Synapse admin credential), or the Synapse admin API. I recommend the bot +user: narrower credential, and the room's power levels remain the real gate. Until it exists, the grant is a +record, a human invites the guest by hand, and the receipt says `delivered_by: manual`. Rooms for guests must be +invite-only; a guest who can reach a public room needs no grant, and that is a chat configuration fact I have not +verified. + +Second gap: a guest has a full Matrix account once MAS provisions the localpart, so Matrix itself will let them +create rooms or DM unless Synapse's room-creation and invite settings (`room_list_publication_rules`, +`allow_public_rooms_*`, a spam-checker or module) say otherwise. These are global in Synapse, not per user, so a +guest limit may have to be power levels in every room they are in. I did not find a per-user switch. + +## Role change on the same account id, with a receipt + +`ChangeRole(accountId, to, actor, reason)` is the only writer of `Membership.Role`. It runs in one transaction: + +1. refuse `Erased` and `Left`; refuse a no-op; +2. write `Role`, and for `member` also set `Status = Active`, `ApprovedAtUtc`, and the default `StandardMember` + capability role (the same effects as `OnPostApproveAsync`); for `patron`, nothing beyond the role (tier + snapshots come from support events as before); +3. write `AccountRoleReceipt { Id, UserAccountId, From, To, ChangedAtUtc, ChangedByUserAccountId, Reason }`; +4. leave `UserAccount.Id`, `NormalizedBifrostIdentity`, `HeimdallAccountId`, grants and profile untouched. + +Who may change: a platform admin (`CanManageMembership`). Promoting to `member` is the existing approve path; +this design routes it through `ChangeRole` so one writer exists. Promoting to `member` also applies whatever the +charter says about joining an estate (not decided; see Questions). Demotion (member to guest) is allowed and +receipted; it also removes the `MemberRole`s and capability flags in the same transaction. + +The receipt is a Postgres row today, like `AuditEvent`. Bifrost's rule is that durable state has a CultCache `.cc` +witness (`docs/jurisdiction-map.md`, Design Rules); the witness is owed (Gaps). + +Seamless means: the guest's session cookie, OIDC subject, Matrix id, display name and room memberships do not +change on promotion. A cookie issued before promotion carries identity claims only, never the role, so it needs +no refresh; the actor is read from the database each request (`CurrentBifrostActorAccessor`). + +## Leave and erase + +Neither exists in Bifrost today. Two different acts: + +**Leave** (guest or any role, self-service): sets `Status = Left`, revokes every grant, and expels the account +from granted rooms through the same effector as grants. The OIDC reconciler already notices a non-`Active` +subject within 30 seconds and logs MAS out, and the token and userinfo endpoints refuse. The account row and +`Id` stay, so a later invite can restore it (a `Left` account re-accepting is a role change from itself, receipted). +Nothing else about the person is deleted by leaving. + +**Erase** (self-service, or admin on request): irreversible. In one transaction: blank `DisplayName`, `AvatarUrl`, +`MemberProfile`, `GitHubLogin`/`GitHubUserId`, clear `HeimdallAccountId` (the authenticator link), set +`Status = Erased`, keep `Id` and `NormalizedBifrostIdentity` as a tombstone so the localpart is never reissued to +someone else (OIDC says it is minted once), keep receipts but with names stripped. The reason to keep a tombstone +row is that receipts and audit events point at the id. + +An erasing guest has no votes, ledger entries or points, because guests cannot create them. A member or patron +who erases does, and those are accounting records: their erase is a separate question (Questions). Guest erase +is the case this design covers. + +Outside Bifrost, erase is incomplete without two effectors: + +- Matrix: Synapse's deactivate-with-erase admin call and MAS deactivation for the user. Federation is disabled in + the chat map (`gamecult-ops/docs/gamecult-chat-map.md`: federation paths 404), which helps: messages are + not copied to other servers. Other members' clients, and any export or training copy, are not reached by an + erase. Whether chat content is training data is `heimdall-body`'s consent rulings (Heimdall PR #6), which already + define exit by redaction; a guest's messages follow whatever that doc says, not this one. +- Heimdall: I found no account-delete or unlink path in Heimdall `src`. Clearing `HeimdallAccountId` on the Bifrost + side leaves the Heimdall account and its provider link alive. Heimdall needs an erase call keyed by the account id + before "erased" is true end to end. + +## What Eureka reads + +Personas read the role, not the account. Do not put it in OIDC: the issuer promises "no membership detail leaves +Bifrost" (`docs/oidc-issuer.md`) and chat does not need it. Publish a typed CultMesh document under the +`gamecult.bifrost.governance` family (the nearest existing schema namespace, `verse-service-contract.md` l.60), id +`gamecult.bifrost.account.v1`, key = account id: + +| field | type | note | +|---|---|---| +| `account_id` | uuid | OIDC `sub`; never changes. | +| `identity` | string | `NormalizedBifrostIdentity`; the Matrix localpart, so Matrix user id is `@:` (server name per MAS config, not verified here). | +| `display_name` | string | blank once erased. | +| `role` | `guest` \| `user` \| `patron` \| `member` | the field Personas read. | +| `status` | `authenticated` \| `pending_approval` \| `active` \| `suspended` \| `left` \| `erased` | | +| `role_since` | UTC ms | from the latest `AccountRoleReceipt`. | +| `rooms` | list of room refs | only for `guest`: the live grants. Others get rooms by estate. | + +A Persona deciding how to treat someone looks up `identity` from the Matrix sender and reads `role`. A sender with +no document is not a Bifrost account (a bridge ghost or an unlinked user) and is `unknown`, never defaulted to +`guest` or `user`. Bifrost does not decide Persona behavior; it states the role. + +No such publisher or witness exists; Bifrost has no `.cc` export for accounts today. + +## Cut sequence (not specs) + +1. `Membership.Role`, backfill, `IsActiveMember` and the OIDC tests moved to the new reading, vote and concept-vote + exclusions, with tests that fail if a guest gets weight or a voter key. +2. `GuestInvitation`, the accept path, the Heimdall provider list aligned. +3. `AccountRoleReceipt` and `ChangeRole`, with `OnPostApproveAsync` routed through it. +4. `GuestRoomGrant` and the Matrix effector. +5. Leave, then erase (Bifrost side), then the Matrix and Heimdall effectors. +6. The account document and its `.cc` witness. + +## Gaps, plainly + +- The Matrix effector for grants, leave and erase does not exist, and no credential for it is provisioned. +- Synapse cannot cap what a guest does per user; room-creation and invite limits are global (unverified: I did not + read the live Synapse config). +- Heimdall has no erase path. Bifrost and Heimdall disagree on provider lists today. +- No `.cc` witness or CultMesh publisher for accounts or receipts. Bifrost's account state is Postgres only. +- Matrix id shape (`@:`) depends on MAS importing `preferred_username` as localpart; the OIDC doc + says so, I did not check the deployed MAS. +- Tie to the answer-collector consent doc (Heimdall PR #6): a guest posting in a room may be posting to a sample + collector. That doc keys on `member_id`, and says a sender with no linked member is dropped. Whether a guest has a + `member_id`, and so whether their answers are collected at all, is not decided here. Default: not collected. +- Erase for member and patron roles (ledger and vote records) is unmapped. + +## Questions for the deciders + +1. **Is `Role` the right name** given `MemberRole`, and is one stored role (this doc) preferred over a boolean + `IsGuest`? Recommendation: stored role. Confidence: medium; the boolean is cheaper if user and patron are not + yet needed. +2. **Bearer link or provider-bound invite?** Recommendation: bearer, single use, seven days, optional + `ExpectedProvider`. Confidence: medium; this is a trust call about how sletz will be sent the link. +3. **Which Heimdall provider will sletz sign in with?** Needed before the lists are aligned. +4. **Do guests get a `member_id` for the answer collector?** Default no. +5. **Does promotion to member join the Members estate immediately**, or does the charter's notice and snapshot + rule apply to the roll? The charter text is a proposal, not in force. From c757acf525da1d60406ba0386f22c36a9f75ba85 Mon Sep 17 00:00:00 2001 From: Heimdall Date: Sat, 7 Nov 2026 18:42:43 +0000 Subject: [PATCH 015/176] Make every cookie host-only: __Host- names, Secure, Path=/, no Domain Session, OAuth correlation, antiforgery, voter and Heimdall attempt cookies all take the __Host- prefix. The prefix forbids a narrower Path, so the voter (was /mill) and attempt (was /auth/heimdall) cookies move to Path=/. Co-Authored-By: Claude Sonnet 5.5 --- .../Features/ConceptVotes/VoterKeyResolver.cs | 5 +- .../Features/Heimdall/HeimdallAuthService.cs | 8 +- .../Features/Shared/BifrostCookies.cs | 17 +++ src/Bifrost.Web/Program.cs | 14 +++ .../Bifrost.Web.Tests/ConceptVotePageTests.cs | 5 +- .../ConceptVoteRateLimitTests.cs | 3 +- .../Bifrost.Web.Tests/CookieHardeningTests.cs | 101 ++++++++++++++++++ .../HeimdallCompletionTests.cs | 18 ++-- .../Support/HeimdallTestKit.cs | 3 +- 9 files changed, 155 insertions(+), 19 deletions(-) create mode 100644 src/Bifrost.Web/Features/Shared/BifrostCookies.cs create mode 100644 tests/Bifrost.Web.Tests/CookieHardeningTests.cs diff --git a/src/Bifrost.Web/Features/ConceptVotes/VoterKeyResolver.cs b/src/Bifrost.Web/Features/ConceptVotes/VoterKeyResolver.cs index ce9fbec..2948700 100644 --- a/src/Bifrost.Web/Features/ConceptVotes/VoterKeyResolver.cs +++ b/src/Bifrost.Web/Features/ConceptVotes/VoterKeyResolver.cs @@ -1,4 +1,5 @@ using System.Security.Cryptography; +using Bifrost.Web.Features.Shared; using Microsoft.AspNetCore.DataProtection; namespace Bifrost.Web.Features.ConceptVotes; @@ -7,8 +8,8 @@ namespace Bifrost.Web.Features.ConceptVotes; // decides the voter key and class. The cookie holds a protected random id, never a count, class or account. public sealed class VoterKeyResolver(IDataProtectionProvider dataProtection) { - public const string CookieName = "bifrost_voter"; - public const string CookiePath = "/mill"; + public const string CookieName = BifrostCookies.Voter; + public const string CookiePath = BifrostCookies.Path; public static readonly TimeSpan CookieLifetime = TimeSpan.FromDays(365); private const string Purpose = "Bifrost.ConceptVotes.DeviceToken.v1"; diff --git a/src/Bifrost.Web/Features/Heimdall/HeimdallAuthService.cs b/src/Bifrost.Web/Features/Heimdall/HeimdallAuthService.cs index 3e0b3a1..7749402 100644 --- a/src/Bifrost.Web/Features/Heimdall/HeimdallAuthService.cs +++ b/src/Bifrost.Web/Features/Heimdall/HeimdallAuthService.cs @@ -446,13 +446,13 @@ public sealed record HeimdallAccount( /// /// The attempt cookies: a ring of fixed names, so the Cookie header a browser sends to -/// /auth/heimdall is bounded by construction (a worst-case attempt is about 2.4 KB; nginx's line limit is 8 KB). +/// every path is bounded by construction (the __Host- prefix forces Path=/; a worst-case attempt is about 2.4 KB, nginx's line limit is 8 KB). /// A start takes a free slot or overwrites the one expiring first; an overwritten attempt finds no cookie and /// is refused. The attempt's nonce lives inside the protected value, never in the cookie name. /// public static class HeimdallAttemptCookie { - public const string Prefix = "bifrost_heimdall_"; + public const string Prefix = BifrostCookies.HeimdallAttemptPrefix; public const int SlotCount = 2; public static readonly TimeSpan Lifetime = TimeSpan.FromMinutes(10); @@ -465,7 +465,7 @@ public static class HeimdallAttemptCookie HttpOnly = true, Secure = true, SameSite = SameSiteMode.Lax, - Path = "/auth/heimdall", + Path = BifrostCookies.Path, MaxAge = Lifetime }; @@ -473,5 +473,5 @@ public static class HeimdallAttemptCookie /// The options a deletion carries: only the attempt cookie's Path, which a cookie is matched on. It carries no /// Max-Age, which would take precedence over the expiry Delete writes and leave the emptied cookie alive. /// - public static CookieOptions DeleteOptions() => new() { Path = "/auth/heimdall" }; + public static CookieOptions DeleteOptions() => new() { Path = BifrostCookies.Path }; } diff --git a/src/Bifrost.Web/Features/Shared/BifrostCookies.cs b/src/Bifrost.Web/Features/Shared/BifrostCookies.cs new file mode 100644 index 0000000..1c099e8 --- /dev/null +++ b/src/Bifrost.Web/Features/Shared/BifrostCookies.cs @@ -0,0 +1,17 @@ +namespace Bifrost.Web.Features.Shared; + +// Every cookie Bifrost sets carries the __Host- prefix: the browser then accepts it only with Secure, Path=/ and no +// Domain, so no sibling subdomain of gamecult.org (the preview host is same-site) can plant or shadow one by setting +// a Domain=gamecult.org cookie of the same name. The prefix forbids a narrower Path, so these all live at Path=/. +public static class BifrostCookies +{ + public const string HostPrefix = "__Host-"; + + public const string Session = HostPrefix + "bifrost_session"; + public const string OAuthCorrelation = HostPrefix + "bifrost_oauth_correlation"; + public const string Antiforgery = HostPrefix + "bifrost_antiforgery"; + public const string Voter = HostPrefix + "bifrost_voter"; + public const string HeimdallAttemptPrefix = HostPrefix + "bifrost_heimdall_"; + + public const string Path = "/"; +} diff --git a/src/Bifrost.Web/Program.cs b/src/Bifrost.Web/Program.cs index d0656d3..c8a524a 100644 --- a/src/Bifrost.Web/Program.cs +++ b/src/Bifrost.Web/Program.cs @@ -76,6 +76,13 @@ builder.Services .AddOptions() .BindConfiguration(ConceptVoteOptions.SectionName); +builder.Services.AddAntiforgery(options => +{ + options.Cookie.Name = BifrostCookies.Antiforgery; + options.Cookie.SecurePolicy = CookieSecurePolicy.Always; + options.Cookie.Path = BifrostCookies.Path; +}); + builder.Services.AddRazorPages(options => { options.Conventions.AuthorizePage("/Membership/Status"); @@ -167,6 +174,10 @@ var authenticationBuilder = builder.Services .AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme) .AddCookie(options => { + options.Cookie.Name = BifrostCookies.Session; + options.Cookie.SecurePolicy = CookieSecurePolicy.Always; + options.Cookie.Path = BifrostCookies.Path; + options.Cookie.Domain = null; options.LoginPath = "/auth/sign-in"; options.AccessDeniedPath = "/Membership/Status"; options.SlidingExpiration = true; @@ -183,6 +194,9 @@ if (configuredGitHubOAuthOptions.IsConfigured) options.TokenEndpoint = "https://github.com/login/oauth/access_token"; options.UserInformationEndpoint = "https://api.github.com/user"; options.SaveTokens = true; + options.CorrelationCookie.Name = BifrostCookies.OAuthCorrelation; + options.CorrelationCookie.SecurePolicy = CookieSecurePolicy.Always; + options.CorrelationCookie.Path = BifrostCookies.Path; options.Scope.Add("read:user"); options.Scope.Add("user:email"); options.ClaimActions.MapJsonKey(ClaimTypes.NameIdentifier, "id"); diff --git a/tests/Bifrost.Web.Tests/ConceptVotePageTests.cs b/tests/Bifrost.Web.Tests/ConceptVotePageTests.cs index 5434e8d..d0675d7 100644 --- a/tests/Bifrost.Web.Tests/ConceptVotePageTests.cs +++ b/tests/Bifrost.Web.Tests/ConceptVotePageTests.cs @@ -1,3 +1,4 @@ +using Bifrost.Web.Features.Shared; using System.Net; using System.Text.RegularExpressions; using Bifrost.Web.Data; @@ -14,7 +15,7 @@ namespace Bifrost.Web.Tests; public sealed partial class ConceptVotePageTests : IClassFixture { - private const string CookieName = "bifrost_voter"; + private const string CookieName = BifrostCookies.Voter; private const string Purpose = "Bifrost.ConceptVotes.DeviceToken.v1"; private readonly TestWebApplicationFactory _factory; @@ -40,7 +41,7 @@ public sealed partial class ConceptVotePageTests : IClassFixture { private const string Site = "https://localhost"; - private const string CookieName = "bifrost_voter"; + private const string CookieName = BifrostCookies.Voter; private readonly LimitedFactory _factory; diff --git a/tests/Bifrost.Web.Tests/CookieHardeningTests.cs b/tests/Bifrost.Web.Tests/CookieHardeningTests.cs new file mode 100644 index 0000000..3a43ebc --- /dev/null +++ b/tests/Bifrost.Web.Tests/CookieHardeningTests.cs @@ -0,0 +1,101 @@ +using Bifrost.Web.Features.ConceptVotes; +using Bifrost.Web.Features.Heimdall; +using Bifrost.Web.Features.Shared; +using Bifrost.Web.Tests.Support; +using Microsoft.AspNetCore.Antiforgery; +using Microsoft.AspNetCore.Authentication.Cookies; +using Microsoft.AspNetCore.Authentication.OAuth; +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; + +namespace Bifrost.Web.Tests; + +// Every cookie is host-only: __Host- name, Secure, Path=/, no Domain. These pin the literals on purpose, so removing +// the prefix, Secure or Path=/ from any of them fails here and not only in a test that reads the same constant. +public sealed class CookieHardeningTests(CookieHardeningTests.OAuthConfiguredFactory factory) + : IClassFixture +{ + // Program reads GitHubOAuth at startup, before the base factory's in-memory settings land, so the GitHub scheme + // is only registered when the settings arrive as host settings. + public sealed class OAuthConfiguredFactory : TestWebApplicationFactory + { + protected override void ConfigureWebHost(Microsoft.AspNetCore.Hosting.IWebHostBuilder builder) + { + builder.UseSetting("GitHubOAuth:ClientId", "configured-for-tests"); + builder.UseSetting("GitHubOAuth:ClientSecret", "configured-for-tests"); + base.ConfigureWebHost(builder); + } + } + + [Fact] + public void Cookie_names_carry_the_host_prefix_and_live_at_the_root() + { + Assert.Equal("__Host-bifrost_session", BifrostCookies.Session); + Assert.Equal("__Host-bifrost_oauth_correlation", BifrostCookies.OAuthCorrelation); + Assert.Equal("__Host-bifrost_antiforgery", BifrostCookies.Antiforgery); + Assert.Equal("__Host-bifrost_voter", VoterKeyResolver.CookieName); + Assert.Equal("__Host-bifrost_heimdall_", HeimdallAttemptCookie.Prefix); + Assert.All(HeimdallAttemptCookie.SlotNames, x => Assert.StartsWith("__Host-", x, StringComparison.Ordinal)); + Assert.Equal("/", BifrostCookies.Path); + Assert.Equal("/", VoterKeyResolver.CookiePath); + } + + [Fact] + public void Session_cookie_is_host_only() + { + var cookie = factory.Services.GetRequiredService>() + .Get(CookieAuthenticationDefaults.AuthenticationScheme).Cookie; + AssertHostOnly(cookie.Name, cookie.SecurePolicy, cookie.Path, cookie.Domain); + Assert.True(cookie.HttpOnly); + } + + [Fact] + public void Oauth_correlation_cookie_is_host_only() + { + var cookie = factory.Services.GetRequiredService>().Get("GitHub").CorrelationCookie; + AssertHostOnly(cookie.Name, cookie.SecurePolicy, cookie.Path, cookie.Domain); + Assert.True(cookie.HttpOnly); + } + + [Fact] + public void Antiforgery_cookie_is_host_only() + { + var cookie = factory.Services.GetRequiredService>().Value.Cookie; + AssertHostOnly(cookie.Name, cookie.SecurePolicy, cookie.Path, cookie.Domain); + } + + [Fact] + public void Voter_and_attempt_cookies_set_secure_root_path_and_no_domain() + { + var context = new DefaultHttpContext(); + new VoterKeyResolver(new Microsoft.AspNetCore.DataProtection.EphemeralDataProtectionProvider()).Mint(context); + context.Response.Cookies.Append("__Host-bifrost_heimdall_0", "v", HeimdallAttemptCookie.Options()); + var deletion = new DefaultHttpContext(); + deletion.Response.Cookies.Delete("__Host-bifrost_heimdall_0", HeimdallAttemptCookie.DeleteOptions()); + + var headers = context.Response.Headers.SetCookie.Concat(deletion.Response.Headers.SetCookie).ToArray(); + Assert.Equal(3, headers.Length); + foreach (var header in headers) + { + var attributes = header!.Split(';').Select(x => x.Trim().ToLowerInvariant()).ToArray(); + Assert.StartsWith("__host-", attributes[0], StringComparison.Ordinal); + Assert.Contains("path=/", attributes); + Assert.DoesNotContain(attributes, x => x.StartsWith("domain", StringComparison.Ordinal)); + } + + Assert.All(headers.Take(2), header => + { + Assert.Contains("secure", header!.Split(';').Select(x => x.Trim().ToLowerInvariant())); + Assert.Contains("httponly", header!.Split(';').Select(x => x.Trim().ToLowerInvariant())); + }); + } + + private static void AssertHostOnly(string? name, CookieSecurePolicy secure, string? path, string? domain) + { + Assert.StartsWith("__Host-", name, StringComparison.Ordinal); + Assert.Equal(CookieSecurePolicy.Always, secure); + Assert.Equal("/", path); + Assert.Null(domain); + } +} diff --git a/tests/Bifrost.Web.Tests/HeimdallCompletionTests.cs b/tests/Bifrost.Web.Tests/HeimdallCompletionTests.cs index 3439b43..68f0a94 100644 --- a/tests/Bifrost.Web.Tests/HeimdallCompletionTests.cs +++ b/tests/Bifrost.Web.Tests/HeimdallCompletionTests.cs @@ -526,7 +526,7 @@ public sealed class HeimdallCompletionTests Assert.Contains("httponly", attributes); Assert.Contains("secure", attributes); Assert.Contains("samesite=lax", attributes); - Assert.Contains("path=/auth/heimdall", attributes); + Assert.Contains("path=/", attributes); Assert.Contains("max-age=600", attributes); Assert.NotEqual(first.Cookie, second.Cookie); Assert.DoesNotContain(first.Nonce, first.Cookie!); @@ -564,7 +564,7 @@ public sealed class HeimdallCompletionTests Assert.Contains("