Sync from openai/math@faee2cf485a8 (part 2)

lean/ComparatorChallenges/FourierLLogL.json

@@ -1,14 +1,14 @@
-{
-  "challenge_module": "ComparatorChallenges.FourierLLogL",
-  "solution_module": "OAI.Analysis.FourierLLogL.PaperMain",
-  "theorem_names": [
-    "OAI.FourierLLogL.paperMain"
-  ],
-  "definition_names": [],
-  "permitted_axioms": [
-    "propext",
-    "Quot.sound",
-    "Classical.choice"
-  ],
-  "enable_nanoda": false
-}
+{
+  "challenge_module": "ComparatorChallenges.FourierLLogL",
+  "solution_module": "OAI.Analysis.FourierLLogL.PaperMain",
+  "theorem_names": [
+    "OAI.FourierLLogL.paperMain"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/FourierLLogL.lean

@@ -1,24 +1,24 @@
-import Mathlib
-
-open MeasureTheory Filter
-open scoped BigOperators Topology
-
-namespace OAI.FourierLLogL
-
-instance circlePeriod_pos : Fact (0 < 2 * Real.pi) :=
-  ⟨mul_pos (by norm_num) Real.pi_pos⟩
-
-/-- Almost-everywhere convergence of all symmetric Fourier partial sums in L log L. -/
-theorem paperMain (f : AddCircle (2 * Real.pi) → ℂ)
-    (hfm : AEStronglyMeasurable f AddCircle.haarAddCircle)
-    (hfi : Integrable (fun x ↦ ‖f x‖ * Real.log (2 + ‖f x‖))
-      AddCircle.haarAddCircle) :
-    ∃ E : Set (AddCircle (2 * Real.pi)),
-      MeasurableSet E ∧ AddCircle.haarAddCircle E = 0 ∧ ∀ x ∉ E,
-        Tendsto
-          (fun N : ℕ ↦
-            ∑ k ∈ Finset.Icc (-(N : ℤ)) (N : ℤ), fourierCoeff f k * fourier k x)
-          atTop (𝓝 (f x)) := by
-  sorry
-
-end OAI.FourierLLogL
+import Mathlib
+
+open MeasureTheory Filter
+open scoped BigOperators Topology
+
+namespace OAI.FourierLLogL
+
+instance circlePeriod_pos : Fact (0 < 2 * Real.pi) :=
+  ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- Almost-everywhere convergence of all symmetric Fourier partial sums in L log L. -/
+theorem paperMain (f : AddCircle (2 * Real.pi) → ℂ)
+    (hfm : AEStronglyMeasurable f AddCircle.haarAddCircle)
+    (hfi : Integrable (fun x ↦ ‖f x‖ * Real.log (2 + ‖f x‖))
+      AddCircle.haarAddCircle) :
+    ∃ E : Set (AddCircle (2 * Real.pi)),
+      MeasurableSet E ∧ AddCircle.haarAddCircle E = 0 ∧ ∀ x ∉ E,
+        Tendsto
+          (fun N : ℕ ↦
+            ∑ k ∈ Finset.Icc (-(N : ℤ)) (N : ℤ), fourierCoeff f k * fourier k x)
+          atTop (𝓝 (f x)) := by
+  sorry
+
+end OAI.FourierLLogL

lean/ComparatorChallenges/HadwigerCounterexample.json

@@ -1,15 +1,15 @@
-{
-  "challenge_module": "ComparatorChallenges.HadwigerCounterexample",
-  "solution_module": "OAI.Combinatorics.HadwigerCounterexample.Main",
-  "theorem_names": [
-    "OAI.HadwigerCounterexample.exists_counterexamples",
-    "OAI.HadwigerCounterexample.not_hadwiger_conjecture"
-  ],
-  "definition_names": [],
-  "permitted_axioms": [
-    "propext",
-    "Quot.sound",
-    "Classical.choice"
-  ],
-  "enable_nanoda": false
-}
+{
+  "challenge_module": "ComparatorChallenges.HadwigerCounterexample",
+  "solution_module": "OAI.Combinatorics.HadwigerCounterexample.Main",
+  "theorem_names": [
+    "OAI.HadwigerCounterexample.exists_counterexamples",
+    "OAI.HadwigerCounterexample.not_hadwiger_conjecture"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/HadwigerCounterexample.lean

@@ -1,56 +1,56 @@
-import Mathlib
-
-namespace OAI
-
-namespace HadwigerMatching
-
-universe u
-variable {V : Type u}
-
-def IsTouchingMatching (G : SimpleGraph V) (M : Finset (Finset V)) : Prop :=
-  (∀ e ∈ M, e.card = 2 ∧ G.IsClique (e : Set V)) ∧
-  (∀ e ∈ M, ∀ f ∈ M, e ≠ f → Disjoint e f) ∧
-  (∀ e ∈ M, ∀ f ∈ M, e ≠ f →
-    ∃ v ∈ e, ∃ w ∈ f, G.Adj v w)
-
-noncomputable def connectedMatchingNumber (G : SimpleGraph V) : ℕ :=
-  sSup {n : ℕ | ∃ M : Finset (Finset V), IsTouchingMatching G M ∧ M.card = n}
-
-end HadwigerMatching
-
-namespace LinearListHadwiger
-
-def HasCliqueMinor {V : Type} (G : SimpleGraph V) (t : ℕ) : Prop :=
-  ∃ B : Fin t → Set V,
-    (∀ i, (G.induce (B i)).Connected) ∧
-    (∀ i j, i ≠ j → Disjoint (B i) (B j)) ∧
-    (∀ i j, i ≠ j → ∃ v ∈ B i, ∃ w ∈ B j, G.Adj v w)
-
-noncomputable def hadwigerNumber {V : Type} (G : SimpleGraph V) : ℕ :=
-  sSup {t : ℕ | HasCliqueMinor G t}
-
-end LinearListHadwiger
-
-namespace HadwigerCounterexample
-
-open HadwigerMatching LinearListHadwiger
-
-theorem exists_counterexamples (M : ℕ) : ∃ m : ℕ, max M 5 ≤ m ∧
-    ∃ G : SimpleGraph (Fin m), G.indepNum ≤ 2 ∧
-      (connectedMatchingNumber G : ℚ) < (m : ℚ) / 100 ∧
-      (hadwigerNumber G : ℚ) < 26 * (m : ℚ) / 75 + 2 / 3 ∧
-      26 * (m : ℚ) / 75 + 2 / 3 < (m : ℚ) / 2 ∧
-      (m : ℚ) / 2 ≤ (G.chromaticNumber.toNat : ℚ) ∧
-      hadwigerNumber G < G.chromaticNumber.toNat ∧
-      G.chromaticNumber ≠ ⊤ ∧
-      G.chromaticNumber = ↑(G.chromaticNumber.toNat) := by
-  sorry
-
-theorem not_hadwiger_conjecture :
-    ¬ (∀ (m : ℕ) (G : SimpleGraph (Fin m)),
-      G.chromaticNumber ≤ ↑(hadwigerNumber G)) := by
-  sorry
-
-end HadwigerCounterexample
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace HadwigerMatching
+
+universe u
+variable {V : Type u}
+
+def IsTouchingMatching (G : SimpleGraph V) (M : Finset (Finset V)) : Prop :=
+  (∀ e ∈ M, e.card = 2 ∧ G.IsClique (e : Set V)) ∧
+  (∀ e ∈ M, ∀ f ∈ M, e ≠ f → Disjoint e f) ∧
+  (∀ e ∈ M, ∀ f ∈ M, e ≠ f →
+    ∃ v ∈ e, ∃ w ∈ f, G.Adj v w)
+
+noncomputable def connectedMatchingNumber (G : SimpleGraph V) : ℕ :=
+  sSup {n : ℕ | ∃ M : Finset (Finset V), IsTouchingMatching G M ∧ M.card = n}
+
+end HadwigerMatching
+
+namespace LinearListHadwiger
+
+def HasCliqueMinor {V : Type} (G : SimpleGraph V) (t : ℕ) : Prop :=
+  ∃ B : Fin t → Set V,
+    (∀ i, (G.induce (B i)).Connected) ∧
+    (∀ i j, i ≠ j → Disjoint (B i) (B j)) ∧
+    (∀ i j, i ≠ j → ∃ v ∈ B i, ∃ w ∈ B j, G.Adj v w)
+
+noncomputable def hadwigerNumber {V : Type} (G : SimpleGraph V) : ℕ :=
+  sSup {t : ℕ | HasCliqueMinor G t}
+
+end LinearListHadwiger
+
+namespace HadwigerCounterexample
+
+open HadwigerMatching LinearListHadwiger
+
+theorem exists_counterexamples (M : ℕ) : ∃ m : ℕ, max M 5 ≤ m ∧
+    ∃ G : SimpleGraph (Fin m), G.indepNum ≤ 2 ∧
+      (connectedMatchingNumber G : ℚ) < (m : ℚ) / 100 ∧
+      (hadwigerNumber G : ℚ) < 26 * (m : ℚ) / 75 + 2 / 3 ∧
+      26 * (m : ℚ) / 75 + 2 / 3 < (m : ℚ) / 2 ∧
+      (m : ℚ) / 2 ≤ (G.chromaticNumber.toNat : ℚ) ∧
+      hadwigerNumber G < G.chromaticNumber.toNat ∧
+      G.chromaticNumber ≠ ⊤ ∧
+      G.chromaticNumber = ↑(G.chromaticNumber.toNat) := by
+  sorry
+
+theorem not_hadwiger_conjecture :
+    ¬ (∀ (m : ℕ) (G : SimpleGraph (Fin m)),
+      G.chromaticNumber ≤ ↑(hadwigerNumber G)) := by
+  sorry
+
+end HadwigerCounterexample
+
+end OAI

lean/ComparatorChallenges/HoneycombBridgeMassSupport.json

@@ -1,14 +1,14 @@
-{
-  "challenge_module": "ComparatorChallenges.HoneycombBridgeMassSupport",
-  "solution_module": "OAI.Combinatorics.HoneycombChords.BridgeMass",
-  "theorem_names": [
-    "OAI.CriticalHoneycomb.finiteBridgeMassEstimate"
-  ],
-  "definition_names": [],
-  "permitted_axioms": [
-    "propext",
-    "Quot.sound",
-    "Classical.choice"
-  ],
-  "enable_nanoda": false
-}
+{
+  "challenge_module": "ComparatorChallenges.HoneycombBridgeMassSupport",
+  "solution_module": "OAI.Combinatorics.HoneycombChords.BridgeMass",
+  "theorem_names": [
+    "OAI.CriticalHoneycomb.finiteBridgeMassEstimate"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/HoneycombBridgeMassSupport.lean

@@ -1,78 +1,78 @@
-import Mathlib
-
-namespace OAI
-
-namespace CriticalHoneycomb
-open scoped ENNReal
-
-abbrev Center := ℤ × ℤ × Bool
-
-def up (i j : ℤ) : Center := (i, j, true)
-def down (i j : ℤ) : Center := (i, j, false)
-
-/-- Adjacency across a full triangular edge. -/
-def Adj (v w : Center) : Prop :=
-  if v.2.2 then
-    w.2.2 = false ∧ ((w.1 = v.1 ∧ w.2.1 = v.2.1) ∨
-      (w.1 = v.1 ∧ w.2.1 = v.2.1 - 1) ∨
-      (w.1 = v.1 - 1 ∧ w.2.1 = v.2.1))
-  else
-    w.2.2 = true ∧ ((w.1 = v.1 ∧ w.2.1 = v.2.1) ∨
-      (w.1 = v.1 ∧ w.2.1 = v.2.1 + 1) ∨
-      (w.1 = v.1 + 1 ∧ w.2.1 = v.2.1))
-
-noncomputable def rowSpacing : ℝ := Real.sqrt 3 / 2
-
-/-- The fixed Euclidean embedding in the unit triangular tiling. -/
-noncomputable def centerPosition (v : Center) : ℝ × ℝ :=
-  if v.2.2 then
-    ((v.1 : ℝ) + (v.2.1 : ℝ) / 2 + 1 / 2,
-      rowSpacing * ((v.2.1 : ℝ) + 1 / 3))
-  else
-    ((v.1 : ℝ) + (v.2.1 : ℝ) / 2 + 1,
-      rowSpacing * ((v.2.1 : ℝ) + 2 / 3))
-
-/-- A midpoint port, oriented into the triangle domain. -/
-structure Port (D : Set Center) where
-  inside : Center
-  outside : Center
-  adjacent : Adj inside outside
-  inside_mem : inside ∈ D
-  outside_not_mem : outside ∉ D
-
-noncomputable def Port.position {D : Set Center} (p : Port D) : ℝ × ℝ :=
-  ((centerPosition p.inside).1 / 2 + (centerPosition p.outside).1 / 2,
-    (centerPosition p.inside).2 / 2 + (centerPosition p.outside).2 / 2)
-
-/-- A simple center trace, with no premature boundary exit. -/
-def IsTrace (D : Set Center) (p : List Center) : Prop :=
-  p.Nodup ∧ p.IsChain Adj ∧ ∀ v ∈ p, v ∈ D
-
-noncomputable def kappa : ℝ := (2 + Real.sqrt 2) ^ (-(1 : ℝ) / 2)
-
-/-- Length counts centers; the port half-edges contribute no factors. -/
-noncomputable def weight (p : List Center) : ℝ≥0∞ :=
-  ENNReal.ofReal (kappa ^ p.length)
-
-/-- The source's strip and tilt-compatible terminal support. -/
-def strip (h : ℕ) : Set Center := {v | 0 ≤ v.2.1 ∧ v.2.1 < (h : ℤ)}
-def StrictBridge (h : ℕ) :=
-  {p : List Center // IsTrace (strip h) p ∧ p.head? = some (up 0 0) ∧
-    ∃ i : ℤ, p.getLast? = some (down i ((h : ℤ) - 1))}
-noncomputable def bridgeMass (h : ℕ) : ℝ≥0∞ :=
-  if h = 0 then 1 else ∑' p : StrictBridge h, weight p.val
-
-/-- Necessary estimate c:finite(1), inputs.tex:13, on the actual path sum. -/
-def FiniteBridgeMassEstimate : Prop :=
-  ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∀ h : ℕ,
-    ENNReal.ofReal (c * (1 + (h : ℝ)) ^ (-(1 : ℝ) / 4)) ≤ bridgeMass h ∧
-    bridgeMass h ≤ ENNReal.ofReal (C * (1 + (h : ℝ)) ^ (-(1 : ℝ) / 4))
-
-/-- Trusted reference hole only; missing necessary main obligation. -/
-theorem finiteBridgeMassEstimate : FiniteBridgeMassEstimate := by
-  sorry
-
-end CriticalHoneycomb
-
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace CriticalHoneycomb
+open scoped ENNReal
+
+abbrev Center := ℤ × ℤ × Bool
+
+def up (i j : ℤ) : Center := (i, j, true)
+def down (i j : ℤ) : Center := (i, j, false)
+
+/-- Adjacency across a full triangular edge. -/
+def Adj (v w : Center) : Prop :=
+  if v.2.2 then
+    w.2.2 = false ∧ ((w.1 = v.1 ∧ w.2.1 = v.2.1) ∨
+      (w.1 = v.1 ∧ w.2.1 = v.2.1 - 1) ∨
+      (w.1 = v.1 - 1 ∧ w.2.1 = v.2.1))
+  else
+    w.2.2 = true ∧ ((w.1 = v.1 ∧ w.2.1 = v.2.1) ∨
+      (w.1 = v.1 ∧ w.2.1 = v.2.1 + 1) ∨
+      (w.1 = v.1 + 1 ∧ w.2.1 = v.2.1))
+
+noncomputable def rowSpacing : ℝ := Real.sqrt 3 / 2
+
+/-- The fixed Euclidean embedding in the unit triangular tiling. -/
+noncomputable def centerPosition (v : Center) : ℝ × ℝ :=
+  if v.2.2 then
+    ((v.1 : ℝ) + (v.2.1 : ℝ) / 2 + 1 / 2,
+      rowSpacing * ((v.2.1 : ℝ) + 1 / 3))
+  else
+    ((v.1 : ℝ) + (v.2.1 : ℝ) / 2 + 1,
+      rowSpacing * ((v.2.1 : ℝ) + 2 / 3))
+
+/-- A midpoint port, oriented into the triangle domain. -/
+structure Port (D : Set Center) where
+  inside : Center
+  outside : Center
+  adjacent : Adj inside outside
+  inside_mem : inside ∈ D
+  outside_not_mem : outside ∉ D
+
+noncomputable def Port.position {D : Set Center} (p : Port D) : ℝ × ℝ :=
+  ((centerPosition p.inside).1 / 2 + (centerPosition p.outside).1 / 2,
+    (centerPosition p.inside).2 / 2 + (centerPosition p.outside).2 / 2)
+
+/-- A simple center trace, with no premature boundary exit. -/
+def IsTrace (D : Set Center) (p : List Center) : Prop :=
+  p.Nodup ∧ p.IsChain Adj ∧ ∀ v ∈ p, v ∈ D
+
+noncomputable def kappa : ℝ := (2 + Real.sqrt 2) ^ (-(1 : ℝ) / 2)
+
+/-- Length counts centers; the port half-edges contribute no factors. -/
+noncomputable def weight (p : List Center) : ℝ≥0∞ :=
+  ENNReal.ofReal (kappa ^ p.length)
+
+/-- The source's strip and tilt-compatible terminal support. -/
+def strip (h : ℕ) : Set Center := {v | 0 ≤ v.2.1 ∧ v.2.1 < (h : ℤ)}
+def StrictBridge (h : ℕ) :=
+  {p : List Center // IsTrace (strip h) p ∧ p.head? = some (up 0 0) ∧
+    ∃ i : ℤ, p.getLast? = some (down i ((h : ℤ) - 1))}
+noncomputable def bridgeMass (h : ℕ) : ℝ≥0∞ :=
+  if h = 0 then 1 else ∑' p : StrictBridge h, weight p.val
+
+/-- Necessary estimate c:finite(1), inputs.tex:13, on the actual path sum. -/
+def FiniteBridgeMassEstimate : Prop :=
+  ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∀ h : ℕ,
+    ENNReal.ofReal (c * (1 + (h : ℝ)) ^ (-(1 : ℝ) / 4)) ≤ bridgeMass h ∧
+    bridgeMass h ≤ ENNReal.ofReal (C * (1 + (h : ℝ)) ^ (-(1 : ℝ) / 4))
+
+/-- Trusted reference hole only; missing necessary main obligation. -/
+theorem finiteBridgeMassEstimate : FiniteBridgeMassEstimate := by
+  sorry
+
+end CriticalHoneycomb
+
+
+end OAI

lean/ComparatorChallenges/LogspaceEquality.json

@@ -1,35 +1,35 @@
-{
-  "challenge_module": "ComparatorChallenges.LogspaceEquality",
-  "solution_module": "OAI.Computability.Logspace.Equality",
-  "theorem_names": [
-    "OAI.ExactDerandomization.exact_logarithmic_space_derandomization"
-  ],
-  "definition_names": [
-    "OAI.ExactDerandomization.Word",
-    "OAI.ExactDerandomization.Language",
-    "OAI.ExactDerandomization.CoinTape",
-    "OAI.ExactDerandomization.Direction.move",
-    "OAI.ExactDerandomization.Direction.moveInput",
-    "OAI.ExactDerandomization.readInput",
-    "OAI.ExactDerandomization.Machine.initial",
-    "OAI.ExactDerandomization.Machine.step",
-    "OAI.ExactDerandomization.Machine.run",
-    "OAI.ExactDerandomization.Machine.spaceThrough",
-    "OAI.ExactDerandomization.Machine.LogSpace",
-    "OAI.ExactDerandomization.Machine.Deterministic",
-    "OAI.ExactDerandomization.Machine.HaltsBy",
-    "OAI.ExactDerandomization.Machine.Decides",
-    "OAI.ExactDerandomization.Machine.extendCoins",
-    "OAI.ExactDerandomization.Machine.acceptanceProbability",
-    "OAI.ExactDerandomization.polynomialClock",
-    "OAI.ExactDerandomization.L",
-    "OAI.ExactDerandomization.RL",
-    "OAI.ExactDerandomization.BPL"
-  ],
-  "permitted_axioms": [
-    "propext",
-    "Quot.sound",
-    "Classical.choice"
-  ],
-  "enable_nanoda": false
-}
+{
+  "challenge_module": "ComparatorChallenges.LogspaceEquality",
+  "solution_module": "OAI.Computability.Logspace.Equality",
+  "theorem_names": [
+    "OAI.ExactDerandomization.exact_logarithmic_space_derandomization"
+  ],
+  "definition_names": [
+    "OAI.ExactDerandomization.Word",
+    "OAI.ExactDerandomization.Language",
+    "OAI.ExactDerandomization.CoinTape",
+    "OAI.ExactDerandomization.Direction.move",
+    "OAI.ExactDerandomization.Direction.moveInput",
+    "OAI.ExactDerandomization.readInput",
+    "OAI.ExactDerandomization.Machine.initial",
+    "OAI.ExactDerandomization.Machine.step",
+    "OAI.ExactDerandomization.Machine.run",
+    "OAI.ExactDerandomization.Machine.spaceThrough",
+    "OAI.ExactDerandomization.Machine.LogSpace",
+    "OAI.ExactDerandomization.Machine.Deterministic",
+    "OAI.ExactDerandomization.Machine.HaltsBy",
+    "OAI.ExactDerandomization.Machine.Decides",
+    "OAI.ExactDerandomization.Machine.extendCoins",
+    "OAI.ExactDerandomization.Machine.acceptanceProbability",
+    "OAI.ExactDerandomization.polynomialClock",
+    "OAI.ExactDerandomization.L",
+    "OAI.ExactDerandomization.RL",
+    "OAI.ExactDerandomization.BPL"
+  ],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/LogspaceEquality.lean

@@ -1,142 +1,142 @@
-import Mathlib
-
-namespace OAI
-
-/-! Exact logarithmic-space derandomization for finite transition-table machines. -/
-
-namespace ExactDerandomization
-
-abbrev Word := List Bool
-abbrev Language := Set Word
-abbrev CoinTape := ℕ → Bool
-
-inductive Direction where
-  | left | stay | right
-  deriving DecidableEq
-
-inductive InputSymbol where
-  | leftMarker | bit (b : Bool) | rightMarker
-  deriving DecidableEq
-
-def Direction.move (d : Direction) (z : ℤ) : ℤ :=
-  match d with
-  | .left => z - 1
-  | .stay => z
-  | .right => z + 1
-
-def Direction.moveInput (d : Direction) {n : ℕ} (i : Fin (n + 2)) : Fin (n + 2) :=
-  match d with
-  | .left => ⟨i.val - 1, lt_of_le_of_lt (Nat.sub_le _ _) i.isLt⟩
-  | .stay => i
-  | .right => ⟨min (i.val + 1) (n + 1), by omega⟩
-
-def readInput (x : Word) (i : Fin (x.length + 2)) : InputSymbol :=
-  if i.val = 0 then .leftMarker else
-    match x[i.val - 1]? with
-    | some b => .bit b
-    | none => .rightMarker
-
-structure Action (q w h : ℕ) where
-  nextState : Fin (q + 1)
-  write : Fin w → Bool
-  workMove : Fin w → Direction
-  inputMove : Fin h → Direction
-
-structure Machine (q w h : ℕ) where
-  initialState : Fin (q + 1)
-  output : Fin (q + 1) → Option Bool
-  transition : Fin (q + 1) → (Fin h → InputSymbol) → (Fin w → Bool) → Bool →
-    Action q w h
-
-structure Configuration (q w h n : ℕ) where
-  state : Fin (q + 1)
-  inputPos : Fin h → Fin (n + 2)
-  workPos : Fin w → ℤ
-  work : Fin w → ℤ → Bool
-
-namespace Machine
-
-variable {q w h : ℕ}
-
-def initial (M : Machine q w h) (n : ℕ) : Configuration q w h n where
-  state := M.initialState
-  inputPos := fun _ => ⟨0, by omega⟩
-  workPos := fun _ => 0
-  work := fun _ _ => false
-
-def step (M : Machine q w h) (x : Word) (b : Bool)
-    (c : Configuration q w h x.length) : Configuration q w h x.length :=
-  match M.output c.state with
-  | some _ => c
-  | none =>
-    let a := M.transition c.state (fun j => readInput x (c.inputPos j))
-      (fun k => c.work k (c.workPos k)) b
-    { state := a.nextState
-      inputPos := fun j => (a.inputMove j).moveInput (c.inputPos j)
-      workPos := fun k => (a.workMove k).move (c.workPos k)
-      work := fun k => Function.update (c.work k) (c.workPos k) (a.write k) }
-
-def run (M : Machine q w h) (x : Word) (coins : CoinTape) :
-    ℕ → Configuration q w h x.length
-  | 0 => M.initial x.length
-  | t + 1 => M.step x (coins t) (M.run x coins t)
-
-def spaceThrough (M : Machine q w h) (x : Word) (coins : CoinTape) (t : ℕ) : ℕ :=
-  ∑ k : Fin w, ((Finset.range (t + 1)).image
-    (fun s => (M.run x coins s).workPos k)).card
-
-def LogSpace (M : Machine q w h) : Prop :=
-  ∃ c : ℕ, 0 < c ∧ ∀ (x : Word) (coins : CoinTape) (t : ℕ),
-    M.spaceThrough x coins t ≤ c * Nat.clog 2 (x.length + 2)
-
-def Deterministic (M : Machine q w h) : Prop :=
-  ∀ s i v, M.transition s i v false = M.transition s i v true
-
-def HaltsBy (M : Machine q w h) (x : Word) (t : ℕ) : Prop :=
-  ∀ coins : CoinTape, ∃ b : Bool, M.output (M.run x coins t).state = some b
-
-def Decides (M : Machine q w h) (A : Language) : Prop :=
-  ∀ x : Word, ∃ (t : ℕ) (b : Bool),
-    (b = true ↔ x ∈ A) ∧ ∀ coins : CoinTape,
-      M.output (M.run x coins t).state = some b
-
-def extendCoins {t : ℕ} (bits : Fin t → Bool) : CoinTape :=
-  fun s => if hs : s < t then bits ⟨s, hs⟩ else false
-
-def acceptanceProbability (M : Machine q w h) (x : Word) (t : ℕ) : ℚ :=
-  ((Finset.univ.filter (fun bits : Fin t → Bool =>
-    M.output (M.run x (extendCoins bits) t).state = some true)).card : ℚ) /
-    (2 : ℚ) ^ t
-
-end Machine
-
-def polynomialClock (c k n : ℕ) : ℕ := c * (n + 2) ^ k
-
-def L : Set Language :=
-  {A | ∃ (q w h : ℕ) (M : Machine q w h),
-    M.Deterministic ∧ M.LogSpace ∧ M.Decides A}
-
-def RL : Set Language :=
-  {A | ∃ (q w h : ℕ) (M : Machine q w h),
-    M.LogSpace ∧ ∃ (c k : ℕ), 0 < c ∧ ∀ x : Word,
-      M.HaltsBy x (polynomialClock c k x.length) ∧
-      (x ∈ A → (1 / 2 : ℚ) ≤ M.acceptanceProbability x
-        (polynomialClock c k x.length)) ∧
-      (x ∉ A → M.acceptanceProbability x (polynomialClock c k x.length) = 0)}
-
-def BPL : Set Language :=
-  {A | ∃ (q w h : ℕ) (M : Machine q w h),
-    M.LogSpace ∧ ∃ (c k : ℕ), 0 < c ∧ ∀ x : Word,
-      M.HaltsBy x (polynomialClock c k x.length) ∧
-      (x ∈ A → (2 / 3 : ℚ) ≤ M.acceptanceProbability x
-        (polynomialClock c k x.length)) ∧
-      (x ∉ A → M.acceptanceProbability x (polynomialClock c k x.length) ≤ (1 / 3 : ℚ))}
-
-
-theorem exact_logarithmic_space_derandomization :
-    L = RL ∧ RL = BPL := by
-  sorry
-
-end ExactDerandomization
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Exact logarithmic-space derandomization for finite transition-table machines. -/
+
+namespace ExactDerandomization
+
+abbrev Word := List Bool
+abbrev Language := Set Word
+abbrev CoinTape := ℕ → Bool
+
+inductive Direction where
+  | left | stay | right
+  deriving DecidableEq
+
+inductive InputSymbol where
+  | leftMarker | bit (b : Bool) | rightMarker
+  deriving DecidableEq
+
+def Direction.move (d : Direction) (z : ℤ) : ℤ :=
+  match d with
+  | .left => z - 1
+  | .stay => z
+  | .right => z + 1
+
+def Direction.moveInput (d : Direction) {n : ℕ} (i : Fin (n + 2)) : Fin (n + 2) :=
+  match d with
+  | .left => ⟨i.val - 1, lt_of_le_of_lt (Nat.sub_le _ _) i.isLt⟩
+  | .stay => i
+  | .right => ⟨min (i.val + 1) (n + 1), by omega⟩
+
+def readInput (x : Word) (i : Fin (x.length + 2)) : InputSymbol :=
+  if i.val = 0 then .leftMarker else
+    match x[i.val - 1]? with
+    | some b => .bit b
+    | none => .rightMarker
+
+structure Action (q w h : ℕ) where
+  nextState : Fin (q + 1)
+  write : Fin w → Bool
+  workMove : Fin w → Direction
+  inputMove : Fin h → Direction
+
+structure Machine (q w h : ℕ) where
+  initialState : Fin (q + 1)
+  output : Fin (q + 1) → Option Bool
+  transition : Fin (q + 1) → (Fin h → InputSymbol) → (Fin w → Bool) → Bool →
+    Action q w h
+
+structure Configuration (q w h n : ℕ) where
+  state : Fin (q + 1)
+  inputPos : Fin h → Fin (n + 2)
+  workPos : Fin w → ℤ
+  work : Fin w → ℤ → Bool
+
+namespace Machine
+
+variable {q w h : ℕ}
+
+def initial (M : Machine q w h) (n : ℕ) : Configuration q w h n where
+  state := M.initialState
+  inputPos := fun _ => ⟨0, by omega⟩
+  workPos := fun _ => 0
+  work := fun _ _ => false
+
+def step (M : Machine q w h) (x : Word) (b : Bool)
+    (c : Configuration q w h x.length) : Configuration q w h x.length :=
+  match M.output c.state with
+  | some _ => c
+  | none =>
+    let a := M.transition c.state (fun j => readInput x (c.inputPos j))
+      (fun k => c.work k (c.workPos k)) b
+    { state := a.nextState
+      inputPos := fun j => (a.inputMove j).moveInput (c.inputPos j)
+      workPos := fun k => (a.workMove k).move (c.workPos k)
+      work := fun k => Function.update (c.work k) (c.workPos k) (a.write k) }
+
+def run (M : Machine q w h) (x : Word) (coins : CoinTape) :
+    ℕ → Configuration q w h x.length
+  | 0 => M.initial x.length
+  | t + 1 => M.step x (coins t) (M.run x coins t)
+
+def spaceThrough (M : Machine q w h) (x : Word) (coins : CoinTape) (t : ℕ) : ℕ :=
+  ∑ k : Fin w, ((Finset.range (t + 1)).image
+    (fun s => (M.run x coins s).workPos k)).card
+
+def LogSpace (M : Machine q w h) : Prop :=
+  ∃ c : ℕ, 0 < c ∧ ∀ (x : Word) (coins : CoinTape) (t : ℕ),
+    M.spaceThrough x coins t ≤ c * Nat.clog 2 (x.length + 2)
+
+def Deterministic (M : Machine q w h) : Prop :=
+  ∀ s i v, M.transition s i v false = M.transition s i v true
+
+def HaltsBy (M : Machine q w h) (x : Word) (t : ℕ) : Prop :=
+  ∀ coins : CoinTape, ∃ b : Bool, M.output (M.run x coins t).state = some b
+
+def Decides (M : Machine q w h) (A : Language) : Prop :=
+  ∀ x : Word, ∃ (t : ℕ) (b : Bool),
+    (b = true ↔ x ∈ A) ∧ ∀ coins : CoinTape,
+      M.output (M.run x coins t).state = some b
+
+def extendCoins {t : ℕ} (bits : Fin t → Bool) : CoinTape :=
+  fun s => if hs : s < t then bits ⟨s, hs⟩ else false
+
+def acceptanceProbability (M : Machine q w h) (x : Word) (t : ℕ) : ℚ :=
+  ((Finset.univ.filter (fun bits : Fin t → Bool =>
+    M.output (M.run x (extendCoins bits) t).state = some true)).card : ℚ) /
+    (2 : ℚ) ^ t
+
+end Machine
+
+def polynomialClock (c k n : ℕ) : ℕ := c * (n + 2) ^ k
+
+def L : Set Language :=
+  {A | ∃ (q w h : ℕ) (M : Machine q w h),
+    M.Deterministic ∧ M.LogSpace ∧ M.Decides A}
+
+def RL : Set Language :=
+  {A | ∃ (q w h : ℕ) (M : Machine q w h),
+    M.LogSpace ∧ ∃ (c k : ℕ), 0 < c ∧ ∀ x : Word,
+      M.HaltsBy x (polynomialClock c k x.length) ∧
+      (x ∈ A → (1 / 2 : ℚ) ≤ M.acceptanceProbability x
+        (polynomialClock c k x.length)) ∧
+      (x ∉ A → M.acceptanceProbability x (polynomialClock c k x.length) = 0)}
+
+def BPL : Set Language :=
+  {A | ∃ (q w h : ℕ) (M : Machine q w h),
+    M.LogSpace ∧ ∃ (c k : ℕ), 0 < c ∧ ∀ x : Word,
+      M.HaltsBy x (polynomialClock c k x.length) ∧
+      (x ∈ A → (2 / 3 : ℚ) ≤ M.acceptanceProbability x
+        (polynomialClock c k x.length)) ∧
+      (x ∉ A → M.acceptanceProbability x (polynomialClock c k x.length) ≤ (1 / 3 : ℚ))}
+
+
+theorem exact_logarithmic_space_derandomization :
+    L = RL ∧ RL = BPL := by
+  sorry
+
+end ExactDerandomization
+
+end OAI

lean/ComparatorChallenges/OneTapeSpace.json

@@ -1,15 +1,15 @@
-{
-  "challenge_module": "ComparatorChallenges.OneTapeSpace",
-  "solution_module": "OAI.Computability.SpaceSimulation.Main",
-  "theorem_names": [
-    "OAI.Fifths.Single.capped",
-    "OAI.Fifths.Single.unknown"
-  ],
-  "definition_names": [],
-  "permitted_axioms": [
-    "propext",
-    "Classical.choice",
-    "Quot.sound"
-  ],
-  "enable_nanoda": false
-}
+{
+  "challenge_module": "ComparatorChallenges.OneTapeSpace",
+  "solution_module": "OAI.Computability.SpaceSimulation.Main",
+  "theorem_names": [
+    "OAI.Fifths.Single.capped",
+    "OAI.Fifths.Single.unknown"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/OneTapeSpace.lean

@@ -1,275 +1,275 @@
-import Mathlib
-
-namespace OAI
-
-/-! Finite-machine statements of the capped and unknown-time one-writable-tape
-simulation theorem. Work space counts the bits in every visited writable cell;
-public endmarked input tapes are read-only. -/
-
-namespace Fifths
-
-inductive Dir
-  | L | N | R
-  deriving DecidableEq
-
-instance : Fintype Dir := ⟨{.L, .N, .R}, by intro d; cases d <;> simp⟩
-
-namespace Dir
-@[simp] def delta : Dir → ℤ
-  | L => -1
-  | N => 0
-  | R => 1
-end Dir
-
-inductive Mark (A : Type)
-  | left
-  | sym (a : A)
-  | right
-  deriving DecidableEq, Fintype
-
-namespace Mark
-variable {A : Type}
-def see (w : List A) : ℕ → Mark A
-  | 0 => left
-  | p+1 =>
-    match w[p]? with
-    | some a => sym a
-    | none => right
-
-def walk (w : List A) (p : ℕ) : Dir → ℕ
-  | .N => p
-  | .L => p - 1
-  | .R => if w.length < p then p else p + 1
-end Mark
-
-inductive Runs {σ Y : Type} (f : σ → Y ⊕ σ) (P : σ → Prop) :
-    σ → σ → Y → Prop
-  | stop {s y} (ok : P s) (eqn : f s = Sum.inl y) : Runs f P s s y
-  | step {s s' t y} (ok : P s) (eqn : f s = Sum.inr s')
-      (tail : Runs f P s' t y) : Runs f P s t y
-
-structure Inputs (X J : Type) where
-  publicWord : List X
-  arg : J → List Bool
-
-structure Readers (J : Type) where
-  px : ℕ := 0
-  parg : J → ℕ := fun _ => 0
-
-structure Reads (X J : Type) where
-  sx : Mark X
-  sarg : J → Mark Bool
-
-structure Advances (J : Type) where
-  dx : Dir := .N
-  darg : J → Dir := fun _ => .N
-
-namespace Readers
-variable {X J : Type}
-def home : Readers J := {}
-def see (r : Readers J) (i : Inputs X J) : Reads X J :=
-  ⟨Mark.see i.publicWord r.px, fun j => Mark.see (i.arg j) (r.parg j)⟩
-def walk (r : Readers J) (i : Inputs X J) (a : Advances J) : Readers J :=
-  ⟨Mark.walk i.publicWord r.px a.dx, fun j => Mark.walk (i.arg j) (r.parg j) (a.darg j)⟩
-end Readers
-
-structure Tape (A : Type) where
-  pos : ℤ
-  sym : ℤ → A
-
-structure WriteMove (A : Type) where
-  sym : A
-  dir : Dir
-
-namespace Tape
-variable {A : Type}
-def init (a : A) : Tape A := ⟨0, fun _ => a⟩
-def see (w : Tape A) : A := w.sym w.pos
-def perform (w : Tape A) (m : WriteMove A) : Tape A :=
-  ⟨w.pos + m.dir.delta, Function.update w.sym w.pos m.sym⟩
-end Tape
-
-structure TAction (Q J K : Type) (W : K → Type) where
-  next : Q
-  advance : Advances J
-  moves : ∀ k : K, WriteMove (W k)
-
-structure TM (X J Y : Type) where
-  Q : Type
-  [finiteQ : Finite Q]
-  K : Type
-  [tapes : Fintype K]
-  W : K → Type
-  [symbols : ∀ k, Fintype (W k)]
-  blank : ∀ k, W k
-  start : Q
-  table : Q → Reads X J → ((k : K) → W k) → Y ⊕ TAction Q J K W
-
-attribute [instance] TM.finiteQ TM.tapes TM.symbols
-
-namespace TM
-variable {X J Y : Type} (M : TM X J Y)
-
-structure Cfg where
-  state : M.Q
-  ro : Readers J
-  work : ∀ k, Tape (M.W k)
-
-def initial : M.Cfg :=
-  ⟨M.start, .home, fun k => .init (M.blank k)⟩
-
-def step (i : Inputs X J) (s : M.Cfg) : Y ⊕ M.Cfg :=
-  match M.table s.state (s.ro.see i) (fun k => (s.work k).see) with
-  | Sum.inl y => .inl y
-  | Sum.inr a =>
-    .inr ⟨a.next, s.ro.walk i a.advance, fun k => (s.work k).perform (a.moves k)⟩
-
-structure Window where
-  l : M.K → ℕ
-  h : M.K → ℕ
-
-def width (k : M.K) : ℕ := max 1 (Fintype.card (M.W k) - 1).size
-
-namespace Window
-variable {M}
-def ok (w : M.Window) (s : M.Cfg) : Prop :=
-  ∀ k, -(w.l k : ℤ) ≤ (s.work k).pos ∧ (s.work k).pos ≤ (w.h k : ℤ)
-open BigOperators
-def bits (w : M.Window) : ℕ :=
-  ∑ k, (w.l k + w.h k + 1) * M.width k
-end Window
-
-def Within (i : Inputs X J) (y : Y) (S : ℕ) : Prop :=
-  ∃ w : M.Window, w.bits ≤ S ∧ ∃ t, Runs (M.step i) w.ok M.initial t y
-end TM
-
-end Fifths
-
-namespace Fifths
-
-structure SingleAct (Q A : Type) (r : ℕ) where
-  out : Q
-  write : WriteMove A
-  others : Fin r → Dir
-
-structure Single (X : Type) where
-  Q : Type
-  [states : Fintype Q]
-  A : Type
-  [symbols : Fintype A]
-  beginState : Q
-  halted : Q → Bool
-  heads : ℕ
-  program : Q → A → (Fin heads → A) → SingleAct Q A heads
-  sensor : List X → Option (Fin heads) → ℤ → A
-
-attribute [instance] Single.states Single.symbols
-
-namespace Single
-variable {X : Type} (M : Single X)
-instance : Nonempty M.A := ⟨M.sensor [] none 0⟩
-instance : Nonempty M.Q := ⟨M.beginState⟩
-abbrev Tag := Option (Fin M.heads)
-
-structure At where
-  state : M.Q
-  tape : Tape M.A
-  ro : Fin M.heads → ℤ
-
-def move (q : M.Q) (s : M.A) (r : Fin M.heads → M.A) :
-    SingleAct M.Q M.A M.heads :=
-  if M.halted q then
-    ⟨q,⟨s,.N⟩,fun _ => .N⟩
-  else M.program q s r
-
-def initial (x : List X) : M.At :=
-  ⟨M.beginState,⟨0,M.sensor x none⟩, fun _ => 0⟩
-
-def next (x : List X) (s : M.At) : M.At :=
-  let t := M.move s.state s.tape.see (fun i => M.sensor x (some i) (s.ro i))
-  ⟨t.out,s.tape.perform t.write,fun i => s.ro i + (t.others i).delta⟩
-
-def atTime (M : Single X) (x : List X) : ℕ → M.At :=
-  Nat.rec (M.initial x) (fun _ s => M.next x s)
-
-abbrev Outcome := M.Q × Bool
-def finish (q : M.Q) : M.Outcome :=
-  (q, M.halted q)
-def outcome (x : List X) (n : ℕ) : M.Outcome :=
-  M.finish (M.atTime x n).state
-
-def Inside (t : ℕ) (q : ℤ) : Prop := -(t:ℤ) ≤ q ∧ q ≤ (t:ℤ)
-end Single
-
-end Fifths
-
-namespace Fifths
-
-namespace Entry
-noncomputable def code {A : Type} [Fintype A] (a : A) : ℕ :=
-  (Fintype.equivFin A a).val
-end Entry
-
-def binaryIn {X J : Type} (pub : List X) (f : J → ℕ) : Inputs X J :=
-  ⟨pub, fun j => (f j).bits⟩
-
-def files {X : Type} (x : List X) : Inputs X Empty :=
-  ⟨x, Empty.elim⟩
-
-namespace Single
-open Entry
-variable {X : Type} (M : Single X)
-
-inductive Arg
-  | cap | tag | minus | magnitude
-  deriving DecidableEq
-
-instance : Fintype Arg :=
-  ⟨{.cap, .tag, .minus, .magnitude}, by intro a; cases a <;> simp⟩
-abbrev Sym := TM X Arg M.A
-
-noncomputable def arg (T : ℕ) (h : M.Tag) (p : ℤ) : Arg → ℕ
-  | .cap => T
-  | .tag => code h
-  | .minus => (decide (p < 0)).toNat
-  | .magnitude => p.natAbs
-end Single
-
-namespace Cost
-noncomputable def Log (T : ℕ) := Real.log (T+2 : ℝ) / Real.log 2
-noncomputable def exponent := (2:ℝ)/5
-end Cost
-
-namespace Single
-open Cost
-variable {X : Type} (M : Single X)
-def Access (A : M.Sym) (p q : ℝ) (x : List X) (T : ℕ) : Prop :=
-  ∀ (h : M.Tag) (l : ℤ), Inside T l →
-    ∃ s : ℕ, (s:ℝ) ≤ p * (Log T)^q ∧
-      A.Within (binaryIn x (M.arg T h l)) (M.sensor x h l) s
-end Single
-
-end Fifths
-
-namespace Fifths.Single
-open Entry Cost
-variable {X : Type} (M : Single X)
-
-theorem capped [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
-    ∃ (N : TM X Unit M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
-      ∀ (x : List X) (T : ℕ), 2 ≤ T → M.Access A p q x T →
-        ∃ b : ℕ, N.Within (binaryIn x (fun _ => T)) (M.outcome x T) b ∧
-          (b:ℝ) ≤ c*(T:ℝ)^exponent*(Log T)^e := by
-  sorry
-
-theorem unknown [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
-    ∃ (N : TM X Empty M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
-      ∀ (x : List X), (∀ T, 2 ≤ T → M.Access A p q x T) →
-        ∀ (t : ℕ), (M.outcome x t).2 = true →
-          ∃ b, N.Within (files x) (M.outcome x t) b ∧
-            (b:ℝ) ≤ c*((t:ℝ)+2)^exponent*(Log t)^e := by
-  sorry
-
-end Fifths.Single
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Finite-machine statements of the capped and unknown-time one-writable-tape
+simulation theorem. Work space counts the bits in every visited writable cell;
+public endmarked input tapes are read-only. -/
+
+namespace Fifths
+
+inductive Dir
+  | L | N | R
+  deriving DecidableEq
+
+instance : Fintype Dir := ⟨{.L, .N, .R}, by intro d; cases d <;> simp⟩
+
+namespace Dir
+@[simp] def delta : Dir → ℤ
+  | L => -1
+  | N => 0
+  | R => 1
+end Dir
+
+inductive Mark (A : Type)
+  | left
+  | sym (a : A)
+  | right
+  deriving DecidableEq, Fintype
+
+namespace Mark
+variable {A : Type}
+def see (w : List A) : ℕ → Mark A
+  | 0 => left
+  | p+1 =>
+    match w[p]? with
+    | some a => sym a
+    | none => right
+
+def walk (w : List A) (p : ℕ) : Dir → ℕ
+  | .N => p
+  | .L => p - 1
+  | .R => if w.length < p then p else p + 1
+end Mark
+
+inductive Runs {σ Y : Type} (f : σ → Y ⊕ σ) (P : σ → Prop) :
+    σ → σ → Y → Prop
+  | stop {s y} (ok : P s) (eqn : f s = Sum.inl y) : Runs f P s s y
+  | step {s s' t y} (ok : P s) (eqn : f s = Sum.inr s')
+      (tail : Runs f P s' t y) : Runs f P s t y
+
+structure Inputs (X J : Type) where
+  publicWord : List X
+  arg : J → List Bool
+
+structure Readers (J : Type) where
+  px : ℕ := 0
+  parg : J → ℕ := fun _ => 0
+
+structure Reads (X J : Type) where
+  sx : Mark X
+  sarg : J → Mark Bool
+
+structure Advances (J : Type) where
+  dx : Dir := .N
+  darg : J → Dir := fun _ => .N
+
+namespace Readers
+variable {X J : Type}
+def home : Readers J := {}
+def see (r : Readers J) (i : Inputs X J) : Reads X J :=
+  ⟨Mark.see i.publicWord r.px, fun j => Mark.see (i.arg j) (r.parg j)⟩
+def walk (r : Readers J) (i : Inputs X J) (a : Advances J) : Readers J :=
+  ⟨Mark.walk i.publicWord r.px a.dx, fun j => Mark.walk (i.arg j) (r.parg j) (a.darg j)⟩
+end Readers
+
+structure Tape (A : Type) where
+  pos : ℤ
+  sym : ℤ → A
+
+structure WriteMove (A : Type) where
+  sym : A
+  dir : Dir
+
+namespace Tape
+variable {A : Type}
+def init (a : A) : Tape A := ⟨0, fun _ => a⟩
+def see (w : Tape A) : A := w.sym w.pos
+def perform (w : Tape A) (m : WriteMove A) : Tape A :=
+  ⟨w.pos + m.dir.delta, Function.update w.sym w.pos m.sym⟩
+end Tape
+
+structure TAction (Q J K : Type) (W : K → Type) where
+  next : Q
+  advance : Advances J
+  moves : ∀ k : K, WriteMove (W k)
+
+structure TM (X J Y : Type) where
+  Q : Type
+  [finiteQ : Finite Q]
+  K : Type
+  [tapes : Fintype K]
+  W : K → Type
+  [symbols : ∀ k, Fintype (W k)]
+  blank : ∀ k, W k
+  start : Q
+  table : Q → Reads X J → ((k : K) → W k) → Y ⊕ TAction Q J K W
+
+attribute [instance] TM.finiteQ TM.tapes TM.symbols
+
+namespace TM
+variable {X J Y : Type} (M : TM X J Y)
+
+structure Cfg where
+  state : M.Q
+  ro : Readers J
+  work : ∀ k, Tape (M.W k)
+
+def initial : M.Cfg :=
+  ⟨M.start, .home, fun k => .init (M.blank k)⟩
+
+def step (i : Inputs X J) (s : M.Cfg) : Y ⊕ M.Cfg :=
+  match M.table s.state (s.ro.see i) (fun k => (s.work k).see) with
+  | Sum.inl y => .inl y
+  | Sum.inr a =>
+    .inr ⟨a.next, s.ro.walk i a.advance, fun k => (s.work k).perform (a.moves k)⟩
+
+structure Window where
+  l : M.K → ℕ
+  h : M.K → ℕ
+
+def width (k : M.K) : ℕ := max 1 (Fintype.card (M.W k) - 1).size
+
+namespace Window
+variable {M}
+def ok (w : M.Window) (s : M.Cfg) : Prop :=
+  ∀ k, -(w.l k : ℤ) ≤ (s.work k).pos ∧ (s.work k).pos ≤ (w.h k : ℤ)
+open BigOperators
+def bits (w : M.Window) : ℕ :=
+  ∑ k, (w.l k + w.h k + 1) * M.width k
+end Window
+
+def Within (i : Inputs X J) (y : Y) (S : ℕ) : Prop :=
+  ∃ w : M.Window, w.bits ≤ S ∧ ∃ t, Runs (M.step i) w.ok M.initial t y
+end TM
+
+end Fifths
+
+namespace Fifths
+
+structure SingleAct (Q A : Type) (r : ℕ) where
+  out : Q
+  write : WriteMove A
+  others : Fin r → Dir
+
+structure Single (X : Type) where
+  Q : Type
+  [states : Fintype Q]
+  A : Type
+  [symbols : Fintype A]
+  beginState : Q
+  halted : Q → Bool
+  heads : ℕ
+  program : Q → A → (Fin heads → A) → SingleAct Q A heads
+  sensor : List X → Option (Fin heads) → ℤ → A
+
+attribute [instance] Single.states Single.symbols
+
+namespace Single
+variable {X : Type} (M : Single X)
+instance : Nonempty M.A := ⟨M.sensor [] none 0⟩
+instance : Nonempty M.Q := ⟨M.beginState⟩
+abbrev Tag := Option (Fin M.heads)
+
+structure At where
+  state : M.Q
+  tape : Tape M.A
+  ro : Fin M.heads → ℤ
+
+def move (q : M.Q) (s : M.A) (r : Fin M.heads → M.A) :
+    SingleAct M.Q M.A M.heads :=
+  if M.halted q then
+    ⟨q,⟨s,.N⟩,fun _ => .N⟩
+  else M.program q s r
+
+def initial (x : List X) : M.At :=
+  ⟨M.beginState,⟨0,M.sensor x none⟩, fun _ => 0⟩
+
+def next (x : List X) (s : M.At) : M.At :=
+  let t := M.move s.state s.tape.see (fun i => M.sensor x (some i) (s.ro i))
+  ⟨t.out,s.tape.perform t.write,fun i => s.ro i + (t.others i).delta⟩
+
+def atTime (M : Single X) (x : List X) : ℕ → M.At :=
+  Nat.rec (M.initial x) (fun _ s => M.next x s)
+
+abbrev Outcome := M.Q × Bool
+def finish (q : M.Q) : M.Outcome :=
+  (q, M.halted q)
+def outcome (x : List X) (n : ℕ) : M.Outcome :=
+  M.finish (M.atTime x n).state
+
+def Inside (t : ℕ) (q : ℤ) : Prop := -(t:ℤ) ≤ q ∧ q ≤ (t:ℤ)
+end Single
+
+end Fifths
+
+namespace Fifths
+
+namespace Entry
+noncomputable def code {A : Type} [Fintype A] (a : A) : ℕ :=
+  (Fintype.equivFin A a).val
+end Entry
+
+def binaryIn {X J : Type} (pub : List X) (f : J → ℕ) : Inputs X J :=
+  ⟨pub, fun j => (f j).bits⟩
+
+def files {X : Type} (x : List X) : Inputs X Empty :=
+  ⟨x, Empty.elim⟩
+
+namespace Single
+open Entry
+variable {X : Type} (M : Single X)
+
+inductive Arg
+  | cap | tag | minus | magnitude
+  deriving DecidableEq
+
+instance : Fintype Arg :=
+  ⟨{.cap, .tag, .minus, .magnitude}, by intro a; cases a <;> simp⟩
+abbrev Sym := TM X Arg M.A
+
+noncomputable def arg (T : ℕ) (h : M.Tag) (p : ℤ) : Arg → ℕ
+  | .cap => T
+  | .tag => code h
+  | .minus => (decide (p < 0)).toNat
+  | .magnitude => p.natAbs
+end Single
+
+namespace Cost
+noncomputable def Log (T : ℕ) := Real.log (T+2 : ℝ) / Real.log 2
+noncomputable def exponent := (2:ℝ)/5
+end Cost
+
+namespace Single
+open Cost
+variable {X : Type} (M : Single X)
+def Access (A : M.Sym) (p q : ℝ) (x : List X) (T : ℕ) : Prop :=
+  ∀ (h : M.Tag) (l : ℤ), Inside T l →
+    ∃ s : ℕ, (s:ℝ) ≤ p * (Log T)^q ∧
+      A.Within (binaryIn x (M.arg T h l)) (M.sensor x h l) s
+end Single
+
+end Fifths
+
+namespace Fifths.Single
+open Entry Cost
+variable {X : Type} (M : Single X)
+
+theorem capped [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
+    ∃ (N : TM X Unit M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
+      ∀ (x : List X) (T : ℕ), 2 ≤ T → M.Access A p q x T →
+        ∃ b : ℕ, N.Within (binaryIn x (fun _ => T)) (M.outcome x T) b ∧
+          (b:ℝ) ≤ c*(T:ℝ)^exponent*(Log T)^e := by
+  sorry
+
+theorem unknown [Fintype X] (A : M.Sym) (p q : ℝ) (hp : 1 ≤ p) (_hq : 1 ≤ q) :
+    ∃ (N : TM X Empty M.Outcome) (e : ℕ) (c : ℝ), 0 < c ∧
+      ∀ (x : List X), (∀ T, 2 ≤ T → M.Access A p q x T) →
+        ∀ (t : ℕ), (M.outcome x t).2 = true →
+          ∃ b, N.Within (files x) (M.outcome x t) b ∧
+            (b:ℝ) ≤ c*((t:ℝ)+2)^exponent*(Log t)^e := by
+  sorry
+
+end Fifths.Single
+
+end OAI