Add lean source and binary files (part 4)

lean/ComparatorChallenges/TraceReconstruction.json

@@ -0,0 +1,16 @@
+{
+  "challenge_module": "ComparatorChallenges.TraceReconstruction",
+  "solution_module": "OAI.Probability.TraceReconstruction",
+  "theorem_names": [
+    "OAI.TraceReconstruction.quantitative_sample_lower_bound",
+    "OAI.TraceReconstruction.superpolynomial_one_trace",
+    "OAI.TraceReconstruction.superpolynomial_sample_complexity"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TraceReconstruction.lean

@@ -0,0 +1,91 @@
+import Mathlib
+
+namespace OAI
+
+open scoped ENNReal
+noncomputable section
+
+namespace TraceReconstruction
+
+abbrev Word (n : ℕ) := Fin n → Bool
+abbrev Mask (n : ℕ) := Fin n → Bool
+abbrev Trace := List Bool
+
+/-- `true` retains the bit. The observer gets only the resulting list. -/
+def traceOfMask {n : ℕ} (x : Word n) (a : Mask n) : Trace :=
+  ((List.finRange n).filter fun i => a i).map x
+
+/-- The deletion-mask probability, with deletion probability `q`. -/
+def maskWeight {n : ℕ} (q : ℝ) (a : Mask n) : ℝ :=
+  ∏ i, if a i then 1 - q else q
+
+/-- Law of a single complete trace. -/
+def traceMass {n : ℕ} (q : ℝ) (x : Word n) (w : Trace) : ℝ :=
+  ∑ a : Mask n, if traceOfMask x a = w then maskWeight q a else 0
+
+/-- All possible complete outputs from length-n inputs, with lengths included. -/
+def traceSpace (n : ℕ) : Finset Trace :=
+  Finset.univ.biUnion fun k : Fin (n + 1) =>
+    Finset.univ.image fun x : Word k.val => List.ofFn x
+
+/-- 1/2 sum of absolute differences, on the full finite output space. -/
+def traceTV {n : ℕ} (q : ℝ) (x y : Word n) : ℝ :=
+  (1 / 2 : ℝ) * ∑ w ∈ traceSpace n, |traceMass q x w - traceMass q y w|
+
+/-- The estimator may depend arbitrarily on n, q and every complete sample.
+    Its value is its conditional probability of reporting the given input. -/
+def IsEstimator {n m : ℕ} (A : (Fin m → Trace) → Word n → ℝ) : Prop :=
+  (∀ z x, 0 ≤ A z x) ∧ (∀ z, ∑ x : Word n, A z x = 1)
+
+/-- Independent masks generate independent complete traces; no retained
+    positions, boundaries or other latent variables are revealed to A. -/
+def reconstructionSuccess {n m : ℕ} (q : ℝ)
+    (A : (Fin m → Trace) → Word n → ℝ) (x : Word n) : ℝ :=
+  ∑ a : Fin m → Mask n,
+    (∏ j, maskWeight q (a j)) * A (fun j => traceOfMask x (a j)) x
+
+def SufficientBudget (n : ℕ) (q s : ℝ) (m : ℕ) : Prop :=
+  ∃ A : (Fin m → Trace) → Word n → ℝ,
+    IsEstimator A ∧ ∀ x, s ≤ reconstructionSuccess q A x
+
+/-- Natural fixed sample budget; infimum of the empty set is infinity. -/
+noncomputable def sampleComplexity (n : ℕ) (q s : ℝ) : ℝ≥0∞ :=
+  sInf {t | ∃ m : ℕ, SufficientBudget n q s m ∧ t = (m : ℝ≥0∞)}
+
+/-- The real infimum is a minimum for n>0 (a nonempty finite set). -/
+noncomputable def minTraceTV (n : ℕ) (q : ℝ) : ℝ :=
+  sInf {t | ∃ x y : Word n, x ≠ y ∧ t = traceTV q x y}
+
+open Filter
+open scoped Topology Classical ENNReal
+
+theorem quantitative_sample_lower_bound
+    (s c : ℝ) (hs : s ∈ Set.Ioc 0 1)
+    (hc : c ∈ Set.Ioo 0 (1 / (4 * Real.log 2)))
+    (n : ℕ → ℕ) (q : ℕ → ℝ)
+    (hn : Tendsto n atTop atTop)
+    (hq : ∀ k, q k ∈ Set.Ioo 0 1)
+    (hscale : Tendsto (fun k => (q k) ^ 3 * Real.log (n k)) atTop atTop) :
+    ∀ᶠ k in atTop,
+      ENNReal.ofReal ((n k : ℝ) ^ (c * Real.log ((q k) ^ 3 * Real.log (n k)))) ≤
+        sampleComplexity (n k) (q k) s := by
+  sorry
+
+theorem superpolynomial_one_trace
+    (q : ℝ) (hq : q ∈ Set.Ioo 0 1) (C : ℝ) (hC : 0 < C) :
+    Tendsto (fun n : ℕ => (n : ℝ) ^ C * minTraceTV n q) atTop (𝓝 0) := by
+  sorry
+
+theorem superpolynomial_sample_complexity
+    (q : ℝ) (hq : q ∈ Set.Ioo 0 1) (s : ℝ) (hs : s ∈ Set.Ioc 0 1)
+    (C : ℝ) (hC : 0 < C) :
+    Tendsto
+      (fun n : ℕ => sampleComplexity n q s / ENNReal.ofReal ((n : ℝ) ^ C))
+      atTop (𝓝 ⊤) := by
+  sorry
+
+end TraceReconstruction
+
+end
+
+end OAI

lean/ComparatorChallenges/TreeEdit.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TreeEdit",
+  "solution_module": "OAI.Combinatorics.TreeEdit.TorusLowerBound",
+  "theorem_names": [
+    "OAI.TreeEdit.binary_torus"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TreeEdit.lean

@@ -0,0 +1,51 @@
+import Mathlib
+
+namespace OAI
+
+namespace TreeEdit
+
+universe u
+
+/-- A single unit-cost insertion, deletion or substitution, at any position. -/
+inductive EditStep {α : Type u} : List α → List α → Prop
+  | insert (p q : List α) (a : α) : EditStep (p ++ q) (p ++ a :: q)
+  | delete (p q : List α) (a : α) : EditStep (p ++ a :: q) (p ++ q)
+  | substitute (p q : List α) (a b : α) : EditStep (p ++ a :: q) (p ++ b :: q)
+
+/-- A script of precisely `n` edits. There is no restriction on its intermediate lengths. -/
+inductive EditScript {α : Type u} : List α → List α → ℕ → Prop
+  | nil (x : List α) : EditScript x x 0
+  | cons {x y z : List α} {n : ℕ} :
+      EditStep x y → EditScript y z n → EditScript x z (n + 1)
+
+/-- Ordinary unit-cost edit distance. The set is nonempty (delete then insert). -/
+noncomputable def ed {α : Type u} (x y : List α) : ℕ :=
+  sInf {n | EditScript x y n}
+
+/-- The full infinite-dimensional real ℓ₁ space. -/
+abbrev RealL1 := lp (fun _ : ℕ => ℝ) 1
+
+/-- Product of the two maximal pairwise distance ratios. -/
+noncomputable def distortion (W : Finset (List Bool)) (f : W → RealL1) : ℝ :=
+  sSup {r : ℝ | ∃ x y : W, x ≠ y ∧
+      r = dist (f x) (f y) / (ed x.val y.val : ℝ)} *
+  sSup {r : ℝ | ∃ x y : W, x ≠ y ∧
+      r = (ed x.val y.val : ℝ) / dist (f x) (f y)}
+
+/-- Infimum over all injective ℓ₁ maps, used on finite sets with at least two points. -/
+noncomputable def c1 (W : Finset (List Bool)) : ℝ :=
+  sInf {D : ℝ | ∃ f : W → RealL1, Function.Injective f ∧ distortion W f = D}
+
+/-- The binary main endpoint, for every sufficiently large cap (natural logarithms). -/
+def BinaryLowerBound : Prop :=
+  ∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →
+    ∃ n : ℕ, n ≤ d ∧ ∃ W : Finset (List Bool),
+      2 ≤ W.card ∧ (∀ w ∈ W, w.length = n) ∧
+      Real.exp (c * Real.sqrt (Real.log (d : ℝ) * Real.log (Real.log (d : ℝ)))) ≤ c1 W
+
+theorem binary_torus : BinaryLowerBound := by
+  sorry
+
+end TreeEdit
+
+end OAI

lean/ComparatorChallenges/TriangleFace.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangleFace",
+  "solution_module": "OAI.Combinatorics.TriangleFace.Main",
+  "theorem_names": [
+    "OAI.TriangleFace198.triangle_expansion_face"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TriangleFace.lean

@@ -0,0 +1,190 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uIndex uι
+
+namespace MatchingEntropyBounds
+
+structure LooplessGraph (V : Type uV) (E : Type uE) where
+  left : E → V
+  right : E → V
+  loopless : ∀ e, left e ≠ right e
+
+variable {V : Type uV} {E : Type uE}
+  [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+namespace LooplessGraph
+
+def Incident (G : LooplessGraph V E) (v : V) (e : E) : Prop :=
+  G.left e = v ∨ G.right e = v
+
+instance incidentDecidable (G : LooplessGraph V E) (v : V) (e : E) :
+    Decidable (G.Incident v e) := inferInstanceAs (Decidable (G.left e = v ∨ G.right e = v))
+
+def IsPerfectMatching (G : LooplessGraph V E) (M : Finset E) : Prop :=
+  ∀ v, ∃! e, e ∈ M ∧ G.Incident v e
+
+abbrev Matching (G : LooplessGraph V E) := {M : Finset E // G.IsPerfectMatching M}
+
+instance matchingFintype (G : LooplessGraph V E) : Fintype G.Matching :=
+  Fintype.ofFinite _
+
+def indicator (G : LooplessGraph V E) (M : G.Matching) (e : E) : ℝ :=
+  if e ∈ M.val then 1 else 0
+
+def polytope (G : LooplessGraph V E) : Set (E → ℝ) :=
+  convexHull ℝ (Set.range G.indicator)
+
+end LooplessGraph
+end MatchingEntropyBounds
+end
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uI uJ uA uB uC uW uF uD uι
+
+namespace MatchingEntropyBounds.LooplessGraph
+
+variable {V : Type uV} {E : Type uE} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def Crosses (G : LooplessGraph V E) (S : Finset V) (e : E) : Prop :=
+  (G.left e ∈ S ∧ G.right e ∉ S) ∨ (G.left e ∉ S ∧ G.right e ∈ S)
+
+instance crossesDecidable (G : LooplessGraph V E) (S : Finset V) (e : E) :
+    Decidable (G.Crosses S e) := inferInstanceAs (Decidable
+      ((G.left e ∈ S ∧ G.right e ∉ S) ∨ (G.left e ∉ S ∧ G.right e ∈ S)))
+
+def cut (G : LooplessGraph V E) (S : Finset V) : Finset E :=
+  Finset.univ.filter (G.Crosses S)
+
+def degree (G : LooplessGraph V E) (x : E → ℝ) (v : V) : ℝ :=
+  ∑ e, if G.Incident v e then x e else 0
+
+def cutMass (G : LooplessGraph V E) (x : E → ℝ) (S : Finset V) : ℝ :=
+  ∑ e ∈ G.cut S, x e
+
+end MatchingEntropyBounds.LooplessGraph
+end
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uI uJ uA uB uC uW uF uD uι
+
+namespace MatchingEntropyBounds.Refined
+
+section TriangleExpansion
+variable {V : Type uV} {E : Type uE} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def triangleTip (v : V) (i : Fin 3) : V ⊕ Fin 2 := ![Sum.inl v, Sum.inr 0, Sum.inr 1] i
+
+def triangleCollapse (v : V) : V ⊕ Fin 2 → V := Sum.elim id (fun _ => v)
+
+def reattach (v : V) (i : Fin 3) (w : V) : V ⊕ Fin 2 :=
+  if w = v then triangleTip v i else Sum.inl w
+
+omit [Fintype V] [Fintype E] [DecidableEq E] in
+theorem collapse_reattach (v : V) (i : Fin 3) (w : V) :
+    triangleCollapse v (reattach v i w) = w := by
+  by_cases h : w = v
+  · subst w
+    fin_cases i <;> simp [reattach,triangleTip,triangleCollapse]
+  · simp [reattach,h,triangleCollapse]
+
+def triangleExpansion (G : LooplessGraph V E) (c : E → Fin 3) (v : V) :
+    LooplessGraph (V ⊕ Fin 2) (E ⊕ Fin 3) where
+  left := Sum.elim (fun e => reattach v (c e) (G.left e)) (fun i => triangleTip v (i + 1))
+  right := Sum.elim (fun e => reattach v (c e) (G.right e)) (fun i => triangleTip v (i + 2))
+  loopless := by
+    intro e h
+    rcases e with e | i
+    · have hh := congrArg (triangleCollapse v) h
+      exact G.loopless e ((collapse_reattach v (c e) (G.left e)).symm.trans
+        (hh.trans (collapse_reattach v (c e) (G.right e))))
+    · fin_cases i <;> simp [triangleTip] at h
+
+def triangleVertices (v : V) : Finset (V ⊕ Fin 2) := Finset.univ.image (triangleTip v)
+
+end TriangleExpansion
+end MatchingEntropyBounds.Refined
+end
+
+namespace CanonicalFace198
+
+variable {A B : Type*} [AddCommGroup A] [Module ℝ A]
+  [AddCommGroup B] [Module ℝ B]
+
+def facesThrough (P : Set A) (x : A) : Set (Set A) :=
+  {F | Convex ℝ F ∧ IsExtreme ℝ P F ∧ x ∈ F}
+
+def minFace (P : Set A) (x : A) : Set A := ⋂₀ facesThrough P x
+
+end CanonicalFace198
+
+noncomputable section
+open scoped BigOperators
+open MatchingEntropyBounds MatchingEntropyBounds.Refined
+namespace TriangleFace198
+variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def LocalLabels (G : LooplessGraph V E) (v : V) (c : E → Fin 3) : Prop :=
+  ∀ i, ∃! e, G.Incident v e ∧ c e = i
+
+def localEdge (G : LooplessGraph V E) (c : E → Fin 3) (v : V)
+    (hc : LocalLabels G v c) (i : Fin 3) : E := Classical.choose (hc i)
+
+def localExtension (G : LooplessGraph V E) (c : E → Fin 3) (v : V)
+    (hc : LocalLabels G v c) : (E → ℝ) →ₗ[ℝ] (E ⊕ Fin 3 → ℝ) where
+  toFun x := Sum.elim x (fun i => x (localEdge G c v hc i))
+  map_add' x y := by ext e; cases e <;> rfl
+  map_smul' a x := by ext e; cases e <;> rfl
+
+def oldRestriction : (E ⊕ Fin 3 → ℝ) →ₗ[ℝ] (E → ℝ) where
+  toFun y e := y (Sum.inl e)
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+end TriangleFace198
+
+end
+
+noncomputable section
+open scoped BigOperators
+open MatchingEntropyBounds MatchingEntropyBounds.Refined
+namespace TriangleFace198
+universe uV uE
+variable {V : Type uV} {E : Type uE} [instFintypeV : Fintype V] [Fintype E] [DecidableEq V] [instDecidableEqE : DecidableEq E]
+
+theorem triangle_expansion_face {V : Type uV} {E : Type uE}
+    [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] (G : LooplessGraph V E) (v : V)
+    (hdeg : Fintype.card {e : E // G.Incident v e} = 3)
+    (_hmatching : Nonempty G.Matching) :
+    ∃ (c : E → Fin 3) (hc : LocalLabels G v c),
+      let H := triangleExpansion G c v
+      let f := localExtension G c v hc
+      let Q := {y | y ∈ H.polytope ∧ H.cutMass y (triangleVertices v) = 1}
+      f '' G.polytope = Q ∧
+      Convex ℝ Q ∧ IsExtreme ℝ H.polytope Q ∧
+      (∀ x, oldRestriction (f x) = x) ∧
+      (∀ y ∈ Q, f (oldRestriction y) = y) ∧
+      (∀ x e, f x (Sum.inl e) = x e) ∧
+      (∀ x i, f x (Sum.inr i) = x (localEdge G c v hc i)) ∧
+      (∀ x, (∀ e, x e = (1/3 : ℝ)) → ∀ e, f x e = (1/3 : ℝ)) ∧
+      (∀ x ∈ G.polytope, CanonicalFace198.minFace H.polytope (f x) = f '' CanonicalFace198.minFace G.polytope x)  := by
+  sorry
+
+end TriangleFace198
+end
+
+end OAI

lean/ComparatorChallenges/TriangleRemoval.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangleRemoval",
+  "solution_module": "OAI.Combinatorics.TriangleRemoval.Main",
+  "theorem_names": [
+    "OAI.SharpTerminalLeave.sharp_terminal_leave"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TriangleRemoval.lean

@@ -0,0 +1,67 @@
+import Mathlib
+
+namespace OAI
+
+section
+section
+
+open Filter
+open scoped BigOperators Topology
+
+namespace SharpTerminalLeave
+
+abbrev Graph (n : ℕ) := Finset (Finset (Fin n))
+
+def completeGraph (n : ℕ) : Graph n := Finset.univ.powersetCard 2
+
+def triangles {n : ℕ} (G : Graph n) : Finset (Finset (Fin n)) :=
+  (Finset.univ.powersetCard 3).filter (fun t => t.powersetCard 2 ⊆ G)
+
+noncomputable def step {n : ℕ} (G : Graph n) : PMF (Graph n) :=
+  if h : (triangles G).Nonempty then
+    (PMF.uniformOfFinset (triangles G) h).map (fun t => G \ t.powersetCard 2)
+  else PMF.pure G
+
+noncomputable def evolve {n : ℕ} (G : Graph n) : ℕ → PMF (Graph n)
+  | 0 => PMF.pure G
+  | k + 1 => (evolve G k).bind step
+
+noncomputable def terminalLaw (n : ℕ) : PMF (Graph n) :=
+  evolve (completeGraph n) (n.choose 2)
+
+noncomputable def expectation (n : ℕ) (f : Graph n → ℝ) : ℝ :=
+  ∑ G, (terminalLaw n G).toReal * f G
+
+noncomputable def probability (n : ℕ) (P : Graph n → Prop) : ℝ := by
+  classical
+  exact expectation n (fun G => if P G then 1 else 0)
+
+noncomputable def normalization (n : ℕ) : ℝ := (n : ℝ) ^ (3 / 2 : ℝ)
+
+noncomputable def normalizedLeave (n : ℕ) (G : Graph n) : ℝ :=
+  (G.card : ℝ) / normalization n
+
+noncomputable def sharpConstant : ℝ := 1 / (2 * Real.sqrt 2)
+
+end SharpTerminalLeave
+end
+end
+
+open Filter
+open scoped BigOperators Topology
+
+namespace SharpTerminalLeave
+
+theorem sharp_terminal_leave :
+    Tendsto (fun n => expectation n (fun G =>
+      (normalizedLeave n G - sharpConstant) ^ 2)) atTop (𝓝 0) ∧
+    (∀ ε : ℝ, 0 < ε →
+      Tendsto (fun n => probability n (fun G =>
+        ε < |normalizedLeave n G - sharpConstant|)) atTop (𝓝 0)) ∧
+    Tendsto (fun n => expectation n (fun G => (G.card : ℝ)) / normalization n)
+      atTop (𝓝 sharpConstant) := by
+  sorry
+
+end SharpTerminalLeave
+
+end OAI

lean/ComparatorChallenges/TriangularCovering.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularCovering",
+  "solution_module": "OAI.Geometry.TriangularCovering.Main",
+  "theorem_names": [
+    "OAI.TriangularCovering.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TriangularCovering.lean

@@ -0,0 +1,72 @@
+import Mathlib
+
+namespace OAI
+
+open Set MeasureTheory
+open scoped InnerProductSpace BigOperators Interval
+
+noncomputable section
+namespace TriangularCovering
+
+abbrev Space := EuclideanSpace ℝ (Fin 3)
+
+def H : ℝ := Real.sqrt 2
+
+def point (x y t : ℝ) : Space := !₂[x, y, H * t]
+
+def K : Set Space :=
+  {z | ∃ x y t : ℝ, 0 ≤ t ∧ t ≤ 1 ∧ |x| ≤ 1 - t ∧ |y| ≤ t ∧ z = point x y t}
+
+def projection (u z : Space) : Space := z - (inner ℝ u z) • u
+
+def area (B : Set Space) : ℝ := (Measure.euclideanHausdorffMeasure 2 B).toReal
+
+def shadowArea (u : Space) : ℝ := area (projection u '' K)
+
+def A_min : ℝ := sInf {a : ℝ | ∃ u : Space, ‖u‖ = 1 ∧ a = shadowArea u}
+
+structure TriCylinder where
+  axis : Space
+  base : Set Space
+  unit_axis : ‖axis‖ = 1
+  perpendicular : ∀ z ∈ base, inner ℝ axis z = 0
+  triangular : ∃ v : Fin 3 → Space, AffineIndependent ℝ v ∧
+    base = convexHull ℝ (Set.range v)
+  compact : IsCompact base
+  convex : Convex ℝ base
+  measurable : MeasurableSet base
+  finite_area : Measure.euclideanHausdorffMeasure 2 base ≠ ⊤
+
+def TriCylinder.carrier (c : TriCylinder) : Set Space :=
+  {z | ∃ b ∈ c.base, ∃ r : ℝ, z = b + r • c.axis}
+
+def Covers {m : ℕ} (c : Fin m → TriCylinder) : Prop :=
+  ∀ z ∈ K, ∃ i : Fin m, z ∈ (c i).carrier
+
+def totalArea {m : ℕ} (c : Fin m → TriCylinder) : ℝ :=
+  ∑ i : Fin m, area (c i).base
+
+def relativeCost {m : ℕ} (c : Fin m → TriCylinder) : ℝ :=
+  ∑ i : Fin m, area (c i).base / shadowArea (c i).axis
+
+def n (ε : ℝ) : ℕ := ⌈2 / ε ^ 2⌉₊
+
+def MainAsymptotic : Prop :=
+  ∃ δ C : ℝ, 0 < δ ∧ 0 < C ∧
+    ∀ ε : ℝ, 0 < ε → ε < δ →
+      ∃ c : Fin (2 * n ε) → TriCylinder,
+        Covers c ∧
+        |totalArea c / H - (1 / 2 - (13 / 6000 : ℝ) * ε ^ 2)| ≤ C * ε ^ 4 ∧
+        totalArea c < A_min / 2
+
+def NormalizedCounterexample : Prop :=
+  ∃ m : ℕ, ∃ c : Fin m → TriCylinder, Covers c ∧ relativeCost c < 1 / 2
+
+theorem main : A_min = H ∧ MainAsymptotic ∧ NormalizedCounterexample := by
+  sorry
+
+end TriangularCovering
+
+end
+
+end OAI

lean/ComparatorChallenges/TriangularEnergy.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularEnergy",
+  "solution_module": "OAI.Analysis.Triangular.Energy.Universal",
+  "theorem_names": [
+    "OAI.AtomicTriangular.universal_energy_minimum"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TriangularEnergy.lean

@@ -0,0 +1,74 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Topology ENNReal
+open Classical Filter
+
+namespace TriangularUniversal
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def LocallyFinite (C : Set Plane) : Prop :=
+  ∀ R : ℝ, (C ∩ Metric.closedBall (0 : Plane) R).Finite
+
+def diskPoints (C : Set Plane) (R : ℝ) : Finset Plane :=
+  if h : (C ∩ Metric.closedBall (0 : Plane) R).Finite then h.toFinset else ∅
+
+def diskCount (C : Set Plane) (R : ℝ) : ℕ := (diskPoints C R).card
+
+def DensityOne (C : Set Plane) : Prop :=
+  Tendsto (fun R : ℝ => (diskCount C R : ℝ) / (Real.pi * R ^ 2))
+    atTop (𝓝 1)
+
+def AdmissiblePotential (g : ℝ → ℝ) : Prop :=
+  ContDiffOn ℝ (⊤ : ℕ∞) g (Set.Ioi 0) ∧
+  (∀ t : ℝ, 0 < t → 0 ≤ g t) ∧
+  ∀ (r : ℕ) (t : ℝ), 0 < t → 0 ≤ (-1 : ℝ) ^ r * iteratedDeriv r g t
+
+def diskEnergy (g : ℝ → ℝ) (C : Set Plane) (R : ℝ) : ℝ≥0∞ :=
+  (diskCount C R : ℝ≥0∞)⁻¹ *
+    ∑ x ∈ diskPoints C R, ∑ y ∈ (diskPoints C R).erase x,
+      ENNReal.ofReal (g (‖x - y‖ ^ 2))
+
+def energy (g : ℝ → ℝ) (C : Set Plane) : ℝ≥0∞ :=
+  Filter.liminf (diskEnergy g C) atTop
+
+end TriangularUniversal
+
+namespace AtomicTriangular
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def triangularPoint (jk : ℤ × ℤ) : Plane :=
+  (Real.sqrt b)⁻¹ •
+    (EuclideanSpace.single 0 ((jk.1 : ℝ) + (jk.2 : ℝ) / 2) +
+      EuclideanSpace.single 1 ((jk.2 : ℝ) * b))
+
+def A : Set Plane := Set.range triangularPoint
+
+abbrev LocallyFinite := TriangularUniversal.LocallyFinite
+abbrev diskPoints := TriangularUniversal.diskPoints
+abbrev diskCount := TriangularUniversal.diskCount
+abbrev DensityOne := TriangularUniversal.DensityOne
+abbrev AdmissiblePotential := TriangularUniversal.AdmissiblePotential
+abbrev diskEnergy := TriangularUniversal.diskEnergy
+abbrev energy := TriangularUniversal.energy
+
+/-- The full nonzero-lattice energy, allowing a divergent series. -/
+def latticeEnergy (g : ℝ → ℝ) : ℝ≥0∞ :=
+  ∑' a : {x : Plane // x ∈ A ∧ x ≠ 0}, ENNReal.ofReal (g (‖a.val‖ ^ 2))
+
+/-- Universal energy minimality for smooth completely monotone potentials, with attainment. -/
+theorem universal_energy_minimum (g : ℝ → ℝ) (C : Set Plane)
+    (hg : AdmissiblePotential g) (hC : LocallyFinite C) (hd : DensityOne C) :
+    latticeEnergy g ≤ energy g C ∧ latticeEnergy g = energy g A := by
+  sorry
+
+end AtomicTriangular
+end
+
+end OAI

lean/ComparatorChallenges/TriangularGaussian.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularGaussian",
+  "solution_module": "OAI.Analysis.Triangular.GaussianMinorants",
+  "theorem_names": [
+    "OAI.AtomicTriangular.sharp_gaussian_minorants_with_construction"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TriangularGaussian.lean

@@ -0,0 +1,275 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+# Sharp Gaussian minorants with atomic interpolation
+
+The sharp Gaussian minorants of the atomic certificate for triangular-lattice
+universal optimality, including the construction for parameters at least one.
+-/
+
+noncomputable section
+open scoped BigOperators FourierTransform SchwartzMap
+open Complex Polynomial
+
+namespace AtomicTriangular
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def triangularPoint (jk : ℤ × ℤ) : Plane :=
+  (Real.sqrt b)⁻¹ •
+    (EuclideanSpace.single 0 ((jk.1 : ℝ) + (jk.2 : ℝ) / 2) +
+      EuclideanSpace.single 1 ((jk.2 : ℝ) * b))
+
+def A : Set Plane := Set.range triangularPoint
+
+def dualA : Set Plane := {w | ∀ a ∈ A, ∃ n : ℤ, inner ℝ a w = (n : ℝ)}
+
+def gaussian (α : ℝ) (x : Plane) : ℝ := Real.exp (-Real.pi * α * ‖x‖ ^ 2)
+
+def Radial (f : Plane → ℝ) : Prop := ∀ x y, ‖x‖ = ‖y‖ → f x = f y
+
+def realFourier (f : Plane → ℝ) (w : Plane) : ℂ := 𝓕 (fun x => (f x : ℂ)) w
+
+end AtomicTriangular
+
+namespace AtomicTriangular.Construction
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def h : ℝ := 17 / 50
+
+def H : ℝ := 27 / 50
+
+def eta : ℝ := 1 / 5
+
+def kappa : ℝ := Real.pi / 36
+
+def residues : Finset ℤ := {0,1,3,4,7,9,12,13,16,19,21,25,27,28,31}
+
+def residue (a : Fin 15) : ℤ := ![0,1,3,4,7,9,12,13,16,19,21,25,27,28,31] a
+
+def Node : Type := {n : ℤ // 0 < n ∧ n % 36 ∈ residues}
+
+def FiniteNodes : Finset ℤ := {1,3,4,7,9,12,13,16,19,21}
+
+def sineFactor (a : Fin 15) (s : ℂ) : ℂ :=
+  2 * Complex.sin ((kappa : ℂ) * (s - (residue a : ℂ)))
+
+def P (s : ℂ) : ℂ := ∏ a : Fin 15, (sineFactor a s)^2
+
+def dBasis (n : Node) : ℂ → ℂ := dslope P (n.val : ℂ)
+
+def cBasis (n : Node) : ℂ → ℂ := dslope (dBasis n) (n.val : ℂ)
+
+def finiteC (a : Fin 15) (s : ℂ) : ℂ :=
+  4 * (kappa : ℂ)^2 * ∏ r ∈ Finset.univ.erase a, (sineFactor r s)^2
+
+def finiteD (a : Fin 15) (s : ℂ) : ℂ :=
+  2 * (kappa : ℂ) * sineFactor a s *
+    Complex.cos ((kappa : ℂ) * (s - (residue a : ℂ))) *
+      ∏ r ∈ Finset.univ.erase a, (sineFactor r s)^2
+
+def phase (s : ℂ) : ℂ := Complex.exp ((Real.pi : ℂ) * Complex.I * s / 18)
+
+def atomFactor (a : Fin 15) : Polynomial ℂ :=
+  -C (phase (residue a)) + C 2 * X - C (phase (-residue a)) * X^2
+
+def atomPolynomial : Polynomial ℂ := ∏ a : Fin 15, atomFactor a
+
+def cAtomPolynomial (a : Fin 15) : Polynomial ℂ :=
+  C (4 * (kappa : ℂ)^2) * ∏ r ∈ Finset.univ.erase a, atomFactor r
+
+def dAtomPolynomial (a : Fin 15) : Polynomial ℂ :=
+  C (Complex.I * (kappa : ℂ)) *
+    (C (phase (residue a)) - C (phase (-residue a)) * X^2) *
+      ∏ r ∈ Finset.univ.erase a, atomFactor r
+
+def fourierCoeff (j : Fin 31) : ℂ := atomPolynomial.coeff j.val
+
+def frequency (j : Fin 31) : ℝ := ((j.val : ℝ)-15)/18
+
+def waveDerivative (k : ℕ) (s : ℂ) : ℂ :=
+  ∑ j : Fin 31, fourierCoeff j * (I*Real.pi*frequency j)^k *
+    exp (I*Real.pi*frequency j*s)
+
+def Q (n : ℤ) : ℝ := (waveDerivative 2 n).re / 2
+
+def D (n : ℤ) : ℝ := (waveDerivative 3 n).re / (6 * Q n)
+
+end AtomicTriangular.Construction
+
+namespace AtomicTriangular.FiniteCertificate
+open Construction
+
+def cShiftPolynomial (a : Fin 15) : Polynomial ℂ := X * cAtomPolynomial a
+
+def cCoefficient (a : Fin 15) (j : Fin 31) : ℂ := (cShiftPolynomial a).coeff j.val
+
+def dCoefficient (a : Fin 15) (j : Fin 31) : ℂ := (dAtomPolynomial a).coeff j.val
+
+end AtomicTriangular.FiniteCertificate
+
+namespace AtomicTriangular.Construction
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def radial (x : Plane) : ℝ := b*‖x‖^2
+
+def waveDen (k t : ℝ) : ℝ := k^2+t^2
+
+def Xwave (k t : ℝ) : ℝ := (4/3)/waveDen k t
+
+def lambda (k t : ℝ) : ℂ := ((k:ℂ)+I*t)/(b*waveDen k t : ℝ)
+
+def zeta (k v t : ℝ) : ℂ := -(t:ℂ)*(Xwave k t:ℂ)+I*(k*Xwave k t-v:ℝ)
+
+def transformedWave (k v t : ℝ) (s : ℂ) : ℂ := lambda k t*exp (I*Real.pi*zeta k v t*s)
+
+def finiteColumn (col : Fin 23) (j : Fin 31) : ℂ :=
+  if hc : col.val<22 then
+    if col.val%2=0 then FiniteCertificate.cCoefficient ⟨col.val/2,by omega⟩ j
+      else FiniteCertificate.dCoefficient ⟨col.val/2,by omega⟩ j
+  else fourierCoeff j
+
+def finiteNode (n : Fin 10) : ℤ := residue ⟨n.val+1,by omega⟩
+
+def jetMultiplier (k v : ℝ) (n : ℤ) (d : Fin 2) (t : ℝ) : ℂ :=
+  (Q n:ℂ)⁻¹*transformedWave k v t n *
+    (if d.val=0 then -1 else (D n:ℂ)-I*Real.pi*zeta k v t)
+
+def jet (k v : ℝ) (n : ℤ) (d : Fin 2) (S : Fin 31 → ℂ) : ℝ :=
+  (∑ j : Fin 31, jetMultiplier k v n d (frequency j)*S j).re
+
+def fullJetMatrix : Matrix (Fin 20) (Fin 23) ℝ := fun i col =>
+  jet (if col.val=22 then h else H) H
+    (finiteNode ⟨i.val/2,by omega⟩) ⟨i.val%2,by omega⟩ (finiteColumn col)
+
+def R : Matrix (Fin 20) (Fin 20) ℝ := fun i j => fullJetMatrix i ⟨j.val+2,by omega⟩
+
+def R0 : Matrix (Fin 20) (Fin 3) ℝ := fun i j =>
+  fullJetMatrix i (if j.val<2 then ⟨j.val,by omega⟩ else 22)
+
+abbrev TailNode := {n : Node // n.val ∉ FiniteNodes}
+
+structure InputCoefficients where
+  C : ℝ
+  finiteC : Fin 11 → ℝ
+  finiteD : Fin 11 → ℝ
+  tailC : TailNode → ℝ
+  tailD : TailNode → ℝ
+  summable : Summable (fun n => |tailC n|+|tailD n|)
+
+def tailInput (a : InputCoefficients) (s : ℂ) : ℂ :=
+  (a.C:ℂ)*P s + ∑' n : TailNode, ((a.tailC n:ℂ)*cBasis n.val s+(a.tailD n:ℂ)*dBasis n.val s)
+
+def finiteInput (a : InputCoefficients) (s : ℂ) : ℂ :=
+  ∑ j : Fin 11, ((a.finiteC j:ℂ)*finiteC ⟨j.val,by omega⟩ s +
+    (a.finiteD j:ℂ)*finiteD ⟨j.val,by omega⟩ s)
+
+def inputComplex (a : InputCoefficients) (x : Plane) : ℂ :=
+  exp (-(Real.pi:ℂ)*h*(radial x:ℂ))*tailInput a (radial x) +
+    exp (-(Real.pi:ℂ)*H*(radial x:ℂ))*finiteInput a (radial x)
+
+def targetCoefficient (n : Fin 10) : ℝ := Q 1 / Q (finiteNode n) * Real.exp (Real.pi*eta*(finiteNode n))
+
+def Yf : Matrix (Fin 20) (Fin 8) ℝ := fun i j =>
+  if i.val<8 then
+    targetCoefficient ⟨i.val/2,by omega⟩ *
+      (if i.val%2=0 then (if j.val=i.val then 1 else 0)
+       else (if j.val=i.val then -1 else if j.val=i.val-1 then Real.pi*eta-D (finiteNode ⟨i.val/2,by omega⟩) else 0))
+  else 0
+
+def gamma (side : Fin 2) : Matrix (Fin 3) (Fin 8) ℝ := fun i j =>
+  if j.val=1 then (if i.val=0 then 11/25 else if i.val=1 then 0 else if side.val=0 then -(3/500) else 3/500) else 0
+
+def Uplus : Matrix (Fin 20) (Fin 8) ℝ :=
+  (1-R)⁻¹*(Yf+R0*(gamma 1+gamma 0))
+
+def Uminus : Matrix (Fin 20) (Fin 8) ℝ :=
+  (1+R)⁻¹*(Yf+R0*(gamma 1-gamma 0))
+
+def finiteSolution (side : Fin 2) : Matrix (Fin 20) (Fin 8) ℝ :=
+  if side.val=0 then (1/2:ℝ) • (Uplus+Uminus) else (1/2:ℝ) • (Uplus-Uminus)
+
+def Acoefficient (side : Fin 2) : Matrix (Fin 23) (Fin 8) ℝ := fun i j =>
+  if hi : i.val<2 then gamma side ⟨i.val,by omega⟩ j
+  else if h22 : i.val=22 then gamma side 2 j
+  else finiteSolution side ⟨i.val-2,by omega⟩ j
+
+def gaussianZ (α : ℝ) : ℝ := 1/(Real.pi*(α/b-h))
+
+def actualParameter (z : ℝ) : Fin 8 → ℝ :=
+  ![z,1,z*Real.exp (-2/z),Real.exp (-2/z),z*Real.exp (-3/z),Real.exp (-3/z),
+    z*Real.exp (-6/z),Real.exp (-6/z)]
+
+def normalizingDen (z : ℝ) := Q 1*z*Real.exp (1/z)
+
+end AtomicTriangular.Construction
+
+end
+
+noncomputable section
+open scoped BigOperators FourierTransform
+
+namespace AtomicTriangular.Construction
+
+def correctedFinite (side : Fin 2) (z : ℝ) (δ : Fin 20 → ℝ) (j : Fin 22) : ℝ :=
+  (∑ r : Fin 8, Acoefficient side ⟨j.val, by omega⟩ r * actualParameter z r) +
+    if hj : j.val < 2 then 0 else δ ⟨j.val - 2, by omega⟩
+
+end AtomicTriangular.Construction
+
+namespace AtomicTriangular
+open Construction
+
+local instance finite_pair_neZero : NeZero (2 : ℕ) := inferInstance
+local instance three_atLeastTwo : Nat.AtLeastTwo 3 := inferInstance
+local instance ten_atLeastTwo : Nat.AtLeastTwo 10 := inferInstance
+local instance five_hundred_atLeastTwo : Nat.AtLeastTwo 500 := inferInstance
+local instance plane_borelSpace : BorelSpace Plane := inferInstance
+local instance plane_finite : Module.Finite ℝ Plane := inferInstance
+
+def AtomicConstruction (α : ℝ) (f : Plane → ℝ) : Prop :=
+  IsUnit (1 - R) ∧ IsUnit (1 + R) ∧
+  (1 - R) * Uplus = Yf + R0 * (gamma 1 + gamma 0) ∧
+  (1 + R) * Uminus = Yf + R0 * (gamma 1 - gamma 0) ∧
+  ∃ (δ : Fin 2 → Fin 20 → ℝ) (a : Fin 2 → InputCoefficients),
+    (∀ side, (∑ j : Fin 20, |δ side j|) < (1 / 10^5 : ℝ)) ∧
+    (∀ side, (a side).C = if side.val = 0 then -(3/500) else 3/500) ∧
+    (∀ side (j : Fin 11),
+      (a side).finiteC j =
+        correctedFinite side (gaussianZ α) (δ side) ⟨2*j.val, by omega⟩ ∧
+      (a side).finiteD j =
+        correctedFinite side (gaussianZ α) (δ side) ⟨2*j.val+1, by omega⟩) ∧
+    (∀ side, Summable (fun n => |(a side).tailC n| + |(a side).tailD n|) ∧
+      (∑' n, (|(a side).tailC n| + |(a side).tailD n|)) < (3 / 10^9 : ℝ)) ∧
+    (∀ x, (f x : ℂ) =
+      (inputComplex (a 0) x + 𝓕 (inputComplex (a 1)) x) /
+        (normalizingDen (gaussianZ α) : ℂ))
+
+end AtomicTriangular
+end
+
+noncomputable section
+open scoped BigOperators FourierTransform
+
+namespace AtomicTriangular
+open Construction
+
+theorem sharp_gaussian_minorants_with_construction (α : ℝ) (hα : 0 < α) :
+    ∃ f : SchwartzMap Plane ℝ,
+      Radial f ∧ (∀ x, f x ≤ gaussian α x) ∧
+      (∀ w, (realFourier f w).im = 0 ∧ 0 ≤ (realFourier f w).re) ∧
+      (∀ a ∈ A, a ≠ 0 → f a = gaussian α a) ∧
+      (∀ w ∈ dualA, w ≠ 0 → realFourier f w = 0) ∧
+      (1 ≤ α → AtomicConstruction α f) := by
+  sorry
+
+end AtomicTriangular
+end
+
+end OAI

lean/ComparatorChallenges/TriangularHilbert.json

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

lean/ComparatorChallenges/TriangularHilbert.lean

@@ -0,0 +1,57 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory
+open scoped ENNReal NNReal
+
+namespace TriangularHilbert
+
+abbrev Plane := ℝ × ℝ
+
+structure Endpoints where
+  lower : ℝ
+  upper : ℝ
+  lower_pos : 0 < lower
+  lower_lt_upper : lower < upper
+
+def annulus (ε R : ℝ) : Set ℝ := {t | ε < |t| ∧ |t| < R}
+
+def integrand (F G : Plane → ℂ) (z : Plane) (t : ℝ) : ℂ :=
+  F (z.1 + t, z.2) * G (z.1, z.2 + t) / (t : ℂ)
+
+def truncation (F G : Plane → ℂ) (E : Endpoints) (z : Plane) : ℂ :=
+  ∫ t in annulus E.lower E.upper, integrand F G z t
+
+def GoodPoint (F G : Plane → ℂ) (z : Plane) : Prop :=
+  ∀ n : ℕ, IntegrableOn (integrand F G z)
+    (annulus (1 / ((n : ℝ) + 2)) ((n : ℝ) + 2))
+
+def maximal (F G : Plane → ℂ) (z : Plane) : ℝ≥0∞ := by
+  classical
+  exact if GoodPoint F G z then
+    ⨆ E : Endpoints, ENNReal.ofReal ‖truncation F G E z‖ else 0
+
+def maximalNorm (F G : Plane → ℂ) : ℝ≥0∞ :=
+  (∫⁻ z : Plane, maximal F G z ^ ((3 : ℝ) / 2)) ^ ((2 : ℝ) / 3)
+
+def MainEstimate : Prop :=
+  ∃ C : ℝ≥0, ∀ F G : Plane → ℂ,
+    MemLp F 3 volume → MemLp G 3 volume →
+    (∀ᵐ z ∂volume, GoodPoint F G z) ∧
+    AEMeasurable (maximal F G) volume ∧
+    maximalNorm F G ≤ (C : ℝ≥0∞) * eLpNorm F 3 volume * eLpNorm G 3 volume
+
+open MeasureTheory Filter
+open scoped ENNReal
+
+theorem main_estimate : MainEstimate := by
+  sorry
+
+end TriangularHilbert
+
+end
+
+end OAI

lean/ComparatorChallenges/TruffetCounterexample.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TruffetCounterexample",
+  "solution_module": "OAI.Optimization.Tropical.TruffetCounterexample",
+  "theorem_names": [
+    "OAI.TruffetV4Counterexample.finite_execution_not_optimal"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TruffetCounterexample.lean

@@ -0,0 +1,134 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+namespace TruffetV4Counterexample
+
+abbrev Coeff := WithBot ℝ
+
+abbrev Form := Fin 3 → Coeff
+
+abbrev Var := Fin 2
+
+abbrev RowIndex := Fin 2
+
+def column (j : Var) : Fin 3 := ⟨j.val, Nat.lt_trans j.isLt (by decide)⟩
+
+def nullForm : Form := fun _ => ⊥
+
+structure Row where
+  lhs : Form
+  rhs : Form
+
+structure State where
+  rows : RowIndex → Row
+  cost : Form
+  remaining : Var → Prop
+
+def wellFormed (s : State) : Prop := ∀ j, ¬ s.remaining j →
+  s.cost (column j) = ⊥ ∧ ∀ i,
+    (s.rows i).lhs (column j) = ⊥ ∧ (s.rows i).rhs (column j) = ⊥
+
+def eval (f : Form) (w : Fin 3 → ℝ) : Coeff :=
+  max (f 0 + (w 0 : Coeff)) (max (f 1 + (w 1 : Coeff)) (f 2 + (w 2 : Coeff)))
+
+def feasible (s : State) (w : Fin 3 → ℝ) : Prop :=
+  ∀ i, eval (s.rows i).rhs w ≤ eval (s.rows i).lhs w
+
+def lower (s : State) (i : RowIndex) (j : Var) : Prop :=
+  (s.rows i).lhs (column j) ≠ ⊥ ∧
+    (s.rows i).rhs (column j) < (s.rows i).lhs (column j)
+
+def upper (s : State) (i : RowIndex) (j : Var) : Prop :=
+  (s.rows i).rhs (column j) ≠ ⊥ ∧
+    (s.rows i).lhs (column j) < (s.rows i).rhs (column j)
+
+def dominating (s : State) (j : Var) : Prop :=
+  s.remaining j ∧ (∃ i, lower s i j) ∧ ∃ i, upper s i j
+
+def eligible (s : State) (i : RowIndex) (j : Var) : Prop :=
+  s.remaining j ∧ lower s i j ∧ ((∃ k, dominating s k) → dominating s j)
+
+def bounded (s : State) : Prop :=
+  ∀ j, s.remaining j → (∃ i, lower s i j) ∨ ∃ i, upper s i j
+
+def stop (s : State) : Prop := ∀ i, (s.rows i).rhs 2 ≤ (s.rows i).lhs 2
+
+def switch (s : State) : Prop :=
+  (∀ j, s.remaining j → s.cost (column j) = ⊥) ∧ ¬ stop s ∧
+  (∃ j, s.remaining j) ∧
+  (¬ ∃ i j, s.remaining j ∧ lower s i j) ∧
+  ∃ i j, s.remaining j ∧ upper s i j
+
+def failure (s : State) : Prop := ¬ stop s ∧
+  ((¬ ∃ j, s.remaining j) ∨
+   ((¬ ∃ i j, s.remaining j ∧ lower s i j) ∧
+    (¬ ∃ i j, s.remaining j ∧ upper s i j)))
+
+def lowerForm (s : State) (i : RowIndex) (j : Var) : Form := fun k =>
+  if k = column j then ⊥ else
+    (s.rows i).rhs k + ((-WithBot.unbotD 0 ((s.rows i).lhs (column j)) : ℝ) : Coeff)
+
+def substitute (f : Form) (j : Var) (g : Form) : Form := fun k =>
+  if k = column j then ⊥ else max (f k) (f (column j) + g k)
+
+def cleanup (r : Row) : Row := by
+  classical
+  exact if ∀ k, r.rhs k ≤ r.lhs k then ⟨nullForm, nullForm⟩ else r
+
+def advance (s : State) (i : RowIndex) (j : Var) : State where
+  rows := fun r => cleanup ⟨substitute (s.rows r).lhs j (lowerForm s i j),
+    substitute (s.rows r).rhs j (lowerForm s i j)⟩
+  cost := substitute s.cost j (lowerForm s i j)
+  remaining := fun k => s.remaining k ∧ k ≠ j
+
+def ForcedSingletonStep (s s' : State) (i : RowIndex) (j : Var) : Prop :=
+  wellFormed s ∧ wellFormed s' ∧
+  bounded s ∧ ¬ stop s ∧ ¬ switch s ∧ ¬ failure s ∧
+  (∀ r k, eligible s r k ↔ r = i ∧ k = j) ∧
+  (∃ k, (substitute s.cost j (lowerForm s i j)) k ≠ ⊥) ∧
+  s' = advance s i j
+
+def initial : State where
+  rows := ![⟨![(0 : Coeff), 0, ⊥], ![⊥, ⊥, (0 : Coeff)]⟩,
+    ⟨![(0 : Coeff), ⊥, ⊥], ![⊥, (1 : Coeff), ((-2 : ℝ) : Coeff)]⟩]
+  cost := ![(0 : Coeff), ⊥, ⊥]
+  remaining := fun _ => True
+
+def middle : State where
+  rows := ![⟨nullForm, nullForm⟩,
+    ⟨![(0 : Coeff), ⊥, ⊥], ![⊥, ⊥, (1 : Coeff)]⟩]
+  cost := ![(0 : Coeff), ⊥, ⊥]
+  remaining := fun j => j = 0
+
+def finalState : State where
+  rows := fun _ => ⟨nullForm, nullForm⟩
+  cost := ![⊥, ⊥, (1 : Coeff)]
+  remaining := fun _ => False
+
+def crossRowRestriction (s : State) : Prop :=
+  ∀ i r : RowIndex, i ≠ r → ∀ α : ℝ, ∃ w : Fin 3 → ℝ,
+    eval (s.rows i).lhs w < (α : Coeff) + eval (s.rows r).rhs w
+
+def output : Fin 3 → ℝ := ![1, 0, 0]
+
+def better : Fin 3 → ℝ := ![0, -1, 0]
+
+theorem finite_execution_not_optimal :
+    crossRowRestriction initial ∧
+    ForcedSingletonStep initial middle 0 1 ∧
+    ForcedSingletonStep middle finalState 1 0 ∧
+    (¬ ∃ j, finalState.remaining j) ∧ stop finalState ∧
+    feasible initial output ∧ feasible initial better ∧
+    output 2 = 0 ∧ better 2 = 0 ∧
+    (output 1 : Coeff) = eval (lowerForm initial 0 1) output ∧
+    (output 0 : Coeff) = eval (lowerForm middle 1 0) output ∧
+    eval initial.cost output = eval finalState.cost output ∧
+    eval initial.cost better < eval finalState.cost output := by
+  sorry
+
+end TruffetV4Counterexample
+end
+
+end OAI

lean/ComparatorChallenges/TwoWayComplementation.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TwoWayComplementation",
+  "solution_module": "OAI.Combinatorics.TwoWayAutomata.Main",
+  "theorem_names": [
+    "OAI.TwoWayComplementation.complementation_lower_bound_finite"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TwoWayComplementation.lean

@@ -0,0 +1,45 @@
+import Mathlib
+
+namespace OAI
+
+namespace TwoWayComplementation
+
+open scoped SetRel
+
+def relStar {α : Type*} (R : SetRel α α) : SetRel α α :=
+  {(x, y) | Relation.ReflTransGen (fun a b => (a, b) ∈ R) x y}
+
+structure TwoNFA (Sigma Q : Type*) where
+  initial : Q
+  accepting : Set Q
+  transition : Q → (Fin 2 ⊕ Sigma) → Set (Q × Fin 3)
+
+def tapeSymbol {Sigma : Type*} (w : List Sigma) (p : Fin (w.length + 2)) : Fin 2 ⊕ Sigma :=
+  if hleft : p.val = 0 then .inl 0
+  else if hright : p.val = w.length + 1 then .inl 1
+  else .inr (w[p.val - 1]'(by omega))
+
+namespace TwoNFA
+
+def step {Sigma Q : Type*} (A : TwoNFA Sigma Q) (w : List Sigma) :
+    SetRel (Q × Fin (w.length + 2)) (Q × Fin (w.length + 2)) :=
+  {(c, d) | ∃ move : Fin 3,
+    (d.1, move) ∈ A.transition c.1 (tapeSymbol w c.2) ∧
+    (d.2.val : ℤ) = (c.2.val : ℤ) + (move.val : ℤ) - 1}
+
+def language {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Set (List Sigma) :=
+  {w | ∃ c, c.1 ∈ A.accepting ∧
+    ((A.initial, ⟨0, by omega⟩), c) ∈ relStar (A.step w)}
+
+end TwoNFA
+
+theorem complementation_lower_bound_finite (n : ℕ) (hn : 4 ≤ n) :
+    ∃ A : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) (Fin n),
+      ∀ (Q : Type*) [Fintype Q], ∀ B : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        B.language = A.languageᶜ →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) - 1 ≤ (Fintype.card Q : ℝ) := by
+  sorry
+
+end TwoWayComplementation
+
+end OAI

lean/ComparatorChallenges/TwoWayDeterminization.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TwoWayDeterminization",
+  "solution_module": "OAI.Combinatorics.TwoWayAutomata.ExplicitFamily",
+  "theorem_names": [
+    "OAI.TwoWayComplementation.explicit_family_main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TwoWayDeterminization.lean

@@ -0,0 +1,73 @@
+import Mathlib
+
+namespace OAI
+
+namespace TwoWayComplementation
+
+open scoped SetRel
+
+/-- Reflexive transitive closure, including the empty path. -/
+def relStar {α : Type*} (R : SetRel α α) : SetRel α α :=
+  {(x, y) | Relation.ReflTransGen (fun a b => (a, b) ∈ R) x y}
+
+/-- A read-only 2NFA. The two endmarkers are `Sum.inl 0` and `Sum.inl 1`.
+    Move codes 0, 1, 2 mean left, stay, right. -/
+structure TwoNFA (Sigma Q : Type*) where
+  /-- The state in which the machine starts on the left endmarker. -/
+  initial : Q
+  /-- States whose occurrence on a finite run constitutes acceptance. -/
+  accepting : Set Q
+  /-- Allowed next-state and move pairs, determined by the state and scanned symbol. -/
+  transition : Q → (Fin 2 ⊕ Sigma) → Set (Q × Fin 3)
+
+/-- Tape lookup includes two distinct endmarkers, even on empty input. -/
+def tapeSymbol {Sigma : Type*} (w : List Sigma) (p : Fin (w.length + 2)) : Fin 2 ⊕ Sigma :=
+  if hleft : p.val = 0 then .inl 0
+  else if hright : p.val = w.length + 1 then .inl 1
+  else .inr (w[p.val - 1]'(by omega))
+
+namespace TwoNFA
+
+/-- One legal step: both head positions stay within the marked input. -/
+def step {Sigma Q : Type*} (A : TwoNFA Sigma Q) (w : List Sigma) :
+    SetRel (Q × Fin (w.length + 2)) (Q × Fin (w.length + 2)) :=
+  {(c, d) | ∃ move : Fin 3,
+    (d.1, move) ∈ A.transition c.1 (tapeSymbol w c.2) ∧
+    (d.2.val : ℤ) = (c.2.val : ℤ) + (move.val : ℤ) - 1}
+
+/-- Existential finite-run acceptance, allowing a run of length zero. -/
+def language {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Set (List Sigma) :=
+  {w | ∃ c, c.1 ∈ A.accepting ∧
+    ((A.initial, ⟨0, by omega⟩), c) ∈ relStar (A.step w)}
+
+end TwoNFA
+
+/-- At most one next-state/move pair at every state and scanned symbol. -/
+def TwoNFA.Deterministic {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Prop :=
+  ∀ q symbol, (A.transition q symbol).Subsingleton
+
+/-- Relation product for an input word; the empty product is the identity. -/
+def relationProduct {H : Type*} (w : List (SetRel H H)) : SetRel H H :=
+  w.foldr SetRel.comp SetRel.id
+
+/-- The source language consists of the words with nonempty relation product. -/
+def sourceLanguage (H : Type*) : Set (List (SetRel H H)) :=
+  {w | (relationProduct w).Nonempty}
+
+/-- Both lower bounds hold for the same n-state liveness witness. -/
+theorem explicit_family_main (n : ℕ) (hn : 4 ≤ n) :
+    ∃ A : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) (Fin n),
+      A.language = sourceLanguage (Fin (n - 2)) ∧
+      (∀ (Q : Type*) [Fintype Q],
+        ∀ B : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        B.language = A.languageᶜ →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) - 1 ≤ (Fintype.card Q : ℝ)) ∧
+      (131 ≤ n → ∀ (Q : Type*) [Fintype Q],
+        ∀ D : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        D.Deterministic → D.language = A.language →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) ≤ (Fintype.card Q : ℝ)) := by
+  sorry
+
+end TwoWayComplementation
+
+end OAI

lean/ComparatorChallenges/TypeSystemNormalization.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TypeSystemNormalization",
+  "solution_module": "OAI.Computability.TypeSystem.Normalization",
+  "theorem_names": [
+    "OAI.PureTypeSystem.weak_implies_strong"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/TypeSystemNormalization.lean

@@ -0,0 +1,122 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+Full annotated PTS syntax, modulo alpha-renaming via de Bruijn indices.
+Contexts are stored newest-first, each declaration in its prefix context.
+No functionality assumptions on axioms or product rules.
+-/
+
+namespace PureTypeSystem
+
+universe u
+
+inductive Expr (Sorts : Type u) : Type u
+  | var : Nat → Expr Sorts
+  | sort : Sorts → Expr Sorts
+  | app : Expr Sorts → Expr Sorts → Expr Sorts
+  | lam : Expr Sorts → Expr Sorts → Expr Sorts
+  | pi : Expr Sorts → Expr Sorts → Expr Sorts
+  deriving DecidableEq
+
+namespace Expr
+
+variable {S : Type u}
+
+def liftRen (ρ : Nat → Nat) : Nat → Nat
+  | 0 => 0
+  | n + 1 => ρ n + 1
+
+def rename (ρ : Nat → Nat) : Expr S → Expr S
+  | var n => var (ρ n)
+  | sort s => sort s
+  | app f a => app (rename ρ f) (rename ρ a)
+  | lam A b => lam (rename ρ A) (rename (liftRen ρ) b)
+  | pi A B => pi (rename ρ A) (rename (liftRen ρ) B)
+
+def liftSub (σ : Nat → Expr S) : Nat → Expr S
+  | 0 => var 0
+  | n + 1 => rename Nat.succ (σ n)
+
+def subst (σ : Nat → Expr S) : Expr S → Expr S
+  | var n => σ n
+  | sort s => sort s
+  | app f a => app (subst σ f) (subst σ a)
+  | lam A b => lam (subst σ A) (subst (liftSub σ) b)
+  | pi A B => pi (subst σ A) (subst (liftSub σ) B)
+
+def single (a : Expr S) : Nat → Expr S
+  | 0 => a
+  | n + 1 => var n
+
+def instantiate (b a : Expr S) : Expr S := subst (single a) b
+
+end Expr
+
+structure Specification (S : Type u) where
+  axioms : S → S → Prop
+  rule : S → S → S → Prop
+
+inductive Beta {S : Type u} : Expr S → Expr S → Prop
+  | head (A b a) : Beta (.app (.lam A b) a) (b.instantiate a)
+  | app_left {f f' a} : Beta f f' → Beta (.app f a) (.app f' a)
+  | app_right {f a a'} : Beta a a' → Beta (.app f a) (.app f a')
+  | lam_domain {A A' b} : Beta A A' → Beta (.lam A b) (.lam A' b)
+  | lam_body {A b b'} : Beta b b' → Beta (.lam A b) (.lam A b')
+  | pi_domain {A A' B} : Beta A A' → Beta (.pi A B) (.pi A' B)
+  | pi_body {A B B'} : Beta B B' → Beta (.pi A B) (.pi A B')
+
+def Converts {S : Type u} : Expr S → Expr S → Prop := Relation.EqvGen Beta
+
+def Normal {S : Type u} (M : Expr S) : Prop := ∀ N, ¬ Beta M N
+
+def WeaklyNormalizing {S : Type u} (M : Expr S) : Prop :=
+  ∃ N, Relation.ReflTransGen Beta M N ∧ Normal N
+
+/-- Accessibility for the converse of reduction: strong normalization,
+including reductions in all type annotations. -/
+def StronglyNormalizing {S : Type u} (M : Expr S) : Prop :=
+  Acc (fun N M : Expr S => Beta M N) M
+
+inductive HasType {S : Type u} (P : Specification S) :
+    List (Expr S) → Expr S → Expr S → Prop
+  | ax {s t} : P.axioms s t → HasType P [] (.sort s) (.sort t)
+  | var {Γ A s} : HasType P Γ A (.sort s) →
+      HasType P (A :: Γ) (.var 0) (A.rename Nat.succ)
+  | weaken {Γ M B A s} : HasType P Γ M B → HasType P Γ A (.sort s) →
+      HasType P (A :: Γ) (M.rename Nat.succ) (B.rename Nat.succ)
+  | product {Γ A B s₁ s₂ s₃} : HasType P Γ A (.sort s₁) →
+      HasType P (A :: Γ) B (.sort s₂) → P.rule s₁ s₂ s₃ →
+      HasType P Γ (.pi A B) (.sort s₃)
+  | abstraction {Γ A b B s} : HasType P (A :: Γ) b B →
+      HasType P Γ (.pi A B) (.sort s) →
+      HasType P Γ (.lam A b) (.pi A B)
+  | application {Γ f a A B} : HasType P Γ f (.pi A B) →
+      HasType P Γ a A → HasType P Γ (.app f a) (B.instantiate a)
+  | conversion {Γ M A B s} : HasType P Γ M A → HasType P Γ B (.sort s) →
+      Converts A B → HasType P Γ M B
+
+inductive ValidContext {S : Type u} (P : Specification S) : List (Expr S) → Prop
+  | nil : ValidContext P []
+  | cons {Γ A s} : ValidContext P Γ → HasType P Γ A (.sort s) →
+      ValidContext P (A :: Γ)
+
+def Legal {S : Type u} (P : Specification S) (Γ : List (Expr S)) (M : Expr S) : Prop :=
+  ∃ A, HasType P Γ M A ∨ HasType P Γ A M
+
+def SystemWeaklyNormalizing {S : Type u} (P : Specification S) : Prop :=
+  ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → WeaklyNormalizing M
+
+def SystemStronglyNormalizing {S : Type u} (P : Specification S) : Prop :=
+  ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → StronglyNormalizing M
+
+/-- System-wide weak normalization implies strong normalization for every PTS,
+including arbitrary sort types, nonfunctional rules and annotated terms. -/
+theorem weak_implies_strong {S : Type u} (P : Specification S)
+    (h : SystemWeaklyNormalizing P) : SystemStronglyNormalizing P := by
+  sorry
+
+end PureTypeSystem
+
+end OAI

lean/ComparatorChallenges/UniformCommutator.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformCommutator",
+  "solution_module": "OAI.Analysis.Commutator.Main",
+  "theorem_names": [
+    "OAI.Kadison.uniform_commutator"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniformCommutator.lean

@@ -0,0 +1,40 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+universe u v
+namespace Kadison
+
+variable {K : Type u} [NormedAddCommGroup K] [InnerProductSpace ℂ K]
+  [CompleteSpace K]
+
+def commutatorSeminorm (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K) : ℝ :=
+  sSup {r : ℝ | ∃ a : K →L[ℂ] K, a ∈ P ∧ ‖a‖ ≤ 1 ∧ r = ‖Y * a - a * Y‖}
+
+def matrixOperator (h : ℕ) (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)) :
+    (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=
+  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp
+    (ContinuousLinearMap.pi (fun i => ∑ j : Fin h,
+      (X i j).comp (PiLp.proj 2 (fun _ : Fin h => K) j)))
+
+def diagonalAmplification (h : ℕ) (Y : K →L[ℂ] K) :
+    (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=
+  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp
+    (ContinuousLinearMap.pi (fun i => Y.comp (PiLp.proj 2 (fun _ : Fin h => K) i)))
+
+theorem uniform_commutator :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (K : Type u) [NormedAddCommGroup K] [InnerProductSpace ℂ K]
+      [CompleteSpace K] (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K)
+      (h : ℕ), 1 ≤ h → ∀ (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)),
+      (∀ i j, X i j ∈ P) →
+      ‖diagonalAmplification h Y * matrixOperator h X -
+        matrixOperator h X * diagonalAmplification h Y‖ ≤
+        C * commutatorSeminorm P Y * ‖matrixOperator h X‖ := by
+  sorry
+
+end Kadison
+
+end
+
+end OAI

lean/ComparatorChallenges/UniformGamma.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformGamma",
+  "solution_module": "OAI.Analysis.TracialSplitting.Challenge",
+  "theorem_names": [
+    "OAI.ComparatorModel.CurrentMain.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniformGamma.lean

@@ -0,0 +1,607 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+/-!
+The final claim constructs the tracial quotients and states the original gamma assertion.
+`Analysis.TracialSplitting.Challenge.main_iff_original` verifies statement preservation.
+-/
+
+universe uA uD uE uI uR uX u v
+
+namespace Pureness
+
+open scoped ComplexOrder
+
+structure CStarAlgebraNorm (R : Type uR) [Ring R] [StarRing R] [Algebra ℂ R]
+    extends AlgebraNorm ℂ R where
+  cstar : ∀ x, toAlgebraNorm (star x * x) = toAlgebraNorm x * toAlgebraNorm x
+
+structure TracialState (A : Type uA) [CStarAlgebra A] [PartialOrder A] where
+  functional : A →ₚ[ℂ] ℂ
+  normalized : functional 1 = 1
+  tracial : ∀ a b : A, functional (a * b) = functional (b * a)
+
+structure ClosedStarIdeal (D : Type uD) [CStarAlgebra D] where
+  ideal : TwoSidedIdeal D
+  star_mem : ∀ {u : D}, u ∈ ideal → star u ∈ ideal
+  isClosed : IsClosed (ideal : Set D)
+
+end Pureness
+
+universe uNuclear
+
+namespace ComparatorModel
+
+namespace Pureness
+
+open scoped TensorProduct ComplexOrder
+
+abbrev CStarAlgebraNorm := @_root_.OAI.Pureness.CStarAlgebraNorm
+
+def IsNuclear (A : Type u) [CStarAlgebra A] : Prop :=
+  ∀ (B : Type v) [CStarAlgebra B], Subsingleton (CStarAlgebraNorm (A ⊗[ℂ] B))
+
+abbrev TracialState := @_root_.OAI.Pureness.TracialState
+
+end Pureness
+
+namespace CurrentMain
+
+open _root_.OAI.ComparatorModel.Pureness
+
+open scoped ComplexOrder
+
+def RealRankZero (D : Type) [CStarAlgebra D] : Prop :=
+  ∀ a : D, IsSelfAdjoint a → ∀ ε : ℝ, 0 < ε →
+    ∃ b : D, IsSelfAdjoint b ∧ (spectrum ℂ b).Finite ∧ ‖a - b‖ < ε
+
+def traceTwoNorm {D : Type} [CStarAlgebra D] [PartialOrder D]
+    (τ : TracialState D) (a : D) : ℝ :=
+  Real.sqrt (τ.functional (star a * a)).re
+
+end CurrentMain
+
+section
+
+open Filter
+
+open scoped Topology NNReal ENNReal
+
+abbrev Pureness.ClosedStarIdeal := @_root_.OAI.Pureness.ClosedStarIdeal
+
+namespace Pureness.ClosedStarIdeal
+
+section
+
+variable {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D)
+
+abbrev Quotient := J.ideal.ringCon.Quotient
+
+def quotientMap : D →ₐ[ℂ] J.Quotient := J.ideal.ringCon.mkₐ ℂ
+
+instance quotientStar : Star (J.Quotient) where
+  star := Quotient.map' star (by
+    intro u v h
+    change J.ideal.ringCon u v at h
+    change J.ideal.ringCon (star u) (star v)
+    rw [TwoSidedIdeal.rel_iff] at h ⊢
+    simpa only [star_sub] using J.star_mem h)
+
+instance quotientStarRing : StarRing (J.Quotient) where
+  star_involutive x := Quotient.inductionOn' x (fun u => congrArg J.quotientMap (star_star u))
+  star_mul x y := Quotient.inductionOn₂' x y (fun u v => congrArg J.quotientMap (star_mul u v))
+  star_add x y := Quotient.inductionOn₂' x y (fun u v => congrArg J.quotientMap (star_add u v))
+
+instance quotientStarModule : StarModule ℂ (J.Quotient) where
+  star_smul c x := Quotient.inductionOn' x (fun u => congrArg J.quotientMap (star_smul c u))
+
+abbrev idealSubmodule : Submodule ℂ (D) :=
+  (J.quotientMap).toLinearMap.ker
+
+instance idealSubmodule_closed : IsClosed (J.idealSubmodule : Set D) := by
+  have he : (J.idealSubmodule : Set D) = (J.ideal : Set D) := by
+    ext u
+    change J.ideal.ringCon.mk' u = J.ideal.ringCon.mk' 0 ↔ u ∈ J.ideal
+    exact Quotient.eq
+  rw [he]
+  exact J.isClosed
+
+def quotientLinearEquiv :
+    (D ⧸ J.idealSubmodule) ≃ₗ[ℂ] J.Quotient :=
+  (J.quotientMap).toLinearMap.quotKerEquivOfSurjective ((J.ideal.ringCon.mkₐ_surjective (α := ℂ)))
+
+instance quotientNormedAddCommGroup : NormedAddCommGroup (J.Quotient) :=
+  NormedAddCommGroup.induced _ _ (J.quotientLinearEquiv).symm
+    (J.quotientLinearEquiv).symm.injective
+
+instance quotientNormedSpace : NormedSpace ℂ (J.Quotient) :=
+  NormedSpace.induced ℂ _ _ (J.quotientLinearEquiv).symm
+
+def quotientNormEquiv : J.Quotient ≃ₗᵢ[ℂ]
+    (D ⧸ J.idealSubmodule) where
+  __ := (J.quotientLinearEquiv).symm
+  norm_map' _ := rfl
+
+instance quotientCompleteSpace : CompleteSpace (J.Quotient) :=
+  (J.quotientNormEquiv).toIsometryEquiv.completeSpace_iff.mpr inferInstance
+
+class NormConstruction : Prop where
+  mul_le : ∀ {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D) (x y : J.Quotient),
+    ‖x*y‖ ≤ ‖x‖*‖y‖
+  star_eq : ∀ {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D) (x : J.Quotient),
+    ‖star x‖ = ‖x‖
+  square_le : ∀ {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (J : ClosedStarIdeal D) (x : J.Quotient), ‖x‖ * ‖x‖ ≤ ‖star x * x‖
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance quotientNormedRing : NormedRing (J.Quotient) where
+  dist_eq := dist_eq_norm_neg_add
+  norm_mul_le := NormConstruction.mul_le J
+
+instance quotientNormedAlgebra : NormedAlgebra ℂ (J.Quotient) where
+  norm_smul_le := norm_smul_le
+
+instance quotientNormedStarGroup : NormedStarGroup (J.Quotient) where
+  norm_star_le x := (NormConstruction.star_eq J x).le
+
+end
+
+open Filter
+
+open scoped Topology NNReal ENNReal
+
+variable {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (J : ClosedStarIdeal D)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance quotientCStarAlgebra : CStarAlgebra (J.Quotient) where
+  norm_mul_self_le := NormConstruction.square_le J
+
+end Pureness.ClosedStarIdeal
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness
+
+section UniformTraceNorm
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+def CurrentMain.familyTwoNorm (a : D) : ℝ := ⨆ i, traceTwoNorm (τ i) a
+
+end UniformTraceNorm
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+open scoped Topology NNReal ENNReal
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance CurrentMain.boundedFamilyProductCStar {X : Type} {D : Type} [CStarAlgebra D] [Nontrivial D] :
+    CStarAlgebra (lp (fun _ : X => D) ∞) where
+
+section UniformNull
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+def CurrentMain.IsFamilyNull (F : Filter X) (u : X → D) : Prop :=
+  Tendsto (fun n => familyTwoNorm τ (u n)) F (𝓝 0)
+
+class CurrentMain.NullConstruction : Prop where
+  zero : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    (F : Filter X), IsFamilyNull τ F (fun _ => 0)
+  add : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F v →
+    IsFamilyNull τ F (fun n => u n + v n)
+  neg : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F (fun n => -u n)
+  star : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F (fun n => star (u n))
+  mul_left : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F v → ∀ {M : ℝ},
+    (∀ n, ‖u n‖ ≤ M) → IsFamilyNull τ F (fun n => u n * v n)
+  mul_right : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F u → ∀ {M : ℝ},
+    (∀ n, ‖v n‖ ≤ M) → IsFamilyNull τ F (fun n => u n * v n)
+  closed : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I] (F : Filter X),
+    IsClosed {u : lp (fun _ : X => D) ∞ | IsFamilyNull τ F (fun n => u n)}
+
+variable [Nontrivial D]
+
+variable [ComparatorModel.CurrentMain.NullConstruction]
+
+def CurrentMain.familyNullTwoSided (F : Filter X) : TwoSidedIdeal (lp (fun _ : X => D) ∞) :=
+  TwoSidedIdeal.mk' {u | IsFamilyNull τ F (fun n => u n)}
+    (NullConstruction.zero τ F)
+    (fun hu hv => NullConstruction.add τ hu hv)
+    (fun hu => NullConstruction.neg τ hu)
+    (fun {u _} hv => NullConstruction.mul_left τ hv
+      (lp.norm_apply_le_norm ENNReal.top_ne_zero u))
+    (fun {_ v} hu => NullConstruction.mul_right τ hu
+      (lp.norm_apply_le_norm ENNReal.top_ne_zero v))
+
+def CurrentMain.familyNullIdeal (F : Filter X) : ClosedStarIdeal (lp (fun _ : X => D) ∞) where
+  ideal := familyNullTwoSided τ F
+  star_mem := by
+    intro u hu
+    apply (TwoSidedIdeal.mem_mk' _ _ _ _ _ _ (star u)).mpr
+    exact NullConstruction.star τ ((TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u).mp hu)
+  isClosed := by
+    have he : (familyNullTwoSided τ F : Set (lp (fun _ : X => D) ∞)) =
+        {u | IsFamilyNull τ F (fun n => u n)} := by
+      ext u
+      exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u
+    rw [he]
+    exact NullConstruction.closed τ F
+
+end UniformNull
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.CurrentMain.NullConstruction]
+
+def CurrentMain.IsFamilyCauchy (u : ℕ → D) : Prop :=
+  IsFamilyNull τ (atTop : Filter (ℕ × ℕ)) (fun p => u p.1 - u p.2)
+
+class CurrentMain.CauchyConstruction : Prop where
+  const : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] (a : D), IsFamilyCauchy τ (fun _ => a)
+  add : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u v : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ v → IsFamilyCauchy τ (fun n => u n+v n)
+  star : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ (fun n => star (u n))
+  mul : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u v : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ v → ∀ {M N : ℝ},
+    (∀ n, ‖u n‖ ≤ M) → (∀ n, ‖v n‖ ≤ N) → IsFamilyCauchy τ (fun n => u n*v n)
+  closed : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] [Nontrivial D],
+    IsClosed {u : lp (fun _ : ℕ => D) ∞ | IsFamilyCauchy τ (fun n => u n)}
+
+variable [Nontrivial D]
+
+variable [ComparatorModel.CurrentMain.CauchyConstruction]
+
+def CurrentMain.familyCauchyAlgebra : StarSubalgebra ℂ (lp (fun _ : ℕ => D) ∞) where
+  carrier := {u | IsFamilyCauchy τ (fun n => u n)}
+  zero_mem' := CauchyConstruction.const τ 0
+  one_mem' := CauchyConstruction.const τ 1
+  add_mem' hu hv := CauchyConstruction.add τ hu hv
+  mul_mem' {u v} hu hv := CauchyConstruction.mul τ hu hv
+    (lp.norm_apply_le_norm ENNReal.top_ne_zero u)
+    (lp.norm_apply_le_norm ENNReal.top_ne_zero v)
+  algebraMap_mem' z := CauchyConstruction.const τ (algebraMap ℂ D z)
+  star_mem' hu := CauchyConstruction.star τ hu
+
+instance CurrentMain.familyCauchy_complete : CompleteSpace (familyCauchyAlgebra τ) :=
+  (CauchyConstruction.closed τ).completeSpace_coe
+
+instance CurrentMain.familyCauchy_cstar : CStarAlgebra (familyCauchyAlgebra τ) where
+
+def CurrentMain.familyCauchyNullIdeal : ClosedStarIdeal (familyCauchyAlgebra τ) where
+  ideal := TwoSidedIdeal.comap (familyCauchyAlgebra τ).val.toRingHom
+    (familyNullIdeal τ atTop).ideal
+  star_mem := by
+    intro u hu
+    apply (familyNullIdeal τ atTop).star_mem hu
+  isClosed := by
+    exact (familyNullIdeal τ atTop).isClosed.preimage
+      (continuous_subtype_val : Continuous (fun u : familyCauchyAlgebra τ => u.1))
+
+abbrev CurrentMain.UniformTracialCompletion := (familyCauchyNullIdeal τ).Quotient
+
+end
+
+section
+
+open scoped ComplexOrder
+
+variable {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction]
+
+instance Pureness.ClosedStarIdeal.quotientOrder (J : ClosedStarIdeal D) : PartialOrder J.Quotient :=
+  CStarAlgebra.spectralOrder _
+
+instance Pureness.ClosedStarIdeal.quotientStarOrdered (J : ClosedStarIdeal D) : StarOrderedRing J.Quotient :=
+  CStarAlgebra.spectralOrderedRing _
+
+variable (J : Pureness.ClosedStarIdeal D)
+
+variable (τ : Pureness.TracialState D) (hτ : ∀ a ∈ J.ideal, τ.functional a = 0)
+
+def Pureness.ClosedStarIdeal.descendedValue : J.Quotient → ℂ := Quotient.lift τ.functional (by
+  intro u v huv
+  change J.ideal.ringCon u v at huv
+  rw [TwoSidedIdeal.rel_iff] at huv
+  have h := hτ (u-v) huv
+  rw [map_sub, sub_eq_zero] at h
+  exact h)
+
+def Pureness.ClosedStarIdeal.descendedLinear : J.Quotient →ₗ[ℂ] ℂ where
+  toFun := J.descendedValue τ hτ
+  map_add' x y := Quotient.inductionOn₂' x y (fun u v => τ.functional.map_add u v)
+  map_smul' c x := Quotient.inductionOn' x (fun u => τ.functional.map_smul c u)
+
+def Pureness.ClosedStarIdeal.descendedTrace : TracialState J.Quotient where
+  functional := { J.descendedLinear τ hτ with
+    monotone' := by
+      intro x y hxy
+      apply sub_nonneg.mp
+      change 0 ≤ J.descendedLinear τ hτ y - J.descendedLinear τ hτ x
+      rw [← map_sub]
+      obtain ⟨z,hz⟩ := CStarAlgebra.nonneg_iff_eq_star_mul_self.mp (sub_nonneg.mpr hxy)
+      rw [hz]
+      induction z using Quotient.inductionOn' with
+      | h u => exact τ.functional.map_nonneg (star_mul_self_nonneg u) }
+  normalized := τ.normalized
+  tracial x y := Quotient.inductionOn₂' x y (fun u v => τ.tracial u v)
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+open scoped Topology NNReal ENNReal ComplexOrder
+
+section UltraTrace
+
+variable {D : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D]
+
+variable (θ : X → TracialState D) (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction]
+
+instance CurrentMain.boundedFamilyProductOrder : PartialOrder (lp (fun _ : X => D) ∞) :=
+  CStarAlgebra.spectralOrder _
+
+instance CurrentMain.boundedFamilyProductStarOrdered : StarOrderedRing (lp (fun _ : X => D) ∞) :=
+  CStarAlgebra.spectralOrderedRing _
+
+def CurrentMain.ultraTraceValue (u : lp (fun _ : X => D) ∞) : ℂ :=
+  limUnder (U : Filter X) (fun n => (θ n).functional (u n))
+
+class CurrentMain.LimitConstruction : Prop where
+  tendsto : ∀ {D X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (θ : X ��� Pureness.TracialState D) (U : Ultrafilter X) (u : lp (fun _ : X => D) ∞),
+    Tendsto (fun n => (θ n).functional (u n)) (U : Filter X) (𝓝 (ultraTraceValue θ U u))
+
+variable [ComparatorModel.CurrentMain.LimitConstruction]
+
+def CurrentMain.ultraTraceLinear : lp (fun _ : X => D) ∞ →ₗ[ℂ] ℂ where
+  toFun := ultraTraceValue θ U
+  map_add' u v := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (u+v))
+    simpa only [lp.coeFn_add, Pi.add_apply, map_add] using
+      (LimitConstruction.tendsto θ U u).add (LimitConstruction.tendsto θ U v)
+  map_smul' z u := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (z • u))
+    simpa only [lp.coeFn_smul, Pi.smul_apply, map_smul, RingHom.id_apply, smul_eq_mul] using
+      (LimitConstruction.tendsto θ U u).const_mul z
+
+def CurrentMain.boundedFamilyEval (n : X) : lp (fun _ : X => D) ∞ →⋆ₐ[ℂ] D where
+  toFun u := u n
+  map_zero' := rfl
+  map_one' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+  commutes' _ := rfl
+  map_star' _ := rfl
+
+def CurrentMain.ultraTrace : TracialState (lp (fun _ : X => D) ∞) where
+  functional := { ultraTraceLinear θ U with
+    monotone' := by
+      intro u v huv
+      exact le_of_tendsto_of_tendsto (LimitConstruction.tendsto θ U u)
+        (LimitConstruction.tendsto θ U v) (Eventually.of_forall (fun n =>
+          (θ n).functional.monotone (map_rel (boundedFamilyEval n) huv))) }
+  normalized := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U 1)
+    have he (n : X) : (θ n).functional ((1 : lp (fun _ : X => D) ∞) n) = 1 :=
+      (θ n).normalized
+    simp only [he]
+    exact tendsto_const_nhds
+  tracial u v := by
+    change ultraTraceValue θ U (u*v) = ultraTraceValue θ U (v*u)
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (u*v))
+    have he (n : X) : (θ n).functional ((u*v) n) = (θ n).functional ((v*u) n) :=
+      (θ n).tracial (u n) (v n)
+    simpa only [he] using LimitConstruction.tendsto θ U (v*u)
+
+end UltraTrace
+
+section UniformQuotient
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D]
+
+variable (τ : I → TracialState D) [Nonempty I] (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction]
+
+abbrev CurrentMain.FamilyUltrapower := (familyNullIdeal τ (U : Filter X)).Quotient
+
+class CurrentMain.TraceConstruction : Prop where
+  null : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    (U : Ultrafilter X) (s : X → I) (u : lp (fun _ : X => D) ∞),
+    IsFamilyNull τ (U : Filter X) (fun n => u n) →
+      (ultraTrace (fun n => τ (s n)) U).functional u = 0
+
+variable [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.familyLimitTrace (s : X → I) : TracialState (FamilyUltrapower τ U) :=
+  (familyNullIdeal τ (U : Filter X)).descendedTrace
+    (ultraTrace (fun n => τ (s n)) U) (fun u hu => by
+      apply TraceConstruction.null τ U s u
+      have he : u ∈ familyNullTwoSided τ (U : Filter X) ↔
+          IsFamilyNull τ (U : Filter X) (fun n => u n) := by
+        unfold familyNullTwoSided
+        exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u
+      exact he.mp hu)
+
+end UniformQuotient
+
+section PullbackTrace
+
+variable {D : Type} {E : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [CStarAlgebra E] [PartialOrder E] [StarOrderedRing E]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.pullbackTrace (τ : TracialState E) (ι : D →⋆ₐ[ℂ] E) : TracialState D where
+  functional := { τ.functional.toLinearMap.comp ι.toLinearMap with
+    monotone' := fun _ _ h => τ.functional.monotone (map_rel ι h) }
+  normalized := by change τ.functional (ι 1) = 1; rw [map_one, τ.normalized]
+  tracial x y := by
+    change τ.functional (ι (x*y)) = τ.functional (ι (y*x))
+    rw [map_mul ι x y, map_mul ι y x]
+    exact τ.tracial _ _
+
+end PullbackTrace
+
+section CompletionTraces
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [Nontrivial D] (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+instance CurrentMain.familyCauchyOrder : PartialOrder (familyCauchyAlgebra τ) :=
+  CStarAlgebra.spectralOrder _
+
+instance CurrentMain.familyCauchyStarOrdered : StarOrderedRing (familyCauchyAlgebra τ) :=
+  CStarAlgebra.spectralOrderedRing _
+
+def CurrentMain.cauchyTrace (i : I) : TracialState (familyCauchyAlgebra τ) :=
+  pullbackTrace (ultraTrace (fun _ : ℕ => τ i) (Ultrafilter.of atTop))
+    (familyCauchyAlgebra τ).subtype
+
+def CurrentMain.completionTrace (i : I) : TracialState (UniformTracialCompletion τ) :=
+  (familyCauchyNullIdeal τ).descendedTrace (cauchyTrace τ i) (fun u hu => by
+    apply TraceConstruction.null τ (Ultrafilter.of atTop) (fun _ => i) u.1
+    have he : u.1 ∈ familyNullTwoSided τ atTop ↔
+        IsFamilyNull τ atTop (fun n => u.1 n) := by
+      unfold familyNullTwoSided
+      exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u.1
+    have hn : IsFamilyNull τ atTop (fun n => u.1 n) := he.mp hu
+    exact hn.mono_left (Ultrafilter.of_le atTop))
+
+def CurrentMain.boundedFamilyConstant {X : Type} (a : D) : lp (fun _ : X => D) ∞ :=
+  ⟨fun _ => a, memℓp_infty_iff.mpr ⟨‖a‖,by rintro _ ⟨n,rfl⟩; exact le_rfl⟩⟩
+
+instance CurrentMain.completionNontrivial : Nontrivial (UniformTracialCompletion τ) := by
+  obtain ⟨i⟩ := ‹Nonempty I›
+  refine ⟨⟨1,0,?_⟩⟩
+  intro h
+  have he := congrArg (completionTrace τ i).functional h
+  rw [(completionTrace τ i).normalized, map_zero] at he
+  exact one_ne_zero he
+
+end CompletionTraces
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [Nontrivial D] (τ : I → TracialState D) [Nonempty I] (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.familyUltrapowerMap : D →⋆ₐ[ℂ] FamilyUltrapower τ U where
+  toFun a := (familyNullIdeal τ (U : Filter X)).quotientMap (boundedFamilyConstant a)
+  map_zero' := (familyNullIdeal τ (U : Filter X)).quotientMap.map_zero
+  map_one' := (familyNullIdeal τ (U : Filter X)).quotientMap.map_one
+  map_add' a b := (familyNullIdeal τ (U : Filter X)).quotientMap.map_add
+    (boundedFamilyConstant a) (boundedFamilyConstant b)
+  map_mul' a b := (familyNullIdeal τ (U : Filter X)).quotientMap.map_mul
+    (boundedFamilyConstant a) (boundedFamilyConstant b)
+  commutes' z := (familyNullIdeal τ (U : Filter X)).quotientMap.commutes z
+  map_star' _a := rfl
+
+end
+
+section
+
+open Filter Topology
+
+variable {A : Type uA} [NormedRing A]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def Pureness.TopologicallySimple (A : Type uA) [NormedRing A] : Prop :=
+  ∀ I : TwoSidedIdeal A, IsClosed (I : Set A) → I = ⊥ ∨ I = ⊤
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.StablyFinite (A : Type uA) [CStarAlgebra A] : Prop :=
+  ∀ n : ℕ, ∀ v : CStarMatrix (Fin n) (Fin n) A,
+    star v*v = 1 → v*star v = 1
+
+def CurrentMain.UniformPropertyGammaAt (A : Type) [CStarAlgebra A]
+    [PartialOrder A] [StarOrderedRing A] [Nontrivial A]
+    [Nonempty (TracialState A)] (U : Ultrafilter ℕ) : Prop :=
+  ∃ p : FamilyUltrapower (completionTrace (fun τ : TracialState A => τ)) U,
+    IsStarProjection p ∧ ∀ x : UniformTracialCompletion (fun τ : TracialState A => τ),
+      p * familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x =
+        familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x * p ∧
+      ∀ s : ℕ → TracialState A,
+        (familyLimitTrace (completionTrace (fun τ : TracialState A => τ)) U s).functional
+          (p * familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x) =
+        (1/2 : ℂ) *
+        (familyLimitTrace (completionTrace (fun τ : TracialState A => τ)) U s).functional
+          (familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x)
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+def CurrentMain.Statement : Prop := ∀
+    {A : Type} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+    [Nontrivial A] [TopologicalSpace.SeparableSpace A]
+    (_hsimple : TopologicallySimple A) (_hinf : ¬FiniteDimensional ℂ A)
+    (_hA : IsNuclear.{0, uNuclear} A) (_hfinite : StablyFinite A)
+    [Nonempty (TracialState A)] (U : Ultrafilter ℕ)
+    (_hfree : (U : Filter ℕ) ≤ atTop)
+    (_hRR : RealRankZero (FamilyUltrapower (completionTrace (fun τ : TracialState A => τ)) U)),
+    UniformPropertyGammaAt A U
+
+end
+
+def CurrentMain.MainClaim : Prop :=
+  ∃ h0 : ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction, letI := h0;
+  ∃ h1 : ComparatorModel.CurrentMain.NullConstruction, letI := h1;
+  ∃ h2 : ComparatorModel.CurrentMain.CauchyConstruction, letI := h2;
+  ∃ h3 : ComparatorModel.CurrentMain.LimitConstruction, letI := h3;
+  ∃ h4 : ComparatorModel.CurrentMain.TraceConstruction, letI := h4;
+  Statement.{uNuclear}
+
+theorem CurrentMain.main : MainClaim.{uNuclear} := by
+  sorry
+
+end ComparatorModel
+
+end
+
+end OAI

lean/ComparatorChallenges/UniformKServer.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformKServer",
+  "solution_module": "OAI.Combinatorics.UniformKServer.Main",
+  "theorem_names": [
+    "OAI.UniformKServer.uniform_squared_logarithmic_main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniformKServer.lean

@@ -0,0 +1,205 @@
+import Mathlib
+
+namespace OAI
+
+   
+
+                                                                               
+
+  
+namespace UniformKServer
+
+structure RationalMetric (n : ℕ) where
+  distance : Fin n → Fin n → ℚ
+  nonneg : ∀ x y, 0 ≤ distance x y
+  eq_zero : ∀ x y, distance x y = 0 ↔ x = y
+  symm : ∀ x y, distance x y = distance y x
+  triangle : ∀ x y z, distance x z ≤ distance x y + distance y z
+
+abbrev Configuration (n k : ℕ) := Fin k → Fin n
+abbrev History (n k : ℕ) := List (Fin n × Fin k)
+
+def serve {n k : ℕ} (s : Configuration n k) (r : Fin n) (j : Fin k) :
+    Configuration n k := Function.update s j r
+
+def costAlong {n k : ℕ} (d : RationalMetric n) :
+    Configuration n k → History n k → ℝ
+  | _, [] => 0
+  | s, (r, j) :: h => (d.distance (s j) r : ℝ) + costAlong d (serve s r j) h
+
+/-- All finite serving-label choices, knowing the entire request word. -/
+noncomputable def offlineCost {n k : ℕ} (d : RationalMetric n) (s : Configuration n k)
+    (w : List (Fin n)) : ℝ :=
+  sInf {c | ∃ h : History n k, h.map Prod.fst = w ∧ c = costAlong d s h}
+
+inductive HeadMove where
+  | left | stay | right
+  deriving DecidableEq
+
+structure BitTape where
+  left : List (Option Bool)
+  head : Option Bool
+  right : List (Option Bool)
+
+namespace BitTape
+
+def blank : BitTape := ⟨[], none, []⟩
+
+def ofWord (w : List Bool) : BitTape :=
+  match w with
+  | [] => blank
+  | b :: bs => ⟨[], some b, bs.map some⟩
+
+def shift (T : BitTape) : HeadMove → BitTape
+  | .stay => T
+  | .left => match T.left with
+    | [] => ⟨[], none, T.head :: T.right⟩
+    | a :: as => ⟨as, a, T.head :: T.right⟩
+  | .right => match T.right with
+    | [] => ⟨T.head :: T.left, none, []⟩
+    | a :: as => ⟨T.head :: T.left, a, as⟩
+
+end BitTape
+
+structure BitAction (q m : ℕ) where
+  control : Fin q
+  inputMove : HeadMove
+  write : Fin m → Option Bool
+  workMove : Fin m → HeadMove
+  emit : Option Bool
+  yield : Bool
+
+structure BitMachine where
+  controls : ℕ
+  tapes : ℕ
+  start : Fin controls
+  transition : Fin controls → Option Bool → (Fin tapes → Option Bool) →
+    Bool → BitAction controls tapes
+
+structure MachineState (M : BitMachine) where
+  control : Fin M.controls
+  input : BitTape
+  work : Fin M.tapes → BitTape
+  outputRev : List Bool
+  yielded : Bool
+
+namespace BitMachine
+
+def initial (M : BitMachine) (input : List Bool) : MachineState M :=
+  ⟨M.start, BitTape.ofWord input, fun _ => BitTape.blank, [], false⟩
+
+def step (M : BitMachine) (s : MachineState M) (coin : Bool) : MachineState M :=
+  if s.yielded then s else
+  let a := M.transition s.control s.input.head (fun i => (s.work i).head) coin
+  { control := a.control
+    input := s.input.shift a.inputMove
+    work := fun i => ({s.work i with head := a.write i}).shift (a.workMove i)
+    outputRev := match a.emit with
+      | none => s.outputRev
+      | some b => b :: s.outputRev
+    yielded := a.yield }
+
+def run (M : BitMachine) (s : MachineState M) (coins : List Bool) : MachineState M :=
+  coins.foldl M.step s
+
+/-- At a request boundary only the input/output interface is refreshed.
+    Work tapes and control retain the complete internal state. -/
+def install (M : BitMachine) (s : MachineState M) (input : List Bool) : MachineState M :=
+  {s with input := BitTape.ofWord input, outputRev := [], yielded := false}
+
+end BitMachine
+
+/-- Self-delimiting binary code: ℓ ones, a zero, then ℓ low-to-high bits.
+    This fixes one standard binary encoding rather than allowing a nonuniform
+    advice string to be included in the input. -/
+def natCode (a : ℕ) : List Bool :=
+  List.replicate a.bits.length true ++ [false] ++ a.bits
+
+def rationalCode (a : ℚ) : List Bool :=
+  (a.num < 0) :: (natCode a.num.natAbs ++ natCode a.den)
+
+def instanceCode {n k : ℕ} (d : RationalMetric n) (s : Configuration n k) : List Bool :=
+  natCode n ++ natCode k ++
+    (List.ofFn fun x : Fin n =>
+      (List.ofFn fun y : Fin n => rationalCode (d.distance x y)).flatten).flatten ++
+    (List.ofFn fun j : Fin k => natCode ((s j).val + 1)).flatten
+
+def bitValue : List Bool → ℕ
+  | [] => 0
+  | b :: bs => (if b then 1 else 0) + 2 * bitValue bs
+
+def outputValue {M : BitMachine} (s : MachineState M) : ℕ :=
+  bitValue s.outputRev.reverse
+
+/-- A dominating polynomial; every fixed polynomial nonnegative on natural
+    inputs is bounded by one of this form after increasing c and e. -/
+def polynomialBudget (c e x : ℕ) : ℕ := c * (x + 1)^e
+
+def requestBudget (c e L t : ℕ) : ℕ :=
+  polynomialBudget c e (L + Nat.clog 2 (t + 1))
+
+def boot {n k : ℕ} (M : BitMachine) (c e : ℕ)
+    (d : RationalMetric n) (s : Configuration n k) : MachineState M :=
+  M.run (M.initial (instanceCode d s))
+    (List.replicate (polynomialBudget c e (instanceCode d s).length) false)
+
+def requestStep {n : ℕ} (M : BitMachine) (c e L t : ℕ)
+    (s : MachineState M) (r : Fin n)
+    (coins : Fin (requestBudget c e L t) → Bool) : MachineState M :=
+  M.run (M.install s (natCode (r.val + 1))) (List.ofFn coins)
+
+/-- Reachability includes every binary choice, not merely an almost-sure set.
+    The index counts requests already served. -/
+inductive Reachable {n k : ℕ} (M : BitMachine) (c e : ℕ)
+    (d : RationalMetric n) (s : Configuration n k) : ℕ → MachineState M → Prop
+  | boot : Reachable M c e d s 0 (boot M c e d s)
+  | next {t z} : Reachable M c e d s t z → (r : Fin n) →
+      (bits : Fin (requestBudget c e (instanceCode d s).length (t+1)) → Bool) →
+      Reachable M c e d s (t+1)
+        (requestStep M c e (instanceCode d s).length (t+1) z r bits)
+
+/-- Modulo makes the semantic recursion total even for unsuccessful machines.
+    The main statement separately requires the output to be < k at *every*
+    reachable outcome, so no invalid output is accepted or silently repaired. -/
+def selectedLabel {M : BitMachine} {k : ℕ} (hk : 0 < k) (s : MachineState M) : Fin k :=
+  ⟨outputValue s % k, Nat.mod_lt _ hk⟩
+
+noncomputable def machineExpectedCost {n k : ℕ} (M : BitMachine) (c e L : ℕ)
+    (d : RationalMetric n) (hk : 0 < k) :
+    ℕ → MachineState M → Configuration n k → List (Fin n) → ℝ
+  | _, _, _, [] => 0
+  | t, z, s, r :: w =>
+      let B := requestBudget c e L (t+1)
+      (∑ bits : Fin B → Bool,
+        let z' := requestStep M c e L (t+1) z r bits
+        let j := selectedLabel hk z'
+        (d.distance (s j) r : ℝ) +
+          machineExpectedCost M c e L d hk (t+1) z' (serve s r j) w) / (2 : ℝ)^B
+
+/-- Full uniform main objective in the explicit bit model, not a theorem or
+    assumption. Machine transition steps are bit operations. Installing the
+    standard input and reading/erasing the output adds only O(L + budget)
+    charged bit operations, hence is absorbed by a single larger polynomial.
+    A single deterministic boot is sufficient for the source construction. -/
+def UniformAlgorithmClaim : Prop :=
+  ∃ (M : BitMachine) (c e : ℕ) (C : ℝ), 0 < c ∧ 0 < C ∧
+    ∀ (n k : ℕ) (hn : 3 ≤ n) (hk : 2 ≤ k) (hkn : k < n)
+      (d : RationalMetric n) (s : Configuration n k),
+      let L := (instanceCode d s).length
+      (boot M c e d s).yielded = true ∧
+      (∀ (t : ℕ) (z : MachineState M), Reachable M c e d s t z →
+        ∀ (r : Fin n) (bits : Fin (requestBudget c e L (t+1)) → Bool),
+          let z' := requestStep M c e L (t+1) z r bits
+          z'.yielded = true ∧ outputValue z' < k) ∧
+      (∃ B : ℝ, 0 ≤ B ∧ ∀ w : List (Fin n),
+        machineExpectedCost M c e L d (by omega) 0 (boot M c e d s) s w ≤
+          C * (Real.log (k + 1))^2 * offlineCost d s w + B)
+
+/-- A single uniform randomized bit machine has squared-logarithmic expected movement
+and a uniform polynomial bound on each request's bit operations. -/
+theorem uniform_squared_logarithmic_main : UniformAlgorithmClaim := by
+  sorry
+
+end UniformKServer
+
+end OAI

lean/ComparatorChallenges/UniformSparsestCut.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformSparsestCut",
+  "solution_module": "OAI.Combinatorics.SparsestCut.Main",
+  "theorem_names": [
+    "OAI.UniformSparsestCut.mainGap"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniformSparsestCut.lean

@@ -0,0 +1,55 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators
+
+namespace UniformSparsestCut
+
+structure Capacity (n : ℕ) where
+  cap : Fin n → Fin n → ℝ
+  nonneg : ∀ i j, 0 ≤ cap i j
+  symm : ∀ i j, cap i j = cap j i
+  diagonal : ∀ i, cap i i = 0
+
+def pairSum {n : ℕ} (f : Fin n → Fin n → ℝ) : ℝ :=
+  ∑ i, ∑ j, if i < j then f i j else 0
+
+noncomputable def cutRatio {n : ℕ} (C : Capacity n) (B : Finset (Fin n)) : ℝ :=
+  (∑ i ∈ B, ∑ j ∈ Bᶜ, C.cap i j) /
+    ((B.card : ℝ) * ((n : ℝ) - (B.card : ℝ)))
+
+noncomputable def OPT {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ B : Finset (Fin n), B.Nonempty ∧ B ≠ Finset.univ ∧ r = cutRatio C B}
+
+def NegativeType {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  (∃ x : Fin n → EuclideanSpace ℝ (Fin n), ∀ i j, d i j = ‖x i - x j‖ ^ 2) ∧
+  ∀ i j k, d i k ≤ d i j + d j k
+
+def Feasible {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  NegativeType d ∧ pairSum d = 1
+
+noncomputable def glValue {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ d : Fin n → Fin n → ℝ, Feasible d ∧
+    r = pairSum (fun i j => C.cap i j * d i j)}
+
+open Filter
+
+theorem mainGap :
+    ∃ c : ℝ, 0 < c ∧
+      ∃ n : ℕ → ℕ, ∃ C : (j : ℕ) → Capacity (n j),
+        (∀ j, 2 ≤ n j) ∧
+        Tendsto n atTop atTop ∧
+        (∀ j, 0 < glValue (C j)) ∧
+        ∀ᶠ j in atTop,
+          c * Real.sqrt (Real.log (n j : ℝ)) / (Real.log (Real.log (n j : ℝ))) ^ 3 ≤
+            OPT (C j) / glValue (C j) := by
+  sorry
+
+end UniformSparsestCut
+
+end
+
+end OAI

lean/ComparatorChallenges/UniqueGamesTheorem.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniqueGamesTheorem",
+  "solution_module": "OAI.Computability.UniqueGames.Main",
+  "theorem_names": [
+    "OAI.UniqueGamesTheorem.theorem11"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniqueGamesTheorem.lean

@@ -0,0 +1,239 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniqueGamesTheorem.Foundations.Target
+
+/-- Finite forward and inverse tables make totality and invertibility explicit.
+An eventual external encoding only needs to serialize the forward table. -/
+structure PermutationTable (alphabet : Nat) where
+  images : Vector (Fin alphabet) alphabet
+  inverseImages : Vector (Fin alphabet) alphabet
+  leftInverse : ∀ label : Fin alphabet, inverseImages[images[label]] = label
+  rightInverse : ∀ label : Fin alphabet, images[inverseImages[label]] = label
+
+structure Constraint (vertices alphabet : Nat) where
+  source : Fin vertices
+  target : Fin vertices
+  permutation : PermutationTable alphabet
+
+def Constraint.satisfied {n q : Nat} (constraint : Constraint n q)
+    (labeling : Fin n → Fin q) : Bool :=
+  decide (constraint.permutation.images[labeling constraint.source] = labeling constraint.target)
+
+/-- Constraint occurrences are list entries, so repeated parallel edges retain
+their multiplicity. No weights are hidden in this representation. -/
+structure Instance (alphabet : Nat) where
+  vertices : Nat
+  constraints : List (Constraint vertices alphabet)
+  nonempty : constraints ≠ []
+
+def countSatisfied {n q : Nat} (labeling : Fin n → Fin q) :
+    List (Constraint n q) → Nat
+  | [] => 0
+  | constraint :: rest =>
+      (if constraint.satisfied labeling then 1 else 0) + countSatisfied labeling rest
+
+end UniqueGamesTheorem.Foundations.Target
+
+namespace UniqueGamesTheorem.BinaryFormula
+
+open UniqueGamesTheorem.Foundations
+
+structure Literal where
+  name : Nat
+  positive : Bool
+  deriving DecidableEq
+
+def Literal.eval (literal : Literal) (assignment : Nat → Bool) : Bool :=
+  if literal.positive then assignment literal.name else !(assignment literal.name)
+
+abbrev Clause := Vector Literal 3
+
+def Clause.eval (clause : Clause) (assignment : Nat → Bool) : Bool :=
+  (clause[0].eval assignment || clause[1].eval assignment) || clause[2].eval assignment
+
+/-- An ordinary conjunction of three-slot clauses with sparse variable names.
+Repeated names and repeated literals are permitted in every clause. -/
+structure Formula where
+  clauses : List Clause
+
+def Formula.Satisfiable (F : Formula) : Prop :=
+  ∃ assignment : Nat → Bool, ∀ clause ∈ F.clauses, clause.eval assignment = true
+
+end UniqueGamesTheorem.BinaryFormula
+
+namespace UniqueGamesTheorem.BinaryEncoding
+
+open BinaryFormula
+
+def bitsValue : List Bool → Nat
+  | [] => 0
+  | b :: bits => Nat.bit b (bitsValue bits)
+
+def parseFrame : List Bool → Option (List Bool × List Bool)
+  | false :: rest => some ([], rest)
+  | true :: b :: rest => do
+      let (bits, trailing) ← parseFrame rest
+      return (b :: bits, trailing)
+  | _ => none
+
+/-- Equality with the canonical digits rejects alternate padded encodings. -/
+def parseName (input : List Bool) : Option (Nat × List Bool) := do
+  let (digits, rest) ← parseFrame input
+  let name := bitsValue digits
+  if digits = name.bits then some (name, rest) else none
+
+def parseLiteral : List Bool → Option (Literal × List Bool)
+  | sign :: input => do
+      let (name, rest) ← parseName input
+      return (⟨name, sign⟩, rest)
+  | [] => none
+
+def parseClause (input : List Bool) : Option (Clause × List Bool) := do
+  let (a, input) ← parseLiteral input
+  let (b, input) ← parseLiteral input
+  let (c, rest) ← parseLiteral input
+  return (#v[a, b, c], rest)
+
+/-- Fuel bounds the number of clause iterations, not the size of any name. -/
+def parseClauses : Nat → List Bool → Option (List Clause × List Bool)
+  | 0, _ => none
+  | _ + 1, false :: rest => some ([], rest)
+  | fuel + 1, true :: input => do
+      let (clause, input) ← parseClause input
+      let (clauses, rest) ← parseClauses fuel input
+      return (clause :: clauses, rest)
+  | _ + 1, [] => none
+
+def decodeFormula (input : List Bool) : Option Formula := do
+  let (clauses, rest) ← parseClauses (input.length + 1) input
+  if rest = [] then some ⟨clauses⟩ else none
+
+end UniqueGamesTheorem.BinaryEncoding
+
+namespace UniqueGamesTheorem.BinaryLanguage
+
+open UniqueGamesTheorem.Foundations
+
+def language (input : List Bool) : Prop :=
+  ∃ formula, BinaryEncoding.decodeFormula input = some formula ∧ formula.Satisfiable
+
+end UniqueGamesTheorem.BinaryLanguage
+
+namespace UniqueGamesTheorem.Integration.BinaryLinear
+
+abbrev F2 := ZMod 2
+
+abbrev Vector (n : Nat) := Fin n → F2
+
+end UniqueGamesTheorem.Integration.BinaryLinear
+
+namespace UniqueGamesTheorem.Integration.TranslationTarget
+
+open UniqueGamesTheorem.Foundations
+open Target
+
+def IsTranslationInstance {q s : Nat} (coordinates : Fin q ≃ BinaryLinear.Vector s)
+    (g : Instance q) : Prop :=
+  ∀ constraint ∈ g.constraints, ∃ shift : BinaryLinear.Vector s,
+    ∀ label : Fin q,
+      coordinates (constraint.permutation.images[label]) = coordinates label + shift
+
+end UniqueGamesTheorem.Integration.TranslationTarget
+
+namespace UniqueGamesTheorem.Foundations.Complexity
+
+def encodeWord (n : Nat) : List Bool := List.replicate n true ++ [false]
+
+def encodeWords : List Nat → List Bool
+  | [] => []
+  | n :: ns => encodeWord n ++ encodeWords ns
+
+end UniqueGamesTheorem.Foundations.Complexity
+
+namespace UniqueGamesTheorem.Foundations.Complexity
+
+open Target
+
+def tableWords {q : Nat} (table : PermutationTable q) : List Nat :=
+  table.images.toList.map Fin.val
+
+def constraintWords {n q : Nat} (constraint : Constraint n q) : List Nat :=
+  [constraint.source.val, constraint.target.val] ++ tableWords constraint.permutation
+
+def gameWords {q : Nat} (game : Instance q) : List Nat :=
+  [game.vertices, q, game.constraints.length] ++ game.constraints.flatMap constraintWords
+
+def gameBits {q : Nat} (game : Instance q) : List Bool := encodeWords (gameWords game)
+
+end UniqueGamesTheorem.Foundations.Complexity
+
+namespace UniqueGamesTheorem.Foundations.Complexity.MachineFiniteAlphabet
+
+open Turing
+
+/-- Every physical tape has a finite alphabet. Together with `M.kFin`, this
+also makes the disjoint union of all physical tape alphabets finite. -/
+def FiniteAlphabet (M : FinTM2) : Prop := ∀ k, Finite (M.Γ k)
+
+end UniqueGamesTheorem.Foundations.Complexity.MachineFiniteAlphabet
+
+namespace UniqueGamesTheorem.Explicit.MachineOutputContract
+
+open UniqueGamesTheorem.Foundations
+open Target
+open scoped BigOperators
+
+/-- A canonical orientation from the false side to the true side. Injectivity
+is on occurrence indices, so two distinct list entries cannot be parallel even
+when their constraint tables are different. -/
+structure SimpleBipartite {q : Nat} (game : Instance q) where
+  side : Fin game.vertices → Bool
+  sourceSide : ∀ i : Fin game.constraints.length,
+    side game.constraints[i].source = false
+  targetSide : ∀ i : Fin game.constraints.length,
+    side game.constraints[i].target = true
+  endpoints_injective : Function.Injective (fun i : Fin game.constraints.length =>
+    (game.constraints[i].source, game.constraints[i].target))
+
+/-- Every parameter, coordinate identification, program, and polynomial is
+fixed before the input quantifier. The identity input encoding measures runtime
+in the original raw bit length, including sparse binary variable names. -/
+structure BinaryGapReduction (ε δ : ℝ) where
+  alphabet : Nat
+  alphabetAtLeastTwo : 2 ≤ alphabet
+  dimension : Nat
+  dimensionPositive : 1 ≤ dimension
+  coordinates : Fin alphabet ≃ Integration.BinaryLinear.Vector dimension
+  construct : List Bool → Instance alphabet
+  simpleBipartite : ∀ input, SimpleBipartite (construct input)
+  translations : ∀ input,
+    Integration.TranslationTarget.IsTranslationInstance coordinates (construct input)
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    Complexity.gameBits construct
+  finiteAlphabet : Complexity.MachineFiniteAlphabet.FiniteAlphabet computation.tm
+  completeness : ∀ input, BinaryLanguage.language input →
+    ∃ labeling, 1 - ε ≤
+      (countSatisfied labeling (construct input).constraints : ℝ) /
+        (construct input).constraints.length
+  soundness : ∀ input, ¬BinaryLanguage.language input →
+    ∀ labeling, (countSatisfied labeling (construct input).constraints : ℝ) /
+      (construct input).constraints.length ≤ δ
+
+end UniqueGamesTheorem.Explicit.MachineOutputContract
+
+namespace UniqueGamesTheorem
+
+/-- For every fixed pair of errors in `(0, 1/2)`, binary 3SAT reduces in
+polynomial time to translation Unique Games with completeness at least `1 - ε`
+and soundness at most `δ`. The alphabet and machine depend only on the errors. -/
+theorem theorem11 (ε δ : ℝ)
+    (hε : 0 < ε) (hεhalf : ε < 1 / 2)
+    (hδ : 0 < δ) (hδhalf : δ < 1 / 2) :
+    Nonempty (Explicit.MachineOutputContract.BinaryGapReduction ε δ) := by
+  sorry
+
+end UniqueGamesTheorem
+
+end OAI

lean/ComparatorChallenges/UniversalFInfinity.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniversalFInfinity",
+  "solution_module": "OAI.GroupTheory.UniversalGroup.Main",
+  "theorem_names": [
+    "OAI.UniversalFInfinity.universal_group_of_type_FInfinity"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/UniversalFInfinity.lean

@@ -0,0 +1,25 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniversalFInfinity
+universe u
+
+def HasTypeFInfinity (G : Type u) [Group G] : Prop :=
+  ∃ (X : Type u) (_ : TopologicalSpace X) (_ : T2Space X)
+    (_ : ConnectedSpace X) (cw : Topology.CWComplex (Set.univ : Set X)),
+    (∀ n : ℕ, Finite (cw.cell n)) ∧
+    (∃ x : X, Nonempty (FundamentalGroup X x ≃* G)) ∧
+    ∃ (E : Type u) (_ : TopologicalSpace E) (_ : ContractibleSpace E)
+      (p : E → X), Function.Surjective p ∧ IsCoveringMap p
+
+theorem universal_group_of_type_FInfinity :
+    ∃ (H : Type u) (groupH : Group H),
+      @HasTypeFInfinity H groupH ∧
+      ∀ (G : Type u) [Group G] [Group.IsFinitelyPresented G],
+        ∃ φ : G →* H, Function.Injective φ := by
+  sorry
+
+end UniversalFInfinity
+
+end OAI

lean/ComparatorChallenges/UniversalTensorSquares.json

@@ -0,0 +1,13 @@
+{
+  "challenge_module": "ComparatorChallenges.UniversalTensorSquares",
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "solution_module": "OAI.RepresentationTheory.UniversalSquare.Main",
+  "theorem_names": [
+    "OAI.UniversalTensorSquares.universal_tensor_square"
+  ]
+}

lean/ComparatorChallenges/UniversalTensorSquares.lean

@@ -0,0 +1,110 @@
+import Mathlib
+
+namespace OAI
+
+/-! Universal tensor squares of irreducible complex symmetric-group representations. -/
+
+noncomputable section
+
+open scoped TensorProduct
+
+universe uG uV
+
+namespace Saxl
+
+abbrev WordSpace (n d : ℕ) := (Fin n → Fin d) → ℂ
+
+def wordRep (n d : ℕ) : Representation ℂ (Equiv.Perm (Fin n)) (WordSpace n d) where
+  toFun g :=
+    { toFun := fun f a => f (a ∘ g)
+      map_add' := by intros; rfl
+      map_smul' := by intros; rfl }
+  map_one' := by ext f a; rfl
+  map_mul' g h := by ext f a; rfl
+
+def cyclic {G : Type uG} {V : Type uV} [Group G] [AddCommGroup V] [Module ℂ V]
+    (ρ : Representation ℂ G V) (v : V) : Subrepresentation ρ where
+  toSubmodule := Submodule.span ℂ (Set.range fun g : G => ρ g v)
+  apply_mem_toSubmodule g := by
+    intro x hx
+    induction hx using Submodule.span_induction with
+    | mem x hx =>
+      obtain ⟨h, rfl⟩ := hx
+      apply Submodule.subset_span
+      exact ⟨g * h, by simp only [map_mul, Module.End.mul_apply]⟩
+    | zero => simp
+    | add x y hx hy ihx ihy =>
+      simpa only [map_add] using Submodule.add_mem _ ihx ihy
+    | smul a x hx ih =>
+      simpa only [map_smul] using Submodule.smul_mem _ a ih
+
+abbrev Tableau (n : ℕ) (μ : YoungDiagram) := Fin n ≃ μ.cells
+
+def canonicalTableau {n : ℕ} (μ : YoungDiagram) (hn : μ.card = n) : Tableau n μ :=
+  (Fintype.equivFinOfCardEq (by simpa using hn)).symm
+
+def rowWord {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) : Fin n → Fin (μ.colLen 0) :=
+  fun i => ⟨(t i).val.1, YoungDiagram.mem_iff_lt_colLen.mp
+    (μ.up_left_mem le_rfl (Nat.zero_le _) (t i).property)⟩
+
+def columnGroup {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    Subgroup (Equiv.Perm (Fin n)) where
+  carrier := {g | ∀ i, (t (g i)).val.2 = (t i).val.2}
+  one_mem' := by intro i; rfl
+  mul_mem' := by
+    intro g h hg hh i
+    exact (hg (h i)).trans (hh i)
+  inv_mem' := by
+    intro g hg i
+    have h := hg (g⁻¹ i)
+    simpa using h.symm
+
+def polytabloid {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    WordSpace n (μ.colLen 0) := by
+  classical
+  letI := Fintype.ofFinite (columnGroup t)
+  exact ∑ g : columnGroup t,
+    (((Equiv.Perm.sign (g : Equiv.Perm (Fin n))) : ℤ) : ℂ) •
+      wordRep n (μ.colLen 0) (g : Equiv.Perm (Fin n)) (Pi.single (rowWord t) 1)
+
+def spechtSub {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :=
+  cyclic (wordRep n (μ.colLen 0)) (polytabloid t)
+
+abbrev Specht {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :=
+  (spechtSub t).toSubmodule
+
+def spechtRep {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    Representation ℂ (Equiv.Perm (Fin n)) (Specht t) :=
+  (spechtSub t).toRepresentation
+
+def kronecker {n : ℕ} {α β μ : YoungDiagram}
+    (a : Tableau n α) (b : Tableau n β) (t : Tableau n μ) : ℕ :=
+  Module.finrank ℂ (Representation.IntertwiningMap (spechtRep t)
+    ((spechtRep a).tprod (spechtRep b)))
+
+end Saxl
+
+namespace UniversalTensorSquares
+
+universe u
+
+theorem universal_tensor_square
+    (n : ℕ) (hn : 0 < n) (h2 : n ≠ 2) (h4 : n ≠ 4) (h9 : n ≠ 9) :
+    ∃ (lam : YoungDiagram) (hlam : lam.card = n),
+      (∀ (ν : YoungDiagram) (hν : ν.card = n),
+        0 < Saxl.kronecker (Saxl.canonicalTableau lam hlam)
+          (Saxl.canonicalTableau lam hlam) (Saxl.canonicalTableau ν hν)) ∧
+      Representation.IsIrreducible (Saxl.spechtRep (Saxl.canonicalTableau lam hlam)) ∧
+      ∀ (V : Type u) [AddCommGroup V] [Module ℂ V] [Module.Finite ℂ V]
+        (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) [Representation.IsIrreducible ρ],
+        ∃ F : Representation.IntertwiningMap ρ
+          ((Saxl.spechtRep (Saxl.canonicalTableau lam hlam)).tprod
+            (Saxl.spechtRep (Saxl.canonicalTableau lam hlam))),
+          Function.Injective F := by
+  sorry
+
+end UniversalTensorSquares
+
+end
+
+end OAI

lean/ComparatorChallenges/VariableWL.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VariableWL",
+  "solution_module": "OAI.Combinatorics.VariableWL.Completeness",
+  "theorem_names": [
+    "OAI.VariableWL.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/VariableWL.lean

@@ -0,0 +1,130 @@
+import Mathlib
+
+namespace OAI
+
+namespace VariableWL
+
+abbrev Word := List Bool
+
+inductive Motion where
+  | left | stay | right
+  deriving DecidableEq
+
+def Motion.displacement : Motion → ℤ
+  | .left => -1
+  | .stay => 0
+  | .right => 1
+
+structure Machine where
+  states : ℕ
+  workSymbols : ℕ
+  extraTapes : ℕ
+  transition : Fin (states + 1) →
+    (Fin (extraTapes + 1) → Fin (workSymbols + 3)) →
+    Option (Fin (states + 1) ×
+      (Fin (extraTapes + 1) → Fin (workSymbols + 3) × Motion))
+
+structure Configuration (M : Machine) where
+  control : Fin (M.states + 1)
+  heads : Fin (M.extraTapes + 1) → ℤ
+  cells : Fin (M.extraTapes + 1) → ℤ → Fin (M.workSymbols + 3)
+
+def wordCells (a : ℕ) (w : Word) (i : ℤ) : Fin (a + 3) :=
+  if 0 ≤ i then
+    match w[i.toNat]? with
+    | none => 0
+    | some false => 1
+    | some true => 2
+  else 0
+
+def initial (M : Machine) (w : Word) : Configuration M where
+  control := 0
+  heads := fun _ => 0
+  cells := fun j => if j = 0 then wordCells M.workSymbols w else fun _ => 0
+
+def scanned {M : Machine} (c : Configuration M) :
+    Fin (M.extraTapes + 1) → Fin (M.workSymbols + 3) :=
+  fun j => c.cells j (c.heads j)
+
+def step (M : Machine) (c : Configuration M) : Option (Configuration M) :=
+  (M.transition c.control (scanned c)).map fun data =>
+    { control := data.1
+      heads := fun j => c.heads j + (data.2 j).2.displacement
+      cells := fun j i => if i = c.heads j then (data.2 j).1 else c.cells j i }
+
+def run (M : Machine) (w : Word) : ℕ → Configuration M
+  | 0 => initial M w
+  | n + 1 => (step M (run M w n)).getD (run M w n)
+
+def OutputsWithin (M : Machine) (w out : Word) (bound : ℕ) : Prop :=
+  ∃ t ≤ bound, step M (run M w t) = none ∧
+    (run M w t).cells 0 = wordCells M.workSymbols out
+
+abbrev Language := Set Word
+
+def InEXPTIME (L : Language) : Prop :=
+  ∃ M : Machine, ∃ c d : ℕ, ∀ w : Word,
+    ∃ b : Bool, (b = true ↔ w ∈ L) ∧
+      OutputsWithin M w [b] (2 ^ (c * (w.length + 1) ^ d))
+
+def PolytimeReduces (L R : Language) : Prop :=
+  ∃ M : Machine, ∃ c d : ℕ, ∀ w : Word,
+    ∃ out : Word, OutputsWithin M w out (c * (w.length + 1) ^ d) ∧
+      (w ∈ L ↔ out ∈ R)
+
+def EXPTIMEComplete (L : Language) : Prop :=
+  InEXPTIME L ∧ ∀ R : Language, InEXPTIME R → PolytimeReduces R L
+
+structure Graph where
+  order : ℕ
+  graph : SimpleGraph (Fin order)
+
+abbrev Tuple (G : Graph) (k : ℕ) := Fin k → Fin G.order
+
+def Color (k : ℕ) : ℕ → Type
+  | 0 => Fin k → Fin k → Bool × Bool
+  | s + 1 => Color k s × Multiset (Fin k → Color k s)
+
+noncomputable def color (G : Graph) (k : ℕ) : (s : ℕ) → Tuple G k → Color k s
+  | 0, v => by
+      classical
+      exact fun i j => (decide (v i = v j), decide (G.graph.Adj (v i) (v j)))
+  | s + 1, v => (color G k s v,
+      Finset.univ.val.map (fun z => fun i => color G k s (Function.update v i z)))
+
+noncomputable def histogram (G : Graph) (k s : ℕ) : Multiset (Color k s) :=
+  Finset.univ.val.map (color G k s)
+
+def Equivalent (G H : Graph) (k : ℕ) : Prop :=
+  ∀ s : ℕ, histogram G k s = histogram H k s
+
+def integerCode (n : ℕ) : Word :=
+  List.replicate (Nat.bits n).length true ++ [false] ++ Nat.bits n
+
+noncomputable def graphCode (G : Graph) : Word := by
+  classical
+  exact integerCode G.order ++
+    (List.ofFn fun i : Fin G.order =>
+      List.ofFn fun j : Fin G.order => decide (G.graph.Adj i j)).flatten
+
+noncomputable def pairCode (G H : Graph) (k : ℕ) : Word :=
+  graphCode G ++ graphCode H ++ integerCode k
+
+def WL : Language :=
+  { w | ∃ G H : Graph, ∃ k : ℕ, w = pairCode G H k ∧ 2 ≤ k ∧ Equivalent G H k }
+
+noncomputable def Subcubic (G : Graph) : Prop := by
+  classical
+  exact ∀ v : Fin G.order, G.graph.degree v ≤ 3
+
+def SubWL : Language :=
+  { w | ∃ G H : Graph, ∃ k : ℕ, w = pairCode G H k ∧ 2 ≤ k ∧
+    0 < G.order ∧ G.order = H.order ∧ G.graph.Connected ∧ H.graph.Connected ∧
+    Subcubic G ∧ Subcubic H ∧ Equivalent G H k }
+
+theorem main : EXPTIMEComplete WL ∧ EXPTIMEComplete SubWL := by
+  sorry
+
+end VariableWL
+
+end OAI

lean/ComparatorChallenges/VelocityHemisphere.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VelocityHemisphere",
+  "solution_module": "OAI.Probability.Ballisticity.VelocityHemisphere",
+  "theorem_names": [
+    "OAI.DirectionalTransience.positive_probability_transience_velocity_hemisphere"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/VelocityHemisphere.lean

@@ -0,0 +1,102 @@
+import Mathlib
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Filter
+open scoped ENNReal NNReal BigOperators Topology
+
+namespace DirectionalTransience
+
+abbrev Lattice (d : ℕ) := Fin d → ℤ
+abbrev Direction (d : ℕ) := Fin d × Bool
+abbrev Vector (d : ℕ) := Fin d → ℝ
+abbrev Row (d : ℕ) := {p : Direction d → ℝ≥0 // ∑ e, p e = 1}
+abbrev Environment (d : ℕ) := Lattice d → Row d
+abbrev State (d : ℕ) := Environment d × Lattice d
+abbrev Path (d : ℕ) := ℕ → Lattice d
+
+def step {d : ℕ} (e : Direction d) : Lattice d :=
+  fun i => if i = e.1 then (if e.2 then 1 else -1) else 0
+
+noncomputable def environmentLaw {d : ℕ} (ν : Measure (Row d)) :
+    Measure (Environment d) := Measure.infinitePi (fun _ => ν)
+
+def UniformElliptic {d : ℕ} (ν : Measure (Row d)) : Prop :=
+  ∃ κ : ℝ≥0, 0 < κ ∧ ∀ᵐ p ∂ν, ∀ e, κ ≤ p.1 e
+
+lemma measurable_current_row {d : ℕ} :
+    Measurable (fun z : State d => z.1 z.2) := by
+  apply measurable_from_prod_countable_left
+  intro x
+  exact measurable_pi_apply x
+
+noncomputable def transition {d : ℕ} : Kernel (State d) (State d) where
+  toFun z := ∑ e : Direction d,
+    ((z.1 z.2).1 e : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step e)
+  measurable' := by
+    apply Measure.measurable_of_measurable_coe
+    intro s hs
+    simp only [Measure.finsetSum_apply, Measure.smul_apply, smul_eq_mul]
+    apply Finset.measurable_fun_sum
+    intro e _
+    apply Measurable.mul
+    · exact (measurable_pi_apply e |>.comp
+        (measurable_subtype_coe.comp measurable_current_row)).coe_nnreal_ennreal
+    · exact (Measure.measurable_coe hs).comp
+        (Measure.measurable_dirac.comp (measurable_fst.prodMk
+          (measurable_snd.add_const (step e))))
+
+instance transition_markov {d : ℕ} : IsMarkovKernel (transition (d := d)) where
+  isProbabilityMeasure z := by
+    constructor
+    change (∑ e : Direction d,
+      ((z.1 z.2).1 e : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step e)) Set.univ = 1
+    simp only [Measure.finsetSum_apply, Measure.smul_apply, Measure.dirac_apply_of_mem
+      (Set.mem_univ _), smul_eq_mul, mul_one]
+    rw [← ENNReal.ofNNReal_finsetSum, (z.1 z.2).2]
+    rfl
+
+noncomputable def historyTransition {d : ℕ} (n : ℕ) :
+    Kernel ((i : Finset.Iic n) → State d) (State d) where
+  toFun z := transition (z ⟨n, Finset.mem_Iic.mpr le_rfl⟩)
+  measurable' := transition.measurable.comp (measurable_pi_apply _)
+
+instance historyTransition_markov {d : ℕ} (n : ℕ) :
+    IsMarkovKernel (historyTransition (d := d) n) where
+  isProbabilityMeasure _ := transition_markov.isProbabilityMeasure _
+
+noncomputable def initialLaw {d : ℕ} (ν : Measure (Row d)) : Measure (State d) :=
+  (environmentLaw ν).map (fun ω => (ω, (0 : Lattice d)))
+
+noncomputable def annealedLaw {d : ℕ} (ν : Measure (Row d)) : Measure (Path d) :=
+  (@Kernel.trajMeasure (fun _ => State d) _ (initialLaw ν) (historyTransition (d := d)) _).map
+    (fun z n => (z n).2)
+
+def dot {d : ℕ} (v ℓ : Vector d) : ℝ := ∑ i, v i * ℓ i
+
+def realPosition {d : ℕ} (x : Lattice d) : Vector d := fun i => (x i : ℝ)
+
+def TransientPaths {d : ℕ} (ℓ : Vector d) : Set (Path d) :=
+  {X | Tendsto (fun n => dot (realPosition (X n)) ℓ) atTop atTop}
+
+def VelocityPaths {d : ℕ} (v : Vector d) : Set (Path d) :=
+  {X | Tendsto (fun n : ℕ => fun i => (X n i:ℝ)/(n:ℝ)) atTop (𝓝 v)}
+
+theorem positive_probability_transience_velocity_hemisphere
+    {d : ℕ} (hd : 3 ≤ d) (ν : Measure (Row d)) [IsProbabilityMeasure ν]
+    (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : ℓ ≠ 0)
+    (hpos : 0 < annealedLaw ν (TransientPaths ℓ)) :
+    ∃ v : Vector d,
+      v ≠ 0 ∧ 0 < dot v ℓ ∧ annealedLaw ν (VelocityPaths v) = 1 ∧
+      (∀ w : Vector d, annealedLaw ν (VelocityPaths w) = 1 → w = v) ∧
+      {u : Vector d | dot u u = 1 ∧ annealedLaw ν (TransientPaths u) = 1} =
+        {u : Vector d | dot u u = 1 ∧ 0 < annealedLaw ν (TransientPaths u)} ∧
+      {u : Vector d | dot u u = 1 ∧ 0 < annealedLaw ν (TransientPaths u)} =
+        {u : Vector d | dot u u = 1 ∧ 0 < dot v u} ∧
+      (∀ u : Vector d, dot u u = 1 → dot v u ≤ 0 →
+        annealedLaw ν (TransientPaths u) = 0) := by
+  sorry
+
+end DirectionalTransience
+
+end OAI

lean/ComparatorChallenges/VertexAlgebraNet.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VertexAlgebraNet",
+  "solution_module": "OAI.RepresentationTheory.VertexAlgebra.MinimalComparator",
+  "theorem_names": [
+    "OAI.MinimalVertex.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/VertexAlgebraNet.lean

@@ -0,0 +1,830 @@
+import Mathlib
+
+/-! The strongly rational unitary vertex operator algebra main result, clause (1). -/
+
+noncomputable section
+universe u v w
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+noncomputable abbrev StateField (V : Type u) (W : Type v)
+    [AddCommGroup V] [Module ℂ V] [AddCommGroup W] [Module ℂ W] :=
+  V →ₗ[ℂ] VertexOperator ℂ W
+
+noncomputable def mode {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (Y : OAI.StronglyRationalVOA.StateField V W) (a : V) (n : ℤ) : Module.End ℂ W :=
+  VertexOperator.ncoeff (Y a) n
+
+noncomputable def JacobiIdentity (Y : OAI.StronglyRationalVOA.StateField V V) : Prop :=
+  ∀ (a b c : V) (m n k : ℤ),
+    (∑ᶠ j : ℕ, Ring.choose (m : ℂ) j •
+      OAI.StronglyRationalVOA.mode Y (OAI.StronglyRationalVOA.mode Y a (n + j) b) (m + k - j) c) =
+    ∑ᶠ j : ℕ, ((-1 : ℂ) ^ j * Ring.choose (n : ℂ) j) •
+      (OAI.StronglyRationalVOA.mode Y a (m + n - j) (OAI.StronglyRationalVOA.mode Y b (k + j) c) -
+        (-1 : ℂ) ^ n • OAI.StronglyRationalVOA.mode Y b (n + k - j) (OAI.StronglyRationalVOA.mode Y a (m + j) c))
+
+structure VertexAlgebra (V : Type u) [AddCommGroup V] [Module ℂ V] where
+  vacuum : V
+  fields : OAI.StronglyRationalVOA.StateField V V
+  vacuum_mode : ∀ (n : ℤ), OAI.StronglyRationalVOA.mode fields vacuum n = if n = -1 then 1 else 0
+  creation : ∀ a : V, OAI.StronglyRationalVOA.mode fields a (-1) vacuum = a
+  creation_truncation : ∀ (a : V) (n : ℤ), 0 ≤ n → OAI.StronglyRationalVOA.mode fields a n vacuum = 0
+  jacobi : OAI.StronglyRationalVOA.JacobiIdentity fields
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.VertexAlgebra
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable (A : VertexAlgebra V)
+
+noncomputable def translation : Module.End ℂ V where
+  toFun a := OAI.StronglyRationalVOA.mode A.fields a (-2) A.vacuum
+  map_add' a b := by simp [OAI.StronglyRationalVOA.mode]
+  map_smul' z a := by simp [OAI.StronglyRationalVOA.mode]
+
+noncomputable def c2 : Submodule ℂ V :=
+  Submodule.span ℂ {x | ∃ a b : V, x = OAI.StronglyRationalVOA.mode A.fields a (-2) b}
+
+noncomputable def C2Cofinite : Prop := FiniteDimensional ℂ (V ⧸ A.c2)
+
+noncomputable def IsIdeal (I : Submodule ℂ V) : Prop :=
+  (∀ a : V, ∀ n : ℤ, ∀ x ∈ I, OAI.StronglyRationalVOA.mode A.fields a n x ∈ I) ∧
+  ∀ x ∈ I, A.translation x ∈ I
+
+noncomputable def IsSimple : Prop :=
+  A.vacuum ≠ 0 ∧ ∀ I : Submodule ℂ V, A.IsIdeal I → I = ⊥ ∨ I = ⊤
+
+end OAI.StronglyRationalVOA.VertexAlgebra
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+noncomputable def ModuleJacobiIdentity {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (A : OAI.StronglyRationalVOA.VertexAlgebra V) (Y : OAI.StronglyRationalVOA.StateField V W) : Prop :=
+  ∀ (a b : V) (c : W) (m n k : ℤ),
+    (∑ᶠ j : ℕ, Ring.choose (m : ℂ) j •
+      OAI.StronglyRationalVOA.mode Y (OAI.StronglyRationalVOA.mode A.fields a (n + j) b) (m + k - j) c) =
+    ∑ᶠ j : ℕ, ((-1 : ℂ) ^ j * Ring.choose (n : ℂ) j) •
+      (OAI.StronglyRationalVOA.mode Y a (m + n - j) (OAI.StronglyRationalVOA.mode Y b (k + j) c) -
+        (-1 : ℂ) ^ n • OAI.StronglyRationalVOA.mode Y b (n + k - j) (OAI.StronglyRationalVOA.mode Y a (m + j) c))
+
+structure WeakModule (A : OAI.StronglyRationalVOA.VertexAlgebra V) (W : Type v)
+    [AddCommGroup W] [Module ℂ W] where
+  fields : OAI.StronglyRationalVOA.StateField V W
+  vacuum_mode : ∀ n : ℤ, OAI.StronglyRationalVOA.mode fields A.vacuum n = if n = -1 then 1 else 0
+  jacobi : OAI.StronglyRationalVOA.ModuleJacobiIdentity A fields
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.WeakModule
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable {W : Type v} [AddCommGroup W] [Module ℂ W]
+    {A : VertexAlgebra V} (M : WeakModule A W)
+
+noncomputable def IsInvariant (I : Submodule ℂ W) : Prop :=
+  ∀ a : V, ∀ n : ℤ, ∀ x ∈ I, OAI.StronglyRationalVOA.mode M.fields a n x ∈ I
+
+noncomputable def CompletelyReducible : Prop :=
+  ∀ I : Submodule ℂ W, M.IsInvariant I →
+    ∃ J : Submodule ℂ W, M.IsInvariant J ∧ IsCompl I J
+
+end OAI.StronglyRationalVOA.WeakModule
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+structure CFTTypeVOA (V : Type u) [AddCommGroup V] [Module ℂ V]
+    extends OAI.StronglyRationalVOA.VertexAlgebra V where
+  conformalVector : V
+  centralCharge : ℂ
+  grade : ℕ → Submodule ℂ V
+  grading_internal : DirectSum.IsInternal grade
+  grade_finite : ∀ d, FiniteDimensional ℂ (grade d)
+  vacuum_ne_zero : vacuum ≠ 0
+  grade_zero : grade 0 = ℂ ∙ vacuum
+  conformal_mem : conformalVector ∈ grade 2
+  conformal_energy : ∀ d, ∀ a ∈ grade d,
+    OAI.StronglyRationalVOA.mode fields conformalVector 1 a = (d : ℂ) • a
+  conformal_translation : OAI.StronglyRationalVOA.mode fields conformalVector 0 = toVertexAlgebra.translation
+  translation_covariance : ∀ a : V, ∀ n : ℤ,
+    OAI.StronglyRationalVOA.mode fields (toVertexAlgebra.translation a) n =
+      (-(n : ℂ)) • OAI.StronglyRationalVOA.mode fields a (n - 1)
+  virasoro : ∀ m n : ℤ,
+    (OAI.StronglyRationalVOA.mode fields conformalVector (m + 1)).comp (OAI.StronglyRationalVOA.mode fields conformalVector (n + 1)) -
+      (OAI.StronglyRationalVOA.mode fields conformalVector (n + 1)).comp (OAI.StronglyRationalVOA.mode fields conformalVector (m + 1)) =
+    ((m - n : ℤ) : ℂ) • OAI.StronglyRationalVOA.mode fields conformalVector (m + n + 1) +
+      (if m + n = 0 then (centralCharge / 12) * ((m : ℂ)^3 - m) else 0) •
+        (1 : Module.End ℂ V)
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable (A : CFTTypeVOA V)
+
+noncomputable def virasoroMode (m : ℤ) : Module.End ℂ V :=
+  OAI.StronglyRationalVOA.mode A.fields A.conformalVector (m + 1)
+
+noncomputable def physicalMode (a : V) (d : ℕ) (m : ℤ) : Module.End ℂ V :=
+  OAI.StronglyRationalVOA.mode A.fields a (m + d - 1)
+
+noncomputable def energyShift : Module.End ℂ V := 1 + A.virasoroMode 0
+
+noncomputable def gradingEquiv : V ≃ₗ[ℂ] DirectSum ℕ (fun d => A.grade d) :=
+  (LinearEquiv.ofBijective (DirectSum.coeLinearMap A.grade) A.grading_internal).symm
+
+noncomputable def IsAdmissible {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (M : OAI.StronglyRationalVOA.WeakModule A.toVertexAlgebra W) : Prop :=
+  ∃ G : ℤ → Submodule ℂ W,
+    DirectSum.IsInternal G ∧ (∀ k : ℤ, k < 0 → G k = ⊥) ∧
+      ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n k : ℤ, ∀ x ∈ G k,
+        OAI.StronglyRationalVOA.mode M.fields a n x ∈ G (k + d - n - 1)
+
+noncomputable def IsRational : Prop :=
+  ∀ (W : Type v) [AddCommGroup W] [Module ℂ W]
+    (M : OAI.StronglyRationalVOA.WeakModule A.toVertexAlgebra W),
+    A.IsAdmissible M → M.CompletelyReducible
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+    (A : CFTTypeVOA V)
+
+noncomputable def PolynomialEnergyBound (a : V) : Prop :=
+  ∃ C : ℝ, 0 < C ∧ ∃ p k : ℕ, ∀ (n : ℤ) (b : V),
+    ‖OAI.StronglyRationalVOA.mode A.fields a n b‖ ≤ C * (1 + |(n : ℝ)|) ^ p * ‖(A.energyShift ^ k) b‖
+
+noncomputable def PolynomialEnergyBounds : Prop := ∀ a : V, A.PolynomialEnergyBound a
+
+structure UnitaryStructure where
+  pct : V →ₛₗ[starRingEnd ℂ] V
+  pct_involutive : Function.Involutive pct
+  pct_vacuum : pct A.vacuum = A.vacuum
+  pct_conformal : pct A.conformalVector = A.conformalVector
+  pct_modes : ∀ (a b : V) (n : ℤ),
+    pct (OAI.StronglyRationalVOA.mode A.fields a n b) = OAI.StronglyRationalVOA.mode A.fields (pct a) n (pct b)
+  vacuum_norm : ‖A.vacuum‖ = 1
+  invariant : ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n : ℤ, ∀ b c : V,
+    inner ℂ (OAI.StronglyRationalVOA.mode A.fields a n b) c =
+      inner ℂ b (((-1 : ℂ) ^ d) •
+        ∑ j ∈ Finset.range (d + 1), ((j.factorial : ℂ)⁻¹) •
+          OAI.StronglyRationalVOA.mode A.fields ((A.virasoroMode 1 ^ j) (pct a))
+            (2 * (d : ℤ) - j - n - 2) c)
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.StronglyRationalVOA.HilbertCore
+open Filter
+open UniformSpace
+variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space (V : Type*) [NormedAddCommGroup V] [InnerProductSpace ℂ V] :
+    Submodule ℂ (Completion V) :=
+  LinearMap.range (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.equiv (V : Type*) [NormedAddCommGroup V] [InnerProductSpace ℂ V] :
+    V ≃ₗ[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space V) :=
+  LinearEquiv.ofInjective (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap
+    (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).injective
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.operator (T : V →ₗ[ℂ] Completion V) : Completion V →ₗ.[ℂ] Completion V where
+  domain := (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space V)
+  toFun := T.comp (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.equiv V).symm.toLinearMap
+
+end OAI.StronglyRationalVOA.HilbertCore
+
+namespace OAI.StronglyRationalVOA
+open Filter
+
+noncomputable def RapidCoefficients (f : ℤ → ℂ) : Prop :=
+  ∀ p : ℕ, Summable (fun n : ℤ => ‖f n‖*(1+|(n : ℝ)|)^p)
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SummableLinearFamily
+open Filter
+variable {ι V H : Type*} [NormedAddCommGroup V] [NormedSpace ℂ V]
+    [NormedAddCommGroup H] [NormedSpace ℂ H]
+
+noncomputable def tsumMap (T : ι → V →ₗ[ℂ] H) (hT : ∀ v, Summable (fun n => T n v)) : V →ₗ[ℂ] H where
+  toFun v := ∑' n, T n v
+  map_add' v w := by simpa only [map_add] using (hT v).tsum_add (hT w)
+  map_smul' z v := by
+    simpa only [map_smul, RingHom.id_apply] using (hT v).tsum_const_smul z
+
+end OAI.StronglyRationalVOA.SummableLinearFamily
+
+namespace OAI.StronglyRationalVOA
+open Filter
+open scoped ContDiff
+
+structure SmoothCircleFunction where
+  toFun : ℝ → ℂ
+  periodic : Function.Periodic toFun (2*Real.pi)
+  smooth : ContDiff ℝ ∞ toFun
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleFunction
+open Filter
+open scoped ContDiff
+
+noncomputable instance : CoeFun OAI.StronglyRationalVOA.SmoothCircleFunction (fun _ => ℝ → ℂ) := ⟨OAI.StronglyRationalVOA.SmoothCircleFunction.toFun⟩
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient (f : OAI.StronglyRationalVOA.SmoothCircleFunction) (n : ℤ) : ℂ := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleFunction_period_pos  : 0 < 2*Real.pi := by positivity
+  exact
+    fourierCoeffOn h_OAI_StronglyRationalVOA_SmoothCircleFunction_period_pos f n
+
+end OAI.StronglyRationalVOA.SmoothCircleFunction
+
+namespace OAI.StronglyRationalVOA.ClosedGraphData
+open Filter
+open scoped ContDiff
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+noncomputable abbrev _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double (H : Type u) := WithLp 2 (H × H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph (T : H →ₗ.[ℂ] H) : Submodule ℂ (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) :=
+  T.graph.comap (WithLp.prodContinuousLinearEquiv 2 ℂ H H).toLinearEquiv.toLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.projection (T : H →ₗ.[ℂ] H) (hT : T.IsClosed) : (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) →L[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) := by
+  classical
+  have h_OAI_StronglyRationalVOA_ClosedGraphData_graph_closed {H : Type u} [instLocal1 : NormedAddCommGroup H] [instLocal2 : InnerProductSpace ℂ H]  {T : H →ₗ.[ℂ] H} (hT : T.IsClosed) :
+      IsClosed ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T) : Set (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H)) :=
+    hT.preimage (WithLp.prodContinuousLinearEquiv 2 ℂ H H).continuous
+  letI : IsClosed ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T) : Set (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H)) := (h_OAI_StronglyRationalVOA_ClosedGraphData_graph_closed hT)
+  exact (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T).starProjection
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.inclusion (i : Bool) : H →L[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) :=
+  (WithLp.prodContinuousLinearEquiv 2 ℂ H H).symm.toContinuousLinearMap.comp
+    (if i then ContinuousLinearMap.inr ℂ H H else ContinuousLinearMap.inl ℂ H H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.coordinate (i : Bool) : (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) →L[ℂ] H :=
+  (if i then ContinuousLinearMap.snd ℂ H H else ContinuousLinearMap.fst ℂ H H).comp
+    (WithLp.prodContinuousLinearEquiv 2 ℂ H H).toContinuousLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.entry (T : H →ₗ.[ℂ] H) (hT : T.IsClosed) (i j : Bool) : H →L[ℂ] H :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.coordinate i).comp ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.projection T hT).comp (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.inclusion j))
+
+end OAI.StronglyRationalVOA.ClosedGraphData
+
+namespace OAI.StronglyRationalVOA.LocalOperatorAlgebra
+open Filter
+open scoped ContDiff
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+open scoped Pointwise
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.LocalOperatorAlgebra.generated (s : Set (H →L[ℂ] H)) : VonNeumannAlgebra H where
+  toStarSubalgebra := StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H))
+  centralizer_centralizer' := by
+    change Set.centralizer (Set.centralizer
+      (StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H)) : Set (H →L[ℂ] H))) =
+        (StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H)) : Set (H →L[ℂ] H))
+    rw [StarSubalgebra.coe_centralizer_centralizer]
+    rw [Set.centralizer_centralizer_centralizer]
+
+end OAI.StronglyRationalVOA.LocalOperatorAlgebra
+
+namespace OAI.StronglyRationalVOA.SmoothCircleFunction
+open Filter
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.onCircle (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : AddCircle (2*Real.pi) → ℂ :=
+  f.periodic.lift
+
+end OAI.StronglyRationalVOA.SmoothCircleFunction
+
+namespace OAI.StronglyRationalVOA
+open Filter
+open scoped ContDiff
+
+structure ProperCircleArc where
+  left : ℝ
+  right : ℝ
+  nonempty' : left < right
+  nondense' : right < left + 2*Real.pi
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.ProperCircleArc
+open Filter
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier (I : OAI.StronglyRationalVOA.ProperCircleArc) : Set (AddCircle (2*Real.pi)) :=
+  (fun t : ℝ => (t : AddCircle (2*Real.pi))) '' Set.Ioo I.left I.right
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.complement (I : OAI.StronglyRationalVOA.ProperCircleArc) : OAI.StronglyRationalVOA.ProperCircleArc where
+  left := I.right
+  right := I.left + 2*Real.pi
+  nonempty' := I.nondense'
+  nondense' := by linarith [I.nonempty']
+
+end OAI.StronglyRationalVOA.ProperCircleArc
+
+namespace OAI.StronglyRationalVOA.BoundedFlow
+open scoped Topology
+open Filter
+open scoped Topology
+open Filter
+open scoped Topology
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+local instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.boundedFlowRationalNormedAlgebra : NormedAlgebra ℚ (H →L[ℂ] H) :=
+  .restrictScalars ℚ ℂ (H →L[ℂ] H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.flow (K : H →L[ℂ] H) (t : ℝ) : H →L[ℂ] H := NormedSpace.exp (t • K)
+
+end OAI.StronglyRationalVOA.BoundedFlow
+
+namespace OAI.StronglyRationalVOA
+open scoped ContDiff
+
+structure SmoothCircleLift where
+  toOrderIso : ℝ ≃o ℝ
+  smooth : ContDiff ℝ ∞ toOrderIso
+  inverse_smooth : ContDiff ℝ ∞ toOrderIso.symm
+  period : ∀ t, toOrderIso (t+2*Real.pi)=toOrderIso t+2*Real.pi
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleLift
+open scoped ContDiff
+
+noncomputable instance : CoeFun OAI.StronglyRationalVOA.SmoothCircleLift (fun _ => ℝ → ℝ) := ⟨fun F => F.toOrderIso⟩
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := OrderIso.refl ℝ
+  smooth := contDiff_id
+  inverse_smooth := contDiff_id
+  period := fun _ => rfl
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose (F G : OAI.StronglyRationalVOA.SmoothCircleLift) : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := G.toOrderIso.trans F.toOrderIso
+  smooth := F.smooth.comp G.smooth
+  inverse_smooth := G.inverse_smooth.comp F.inverse_smooth
+  period := by intro t; change F (G (t+2*Real.pi))=F (G t)+2*Real.pi; rw [G.period,F.period]
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse (F : OAI.StronglyRationalVOA.SmoothCircleLift) : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := F.toOrderIso.symm
+  smooth := F.inverse_smooth
+  inverse_smooth := F.smooth
+  period := by
+    intro t
+    apply F.toOrderIso.injective
+    rw [F.toOrderIso.apply_symm_apply,F.period,F.toOrderIso.apply_symm_apply]
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.instGroup : Group OAI.StronglyRationalVOA.SmoothCircleLift := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_ext  {F G : OAI.StronglyRationalVOA.SmoothCircleLift} (h : ∀ t, F t=G t) : F=G := by
+    cases F with
+    | mk f hf hfi hp =>
+      cases G with
+      | mk g hg hgi hgp =>
+        have he : f=g := DFunLike.ext _ _ h
+        subst g
+        rfl
+  exact {
+    mul := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose
+    one := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity
+    inv := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse
+    npow := @npowRec OAI.StronglyRationalVOA.SmoothCircleLift
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩
+    div := fun F G => OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose F
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse G)
+    zpow := @zpowRec OAI.StronglyRationalVOA.SmoothCircleLift
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse⟩
+      (@npowRec OAI.StronglyRationalVOA.SmoothCircleLift
+        ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+        ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩)
+    mul_assoc F G H := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    one_mul F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    mul_one F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    inv_mul_cancel F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; exact F.toOrderIso.symm_apply_apply t
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F : OAI.StronglyRationalVOA.SmoothCircleLift) : AddCircle (2*Real.pi) → AddCircle (2*Real.pi) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_circle_periodic  (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Function.Periodic (fun t : ℝ => (F t : AddCircle (2*Real.pi))) (2*Real.pi) := by
+    intro t
+    change ((F.toOrderIso (t+2*Real.pi) : ℝ) : AddCircle (2*Real.pi)) =
+      (F.toOrderIso t : AddCircle (2*Real.pi))
+    rw [F.period,AddCircle.coe_add]
+    simp
+  exact
+    (h_OAI_StronglyRationalVOA_SmoothCircleLift_circle_periodic F).lift
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleHomeomorph (F : OAI.StronglyRationalVOA.SmoothCircleLift) :
+    AddCircle (2*Real.pi) ≃ₜ AddCircle (2*Real.pi) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one  (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle 1 t)=t := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) :
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F * G) t)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle G t)) := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse  (F : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F⁻¹ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F t))=t := by
+    rw [← h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul,inv_mul_cancel,h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one]
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle  (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Continuous (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F) := by
+    exact ((AddCircle.continuous_mk' (2*Real.pi)).comp F.smooth.continuous).quotient_liftOn' _
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  exact {
+    toFun := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F)
+    invFun := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F⁻¹)
+    left_inv := (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse F)
+    right_inv := by intro t; simpa [h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply, h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply] using (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse F⁻¹ t)
+    continuous_toFun := (h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle F)
+    continuous_invFun := (h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle F⁻¹)
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction : OAI.StronglyRationalVOA.SmoothCircleLift →* Equiv.Perm (AddCircle (2*Real.pi)) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one  (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle 1 t)=t := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) :
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F * G) t)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle G t)) := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  exact {
+    toFun F := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleHomeomorph F).toEquiv
+    map_one' := by ext x; exact (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one x)
+    map_mul' F G := by ext x; exact (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul F G x)
+  }
+
+end OAI.StronglyRationalVOA.SmoothCircleLift
+
+namespace OAI.StronglyRationalVOA
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.instGroupSmoothCircleDiffeomorphism : Group OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := inferInstanceAs
+  (Group (OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker))
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA
+open UniformSpace
+
+noncomputable def scalarPhaseSubgroup (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    Subgroup (H ≃ₗᵢ[ℂ] H) where
+  carrier := {E | ∃ c : ℂ, ‖c‖=1 ∧ ∀ x : H, E x=c • x}
+  one_mem' := ⟨1,by simp,fun x => (one_smul ℂ x).symm⟩
+  mul_mem' := by
+    rintro E F ⟨c,hc,he⟩ ⟨d,hd,hf⟩
+    refine ⟨c*d,by rw [norm_mul,hc,hd,one_mul],?_⟩
+    intro x
+    change E (F x)=(c*d) • x
+    rw [hf,he,mul_smul]
+  inv_mem' := by
+    rintro E ⟨c,hc,he⟩
+    have hn : c ≠ 0 := by intro h; rw [h,norm_zero] at hc; norm_num at hc
+    refine ⟨c⁻¹,by rw [norm_inv,hc,inv_one],?_⟩
+    intro x
+    apply E.injective
+    change E (E.symm x)=E (c⁻¹ • x)
+    rw [E.apply_symm_apply,map_smul,he,smul_smul,inv_mul_cancel₀ hn,one_smul]
+
+noncomputable instance scalarPhaseSubgroup_normal (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    (OAI.StronglyRationalVOA.scalarPhaseSubgroup H).Normal where
+  conj_mem := by
+    rintro E ⟨c,hc,he⟩ F
+    refine ⟨c,hc,?_⟩
+    intro x
+    change F (E (F.symm x))=c • x
+    rw [he,map_smul,F.apply_symm_apply]
+
+noncomputable abbrev ProjectiveUnitaryGroup (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :=
+  (H ≃ₗᵢ[ℂ] H) ⧸ OAI.StronglyRationalVOA.scalarPhaseSubgroup H
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleLift
+open Filter Set
+open scoped Topology ContDiff
+
+noncomputable def jet (F : OAI.StronglyRationalVOA.SmoothCircleLift) (k : ℕ) : C(ℝ,ℝ) :=
+  ⟨iteratedDeriv k F, F.smooth.continuous_iteratedDeriv k
+    (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))⟩
+
+noncomputable instance : TopologicalSpace OAI.StronglyRationalVOA.SmoothCircleLift :=
+  TopologicalSpace.induced (fun F => OAI.StronglyRationalVOA.SmoothCircleLift.jet F) inferInstance
+
+end OAI.StronglyRationalVOA.SmoothCircleLift
+
+namespace OAI.StronglyRationalVOA
+open UniformSpace Filter Set
+open scoped Topology
+
+noncomputable instance unitaryStrongTopology (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    TopologicalSpace (H ≃ₗᵢ[ℂ] H) :=
+  TopologicalSpace.induced (fun E : H ≃ₗᵢ[ℂ] H => (E : H → H)) inferInstance
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.instTopologicalSpaceSmoothCircleDiffeomorphism : TopologicalSpace OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := inferInstanceAs
+  (TopologicalSpace (OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker))
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CircleMobiusGeometry
+open Set
+open scoped MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel (M : SL(2,ℝ)) (x y : ℝ) : Prop :=
+  (M 0 0*Real.cos (x/2)+M 0 1*Real.sin (x/2))*Real.sin (y/2)=
+    (M 1 0*Real.cos (x/2)+M 1 1*Real.sin (x/2))*Real.cos (y/2)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements (M : SL(2,ℝ)) (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Prop := ∀ x, (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel M x ((OAI.StronglyRationalVOA.SmoothCircleLift.toOrderIso F) x))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts : Subgroup OAI.StronglyRationalVOA.SmoothCircleLift := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_apply_inv_apply  (F : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : F (F⁻¹ t)=t := F.toOrderIso.apply_symm_apply t
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_inv  {M : SL(2,ℝ)} {F : OAI.StronglyRationalVOA.SmoothCircleLift}
+      (hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M⁻¹ F⁻¹) := by
+    intro x
+    have h := hF (F⁻¹ x)
+    rw [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,(h_OAI_StronglyRationalVOA_SmoothCircleLift_apply_inv_apply F)] at h
+    simp only [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,Matrix.SpecialLinearGroup.SL2_inv_expl,Matrix.cons_val_zero,
+      Matrix.cons_val_one,Matrix.cons_val_fin_one]
+    linear_combination -h
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_one  : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements 1 1) := by
+    intro x
+    simp [h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply, OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,mul_comm]
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_collinear_unit  {p q c s : ℝ} (hu : c^2+s^2=1) (h : p*s=q*c) :
+      (p*c+q*s)*c=p ∧ (p*c+q*s)*s=q := by
+    constructor
+    · linear_combination p*hu-s*h
+    · linear_combination q*hu+c*h
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq  (x : ℝ) : Real.cos x^2+Real.sin x^2=1 := by
+    nlinarith [Real.sin_sq_add_cos_sq x]
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_mul  {M N : SL(2,ℝ)} {F G : OAI.StronglyRationalVOA.SmoothCircleLift}
+      (hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)) (hG : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements N G)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements (M * N) (F * G)) := by
+    intro x
+    have hh := hF (G x)
+    have hg := hG x
+    obtain ⟨hr1,hr2⟩ := (h_OAI_StronglyRationalVOA_CircleMobiusGeometry_collinear_unit
+    (h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq
+      ((OAI.StronglyRationalVOA.SmoothCircleLift.toOrderIso G) x / 2))
+    hg)
+    let r := (N 0 0*Real.cos (x/2)+N 0 1*Real.sin (x/2))*Real.cos (G x/2)+
+      (N 1 0*Real.cos (x/2)+N 1 1*Real.sin (x/2))*Real.sin (G x/2)
+    change r*Real.cos (G x/2)=N 0 0*Real.cos (x/2)+N 0 1*Real.sin (x/2) at hr1
+    change r*Real.sin (G x/2)=N 1 0*Real.cos (x/2)+N 1 1*Real.sin (x/2) at hr2
+    change (M 0 0*Real.cos (G x/2)+M 0 1*Real.sin (G x/2))*Real.sin (F (G x)/2)=
+      (M 1 0*Real.cos (G x/2)+M 1 1*Real.sin (G x/2))*Real.cos (F (G x)/2) at hh
+    simp only [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,(h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply),Matrix.SpecialLinearGroup.coe_mul,
+      Matrix.mul_apply,Fin.sum_univ_two]
+    linear_combination r*hh+(M 1 0*Real.cos (F (G x)/2)-M 0 0*Real.sin (F (G x)/2))*hr1+
+      (M 1 1*Real.cos (F (G x)/2)-M 0 1*Real.sin (F (G x)/2))*hr2
+  exact {
+    carrier := {F | ∃ M : SL(2,ℝ), (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)}
+    one_mem' := ⟨1,h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_one⟩
+    mul_mem' := by rintro F G ⟨M,hM⟩ ⟨N,hN⟩; exact ⟨M*N,(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_mul hM hN)⟩
+    inv_mem' := by rintro F ⟨M,hM⟩; exact ⟨M⁻¹,(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_inv hM)⟩
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.rotationMatrix (s : ℝ) : SL(2,ℝ) := by
+  classical
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq  (x : ℝ) : Real.cos x^2+Real.sin x^2=1 := by
+    nlinarith [Real.sin_sq_add_cos_sq x]
+  exact
+    ⟨!![Real.cos (s/2),-Real.sin (s/2);Real.sin (s/2),Real.cos (s/2)],by
+        simp only [Matrix.det_fin_two_of]
+        nlinarith [(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq (s / 2))]⟩
+
+noncomputable abbrev _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group := OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts ⧸ ((OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype).ker
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.inclusion : OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group →* OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism :=
+  QuotientGroup.lift ((OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype).ker
+    ((QuotientGroup.mk' (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype) (by
+      intro F hF
+      exact (QuotientGroup.eq_one_iff _).mpr hF)
+
+end OAI.StronglyRationalVOA.CircleMobiusGeometry
+
+namespace OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism
+open Set
+open scoped Topology MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action : OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism →* Equiv.Perm (AddCircle (2*Real.pi)) :=
+  QuotientGroup.lift (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction)
+    (fun _ h => h)
+
+end OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism
+
+namespace OAI.StronglyRationalVOA
+open Set
+open scoped Topology MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] : OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H → ((H →L[ℂ] H) ≃⋆ₐ[ℂ] (H →L[ℂ] H)) := by
+  classical
+  have h_OAI_StronglyRationalVOA_projective_equality_conjugation  {H : Type _} [NormedAddCommGroup H]
+      [InnerProductSpace ℂ H] [CompleteSpace H] (E F : H ≃ₗᵢ[ℂ] H)
+      (h : (QuotientGroup.mk E : OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H)=QuotientGroup.mk F) :
+      E.conjStarAlgEquiv=F.conjStarAlgEquiv := by
+    obtain ⟨c,_,hc⟩ := QuotientGroup.eq.mp h
+    have he (x : H) : F x=c • E x := by
+      have H := congrArg E (hc x)
+      change E (E.symm (F x))=E (c • x) at H
+      simpa only [E.apply_symm_apply,map_smul] using H
+    ext B x
+    change E (B (E.symm x))=F (B (F.symm x))
+    have hi : E.symm x=c • F.symm x := by
+      apply E.injective
+      rw [E.apply_symm_apply,map_smul,← he,F.apply_symm_apply]
+    rw [hi,map_smul,map_smul,← he]
+  exact
+    Quotient.lift (fun E : H ≃ₗᵢ[ℂ] H => E.conjStarAlgEquiv) (by
+        intro E F h
+        exact (h_OAI_StronglyRationalVOA_projective_equality_conjugation E F (Quotient.sound h)))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.globalObservableAlgebra {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) :
+    Subalgebra ℂ (H →L[ℂ] H) :=
+  Algebra.adjoin ℂ (⋃ I, (N I : Set (H →L[ℂ] H)))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.globalCyclicSpace {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) (Ω : H) : Submodule ℂ H :=
+  (Submodule.span ℂ {x | ∃ B ∈ (OAI.MinimalVertex.Code.StronglyRationalVOA.globalObservableAlgebra N), x=B Ω}).topologicalClosure
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V] (A : CFTTypeVOA V)
+
+noncomputable abbrev GradedDual := DirectSum ℕ (fun d => Module.Dual ℂ (A.grade d))
+
+noncomputable def gradedDualPairing (φ : A.GradedDual) (b : V) : ℂ := by
+  classical
+  exact φ.sum (fun d f => f (A.gradingEquiv b d))
+
+noncomputable def IsSelfContragredient : Prop :=
+  ∃ e : V ≃ₗ[ℂ] A.GradedDual,
+    ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n : ℤ, ∀ b c : V,
+      A.gradedDualPairing (e (OAI.StronglyRationalVOA.mode A.fields a n b)) c =
+        ((-1 : ℂ)^d) * ∑ j ∈ Finset.range (d+1), ((j.factorial : ℂ)⁻¹) *
+          A.gradedDualPairing (e b)
+            (OAI.StronglyRationalVOA.mode A.fields ((A.virasoroMode 1 ^ j) a) (2*(d:ℤ)-j-n-2) c)
+
+noncomputable def IsStronglyRational : Prop :=
+  A.IsSelfContragredient ∧ A.IsRational.{u,v} ∧ A.toVertexAlgebra.C2Cofinite
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+  {A : CFTTypeVOA V}
+
+noncomputable def smearedMap (A : OAI.StronglyRationalVOA.CFTTypeVOA V) (a : V) (d : ℕ) (_ha : A.PolynomialEnergyBound a)
+    (f : ℤ → ℂ) (_hf : OAI.StronglyRationalVOA.RapidCoefficients f) : V →ₗ[ℂ] Completion V := by
+  classical
+  let family : ℤ → (V →ₗ[ℂ] Completion V) := fun m =>
+    f m • (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap.comp
+      (A.physicalMode a d m)
+  exact if h : ∀ v, Summable (fun m => family m v) then
+    SummableLinearFamily.tsumMap family h
+  else 0
+
+noncomputable def smoothSmearedField (_U : A.UnitaryStructure) (_hc : A.toVertexAlgebra.C2Cofinite)
+    (a : V) (d : ℕ) (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : Completion V →ₗ.[ℂ] Completion V := by
+  classical
+  exact if h : A.PolynomialEnergyBounds ∧ OAI.StronglyRationalVOA.RapidCoefficients (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient f) then
+    (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.operator
+  (OAI.MinimalVertex.smearedMap A a d (And.left h a) (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient f)
+    (And.right h)))
+  else 0
+
+noncomputable def closedSmoothField (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (a : V) (d : ℕ) (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : Completion V →ₗ.[ℂ] Completion V :=
+  (OAI.MinimalVertex.smoothSmearedField U hc a d f).closure
+
+noncomputable def localGraphData (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (O : Set (AddCircle (2*Real.pi))) : Set (Completion V →L[ℂ] Completion V) :=
+  {x | ∃ (a : V) (d : ℕ), a ∈ A.grade d ∧ ∃ (f : OAI.StronglyRationalVOA.SmoothCircleFunction),
+      tsupport (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.onCircle f) ⊆ O ∧ ∃ (h : (OAI.MinimalVertex.closedSmoothField U hc a d f).IsClosed),
+        ∃ i j : Bool, x = (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.entry (OAI.MinimalVertex.closedSmoothField U hc a d f) h i j)}
+
+noncomputable def localAlgebra (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (O : Set (AddCircle (2*Real.pi))) : VonNeumannAlgebra (Completion V) :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.LocalOperatorAlgebra.generated (OAI.MinimalVertex.localGraphData U hc O))
+
+noncomputable def intervalAlgebra (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (I : OAI.StronglyRationalVOA.ProperCircleArc) : VonNeumannAlgebra (Completion V) :=
+  OAI.MinimalVertex.localAlgebra U hc (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I)
+
+noncomputable def CKLWStrongLocal (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite) : Prop :=
+  (∀ a : V, A.PolynomialEnergyBound a) ∧
+    ∀ I : OAI.StronglyRationalVOA.ProperCircleArc, OAI.MinimalVertex.intervalAlgebra U hc I ≤
+      (OAI.MinimalVertex.intervalAlgebra U hc (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.complement I)).commutant
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+noncomputable def resolvent (T : H →ₗ.[ℂ] H) (_hs : IsSelfAdjoint T) (z : ℂ) (_hz : 1 ≤ |z.im|) :
+    H →L[ℂ] H := by
+  classical
+  exact if h : ∃ R : H →L[ℂ] H, ∀ y, (R y, y + z • R y) ∈ T.graph then h.choose
+  else 0
+
+noncomputable def boundedGenerator (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T)
+    (r : ℝ) (hr : 1 ≤ r) : H →L[ℂ] H :=
+  ((r : ℂ)^2/2) •
+    (OAI.MinimalVertex.resolvent T hs ((r : ℂ)*Complex.I) (by simpa [abs_of_nonneg (by linarith : 0 ≤ r)] using hr) +
+     OAI.MinimalVertex.resolvent T hs (-((r : ℂ)*Complex.I)) (by simpa [abs_of_nonneg (by linarith : 0 ≤ r)] using hr))
+
+noncomputable def approximatingFlow (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T) (n : ℕ) (t : ℝ) : H →L[ℂ] H :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.flow
+  (Complex.I • OAI.MinimalVertex.boundedGenerator T hs (↑n + 1) (le_add_of_nonneg_left (Nat.cast_nonneg n))) t)
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+
+noncomputable def flow {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+    (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T) (t : ℝ) : H →L[ℂ] H := by
+  classical
+  exact if h : ∃ L : H →L[ℂ] H, ∀ x,
+      Tendsto (fun n => OAI.MinimalVertex.approximatingFlow T hs n t x) atTop (𝓝 (L x)) then
+    h.choose
+  else 0
+
+noncomputable def projectiveStandardAction : PSL(2,ℝ) →* (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group) := by
+  classical
+  exact if h : ∃ L : PSL(2,ℝ) →* (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group),
+      ∀ M : SL(2,ℝ), ∃ F : OAI.StronglyRationalVOA.SmoothCircleLift, ∃ hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F),
+        L (QuotientGroup.mk M) =
+          QuotientGroup.mk (⟨F, M, hF⟩ : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts)) then h.choose
+  else 1
+
+structure IrreducibleConformalNetStructure {H : Type*} [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H]
+    (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) where
+  separable : TopologicalSpace.SeparableSpace H
+  carrier_congr : ∀ I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I)=(OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I=N J
+  isotony : ∀ I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) ⊆ (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I ≤ N J
+  locality : ∀ I J, Disjoint (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I ≤ (N J).commutant
+  mobius : PSL(2,ℝ) →* (H ≃ₗᵢ[ℂ] H)
+  mobius_continuous : Continuous mobius
+  diffeomorphism : OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism →* OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H
+  diffeomorphism_continuous : Continuous diffeomorphism
+  extends_mobius : ∀ F, diffeomorphism ((OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.inclusion) (OAI.MinimalVertex.projectiveStandardAction F))=QuotientGroup.mk (mobius F)
+  covariance : ∀ F I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action) F '' (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) →
+    ∀ B : H →L[ℂ] H, OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation (diffeomorphism F) B ∈ N J ↔ B ∈ N I
+  local_action : ∀ F I, (∀ x ∈ (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I), (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action) F x=x) →
+    ∀ B ∈ N I, OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation (diffeomorphism F) B=B
+  vacuum : H
+  vacuum_norm : ‖vacuum‖=1
+  vacuum_invariant : ∀ F, mobius F vacuum=vacuum
+  vacuum_unique : ∀ x : H, (∀ F, mobius F x=x) → ∃ c : ℂ, x=c • vacuum
+  vacuum_cyclic : (OAI.MinimalVertex.Code.StronglyRationalVOA.globalCyclicSpace N vacuum)=⊤
+  hamiltonian : H →ₗ.[ℂ] H
+  hamiltonian_selfAdjoint : IsSelfAdjoint hamiltonian
+  positive_energy : ∀ x y, (x,y) ∈ hamiltonian.graph → 0 ≤ (inner ℂ x y).re
+  rotation_flow : ∀ t : ℝ,
+    (mobius (QuotientGroup.mk (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.rotationMatrix t))).toLinearIsometry.toContinuousLinearMap=
+      OAI.MinimalVertex.flow hamiltonian hamiltonian_selfAdjoint t
+  irreducible : ∀ Q : H →L[ℂ] H, (∀ I, Q ∈ (N I).commutant) →
+    ∃ c : ℂ, Q=c • (1 : H →L[ℂ] H)
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+  {A : CFTTypeVOA V} (U : A.UnitaryStructure)
+
+theorem main (_hSimple : A.toVertexAlgebra.IsSimple)
+    (hSR : A.IsStronglyRational.{u,v}) :
+    A.PolynomialEnergyBounds ∧ OAI.MinimalVertex.CKLWStrongLocal U hSR.2.2 ∧
+      Nonempty (OAI.MinimalVertex.IrreducibleConformalNetStructure (OAI.MinimalVertex.intervalAlgebra U hSR.2.2)) := by
+  sorry
+
+end OAI.MinimalVertex
+
+end

lean/ComparatorChallenges/VertexCover.json

@@ -0,0 +1,15 @@
+{
+  "challenge_module": "ComparatorChallenges.VertexCover",
+  "solution_module": "OAI.Computability.VertexCover.Main",
+  "theorem_names": [
+    "OAI.VertexCover.explicit_cover_gap",
+    "OAI.VertexCover.every_fixed_factor_below_two"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/VertexCover.lean

@@ -0,0 +1,154 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniqueGames.BinaryFormula
+
+structure Literal where
+  name : Nat
+  positive : Bool
+  deriving DecidableEq
+
+def Literal.eval (literal : Literal) (assignment : Nat → Bool) : Bool :=
+  if literal.positive then assignment literal.name else !(assignment literal.name)
+
+abbrev Clause := Vector Literal 3
+
+def Clause.eval (clause : Clause) (assignment : Nat → Bool) : Bool :=
+  (clause[0].eval assignment || clause[1].eval assignment) || clause[2].eval assignment
+
+structure Formula where
+  clauses : List Clause
+
+def Formula.Satisfiable (F : Formula) : Prop :=
+  ∃ assignment : Nat → Bool, ∀ clause ∈ F.clauses, clause.eval assignment = true
+
+end UniqueGames.BinaryFormula
+
+namespace UniqueGames.BinaryEncoding
+
+open BinaryFormula
+
+def bitsValue : List Bool → Nat
+  | [] => 0
+  | b :: bits => Nat.bit b (bitsValue bits)
+
+def frame : List Bool → List Bool
+  | [] => [false]
+  | b :: bits => true :: b :: frame bits
+
+def parseFrame : List Bool → Option (List Bool × List Bool)
+  | false :: rest => some ([], rest)
+  | true :: b :: rest => do
+      let (bits, trailing) ← parseFrame rest
+      return (b :: bits, trailing)
+  | _ => none
+
+def nameBits (name : Nat) : List Bool := frame name.bits
+
+def parseName (input : List Bool) : Option (Nat × List Bool) := do
+  let (digits, rest) ← parseFrame input
+  let name := bitsValue digits
+  if digits = name.bits then some (name, rest) else none
+
+def parseLiteral : List Bool → Option (Literal × List Bool)
+  | sign :: input => do
+      let (name, rest) ← parseName input
+      return (⟨name, sign⟩, rest)
+  | [] => none
+
+def parseClause (input : List Bool) : Option (Clause × List Bool) := do
+  let (a, input) ← parseLiteral input
+  let (b, input) ← parseLiteral input
+  let (c, rest) ← parseLiteral input
+  return (#v[a, b, c], rest)
+
+def parseClauses : Nat → List Bool → Option (List Clause × List Bool)
+  | 0, _ => none
+  | _fuel + 1, false :: rest => some ([], rest)
+  | fuel + 1, true :: input => do
+      let (clause, input) ← parseClause input
+      let (clauses, rest) ← parseClauses fuel input
+      return (clause :: clauses, rest)
+  | _ + 1, [] => none
+
+def decodeFormula (input : List Bool) : Option Formula := do
+  let (clauses, rest) ← parseClauses (input.length + 1) input
+  if rest = [] then some ⟨clauses⟩ else none
+
+end UniqueGames.BinaryEncoding
+
+namespace VertexCover
+
+def ThreeSAT (input : List Bool) : Prop :=
+  ∃ formula, UniqueGames.BinaryEncoding.decodeFormula input = some formula ∧
+    formula.Satisfiable
+
+structure ExplicitGraph where
+  n : ℕ
+  edges : List (Fin n × Fin n)
+  increasing : ∀ e ∈ edges, e.1 < e.2
+  nodup : edges.Nodup
+
+namespace ExplicitGraph
+
+def Cover (G : ExplicitGraph) (S : Finset (Fin G.n)) : Prop :=
+  ∀ e ∈ G.edges, e.1 ∈ S ∨ e.2 ∈ S
+
+instance (G : ExplicitGraph) (S : Finset (Fin G.n)) : Decidable (G.Cover S) :=
+  inferInstanceAs (Decidable (∀ e ∈ G.edges, e.1 ∈ S ∨ e.2 ∈ S))
+
+noncomputable def coverNumber (G : ExplicitGraph) : ℕ :=
+  Nat.find (show ∃ k : ℕ, ∃ S : Finset (Fin G.n), G.Cover S ∧ S.card = k from
+    ⟨G.n, Finset.univ, by simp [Cover], by simp⟩)
+
+def bits (G : ExplicitGraph) : List Bool :=
+  let names := [G.n] ++ List.range G.n ++ [G.edges.length] ++
+    G.edges.flatMap (fun e => [e.1.val, e.2.val])
+  names.flatMap UniqueGames.BinaryEncoding.nameBits
+
+end ExplicitGraph
+
+def FiniteAlphabet (M : Turing.FinTM2) : Prop := ∀ k, Finite (M.Γ k)
+
+structure GapReduction (m : ℕ) where
+  construct : List Bool → ExplicitGraph
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    ExplicitGraph.bits construct
+  finiteAlphabet : FiniteAlphabet computation.tm
+  completeness : ∀ input, ThreeSAT input →
+    ((construct input).coverNumber : ℝ) <
+      (1 / 2 + 1 / (m : ℝ)) * (construct input).n
+  soundness : ∀ input, ¬ ThreeSAT input →
+    (1 - 1 / (m : ℝ)) * (construct input).n <
+      ((construct input).coverNumber : ℝ)
+
+def natListBits (L : List ℕ) : List Bool :=
+  (L.length :: L).flatMap UniqueGames.BinaryEncoding.nameBits
+
+structure Approximation (α : ℝ) where
+  run : ExplicitGraph → List ℕ
+  computation : Turing.TM2ComputableInPolyTime ExplicitGraph.bits natListBits run
+  finiteAlphabet : FiniteAlphabet computation.tm
+  nodup : ∀ G, (run G).Nodup
+  vertices : ∀ G, ∀ v ∈ run G, v < G.n
+  covers : ∀ G, ∀ e ∈ G.edges, e.1.val ∈ run G ∨ e.2.val ∈ run G
+  quality : ∀ G, ((run G).length : ℝ) ≤ α * (G.coverNumber : ℝ)
+
+structure ThreeSATDecision where
+  run : List Bool → Bool
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    (fun b : Bool => [b]) run
+  finiteAlphabet : FiniteAlphabet computation.tm
+  correct : ∀ input, run input = true ↔ ThreeSAT input
+
+theorem explicit_cover_gap (m : ℕ) (hm : 4 ≤ m) : Nonempty (GapReduction m) := by
+  sorry
+
+theorem every_fixed_factor_below_two (α : ℝ) (hα : 1 ≤ α) (hα2 : α < 2)
+    (algorithm : Approximation α) : Nonempty ThreeSATDecision := by
+  sorry
+
+end VertexCover
+
+end OAI

lean/ComparatorChallenges/VlasovMaxwell.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VlasovMaxwell",
+  "solution_module": "OAI.Analysis.VlasovMaxwell.Main",
+  "theorem_names": [
+    "OAI.RVM.global_classical_solution"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/VlasovMaxwell.lean

@@ -0,0 +1,112 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Set
+open scoped ContDiff
+namespace RVM
+
+abbrev Vec := EuclideanSpace ℝ (Fin 3)
+abbrev Phase := Vec × Vec
+abbrev Particle := ℝ × Phase → ℝ
+abbrev Field := ℝ × Vec → Vec
+
+def q (v : Vec) : ℝ := Real.sqrt (1 + ‖v‖ ^ 2)
+def velocity (v : Vec) : Vec := (q v)⁻¹ • v
+
+def basis (i : Fin 3) : Vec := WithLp.toLp 2 (Pi.single i (1 : ℝ))
+def dot (a b : Vec) : ℝ := ∑ i : Fin 3, a i * b i
+def cross (a b : Vec) : Vec := WithLp.toLp 2
+  ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2,
+    a 0 * b 1 - a 1 * b 0]
+
+def spatialPartial (g : Vec → ℝ) (x : Vec) (i : Fin 3) : ℝ :=
+  fderiv ℝ g x (basis i)
+def divergence (F : Vec → Vec) (x : Vec) : ℝ :=
+  ∑ i : Fin 3, spatialPartial (fun y => F y i) x i
+
+def curl (F : Vec → Vec) (x : Vec) : Vec := WithLp.toLp 2
+  ![spatialPartial (fun y => F y 2) x 1 - spatialPartial (fun y => F y 1) x 2,
+    spatialPartial (fun y => F y 0) x 2 - spatialPartial (fun y => F y 2) x 0,
+    spatialPartial (fun y => F y 1) x 0 - spatialPartial (fun y => F y 0) x 1]
+
+def rho (g : Phase → ℝ) (x : Vec) : ℝ := ∫ v : Vec, g (x, v)
+def current (g : Phase → ℝ) (x : Vec) : Vec :=
+  ∫ v : Vec, g (x, v) • velocity v
+
+structure Datum where
+  f₀ : Phase → ℝ
+  E₀ : Vec → Vec
+  B₀ : Vec → Vec
+
+def BoundedSmooth (F : Vec → Vec) : Prop :=
+  ContDiff ℝ ∞ F ∧ ∀ n : ℕ, ∃ C : ℝ, ∀ x : Vec,
+    ‖iteratedFDeriv ℝ n F x‖ ≤ C
+
+def Admissible (d : Datum) : Prop :=
+  ContDiff ℝ ∞ d.f₀ ∧ HasCompactSupport d.f₀ ∧ (∀ z, 0 ≤ d.f₀ z) ∧
+  BoundedSmooth d.E₀ ∧ BoundedSmooth d.B₀ ∧
+  MemLp d.E₀ 2 volume ∧ MemLp d.B₀ 2 volume ∧
+  (∀ x, divergence d.E₀ x = rho d.f₀ x) ∧
+  (∀ x, divergence d.B₀ x = 0)
+
+structure Solution where
+  f : Particle
+  E : Field
+  B : Field
+
+def particleHalfSpace : Set (ℝ × Phase) := {z | 0 ≤ z.1}
+def fieldHalfSpace : Set (ℝ × Vec) := {z | 0 ≤ z.1}
+def particleSlab (T : ℝ) : Set (ℝ × Phase) := {z | z.1 ∈ Icc 0 T}
+def fieldSlab (T : ℝ) : Set (ℝ × Vec) := {z | z.1 ∈ Icc 0 T}
+
+def TimeContinuousL2 (F : Field) : Prop :=
+  ∃ F₂ : ℝ → Lp Vec 2 (volume : Measure Vec),
+    ContinuousOn F₂ (Ici 0) ∧
+    ∀ t, 0 ≤ t → (F₂ t : Vec → Vec) =ᵐ[volume] (fun x => F (t, x))
+
+def Equations (s : Solution) : Prop := ∀ t, 0 ≤ t →
+  (∀ x v,
+    derivWithin (fun t' => s.f (t', x, v)) (Ici 0) t +
+    (∑ i : Fin 3, velocity v i * spatialPartial (fun y => s.f (t, y, v)) x i) +
+    (∑ i : Fin 3, (s.E (t, x) + cross (velocity v) (s.B (t, x))) i *
+      spatialPartial (fun v' => s.f (t, x, v')) v i) = 0) ∧
+  (∀ x, derivWithin (fun t' => s.E (t', x)) (Ici 0) t -
+    curl (fun y => s.B (t, y)) x = -current (fun z => s.f (t, z)) x) ∧
+  (∀ x, derivWithin (fun t' => s.B (t', x)) (Ici 0) t +
+    curl (fun y => s.E (t, y)) x = 0) ∧
+  (∀ x, divergence (fun y => s.E (t, y)) x = rho (fun z => s.f (t, z)) x) ∧
+  (∀ x, divergence (fun y => s.B (t, y)) x = 0)
+
+def CompactOnFiniteHorizons (s : Solution) : Prop :=
+  ∀ T : ℝ, 0 ≤ T → ∃ K : Set Phase, IsCompact K ∧
+    ∀ t ∈ Icc 0 T, tsupport (fun z => s.f (t, z)) ⊆ K
+
+def Classical (d : Datum) (s : Solution) : Prop :=
+  ContDiffOn ℝ 1 s.f particleHalfSpace ∧
+  ContDiffOn ℝ 1 s.E fieldHalfSpace ∧ ContDiffOn ℝ 1 s.B fieldHalfSpace ∧
+  (∀ t, 0 ≤ t → ∀ z, 0 ≤ s.f (t, z)) ∧
+  TimeContinuousL2 s.E ∧ TimeContinuousL2 s.B ∧
+  CompactOnFiniteHorizons s ∧ Equations s ∧
+  (∀ z, s.f (0, z) = d.f₀ z) ∧
+  (∀ x, s.E (0, x) = d.E₀ x) ∧ (∀ x, s.B (0, x) = d.B₀ x)
+
+def SmoothOnFiniteHorizons (s : Solution) : Prop := ∀ T : ℝ, 0 ≤ T →
+  ContDiffOn ℝ ∞ s.f (particleSlab T) ∧
+  ContDiffOn ℝ ∞ s.E (fieldSlab T) ∧ ContDiffOn ℝ ∞ s.B (fieldSlab T)
+
+def SameNonnegativeTime (s s' : Solution) : Prop := ∀ t, 0 ≤ t →
+  (∀ z, s.f (t, z) = s'.f (t, z)) ∧
+  (∀ x, s.E (t, x) = s'.E (t, x)) ∧ (∀ x, s.B (t, x) = s'.B (t, x))
+
+theorem global_classical_solution (d : Datum) (hd : Admissible d) :
+    ∃ s : Solution, Classical d s ∧ SmoothOnFiniteHorizons s ∧
+      ∀ s' : Solution, Classical d s' → SameNonnegativeTime s s' := by
+  sorry
+
+end RVM
+
+end
+
+end OAI

lean/ComparatorChallenges/WLIdentification.json

@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WLIdentification",
+  "solution_module": "OAI.Computability.WLIdentification.Main",
+  "theorem_names": [
+    "OAI.WLIdentification.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}

lean/ComparatorChallenges/WLIdentification.lean

@@ -0,0 +1,146 @@
+import Mathlib
+
+namespace OAI
+
+namespace WLIdentification
+
+structure Graph where
+  order : ℕ
+  edge : Fin order → Fin order → Bool
+  symmetric : ∀ u v, edge u v = edge v u
+  loopless : ∀ u, edge u u = false
+
+def Isomorphic (G H : Graph) : Prop :=
+  ∃ e : Fin G.order ≃ Fin H.order, ∀ u v, G.edge u v = H.edge (e u) (e v)
+
+/-- Colors retain their full history, and hence are shared between graphs. -/
+def NeighborColor : ℕ → Type
+  | 0 => Unit
+  | s + 1 => NeighborColor s × Multiset (NeighborColor s)
+
+def neighborColor (G : Graph) : (s : ℕ) → Fin G.order → NeighborColor s
+  | 0, _ => ()
+  | s + 1, v => (neighborColor G s v,
+      (Finset.univ.filter (fun w => G.edge v w = true)).val.map (neighborColor G s))
+
+def neighborHistogram (G : Graph) (s : ℕ) : Multiset (NeighborColor s) :=
+  Finset.univ.val.map (neighborColor G s)
+
+def TupleColor (k : ℕ) : ℕ → Type
+  | 0 => (Fin k → Fin k → Bool) × (Fin k → Fin k → Bool)
+  | s + 1 => TupleColor k s × Multiset (Fin k → TupleColor k s)
+
+/-- Joint update: one multiset of whole replacement vectors, not independent marginals. -/
+def tupleColor (G : Graph) (k : ℕ) : (s : ℕ) → (Fin k → Fin G.order) → TupleColor k s
+  | 0, v => (fun i j => decide (v i = v j), fun i j => G.edge (v i) (v j))
+  | s + 1, v => (tupleColor G k s v,
+      Finset.univ.val.map (fun z => fun i => tupleColor G k s (Function.update v i z)))
+
+def tupleHistogram (G : Graph) (k s : ℕ) : Multiset (TupleColor k s) :=
+  Finset.univ.val.map (tupleColor G k s)
+
+def Equivalent (k : ℕ) (G H : Graph) : Prop :=
+  if k = 1 then ∀ s, neighborHistogram G s = neighborHistogram H s
+  else ∀ s, tupleHistogram G k s = tupleHistogram H k s
+
+/-- There is no restriction to mates from a graph construction or to a selected order. -/
+def Identifies (k : ℕ) (G : Graph) : Prop :=
+  ∀ H : Graph, Equivalent k G H → Isomorphic G H
+
+/-- The infimum of the positive identifying dimensions; this set is nonempty for finite G. -/
+noncomputable def WLdim (G : Graph) : ℕ :=
+  sInf {k : ℕ | 0 < k ∧ Identifies k G}
+
+abbrev Word := List Bool
+abbrev BinaryLanguage := Set Word
+
+def binaryValue (bits : Word) : ℕ :=
+  bits.foldl (fun z b => 2 * z + if b then 1 else 0) 0
+
+def matrixWord (G : Graph) : Word :=
+  (List.ofFn (fun i : Fin G.order => List.ofFn (G.edge i))).flatten
+
+/-- Unary order header, row-major binary matrix, then most-significant-first binary k. -/
+def inputWord (G : Graph) (bits : Word) : Word :=
+  List.replicate G.order true ++ [false] ++ matrixWord G ++ bits
+
+/-- A malformed word is rejected: membership requires a valid nonempty simple matrix and k>0. -/
+def dimensionLanguage : BinaryLanguage :=
+  {w | ∃ (G : Graph) (bits : Word),
+    0 < G.order ∧ (∃ tail, bits = true :: tail) ∧ 0 < binaryValue bits ∧
+    w = inputWord G bits ∧ WLdim G ≤ binaryValue bits}
+
+/- The deterministic local machine model is explicit; no oracle or arbitrary
+   state-transition on whole inputs is included. Both alphabets are fixed finite
+   types for each machine. Extra symbols and states allow arbitrary finite tables. -/
+inductive Move where
+  | left | stay | right
+  deriving DecidableEq
+
+def Move.displacement : Move → ℤ
+  | .left => -1
+  | .stay => 0
+  | .right => 1
+
+structure Machine where
+  extraSymbols : ℕ
+  extraStates : ℕ
+  transition : Fin (extraStates + 3) → Fin (extraSymbols + 3) →
+    Fin (extraStates + 3) × Fin (extraSymbols + 3) × Move
+
+structure Configuration (M : Machine) where
+  state : Fin (M.extraStates + 3)
+  head : ℤ
+  tape : ℤ → Fin (M.extraSymbols + 3)
+
+def inputSymbol (M : Machine) (b : Bool) : Fin (M.extraSymbols + 3) :=
+  if b then 2 else 1
+
+def initial (M : Machine) (w : Word) : Configuration M where
+  state := 0
+  head := 0
+  tape z := if 0 ≤ z then (w[z.toNat]?).elim 0 (inputSymbol M) else 0
+
+def Halted {M : Machine} (c : Configuration M) : Prop :=
+  c.state = 1 ∨ c.state = 2
+
+/-- One read/write/head-movement transition. A halted configuration is frozen. -/
+def step (M : Machine) (c : Configuration M) : Configuration M :=
+  if c.state = 1 ∨ c.state = 2 then c else
+    let t := M.transition c.state (c.tape c.head)
+    { state := t.1, head := c.head + t.2.2.displacement,
+      tape := Function.update c.tape c.head t.2.1 }
+
+def run (M : Machine) (w : Word) (t : ℕ) : Configuration M :=
+  (step M)^[t] (initial M w)
+
+/-- Output is the binary word beginning at origin and ending at its first blank. -/
+def Output {M : Machine} (c : Configuration M) (w : Word) : Prop :=
+  (∀ i : Fin w.length, c.tape (i.val : ℤ) = inputSymbol M w[i]) ∧
+    c.tape (w.length : ℤ) = 0
+
+/-- Uniform genuine executions on every bit word, including malformed graph words. -/
+def DecidesWithin (M : Machine) (L : BinaryLanguage) (bound : ℕ → ℕ) : Prop :=
+  ∀ w, ∃ t ≤ bound w.length, Halted (run M w t) ∧ ((run M w t).state = 1 ↔ w ∈ L)
+
+def InEXPTIME (L : BinaryLanguage) : Prop :=
+  ∃ (M : Machine) (C d : ℕ),
+    DecidesWithin M L (fun n => 2 ^ (C * (n + 1) ^ d))
+
+def ComputesWithin (M : Machine) (f : Word → Word) (bound : ℕ → ℕ) : Prop :=
+  ∀ w, ∃ t ≤ bound w.length, (run M w t).state = 1 ∧ Output (run M w t) (f w)
+
+def PolytimeManyOne (L S : BinaryLanguage) : Prop :=
+  ∃ (f : Word → Word) (M : Machine) (C d : ℕ),
+    ComputesWithin M f (fun n => C * (n + 1) ^ d) ∧ ∀ w, w ∈ L ↔ f w ∈ S
+
+def EXPTIMEComplete (S : BinaryLanguage) : Prop :=
+  InEXPTIME S ∧ ∀ L : BinaryLanguage, InEXPTIME L → PolytimeManyOne L S
+
+theorem main : EXPTIMEComplete dimensionLanguage :=
+  by
+    sorry
+
+end WLIdentification
+
+end OAI