Foundation Active Edge Budget

The one-edge budget

The active edge budget, written A, is the number of connections the framework's ledger traverses in one tick. The ledger is a discrete record of recognition events, and a tick is one step in that record. The budget asks a simple question: when the system moves from one posted state to the next, how many edges of its underlying structure does it cross? The answer, the module proves, is always exactly one.

The setting is the three-dimensional cube, a familiar object from geometry. Its eight corners are the possible states, and its edges connect corners that differ in exactly one coordinate. The framework's recognition cycle visits all eight corners in a specific order, the Gray cycle, where each step changes exactly one bit. A Gray cycle is a sequence of binary strings where consecutive strings differ in one position. Because each step in the cycle is a single-bit change, each step crosses exactly one edge of the cube.

The proof is a counting argument. The cycle has eight steps, and each step crosses one edge, so the whole cycle crosses eight edges. If the per-tick edge count were some number n, then eight steps would cross 8n edges. Since the cycle crosses exactly eight edges, n must be 1. The module states this as a theorem: the per-tick edge count is unique and equals one. The constant A, previously a definition with a comment, is now a proved result in the machine-checked library of formal theorems.

This matters because the active edge budget feeds into a larger identity. The framework's duality between matter content and consciousness ceiling multiplies to the golden ratio, and that product rests on A being one. With A now forced rather than assumed, the identity stands on a proved foundation. The module also packages its results into a certificate, a single structure that bundles the key theorems for downstream use.

The practical consequence is that the framework no longer carries this number as a postulate. The number one is not chosen; it is the only cardinality consistent with the Gray cycle's one-bit steps. The budget is a derived fact, not a free parameter, and the derivation is checked by the library's kernel.

/-- **The active-edge budget per tick is uniquely forced to 1.**

Any natural number `n` such that the per-tick edge count under the
canonical 3-bit Gray cycle is constantly `n` must equal 1. This is
the structural forcing of `active_edges_per_tick = 1`: no other value
of `n` is consistent with the Gray-cycle adjacency. -/
theorem per_tick_edge_count_unique (n : ℕ)
    (h : ∀ i : Fin 8,
      edgesTraversed (grayCycle3Path i) (grayCycle3Path (i + 1)) = n) :
    n = 1 := by
  have h0 := h 0
  rw [grayCycle3_per_tick_edge_count 0] at h0
  exact h0.symm

/-- **CONSEQUENCE.** Consecutive postings in the canonical 3-bit
Gray cycle traverse exactly one cube edge. -/
theorem grayCycle3_per_tick_edge_count (i : Fin 8) :
    edgesTraversed (grayCycle3Path i) (grayCycle3Path (i + 1)) = 1 := by
  unfold edgesTraversed
  exact (oneBitDiff_iff_hamming_one _ _).mp (grayCycle3_oneBit_step i)

/-- The total edge count over one octave is exactly 8: each of the
8 ticks contributes exactly 1 edge traversal. -/
theorem octaveEdgeCount_eq_eight : octaveEdgeCount = 8 := by
  unfold octaveEdgeCount
  rw [Finset.sum_congr rfl (fun i _ => grayCycle3_per_tick_edge_count i)]
  simp

/-- The downstream definition equals 1 (`rfl`-level), and 1 is the
unique value forced by `oneBit_step` (`per_tick_edge_count_unique`).
Together: the postulate is correctly chosen. -/
theorem active_edges_per_tick_eq_one_and_forced :
    Constants.AlphaDerivation.active_edges_per_tick = 1 ∧
    (∀ n : ℕ,
       (∀ i : Fin 8,
         edgesTraversed (grayCycle3Path i) (grayCycle3Path (i + 1)) = n) →
       n = 1) := by
  refine ⟨rfl, per_tick_edge_count_unique⟩

/-- The matter-consciousness budget identity, with the active-edge
exponent `A` reduced to its forced value `1`. -/
theorem budget_partition_with_A_forced :
    Foundation.RecognitionBudget.matter_content *
        Foundation.RecognitionBudget.consciousness_ceiling = phi := by
  exact Foundation.RecognitionBudget.budget_partition

What this page does not claim

The active edge budget is not a measured quantity; it is a theorem within the framework. This module does not prove that the recognition cycle is the only possible cycle on the cube. The one-edge budget does not by itself establish the three-dimensionality of physical space.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Foundation/ActiveEdgeBudget.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: