Documentation

LeanPool.ACMax.Counting.StarvedCensus

The starved-world census and the owner-choke rows #

The pure-counting census of the starved world — the e(M) = 0 stratum: a never-firing graph on Fin n with 2(n−2) edges, minimum degree ≥ 3, and no degree-3–degree-3 edge. Its degree-3 vertices are twins (all M-isolated), the degree-4 vertices the sea, the degree-≥ 4 vertices the hubs. The contrapositive of the star-moat law caps twin-hoarding (starved_cap), and feeding the caps into the twin-incidence total against the degree-excess ledger Σ_h(deg − 3) = n − 8 produces the census rows.

Main results #

theorem ACMax.starved_cap {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (h : Fin n) (hfire : 9 * G.degree h ≤ n + 15) :

The starved cap (contrapositive of star_moat_fires). In a never-firing census world (m = 2(n−2), δ ≥ 3) a hub h under the cap horizon 9·deg h ≤ n + 15 owns at most deg h − 3 M-isolated twins: if it owned deg h − 2, that twin star would fire.

theorem ACMax.cap_sum_le {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (S : Finset (Fin n)) (hS : S ⊆ hubSet G) :
∑ h ∈ S, (G.neighborFinset h ∩ isoTwins G).card ≤ ∑ h ∈ S, (G.degree h - 3) + 3 * {h ∈ S | n + 15 < 9 * G.degree h}.card

The cap ledger. Over any hub set S, the total twin ownership is bounded by the degree excess plus a 3-per-giant credit: a capped hub (9·deg ≤ n + 15) owns ≤ deg − 3 twins (starved_cap), while a giant contributes the trivial ≤ deg = (deg − 3) + 3.

theorem ACMax.twin_total_eq {n : ℕ} (G : SimpleGraph (Fin n)) (hn : 2 ≤ n) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) :
∑ h ∈ hubSet G, (G.neighborFinset h ∩ isoTwins G).card = 24 + 3 * excessX n G

The twin total. Under hs0 (e(M) = 0) the degree-3 set is the M-isolated twin set, so the hub-to-twin incidence sum is 3·(8 + X) = 24 + 3X.

theorem ACMax.hub_deg_excess_eq {n : ℕ} (G : SimpleGraph (Fin n)) (hn : 8 ≤ n) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) :
∑ h ∈ hubSet G, (G.degree h - 3) = n - 8

The hub excess ledger. The degree excess is carried entirely by the hubs: Σ_{h ∈ Hub}(deg h − 3) = n − 8, since every non-hub is a degree-3 twin (total_excess_eq).

theorem ACMax.hoarding_law {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hn : 8 ≤ n) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) :
3 * excessX n G + 32 ≤ n + 3 * {h ∈ hubSet G | n + 15 < 9 * G.degree h}.card

The hoarding law (SW §S2). Twin-slot supply meets capacity: the 24 + 3X twin incidences are hosted by the hubs, capped at deg − 3 apart from the 3-per-giant credit, so 3X + 32 ≤ n + 3·n_g where n_g is the number of giants (hubs above the cap horizon 9·deg ≤ n + 15).

theorem ACMax.slots_law {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hn : 8 ≤ n) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) :
24 + 2 * excessX n G ≤ ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + {h : Fin n | 5 ≤ G.degree h}.card + 3 * {h ∈ hubSet G | n + 15 < 9 * G.degree h}.card

The slots row (SW §S2 / §4 slots). Splitting the twin total by degree class: the deg-≥ 5 hubs absorb at most X + h slots (h = number of heavies), plus the 3-per-giant credit, so the deg-4 owner-slot total t₄ is forced up to 24 + 2X ≤ t₄ + h + 3·n_g.

theorem ACMax.giant_excess_bound {n : ℕ} (G : SimpleGraph (Fin n)) (hn : 30 ≤ n) :
{h ∈ hubSet G | n + 15 < 9 * G.degree h}.card * (n - 20) ≤ 9 * excessX n G

The giant census bound (SW §S2). A giant h (n + 15 < 9·deg h) has 9·(deg h − 4) ≥ n − 20, and every giant is a heavy, so summing gives n_g·(n − 20) ≤ 9·X. With hoarding this pins n_g ≤ 2 at n ≤ 49.

theorem ACMax.heavy_le_excess {n : ℕ} (G : SimpleGraph (Fin n)) :
{h : Fin n | 5 ≤ G.degree h}.card ≤ excessX n G

Heavies are bounded by the excess. The number of heavies (deg ≥ 5) is at most the total excess X, since each heavy contributes deg − 4 ≥ 1.

The per-p sharpened slots row (D1) #

Sharpens slots_law by splitting the deg-≥ 5 twin demand along the per-heavy caps starved_cap (no independence law). The twin total 24 + 3X splits into the deg-4 owner slots t₄ and a deg-≥ 5 remainder ≤ X + p + h₆₊ + 4n_g, giving the sharpened row 24 + 2X ≤ t₄ + p + h₆₊ + 4n_g (p = saturated deg-5 hubs, h₆₊ = non-giant deg-≥ 6 hubs, n_g = giants).

theorem ACMax.slots_p_row {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hn : 8 ≤ n) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) :
24 + 2 * excessX n G ≤ ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + {h ∈ hubSet G | G.degree h = 5 ∧ (G.neighborFinset h ∩ isoTwins G).card = 2}.card + {h ∈ hubSet G | 6 ≤ G.degree h ∧ ¬n + 15 < 9 * G.degree h}.card + 4 * {h ∈ hubSet G | n + 15 < 9 * G.degree h}.card

D1 — the per-p sharpened slots row. In a never-firing starved census (m = 2(n−2), δ ≥ 3, hs0) the twin total 24 + 3X splits along the honest per-heavy caps into 24 + 2X ≤ t₄ + p + h₆₊ + 4·n_g, where t₄ = ∑_{deg-4 hubs} |N(h) ∩ Iso|, p is the count of saturated deg-5 hubs (deg 5, owning exactly 2 M-isolated twins), h₆₊ the count of non-giant deg-≥ 6 hubs (6 ≤ deg, 9·deg ≤ n + 15) and n_g the number of giants (n + 15 < 9·deg). Each deg-≥ 5 hub contributes at most (deg − 4) plus one of the class credits, so the deg-≥ 5 remainder is ≤ X + p + h₆₊ + 4·n_g; the star-moat cap starved_cap supplies the non-giant per-hub bounds.

Independence and triangle helpers #

theorem ACMax.tri_deg445_fires {n : ℕ} [Nonempty (Fin n)] (hn : 16 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (a b t : Fin n) (hab : G.Adj a b) (hat : G.Adj a t) (hbt : G.Adj b t) (hda : G.degree a = 4) (hdb : G.degree b = 4) (hdt : G.degree t = 3) :

Triangle test.

theorem ACMax.owner_independence {n : ℕ} [Nonempty (Fin n)] (hn : 30 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (o₁ o₂ t₁ t₂ : Fin n) (ho1 : G.degree o₁ = 4) (ho2 : G.degree o₂ = 4) (ht1 : G.Adj o₁ t₁) (hdt1 : G.degree t₁ = 3) (ht2 : G.Adj o₂ t₂) (hdt2 : G.degree t₂ = 3) :
¬G.Adj o₁ o₂

Owner independence. In a never-firing starved census (m = 2(n−2), δ ≥ 3) at n ≥ 30, any two distinct degree-4 vertices o₁, o₂, each carrying a degree-3 neighbour (t₁ resp. t₂), are non-adjacent. If they were adjacent: distinct twins (t₁ ≠ t₂) fire the (4,4) decorated edge z4c_fires; a shared twin (t₁ = t₂) makes {o₁, o₂, t₁} a degree-(4,4,3) triangle which fires the master cycle tri_deg445_fires — either way contradicting ¬ algConn G ≤ 2.

theorem ACMax.choke_count {n : ℕ} (hn : 8 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) (hcap : ∀ (h : Fin n), G.degree h = 4 → (G.neighborFinset h ∩ isoTwins G).card ≤ 1) (hindep : ∀ (o₁ o₂ : Fin n), G.degree o₁ = 4 → G.degree o₂ = 4 → (G.neighborFinset o₁ ∩ isoTwins G).Nonempty → (G.neighborFinset o₂ ∩ isoTwins G).Nonempty → o₁ ≠ o₂ → ¬G.Adj o₁ o₂) :
7 * ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + 3 * excessX n G + 32 ≤ 4 * n

The owner-choke count. In a starved census (m = 2(n−2), δ ≥ 3, hs0), under the starved degree-4 twin cap (hcap: each degree-4 hub owns ≤ 1 twin) and owner independence (hindep: distinct twin-carrying degree-4 hubs are non-adjacent), the degree-4 owner-slot total t₄ = ∑_{deg 4 hubs} |N(h) ∩ Iso| satisfies the choke 7·t₄ + 3X + 32 ≤ 4n.

Each owner o (degree-4 hub with its unique twin) spends 1 edge on that twin and, by independence, 0 on other owners, so its remaining 3 edges land on non-owner hubs (|N(o) ∩ NH| = 3). The bipartite double count cross_count transposes ∑_{o} |N(o) ∩ NH| = 3·t₄ into ∑_{w ∈ NH} |N(w) ∩ O| ≤ ∑_{w ∈ NH} deg w, and the hub degree total ∑_{Hub} deg + 3X + 32 = 4n splits as ∑_{NH} deg + 4·t₄; combining gives the choke.

The per-p sharpened owner-choke #

Sharpens the owner-choke choke_count (7·t₄ + 3X + 32 ≤ 4n) by 8·p, where p counts saturated degree-5 hubs (owning exactly two twins). A saturated degree-5 hub spends 2 edges on its twins and, by the decorated-edge law, 0 on owners and 0 on other saturated hubs, so its remaining 3 edges land on non-owner non-saturated hubs; the transposed slice count gives p_choke_count / p_choke_row (7·t₄ + 8·p + 3X + 32 ≤ 4n). The (4,5) independence is owner_sat_independence; the (5,5) independence is threaded as hindep55.

theorem ACMax.p_choke_count {n : ℕ} (hn : 8 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) (hcap4 : ∀ (h : Fin n), G.degree h = 4 → (G.neighborFinset h ∩ isoTwins G).card ≤ 1) (hindep44 : ∀ (o₁ o₂ : Fin n), G.degree o₁ = 4 → G.degree o₂ = 4 → (G.neighborFinset o₁ ∩ isoTwins G).Nonempty → (G.neighborFinset o₂ ∩ isoTwins G).Nonempty → o₁ ≠ o₂ → ¬G.Adj o₁ o₂) (hindep45 : ∀ (o s : Fin n), G.degree o = 4 → (G.neighborFinset o ∩ isoTwins G).Nonempty → G.degree s = 5 → (G.neighborFinset s ∩ isoTwins G).card = 2 → ¬G.Adj o s) (hindep55 : ∀ (s₁ s₂ : Fin n), G.degree s₁ = 5 → (G.neighborFinset s₁ ∩ isoTwins G).card = 2 → G.degree s₂ = 5 → (G.neighborFinset s₂ ∩ isoTwins G).card = 2 → s₁ ≠ s₂ → ¬G.Adj s₁ s₂) :
7 * ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + 8 * {h ∈ hubSet G | G.degree h = 5 ∧ (G.neighborFinset h ∩ isoTwins G).card = 2}.card + 3 * excessX n G + 32 ≤ 4 * n

N5 — the per-p sharpened owner-choke (counting core). In a starved census (m = 2(n−2), δ ≥ 3, hs0) under the degree-4 twin cap (hcap4) and the three independence rows — degree-4 owners pairwise non-adjacent (hindep44), owner–saturated non-adjacent (hindep45), saturated–saturated non-adjacent (hindep55) — the degree-4 owner-slot total t₄ = ∑_{deg 4 hubs} |N(h) ∩ Iso| and the saturated degree-5 count p satisfy the sharpened choke 7·t₄ + 8·p + 3·X + 32 ≤ 4n.

Owners O (degree-4, one twin) each spend 3 edges on non-owner non-saturated hubs NH; saturated degree-5s P (two twins) each spend 3 edges on NH (the 2 twin edges and the 0 owner/saturated edges being excluded by independence). The bipartite double count cross_count transposes ∑_{O ∪ P} |N(·) ∩ NH| = 3·t₄ + 3·p into ∑_{NH} |N(w) ∩ (O ∪ P)| ≤ ∑_{NH} deg w, and the hub degree total ∑_{Hub} deg + 3X + 32 = 4n splits as ∑_{NH} deg + 4·t₄ + 5·p; combining gives the choke.

theorem ACMax.owner_sat_independence {n : ℕ} [Nonempty (Fin n)] (hn : 39 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (o s : Fin n) (hdo : G.degree o = 4) (hds : G.degree s = 5) (hoNE : (G.neighborFinset o ∩ isoTwins G).Nonempty) (hscard : (G.neighborFinset s ∩ isoTwins G).card = 2) :
¬G.Adj o s

The (4,5) decorated-edge independence. In a never-firing starved census (m = 2(n−2), δ ≥ 3) at n ≥ 39, a degree-4 owner o (carrying a twin) and a saturated degree-5 hub s (owning exactly 2 twins) are non-adjacent. If they were adjacent: a shared twin makes {o, s, t} a degree-(4,5,3) triangle (Σdeg = 12 = 4·3) firing master_cycle_fires (n ≥ 19); distinct twins fire the (4,5) decorated edge deco_edge_moat_fires (9·(4 + 5) = 81 ≤ n + 42, i.e. n ≥ 39) — either way contradicting ¬ algConn G ≤ 2.

theorem ACMax.p_choke_row {n : ℕ} [Nonempty (Fin n)] (hn : 48 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) (hnf : ¬algConn G ≤ 2) (hindep55 : ∀ (s₁ s₂ : Fin n), G.degree s₁ = 5 → (G.neighborFinset s₁ ∩ isoTwins G).card = 2 → G.degree s₂ = 5 → (G.neighborFinset s₂ ∩ isoTwins G).card = 2 → s₁ ≠ s₂ → ¬G.Adj s₁ s₂) :
7 * ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + 8 * {h ∈ hubSet G | G.degree h = 5 ∧ (G.neighborFinset h ∩ isoTwins G).card = 2}.card + 3 * excessX n G + 32 ≤ 4 * n

N5 — the per-p sharpened owner-choke (assembled row). A never-firing starved census (m = 2(n−2), δ ≥ 3, hs0) on n ≥ 48 satisfies the sharpened choke 7·t₄ + 8·p + 3·X + 32 ≤ 4n. The degree-4 twin cap is the contrapositive of the star moat (starved_cap at deg = 4), the (4,4) independence is owner_independence, and the (4,5) independence is owner_sat_independence; the (5,5) independence hindep55 is threaded as the single moat-provenance hypothesis (its shared-single-twin subcase requires a shared-twin decorated-edge moat, a separate node — scratchpad/ahl_import.md §1.3/§4.4).

The shared-twin decorated-edge moat and the unconditional row #

Reworks the decorated-edge moat for the overlapping-twin case and discharges the last hypothesis of the per-p owner-choke. deco_edge_shared_twin_fires: adjacent hubs sharing exactly one twin fire at 9·(deg u + deg v) ≤ n + 56 (the shared twin has external budget 1, so the threshold is easier than the disjoint n + 42). sat_sat_independence: two adjacent saturated degree-5 hubs are non-adjacent at n ≥ 48. p_choke_row_unconditional: the census-only per-p choke row, discharging hindep55 via sat_sat_independence.

theorem ACMax.deco_edge_shared_twin_fires {n : ℕ} [Nonempty (Fin n)] (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (w : Fin n), 3 ≤ G.degree w) (u v t₀ : Fin n) (Ku Kv : Finset (Fin n)) (huv : G.Adj u v) (hKusub : Ku ⊆ G.neighborFinset u) (hKudeg : ∀ t ∈ Ku, G.degree t = 3) (hKucard : Ku.card = G.degree u - 3) (hKvsub : Kv ⊆ G.neighborFinset v) (hKvdeg : ∀ t ∈ Kv, G.degree t = 3) (hKvcard : Kv.card = G.degree v - 3) (huKv : u ∉ Kv) (hvKu : v ∉ Ku) (hshare : Ku ∩ Kv = {t₀}) (hfire : 9 * (G.degree u + G.degree v) ≤ n + 56) :

The shared-twin decorated-edge moat certificate. A graph on Fin n with 2(n−2) edges, minimum degree ≥ 3, adjacent hubs u, v, and twin sets Ku ⊆ N(u), Kv ⊆ N(v) of degree-3 vertices with |Ku| = deg u − 3, |Kv| = deg v − 3 (avoiding the opposite hub) sharing exactly one common twin (Ku ∩ Kv = {t₀}) has algConn G ≤ 2 whenever 9·(deg u + deg v) ≤ n + 56.

Instantiate the two-cluster law with the tie-block S₁ = {u, v} ∪ Ku ∪ Kv (|S₁| = deg u + deg v − 5) against the bulk S₂ = (S₁ ∪ F)ᶜ, F = (⋃_{x ∈ S₁} N(x)) ∖ S₁ the moat: every hub slice loses deg − 2 internally (budget 2) and every twin loses its hub (budget 2), except the shared twin t₀ which loses both hubs (budget 1), so |F| + 1 ≤ 2·|S₁|; the pair-credited excess ledger then gives ∂₂ ≤ 2·|S₂| and the Fiedler cut condition closes by ring.

theorem ACMax.sat_sat_independence {n : ℕ} [Nonempty (Fin n)] (hn : 48 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hnf : ¬algConn G ≤ 2) (s₁ s₂ : Fin n) (hd1 : G.degree s₁ = 5) (hd2 : G.degree s₂ = 5) (hc1 : (G.neighborFinset s₁ ∩ isoTwins G).card = 2) (hc2 : (G.neighborFinset s₂ ∩ isoTwins G).card = 2) (hne : s₁ ≠ s₂) :
¬G.Adj s₁ s₂

The (5,5) saturated-pair independence. In a never-firing starved census (m = 2(n−2), δ ≥ 3) at n ≥ 48, two saturated degree-5 hubs s₁, s₂ — each owning exactly 2 M-isolated twins — are non-adjacent. If they were adjacent: disjoint twin sets fire the disjoint decorated edge (deco_edge_moat_fires, 90 ≤ n + 42); one shared twin fires the shared-twin decorated edge (deco_edge_shared_twin_fires, 90 ≤ n + 56); two shared twins form a (5,3,5,3) 4-cycle s₁, t₁, s₂, t₂ firing master_cycle_fires (Σdeg = 16 = 4·4, 3·12 = 36 ≤ n + 8) — either way contradicting ¬ algConn G ≤ 2.

theorem ACMax.p_choke_row_unconditional {n : ℕ} [Nonempty (Fin n)] (hn : 48 ≤ n) (G : SimpleGraph (Fin n)) (hm : G.edgeFinset.card = 2 * (n - 2)) (h3 : ∀ (v : Fin n), 3 ≤ G.degree v) (hs0 : ∀ (v w : Fin n), G.degree v = 3 → G.degree w = 3 → ¬G.Adj v w) (hnf : ¬algConn G ≤ 2) :
7 * ∑ h ∈ hubSet G with G.degree h = 4, (G.neighborFinset h ∩ isoTwins G).card + 8 * {h ∈ hubSet G | G.degree h = 5 ∧ (G.neighborFinset h ∩ isoTwins G).card = 2}.card + 3 * excessX n G + 32 ≤ 4 * n

The fully census-only per-p owner-choke row. A never-firing starved census (m = 2(n−2), δ ≥ 3, hs0) on n ≥ 48 satisfies the sharpened choke 7·t₄ + 8·p + 3·X + 32 ≤ 4n, with the (5,5) saturated-pair independence discharged internally by sat_sat_independence (no moat-provenance hypothesis remains).