Conversation
…raduation, ADR impl) First implementation step of the Graph substrate ADR (PR #316 merged on main). Ships the minimum viable core: type + mutation operators + accessors + retraction-conservation test. Detection primitives (largestEigenvalue, modularityScore) and toy cartel detector ship in follow-up PRs composing on this foundation. Splits the ADR's single-PR preference across multiple PRs per Otto-105 small-graduation cadence. Each PR composes on the prior. Type commitment (from ADR): type Graph<'N when 'N : comparison> = internal { Edges: ZSet<'N * 'N> } Event type: type GraphEvent<'N> = | EdgeAdded of source:'N * target:'N * weight:int64 | EdgeRemoved of source:'N * target:'N * weight:int64 Surface (this PR): - Graph.empty / isEmpty / edgeCount / edgeWeight - Graph.addEdge / removeEdge (return updated graph + event list) - Graph.fromEdgeSeq (build from unordered triples) - Graph.nodes / nodeCount (derived from edge endpoints) - Graph.outNeighbors / inNeighbors (direct lookup, no traversal) - Graph.degree (in + out weight sum; self-loops count twice) Retraction-native properties validated by tests: - removeEdge is NOT destructive; partial retraction leaves remainder - addEdge then removeEdge restores empty (the load-bearing retraction-conservation invariant from the ADR) - removeEdge on absent edge produces net-negative weight (anti-edge); this is what makes retraction-native counterfactuals O(|delta|) Multi-edge support: - ZSet signed-weight naturally handles multi-edges; adding 3 then 4 on same edge sums to multiplicity 7; edgeCount still reports 1 (distinct edges), edgeWeight reports 7 (multiplicity) Self-loop support: - source = target is a legal edge; counts once in edgeCount, twice in degree (once as in-edge, once as out-edge) Attribution: - Concept: Aaron (differentiable firefly network + tight-in- all-aspects directive Otto-121) - Formalization: Amara (11th+12th+13th+14th ferries on temporal coord + cartel detection; 15th-16th ferry validation-bar pressure Otto-122/123) - Implementation: Otto-124 (8th graduation) ADR reference: docs/DECISIONS/2026-04-24-graph-substrate- zset-backed-retraction-native.md Tests (17 new, all passing): - empty + basic accessors (edgeCount, nodeCount, edgeWeight on absent) - addEdge: sets weight, emits event, no-op on zero-weight - addEdge: multi-edge accumulation - removeEdge: subtracts + emits event + preserves remainder - retraction conservation: add then remove restores empty - remove-before-add creates anti-edge (negative weight) - nodes derived from endpoints - outNeighbors / inNeighbors direct lookup - degree sums in+out; self-loop counts twice - fromEdgeSeq sums duplicates, drops zero-weight Build: 0 Warning / 0 Error. SPOF (per Otto-106): pure functions + algebraic data types; no external deps; no SPOF introduced. The `Graph<'N>` type is `internal` on its record field — callers use the module functions, not the raw ZSet, to preserve retraction-native invariants. Next graduation (queue): - Graph.map / filter / distinct (operator-algebra composition with existing ZSet operators) - Graph.largestEigenvalue + modularityScore (first detection primitives; cartel-detection proof-point per ADR + Amara Otto-122 validation bar) - Toy cartel detector property test (50 validators + 5-node cartel injection; detection rate >= 90% across 1000 FsCheck seeds) Composes with: - src/Core/ZSet.fs (substrate) - src/Core/RobustStats.fs (outlier-resistant aggregation for signal combination) - src/Core/TemporalCoordinationDetection.fs (companion detection module) - src/Core/Veridicality.fs (claim-level scoring; complementary) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
|
You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard. |
There was a problem hiding this comment.
Pull request overview
Introduces an initial Graph<'N> substrate in Zeta.Core backed by ZSet<'N * 'N> to support retraction-native edge deltas, along with focused unit tests and project wiring.
Changes:
- Add
src/Core/Graph.fsimplementingGraph<'N>, mutation operators (addEdge/removeEdge), and basic accessors (weights, nodes, neighbors, degree). - Add
tests/Tests.FSharp/Algebra/Graph.Tests.fscovering empty graph behavior, multi-edge accumulation, retraction-conservation, neighbors, and self-loops. - Register the new source/test files in the corresponding
.fsprojcompile lists.
Reviewed changes
Copilot reviewed 4 out of 4 changed files in this pull request and generated 6 comments.
| File | Description |
|---|---|
| tests/Tests.FSharp/Tests.FSharp.fsproj | Adds Algebra/Graph.Tests.fs to the test compile list. |
| tests/Tests.FSharp/Algebra/Graph.Tests.fs | New unit tests validating core Graph semantics and accessors. |
| src/Core/Graph.fs | New Graph substrate implementation on top of ZSet. |
| src/Core/Core.fsproj | Adds Graph.fs to the core library compile list. |
| /// pass (Spine-backed when persisted). | ||
| /// | ||
| /// **Design contract:** `docs/DECISIONS/2026-04-24-graph- | ||
| /// substrate-zset-backed-retraction-native.md` (Otto-123 ADR) |
There was a problem hiding this comment.
P1: The “Design contract” comment labels the linked ADR as “Otto-123 ADR”, but the referenced file (docs/DECISIONS/2026-04-24-graph-substrate-zset-backed-retraction-native.md) doesn’t use that identifier. Consider removing the “Otto-123” label or aligning it with the ADR’s actual title/identifier to avoid confusing cross-references.
Suggested change
| /// substrate-zset-backed-retraction-native.md` (Otto-123 ADR) | |
| /// substrate-zset-backed-retraction-native.md` |
| /// count here — `edgeWeight` exposes the multiplicity). | ||
| let edgeCount (g: Graph<'N>) : int = ZSet.count g.Edges | ||
|
|
||
| /// `edgeWeight g source target` — the signed multiplicity |
There was a problem hiding this comment.
P2: The example call form in the doc comment doesn’t match the actual parameter order. edgeWeight is defined as edgeWeight source target g, but the comment says edgeWeight g source target. Update the comment to match the signature so callers aren’t misled.
Suggested change
| /// `edgeWeight g source target` — the signed multiplicity | |
| /// `edgeWeight source target g` — the signed multiplicity |
Comment on lines
+78
to
+82
| /// `addEdge g source target weight` — add `weight` to the | ||
| /// multiplicity of the edge `source → target`. Returns the | ||
| /// updated graph AND the emitted event. Weight of zero is | ||
| /// a no-op and emits no event. | ||
| let addEdge |
There was a problem hiding this comment.
P2: The example call form in the doc comment doesn’t match the actual parameter order. addEdge is defined as addEdge source target weight g, but the comment says addEdge g source target weight. Update the comment to match the signature.
Comment on lines
+94
to
+101
| /// `removeEdge g source target weight` — subtract `weight` | ||
| /// from the multiplicity of the edge. NON-DESTRUCTIVE: | ||
| /// emits a negative-weight ZSet delta; if the result | ||
| /// net-zeros, ZSet consolidation drops the entry but the | ||
| /// Spine trace preserves the history. Weight of zero is | ||
| /// a no-op. | ||
| let removeEdge | ||
| (source: 'N) |
There was a problem hiding this comment.
P2: The example call form in the doc comment doesn’t match the actual parameter order. removeEdge is defined as removeEdge source target weight g, but the comment says removeEdge g source target weight. Update the comment to match the signature.
Comment on lines
+78
to
+92
| /// `addEdge g source target weight` — add `weight` to the | ||
| /// multiplicity of the edge `source → target`. Returns the | ||
| /// updated graph AND the emitted event. Weight of zero is | ||
| /// a no-op and emits no event. | ||
| let addEdge | ||
| (source: 'N) | ||
| (target: 'N) | ||
| (weight: int64) | ||
| (g: Graph<'N>) | ||
| : Graph<'N> * GraphEvent<'N> list = | ||
| if weight = 0L then (g, []) | ||
| else | ||
| let delta = ZSet.singleton (source, target) weight | ||
| let merged = ZSet.add g.Edges delta | ||
| ({ Edges = merged }, [ EdgeAdded(source, target, weight) ]) |
There was a problem hiding this comment.
P1: addEdge/removeEdge only special-case weight = 0L. If a caller passes a negative weight, addEdge will effectively remove and still emit EdgeAdded(…, negativeWeight), and removeEdge will effectively add (double-negation). Either validate/normalize weights (e.g., require weight > 0L and reinterpret negative weights consistently) or adjust the API/event naming to explicitly accept signed deltas.
Comment on lines
+13
to
+32
| /// substrate-zset-backed-retraction-native.md` (Otto-123 ADR) | ||
| /// codifies the 5 tightness properties: ZSet-backed, first-class | ||
| /// event support, retractable, storage-format tight, operator- | ||
| /// algebra composable. | ||
| /// | ||
| /// **Attribution.** | ||
| /// * Aaron — design bar ("tight in all aspects") Otto-121 | ||
| /// * Amara — formalization (11th + 12th + 13th + 14th ferries | ||
| /// + validation-bar Otto-122 "can it detect a dumb cartel in | ||
| /// a toy simulation?") | ||
| /// * Otto — implementation (8th graduation under Otto-105 | ||
| /// cadence; first module that completes a cross-ferry arc | ||
| /// from concept to running substrate) | ||
| /// | ||
| /// **Scope of this first graduation.** Core type + minimal | ||
| /// mutation operators + node/edge accessors + retraction- | ||
| /// conservation property test. Detection primitives | ||
| /// (`largestEigenvalue`, `modularityScore`) and toy cartel | ||
| /// detector ship in follow-up PRs composing on this | ||
| /// foundation. Splitting across multiple PRs per Otto-105 |
There was a problem hiding this comment.
P1: The file-level doc comment includes direct contributor name attribution (e.g., “Aaron”, “Amara”, “Otto”), which violates the repo’s operational standing rule “No name attribution in code, docs, or skills” (docs/AGENT-BEST-PRACTICES.md:284-292). Replace these with role references (e.g., “architect”, “research courier”, “human maintainer”) and move any detailed attribution to an allowed surface (memory/persona/** or docs/BACKLOG.md).
Suggested change
| /// substrate-zset-backed-retraction-native.md` (Otto-123 ADR) | |
| /// codifies the 5 tightness properties: ZSet-backed, first-class | |
| /// event support, retractable, storage-format tight, operator- | |
| /// algebra composable. | |
| /// | |
| /// **Attribution.** | |
| /// * Aaron — design bar ("tight in all aspects") Otto-121 | |
| /// * Amara — formalization (11th + 12th + 13th + 14th ferries | |
| /// + validation-bar Otto-122 "can it detect a dumb cartel in | |
| /// a toy simulation?") | |
| /// * Otto — implementation (8th graduation under Otto-105 | |
| /// cadence; first module that completes a cross-ferry arc | |
| /// from concept to running substrate) | |
| /// | |
| /// **Scope of this first graduation.** Core type + minimal | |
| /// mutation operators + node/edge accessors + retraction- | |
| /// conservation property test. Detection primitives | |
| /// (`largestEigenvalue`, `modularityScore`) and toy cartel | |
| /// detector ship in follow-up PRs composing on this | |
| /// foundation. Splitting across multiple PRs per Otto-105 | |
| /// substrate-zset-backed-retraction-native.md` (ADR record) | |
| /// codifies the 5 tightness properties: ZSet-backed, first-class | |
| /// event support, retractable, storage-format tight, operator- | |
| /// algebra composable. | |
| /// | |
| /// **Attribution.** | |
| /// * Architect — design bar ("tight in all aspects") | |
| /// * Research courier — formalization across the ferry sequence | |
| /// and validation bar ("can it detect a dumb cartel in a toy | |
| /// simulation?") | |
| /// * Human maintainer — implementation under the small- | |
| /// graduation cadence; first module that completes a cross- | |
| /// ferry arc from concept to running substrate | |
| /// | |
| /// **Scope of this first graduation.** Core type + minimal | |
| /// mutation operators + node/edge accessors + retraction- | |
| /// conservation property test. Detection primitives | |
| /// (`largestEigenvalue`, `modularityScore`) and toy cartel | |
| /// detector ship in follow-up PRs composing on this | |
| /// foundation. Splitting across multiple PRs per the |
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
…ifference) — 9th graduation Second Graph-substrate step per the ADR (PR #316). Demonstrates the ADR's 5th tightness property — "operator-algebra composable" — by delegating directly to the corresponding ZSet operators. No graph- specific implementation; each function is a 1-2 line projection through ZSet. Aaron Otto-121 claim validated: "first of its kind, no competitors" because the Graph operators ARE the ZSet operators, reused without reimplementation. Standard graph libraries reimplement map/filter for their own mutable types; Zeta's Graph gets them for free from the underlying algebraic substrate. Surface (5 new functions): - Graph.map : ('N -> 'M) -> Graph<'N> -> Graph<'M> Relabel via projection over node-tuple. Collisions sum via ZSet consolidation. - Graph.filter : ('N * 'N -> bool) -> Graph<'N> -> Graph<'N> Edge-predicate filter. Direct ZSet.filter delegation. - Graph.distinct : Graph<'N> -> Graph<'N> Collapse multi-edges to multiplicity 1; drop anti-edges (negative-weight entries). Set-semantics view of the graph. - Graph.union : Graph<'N> -> Graph<'N> -> Graph<'N> Sum edge weights across graphs. Useful for merging views. - Graph.difference : Graph<'N> -> Graph<'N> -> Graph<'N> Subtract b from a. Useful for counterfactuals ("what does graph minus suspected-cartel-edges look like?"). Retraction- native: produces anti-edges when b has entries a lacks. Retraction-native discipline carries through across operators: - union-with-b followed by difference-with-b restores original (cross-operator retraction-conservation test verifies this) - distinct drops anti-edges (negative-weight entries) to produce proper set semantics Tests (8 new, 25 total in GraphTests module, all passing): - map relabels nodes - map collisions sum via ZSet consolidation - filter with source-predicate keeps matching edges - distinct collapses multi-edge 7 to multiplicity 1 - distinct drops anti-edges - union sums weights across graphs - difference subtracts (produces anti-edges when b > a) - union+difference round-trip restores original Build: 0 Warning / 0 Error. SPOF (per Otto-106): pure functions; no external deps; no SPOF. Each operator is ~1-2 lines because the algebraic substrate already provides the semantics. Next graduation (queue): - Graph.largestEigenvalue (power iteration; cartel-detection proof-point) - Graph.modularityScore (Louvain or spectral clustering) - Toy cartel detector property test (50 validators + 5-node cartel; Amara Otto-122 validation bar; detection rate >=90% across 1000 FsCheck seeds) Composes with: - src/Core/Graph.fs (PR #317 skeleton — merged main) - src/Core/ZSet.fs operator API (substrate) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
…first detection primitive) First cartel-detection primitive per the Graph ADR (PR #316). Computes approximate lambda_1 (principal eigenvalue of the symmetrized adjacency matrix) via standard power iteration with L2 normalization + Rayleigh quotient. Surface: Graph.largestEigenvalue (tolerance: double) (maxIterations: int) (g: Graph<'N>) : double option Method: - Build adjacency map from edge ZSet (coerce int64 weights to double; include negative weights as signed entries) - Symmetrize: A_sym[i,j] = (A[i,j] + A[j,i]) / 2 - Start with all-ones vector (non-pathological seed; avoids zero-vector trap) - Iterate v <- A_sym * v; v <- v / ||v|| - Stop when |lambda_k - lambda_{k-1}| / (|lambda_k| + eps) < tolerance or hit maxIterations - Return Rayleigh quotient as lambda estimate Cartel-detection use: Sharp jump in lambda_1 between baseline graph and injected- cartel graph indicates a dense subgraph formed. The 11th-ferry / 13th-ferry / 14th-ferry spec treats this as the first trivial-cartel warning signal. Performance note: dense Array2D adjacency for MVP. Suitable for toy simulations (50-500 nodes). For larger graphs, Lanczos- based incremental spectral method is a future graduation. Tests (4 new, 21 total in GraphTests, all passing): - None on empty graph - Symmetric 2-edge (weight 5) graph -> lambda ≈ 5 (exact to 1e-6) - K3 triangle (weight 1) -> lambda ≈ 2 (K_n has lambda_1 = n-1) - Cartel-injection test (the LOAD-BEARING one): baseline sparse 5-node graph vs. baseline + K_4 clique (weight 10). Attacked lambda >= 5x baseline lambda. This is the cartel-detection signal in action. Provenance: - Concept: Aaron (differentiable firefly network; first-order detection signal) - Formalization: Amara (11th ferry signal-model §2 + 13th ferry metrics §2 "lambda_1 growth" + 14th ferry "principal eigenvalue growth" alert row) - Implementation: Otto (10th graduation) Build: 0 Warning / 0 Error. SPOF (per Otto-106): pure function; deterministic output for same input (within floating-point). Caller threshold is the sensitivity SPOF — too low -> false positives, too high -> missed cartels. Mitigation documented: threshold should come from baseline-null-distribution percentile, not hard-coded. Future graduation: null-baseline calibration helper. Toy cartel detector (Amara Otto-122 validation bar) prerequisite: this is the first half. Next graduation: modularityScore + toy harness combining both signals + 90%-detection-across- 1000-FsCheck-seeds property test. Composes with: - src/Core/Graph.fs skeleton (PR #317 merged main) - src/Core/Graph.fs operators (PR #319 pending) - src/Core/RobustStats.fs (PR #295) for outlier-resistant signal combination across many graph-pair comparisons Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
…first detection primitive) (#321) First cartel-detection primitive per the Graph ADR (PR #316). Computes approximate lambda_1 (principal eigenvalue of the symmetrized adjacency matrix) via standard power iteration with L2 normalization + Rayleigh quotient. Surface: Graph.largestEigenvalue (tolerance: double) (maxIterations: int) (g: Graph<'N>) : double option Method: - Build adjacency map from edge ZSet (coerce int64 weights to double; include negative weights as signed entries) - Symmetrize: A_sym[i,j] = (A[i,j] + A[j,i]) / 2 - Start with all-ones vector (non-pathological seed; avoids zero-vector trap) - Iterate v <- A_sym * v; v <- v / ||v|| - Stop when |lambda_k - lambda_{k-1}| / (|lambda_k| + eps) < tolerance or hit maxIterations - Return Rayleigh quotient as lambda estimate Cartel-detection use: Sharp jump in lambda_1 between baseline graph and injected- cartel graph indicates a dense subgraph formed. The 11th-ferry / 13th-ferry / 14th-ferry spec treats this as the first trivial-cartel warning signal. Performance note: dense Array2D adjacency for MVP. Suitable for toy simulations (50-500 nodes). For larger graphs, Lanczos- based incremental spectral method is a future graduation. Tests (4 new, 21 total in GraphTests, all passing): - None on empty graph - Symmetric 2-edge (weight 5) graph -> lambda ≈ 5 (exact to 1e-6) - K3 triangle (weight 1) -> lambda ≈ 2 (K_n has lambda_1 = n-1) - Cartel-injection test (the LOAD-BEARING one): baseline sparse 5-node graph vs. baseline + K_4 clique (weight 10). Attacked lambda >= 5x baseline lambda. This is the cartel-detection signal in action. Provenance: - Concept: Aaron (differentiable firefly network; first-order detection signal) - Formalization: Amara (11th ferry signal-model §2 + 13th ferry metrics §2 "lambda_1 growth" + 14th ferry "principal eigenvalue growth" alert row) - Implementation: Otto (10th graduation) Build: 0 Warning / 0 Error. SPOF (per Otto-106): pure function; deterministic output for same input (within floating-point). Caller threshold is the sensitivity SPOF — too low -> false positives, too high -> missed cartels. Mitigation documented: threshold should come from baseline-null-distribution percentile, not hard-coded. Future graduation: null-baseline calibration helper. Toy cartel detector (Amara Otto-122 validation bar) prerequisite: this is the first half. Next graduation: modularityScore + toy harness combining both signals + 90%-detection-across- 1000-FsCheck-seeds property test. Composes with: - src/Core/Graph.fs skeleton (PR #317 merged main) - src/Core/Graph.fs operators (PR #319 pending) - src/Core/RobustStats.fs (PR #295) for outlier-resistant signal combination across many graph-pair comparisons Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
…ns tracked; 3 already shipped) (#330) * ferry: Amara 17th absorb — Cartel-Lab Implementation Closure + 5.5 Verification (8 corrections tracked) Two-part ferry: Amara's deep-research Implementation Closure for Cartel-Lab + her own GPT-5.5 Thinking verification pass with 8 load-bearing corrections. Otto correction-pass status (all 8 tracked): 1. λ₁(K₃) = 2 — ALREADY CORRECT PR #321 Otto-127 (independent convergence before verification arrived) 2. Modularity relational-not-absolute — ALREADY CORRECT PR #324 Otto-128 (caught mid-tick via hand-calc) 3. Cohesion/Exclusivity/Conductance replace entropy-collapse — SHIPPED PR #329 Otto-135 (3 primitives + 6 tests) 4. Windowed stake covariance acceleration — FUTURE GRADUATION 5. Event-stream → phase pipeline for PLV — FUTURE GRADUATION 6. 'ZSet invertible' → 'deltas support retractions' — ADR ALREADY PHRASED CORRECTLY (PR #316 never claimed full invertibility) 7. KSK 'contract' → 'policy layer' — FILED BACKLOG PR #318 Otto-124 (Max coord pending) 8. SOTA humility — DOC PHRASING (applied in new absorb docs) Amara's proposed 3-PR split NOT adopted (Otto-105 small- graduation cadence; content delivered across 7 ticks instead: PRs #317, #321, #323, #324, #326, #328, #329). Amara's proposed /cartel-lab/ folder NOT adopted (Otto-108 Conway's-Law: single-module-tree until interfaces harden). Current Graph.fs + test-support split works. Aaron's SharderInfoTheoreticTests flake flag (trailing Otto-132 note) filed as BACKLOG PR #327 Otto-133 — unrelated hygiene item. Amara's Otto-136 follow-up note: '#323 conceptually accepted, do not canonicalize until sharder test is seed-locked/ recalibrated'. Acknowledged — #323 lives in tests/Simulation/ already (test-scoped); 'canonicalize' = future promotion to src/Core/NetworkIntegrity/ per Amara's PR #3 split suggestion; that's gated on #327 completion. §33 archive header compliance. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * lint: fix line-start PR-number header false-positive in 17th-ferry absorb --------- Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
The bar Amara set Otto-122: "Can this detect even a dumb cartel
in a toy simulation?"
Answer: **YES.** 2 property tests, both passing:
1. ``toy cartel detector — 100 seeds, detection rate >= 90%``
Generates 50-validator baseline + injects 5-node cartel clique
(weight 10) per seed. Rule: attacked-lambda >= 2.0 *
baseline-lambda triggers detection. Runs 100 seeds;
detection rate >= 90% required. Actual run on local machine:
PASSED.
2. ``toy cartel detector — clean baseline rarely triggers``
False-positive rate check. Compares two independent baseline
lambdas; detection rule applied. Allows up to 20% false-
positive rate (generous upper bound; real deployment uses
null-baseline calibration per Amara 14th ferry). 100 seeds;
PASSED.
New code:
- tests/Tests.FSharp/_Support/CartelInjector.fs
Red-team synthetic cartel generator. TEST-ONLY per Otto-118
discipline: lives in _Support/, NOT shipped as public API.
Two functions:
- buildBaseline (rng, nodeCount, avgDegree) : Graph<int>
- injectCartel (rng, baseline, cartelSize, weight, nodeCount)
: Graph<int> * Set<int>
- tests/Tests.FSharp/Simulation/CartelToy.Tests.fs
The property tests above.
Parameters matching Amara's 15th/16th ferry prescription:
- 50 validators
- 5-node cartel
- avgDegree=3 (sparse baseline)
- cartelWeight=10
- detectionMultiplier=2.0 (attacked-lambda >= 2x baseline)
- 100 seeds (1000-seed scaled-up run is a follow-up bench-
project; unit-test obligation is 100)
What this proves per Graph ADR (PR #316):
- The Graph substrate (ZSet-backed, retraction-native) compiles
under real detection workload
- largestEigenvalue (PR #321) produces a reliable cartel signal
on synthetic data
- The theory-cathedral warning (Amara 15th ferry) is addressed:
running code detects a dumb cartel at the promised rate
What this does NOT yet prove:
- Real-world cartels (stealthy weights, partial coordination,
adversarial evasion)
- Full composite detector (adds modularity #322 + covariance)
- Null-baseline threshold calibration (per Amara 14th ferry)
- 1000-seed + adversarial-seed-selection (benchmark project)
These are the next graduations. For now: the substrate works.
Every primitive shipped (RobustStats, crossCorrelation, PLV,
burstAlignment, Veridicality.Provenance/Claim/validate +
antiConsensusGate + CanonicalClaimKey, Graph.addEdge /
removeEdge / ... / largestEigenvalue / modularityScore)
composes cleanly and produces the detection signal it was
designed to produce.
12th graduation under the Otto-105 cadence (counts as the
first INTEGRATION ship — uses primitives from Graph + the
test-support CartelInjector to produce a working detector).
Provenance:
- Design bar: Aaron Otto-121 ("tight in all aspects") +
Amara Otto-122 ("toy cartel simulation")
- Formalization: Amara 11th/12th/13th/14th ferries
- Implementation: Otto-123 ADR (PR #316) + Otto-124 skeleton
(PR #317) + Otto-126 operators (PR #319) + Otto-127
eigenvalue (PR #321) + Otto-129 integration (THIS PR)
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
AceHack
added a commit
that referenced
this pull request
Apr 24, 2026
* test: toy cartel detector — Amara Otto-122 validation bar CLEARED
The bar Amara set Otto-122: "Can this detect even a dumb cartel
in a toy simulation?"
Answer: **YES.** 2 property tests, both passing:
1. ``toy cartel detector — 100 seeds, detection rate >= 90%``
Generates 50-validator baseline + injects 5-node cartel clique
(weight 10) per seed. Rule: attacked-lambda >= 2.0 *
baseline-lambda triggers detection. Runs 100 seeds;
detection rate >= 90% required. Actual run on local machine:
PASSED.
2. ``toy cartel detector — clean baseline rarely triggers``
False-positive rate check. Compares two independent baseline
lambdas; detection rule applied. Allows up to 20% false-
positive rate (generous upper bound; real deployment uses
null-baseline calibration per Amara 14th ferry). 100 seeds;
PASSED.
New code:
- tests/Tests.FSharp/_Support/CartelInjector.fs
Red-team synthetic cartel generator. TEST-ONLY per Otto-118
discipline: lives in _Support/, NOT shipped as public API.
Two functions:
- buildBaseline (rng, nodeCount, avgDegree) : Graph<int>
- injectCartel (rng, baseline, cartelSize, weight, nodeCount)
: Graph<int> * Set<int>
- tests/Tests.FSharp/Simulation/CartelToy.Tests.fs
The property tests above.
Parameters matching Amara's 15th/16th ferry prescription:
- 50 validators
- 5-node cartel
- avgDegree=3 (sparse baseline)
- cartelWeight=10
- detectionMultiplier=2.0 (attacked-lambda >= 2x baseline)
- 100 seeds (1000-seed scaled-up run is a follow-up bench-
project; unit-test obligation is 100)
What this proves per Graph ADR (PR #316):
- The Graph substrate (ZSet-backed, retraction-native) compiles
under real detection workload
- largestEigenvalue (PR #321) produces a reliable cartel signal
on synthetic data
- The theory-cathedral warning (Amara 15th ferry) is addressed:
running code detects a dumb cartel at the promised rate
What this does NOT yet prove:
- Real-world cartels (stealthy weights, partial coordination,
adversarial evasion)
- Full composite detector (adds modularity #322 + covariance)
- Null-baseline threshold calibration (per Amara 14th ferry)
- 1000-seed + adversarial-seed-selection (benchmark project)
These are the next graduations. For now: the substrate works.
Every primitive shipped (RobustStats, crossCorrelation, PLV,
burstAlignment, Veridicality.Provenance/Claim/validate +
antiConsensusGate + CanonicalClaimKey, Graph.addEdge /
removeEdge / ... / largestEigenvalue / modularityScore)
composes cleanly and produces the detection signal it was
designed to produce.
12th graduation under the Otto-105 cadence (counts as the
first INTEGRATION ship — uses primitives from Graph + the
test-support CartelInjector to produce a working detector).
Provenance:
- Design bar: Aaron Otto-121 ("tight in all aspects") +
Amara Otto-122 ("toy cartel simulation")
- Formalization: Amara 11th/12th/13th/14th ferries
- Implementation: Otto-123 ADR (PR #316) + Otto-124 skeleton
(PR #317) + Otto-126 operators (PR #319) + Otto-127
eigenvalue (PR #321) + Otto-129 integration (THIS PR)
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(#323): 3 review threads — docstring accuracy + injectCartel node-set source
Thread 1 (PRRT_kwDOSF9kNM59VAIi, line 7): docstring path corrected
from `tests/_Support/` to `tests/Tests.FSharp/_Support/` — the
actual location of this helper.
Thread 2 (PRRT_kwDOSF9kNM59VAI2, line 27): docstring for
buildBaseline clarified. `Graph.fromEdgeSeq` derives nodes from
edge endpoints, and self-edges are skipped, so `Graph.nodes
baseline` may be a **strict subset** of `0..nodeCount-1`. The
prior phrasing incorrectly implied a contiguous node range.
Thread 3 (PRRT_kwDOSF9kNM59VAJB, line 55): BEHAVIOR fix.
injectCartel now derives the candidate cartel node set from
`Graph.nodes baseline` (the actual node set) rather than
`0..nodeCount-1`. Previously, if a caller ever passed a baseline
whose node set diverged from that index range, the cartel would
inject edges onto non-existent nodes. The `nodeCount` parameter is
retained (now `_nodeCount`) for signature-compatibility with
existing callers in CartelToy.Tests.fs. A `min cartelSize
shuffled.Length` guard prevents Array.take from throwing if
baseline happens to have fewer nodes than requested cartel size.
Build: 0 warnings / 0 errors. Cartel tests: 5 passed / 0 failed.
---------
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
First implementation step of the Graph substrate ADR (PR #316 merged). Ships type + mutation operators + accessors + retraction-conservation test. 17 tests passing. Detection primitives (largestEigenvalue / modularity) and toy cartel detector ship in follow-up PRs.
Type:
Graph<'N> = ZSet<'N * 'N>(internal). Retraction-native: removeEdge is non-destructive; addEdge then removeEdge restores empty. Multi-edge via signed-weight. Self-loops allowed.🤖 Generated with Claude Code