core: Graph.largestEigenvalue via power iteration — 10th graduation

[AceHack]

First cartel-detection primitive per Graph ADR #316. Power iteration + L2 normalize + Rayleigh quotient on symmetrized adjacency.

Load-bearing cartel-injection test: baseline 5-node sparse graph vs. baseline + K_4 clique (weight 10). Attacked lambda ≥ 5x baseline lambda. Detection signal in action.

Test invariants:

• K3 triangle (weight 1) → lambda ≈ 2 (matches K_n theoretical n-1)
• Symmetric 2-edge (weight 5) → lambda ≈ 5
• Empty graph → None

21 tests passing. Next: modularity + toy harness.

🤖 Generated with Claude Code

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[Copilot]

Pull request overview

Adds the first spectral cartel-detection primitive to the ZSet-backed Graph<'N> substrate by implementing Graph.largestEigenvalue (λ₁) using power iteration over the symmetrized adjacency matrix, along with correctness and “cartel injection” tests.

Changes:

• Implement Graph.largestEigenvalue (power iteration + Rayleigh quotient) on symmetrized adjacency.
• Add unit tests for empty graph, simple known-spectrum graphs, and a cartel-clique injection signal test.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 5 comments.

File	Description
src/Core/Graph.fs	Adds Graph.largestEigenvalue implementation and extensive docstring describing the method and intended use.
tests/Tests.FSharp/Algebra/Graph.Tests.fs	Adds test coverage for largestEigenvalue, including a load-bearing cartel-injection growth assertion.

[Copilot]

The docstring says this function “builds a dense IReadOnlyDictionary<'N, Dictionary<'N, double>>” adjacency representation, but the implementation actually builds dense Array2D matrices (adj and sym). Please update the docstring to match the actual representation (or change the implementation) so readers don’t optimize/extend based on incorrect assumptions.

Suggested change

	/// **Performance note:** builds a dense
	/// `IReadOnlyDictionary<'N, Dictionary<'N, double>>` as the
	/// adjacency representation. Suitable for MVP / toy
	/// simulations (50-500 nodes). For larger graphs, a
	/// Lanczos-based incremental spectral method is the next
	/// graduation; documented as future work.
	/// **Performance note:** builds dense `Array2D<double>`
	/// adjacency and symmetric-adjacency matrices for the
	/// power iteration. Suitable for MVP / toy simulations
	/// (50-500 nodes). For larger graphs, a Lanczos-based
	/// incremental spectral method is the next graduation;
	/// documented as future work.

[Copilot]

This provenance/attribution block introduces contributor names in a code comment. Repo convention is to avoid name attribution in code/docs/skills and use role references instead (see docs/AGENT-BEST-PRACTICES.md:284-292). Please rephrase this section to remove personal names.

[Copilot]

Return semantics/documentation don’t match: the docstring says the function returns None when it fails to converge within maxIterations, but the implementation returns Some lambda when iter >= maxIterations. Also, the final else None branch is unreachable. Please decide on the contract (return None on non-convergence, or update docs and remove the dead branch / consider returning a richer result indicating convergence).

[Copilot]

attacked duplicates the baseline edge list inline instead of reusing baseline (or a shared baselineEdges list). This makes the test harder to maintain and easy to accidentally diverge from the baseline scenario when edits happen.

Suggested change

	let baseline =
	Graph.fromEdgeSeq [
	(1, 2, 1L); (2, 1, 1L)
	(3, 4, 1L); (4, 3, 1L)
	(2, 5, 1L); (5, 2, 1L)
	]
	let cartelEdges =
	[
	for s in [6; 7; 8; 9] do
	for t in [6; 7; 8; 9] do
	if s <> t then yield (s, t, 10L)
	]
	let attacked = Graph.fromEdgeSeq (List.append [ (1, 2, 1L); (2, 1, 1L); (3, 4, 1L); (4, 3, 1L); (2, 5, 1L); (5, 2, 1L) ] cartelEdges)
	let baselineEdges =
	[
	(1, 2, 1L); (2, 1, 1L)
	(3, 4, 1L); (4, 3, 1L)
	(2, 5, 1L); (5, 2, 1L)
	]
	let baseline = Graph.fromEdgeSeq baselineEdges
	let cartelEdges =
	[
	for s in [6; 7; 8; 9] do
	for t in [6; 7; 8; 9] do
	if s <> t then yield (s, t, 10L)
	]
	let attacked = Graph.fromEdgeSeq (List.append baselineEdges cartelEdges)

[Copilot]

This comment claims the baseline λ₁ is “~1 (max single-edge weight)”, but the baseline component with nodes 1-2-5 is a 3-node path whose top eigenvalue is √2 (~1.414) (and the 3-4 edge contributes 1). Please adjust the comment to avoid misleading future readers about expected magnitudes.

Suggested change

	// Baseline lambda on sparse 5-node graph is ~1 (max
	// single-edge weight). Attacked lambda should be ~30
	// (K_4 with weight 10 has lambda_1 = 3*10 = 30, since
	// K_n has lambda_1 = n-1 scaled by weight).
	// Baseline lambda on this sparse 5-node graph is driven by
	// the 3-node path 1-2-5, whose top eigenvalue is sqrt(2)
	// (~1.414); the separate 3-4 edge contributes 1. Attacked
	// lambda should be ~30 (K_4 with weight 10 has lambda_1 =
	// 3*10 = 30, since K_n has lambda_1 = n-1 scaled by weight).