{"family": "012", "title": "Independent largest prime factors of consecutive integers", "claim": "Independent largest prime factors of consecutive integers. Resolves the Erdős–Pomerance joint Dickman conjecture: the logarithmic sizes of the largest prime factors of n and $`n+1`$ are asymptotically independent in ordinary natural density. In particular, the integers satisfying $`P^+(n)\\lt P^+(n+1)`$ have density 1/2.", "abstracts": ["Let $P^+(n)$ denote the largest prime factor of $n$. We prove that $\\log P^+(n)/\\log n$ and $\\log P^+(n+1)/\\log n$ are asymptotically independent in ordinary natural density, with Dickman marginals. This resolves the Erd\\H{o}s--Pomerance joint Dickman conjecture positively and implies that the ordering $P^+(n) fun _ => 1\n | n + 1 => fun u => 1 + σ * ∫ t in (1 : ℝ)..max 1 u, kernel (stepApprox σ n) t\n\nnoncomputable def delay (σ u : ℝ) : ℝ := stepApprox σ ⌈u⌉₊ u\n\nend Erdos970.NumberTheoryLean.DelayConstruction\n\nnamespace Erdos970.NumberTheoryLean.Dickman\n\n/-- The continuous delay-equation construction of the Dickman function. -/\nnoncomputable def rho : ℝ → ℝ := DelayConstruction.delay (-1)\n\nend Erdos970.NumberTheoryLean.Dickman\n\nnamespace JointDickman\n\nnoncomputable def empiricalCount (P : ℕ → Prop) (N : ℕ) : ℕ := by\n classical\n exact ((Finset.Icc 2 N).filter P).card\n\n/-- Ordinary natural density over `2 ≤ n ≤ X`, normalized by the real endpoint. -/\nnoncomputable def realDensity (P : ℕ → Prop) (X : ℝ) : ℝ :=\n (empiricalCount P ⌊X⌋₊ : ℝ) / X\n\nend JointDickman\n\nnamespace JointDickmanPaper\n\nopen Filter JointDickman\nopen scoped Topology\n\n/-- Theorem 1: ordinary natural density, with both thresholds based at `n`. -/\ntheorem joint_law (a b : ℝ) (ha : 0 < a) (ha1 : a < 1) (hb : 0 < b) (hb1 : b < 1) :\n Tendsto (realDensity (fun n =>\n (n.maxPrimeFac : ℝ) ≤ (n : ℝ) ^ a ∧ ((n + 1).maxPrimeFac : ℝ) ≤ (n : ℝ) ^ b))\n atTop (𝓝 (Erdos970.NumberTheoryLean.Dickman.rho (1 / a) *\n Erdos970.NumberTheoryLean.Dickman.rho (1 / b))) := by\n sorry\n\n/-- Corollary 2: the increasing strict ordering has natural density one half. -/\ntheorem increasing_order :\n Tendsto (realDensity (fun n => n.maxPrimeFac < (n + 1).maxPrimeFac))\n atTop (𝓝 (1 / 2)) := by\n sorry\n\n/-- The reverse strict ordering also has natural density one half. -/\ntheorem decreasing_order :\n Tendsto (realDensity (fun n => (n + 1).maxPrimeFac < n.maxPrimeFac))\n atTop (𝓝 (1 / 2)) := by\n sorry\n\nend JointDickmanPaper\n\nend OAI\n"], "formalization_scope": "Let $P^+(n)$ be the largest prime factor of $n$. The formalization proves the joint Dickman law in ordinary natural density: for every $0d ≥ 4.", "abstracts": ["We prove that every irreducible integer quartic with no fixed prime-square divisor takes squarefree values with the predicted positive Euler-product density. More generally, we obtain the corresponding $(d-2)$-power-free density in degrees $4\\le d\\le8$. The proof combines number-field factorization, determinant estimates with adaptive auxiliary primes, and explicit low-degree geometry. Together with Browning's theorem for higher degrees, this gives the $(d-2)$-power-free density for every $d\\ge4$."], "papers": ["https://github.com/openai/math/tree/main/preprints/Squarefree-values-of-quartics-and-power-free-values-of-polynomials-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/PowerFreeValues.lean"], "lean_statements": ["-- ComparatorChallenges/PowerFreeValues.lean\nimport Mathlib\n\nnamespace OAI\n\n\n\nopen Filter Asymptotics\nopen scoped Topology\n\nnamespace QuarticPowerFree\n\ndef PowerFree (k : ℕ) (a : ℤ) : Prop :=\n ∀ p : ℕ, p.Prime → ¬ (p : ℤ) ^ k ∣ a\n\ndef rho (f : Polynomial ℤ) (q : ℕ) : ℕ :=\n ((Finset.range q).filter fun a : ℕ => (q : ℤ) ∣ f.eval (a : ℤ)).card\n\nnoncomputable def count (f : Polynomial ℤ) (k : ℕ) (X : ℝ) : ℕ := by\n classical\n exact ((Finset.Icc 1 ⌊X⌋₊).filter fun n : ℕ => PowerFree k (f.eval (n : ℤ))).card\n\ndef LocallyAdmissible (f : Polynomial ℤ) (k : ℕ) : Prop :=\n ∀ p : ℕ, p.Prime → rho f (p ^ k) < p ^ k\n\nnoncomputable def localFactor (f : Polynomial ℤ) (k : ℕ) (p : Nat.Primes) : ℝ :=\n 1 - (rho f (p.val ^ k) : ℝ) / (p.val : ℝ) ^ k\n\nnoncomputable def densityConstant (f : Polynomial ℤ) (k : ℕ) : ℝ :=\n ∏' p : Nat.Primes, localFactor f k p\n\ndef DensityStatement (f : Polynomial ℤ) (k : ℕ) : Prop :=\n Multipliable (localFactor f k) ∧\n 0 < densityConstant f k ∧\n (fun X : ℝ => (count f k X : ℝ) - densityConstant f k * X) =o[atTop]\n (fun X : ℝ => X)\n\ntheorem allDegrees (f : Polynomial ℤ)\n (hirr : Irreducible (f.map (Int.castRingHom ℚ)))\n (hdeglo : 4 ≤ f.natDegree)\n (hlocal : LocallyAdmissible f (f.natDegree - 2)) :\n DensityStatement f (f.natDegree - 2) := by\n sorry\n\nend QuarticPowerFree\n\nend OAI\n"], "formalization_scope": "The formalized result proves positive-density power-free values for every integer polynomial $f$ irreducible over $\\mathbb Q$ of degree $d\\ge4$. Put $k=d-2$ and assume no prime $k$th power divides every value of $f$. Then the number of positive integers $n\\le X$ for which $f(n)$ is $k$-free is $c_fX+o_f(X)$, where $c_f>0$ is the convergent product of local factors. Negative values are allowed and zero is excluded. No monicity, primitivity, or coefficient-height restriction is imposed.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement quantifies over integer polynomials of degree at least 4, assumes irreducibility over Q and local admissibility for k = d-2, and concludes a positive convergent Euler-product constant with count = C X + o(X). This captures the squarefree quartic case (d=4) and the general (d-2)-power-free density claim, and in fact asserts the full d ≥ 4 range. The definitions of power-free values, local factors, and asymptotic density match the usual mathematical meaning; using irreducibility over Q rather than Z[x] and omitting an upper degree bound are minor technical differences that make the statement at least as strong.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean theorem statement faithfully expresses the paper's main claim. It captures: (1) irreducibility over ℚ (equivalent to ℤ for primitive polynomials), (2) degree ≥ 4 covering all cases mentioned (4–8 directly, plus higher degrees via Browning's theorem as noted in the abstract), (3) the (d−2)-power-free condition via `PowerFree k` with k = f.natDegree − 2, (4) the necessary local admissibility condition via `LocallyAdmissible`, and (5) the predicted positive Euler-product density with o(X) error term via `DensityStatement`. All definitions match the mathematical meaning, and the hypotheses/conclusions align precisely with the claim.\", \"score\": 5}"}}
{"family": "021", "title": "A quadratic bound for Jacobsthal’s function", "claim": "A quadratic bound for Jacobsthal’s function. Answers Jacobsthal's quadratic-bound question: every interval of $`Ck^2`$ consecutive integers contains an integer coprime to any prescribed positive integer with at most k distinct prime divisors, for an absolute constant C. The bound is uniform over prime sets and interval positions and removes the classical logarithmic loss.", "abstracts": ["Let $h(k)$ be the least integer such that every interval of $h(k)$ consecutive integers contains an integer coprime to any prescribed positive integer having at most $k$ distinct prime divisors. We prove $h(k)\\ll k^2/(\\log\\log(3k))^2$, giving an affirmative answer to Jacobsthal's quadratic-bound question."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-quadratic-bound-for-Jacobsthals-function-September-25-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/Jacobsthal.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/JacobsthalImproved.lean"], "lean_statements": ["-- ComparatorChallenges/Jacobsthal.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace Erdos970\n\nnamespace NumberTheoryLean.Targets\n\nopen Filter\nopen scoped Topology\n\ndef IsJacobsthalBound (k m : ℕ) : Prop :=\n ∀ n : ℕ, 0 < n → n.primeFactors.card ≤ k →\n ∀ a : ℤ, ∃ i : ℕ, i < m ∧ (a + i).natAbs.Coprime n\n\ndef JacobsthalQuadratic : Prop :=\n ∃ C : ℝ, 0 < C ∧ ∀ k : ℕ, 0 < k →\n ∃ m : ℕ, IsJacobsthalBound k m ∧ (m : ℝ) ≤ C * (k : ℝ) ^ 2\n\nend NumberTheoryLean.Targets\n\nnamespace Erdos970Final\n\ntheorem erdos_970_quadratic : NumberTheoryLean.Targets.JacobsthalQuadratic := by\n sorry\n\nend Erdos970Final\n\nend Erdos970\n\nend OAI\n", "-- ComparatorChallenges/JacobsthalImproved.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace Erdos970\n\nnamespace NumberTheoryLean.Targets\n\ndef IsJacobsthalBound (k m : ℕ) : Prop :=\n ∀ n : ℕ, 0 < n → n.primeFactors.card ≤ k →\n ∀ a : ℤ, ∃ i : ℕ, i < m ∧ (a + i).natAbs.Coprime n\n\ndef JacobsthalIteratedLog : Prop :=\n ∃ C : ℝ, 0 < C ∧ ∀ k : ℕ, 0 < k →\n ∃ m : ℕ, IsJacobsthalBound k m ∧\n (m : ℝ) ≤ C * (k : ℝ) ^ 2 / (Real.log (Real.log (3 * (k : ℝ)))) ^ 2\n\nend NumberTheoryLean.Targets\n\nnamespace Erdos970Final\n\ntheorem erdos_970_iterated_log : NumberTheoryLean.Targets.JacobsthalIteratedLog := by\n sorry\n\nend Erdos970Final\n\nend Erdos970\n\nend OAI\n"], "formalization_scope": "Let $h(k)$ be the least interval length that guarantees an integer coprime to any prescribed positive modulus with at most $k$ distinct prime factors. The formalization proves the paper's strengthened Jacobsthal bound $h(k)\\le Ck^2/(\\log\\log(3k))^2$ for one absolute $C>0$ and every $k\\ge1$. Intervals may begin at any signed integer. The earlier quadratic bound is also retained as a separate statement; the optimal order of growth is not determined.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The definition IsJacobsthalBound correctly encodes the uniform Jacobsthal property: for every positive n with at most k distinct prime factors and every integer starting point a, one of a, ..., a+m-1 is coprime to n, using natAbs to handle negative integers. The quadratic theorem states exactly the existence of an absolute C such that m ≤ C k^2 works for all k>0, and the second theorem states the stronger abstract bound with (log log(3k))^2 in the denominator. The quantifiers are uniform over n, interval positions, and k, with only harmless real/ℕ casting and the standard restriction k>0. Thus the Lean statements faithfully express the paper's main claim, and also include the stronger iterated-log version from the abstract.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully expresses the main claim. The `IsJacobsthalBound` definition correctly captures the requirement that every interval of `m` consecutive integers contains an integer coprime to any `n` with at most `k` distinct prime factors. The `JacobsthalQuadratic` theorem exactly formalizes the quadratic bound claim: there exists an absolute constant `C > 0` such that for every `k > 0`, there exists `m ≤ C·k²` satisfying the bound. The `erdos_970_quadratic` theorem directly asserts this main claim. The additional `erdos_970_iterated_log` theorem expresses a stronger improvement mentioned in the abstract but does not contradict or weaken the main claim; it is consistent with and strengthens the quadratic bound result.\", \"score\": 5}"}}
{"family": "025", "title": "Short Egyptian fractions", "claim": "Short Egyptian fractions. Every rational $`a/b`$ with $`1\\le a\\lt b`$ is a sum of $`O(\\log\\log b)`$ distinct positive unit fractions. The worst-case minimum number of terms has the same order, resolving Erdős’s conjecture on short Egyptian fractions.", "abstracts": ["We prove a conjecture of Erd\\H{o}s: for every sufficiently large integer $b$, every rational number $a/b$ with $1\\le a if 1 ≤ a then egyptianLength a b else 0)\n\ndef IsOneExpansion {k : ℕ} (n : Fin k → ℕ) : Prop :=\n (∀ i, 1 ≤ n i) ∧ StrictMono n ∧\n (∑ i : Fin k, (1 : ℚ) / (n i : ℚ)) = 1\n\ndef OneExpansions (k : ℕ) : Set (Fin k → ℕ) :=\n {n | IsOneExpansion n}\n\ndef F (k : ℕ) : ℕ :=\n (OneExpansions k).ncard\n\ndef D (k : ℕ) : Set ℕ :=\n {m | 2 ≤ m ∧ ∃ n : Fin k → ℕ,\n IsOneExpansion n ∧ ∃ i : Fin k, n i = m}\n\ndef missingDenominators (k : ℕ) : Set ℕ :=\n {m : ℕ | 2 ≤ m} \\ D k\n\ndef v (k : ℕ) : ℕ :=\n sInf (missingDenominators k)\n\ndef prescribedSlope (k : ℕ) : ℝ :=\n Real.log (Real.log (v k : ℝ)) / (k : ℝ)\n\ntheorem egyptian_length_is_minimum :\n ∀ a b : ℕ, 1 ≤ a → a < b →\n (∃ n : Fin (egyptianLength a b) → ℕ,\n IsEgyptianExpansion ((a : ℚ) / (b : ℚ)) n) ∧\n (∀ k : ℕ, (∃ n : Fin k → ℕ,\n IsEgyptianExpansion ((a : ℚ) / (b : ℚ)) n) →\n egyptianLength a b ≤ k) := by\n sorry\n\ntheorem main_double_log_order :\n ∃ c1 c2 : ℝ, 0 < c1 ∧ 0 < c2 ∧ ∃ b0 : ℕ,\n ∀ b : ℕ, b0 ≤ b →\n c1 * Real.log (Real.log (b : ℝ)) ≤ (maxEgyptianLength b : ℝ) ∧\n (maxEgyptianLength b : ℝ) ≤ c2 * Real.log (Real.log (b : ℝ)) := by\n sorry\n\ntheorem one_expansions_finite_and_bounded :\n (∀ k : ℕ, Set.Finite (OneExpansions k) ∧\n F k ≤ k ^ (2 ^ k - 1)) ∧\n (∀ k : ℕ, ∀ n : Fin k → ℕ, IsOneExpansion n →\n ∀ i : Fin k, n i ≤ k ^ (2 ^ i.val)) := by\n sorry\n\ntheorem counting_double_log_order :\n ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∃ k0 : ℕ,\n ∀ k : ℕ, k0 ≤ k →\n c * (k : ℝ) ≤ Real.log (Real.log (F k : ℝ)) ∧\n Real.log (Real.log (F k : ℝ)) ≤ C * (k : ℝ) := by\n sorry\n\ntheorem exact_marker_padding :\n ∀ r : ℕ, 3 ≤ r → ∀ n : Fin r → ℕ, IsOneExpansion n →\n ∀ m : ℕ, (∃ i : Fin r, n i = m) →\n ∃ n' : Fin (r + 1) → ℕ,\n IsOneExpansion n' ∧ ∃ i : Fin (r + 1), n' i = m := by\n sorry\n\ntheorem every_exact_marker_occurs :\n ∀ m : ℕ, 2 ≤ m → ∃ k : ℕ, m ∈ D k := by\n sorry\n\ntheorem quantitative_marked_length :\n ∀ ε : ℝ, 0 < ε → ∃ mε : ℕ, 2 ≤ mε ∧\n ∀ m : ℕ, mε ≤ m →\n ∃ k : ℕ, ∃ n : Fin k → ℕ,\n IsOneExpansion n ∧\n (∃ i : Fin k, n i = m) ∧\n (k : ℝ) ≤ (257 / Real.log 2 + ε) * Real.log (Real.log (m : ℝ)) := by\n sorry\n\ntheorem missing_denominator_semantics :\n ∀ k : ℕ,\n Set.Finite (D k) ∧\n (∃ m : ℕ, m ∈ missingDenominators k) ∧\n 2 ≤ v k ∧ v k ∉ D k ∧\n (∀ m : ℕ, 2 ≤ m → m < v k → m ∈ D k) ∧\n (1 ≤ k → v k ≤ 1 + k ^ (2 ^ (k - 1))) := by\n sorry\n\ntheorem prescribed_denominator_corollary :\n (∃ k0 : ℕ, ∀ k : ℕ, k0 ≤ k →\n Real.exp (Real.exp ((k : ℝ) / 600)) ≤ (v k : ℝ) ∧\n v k ≤ 1 + k ^ (2 ^ (k - 1))) ∧\n (Real.log 2 / 257 ≤ Filter.liminf prescribedSlope Filter.atTop ∧\n Filter.liminf prescribedSlope Filter.atTop ≤\n Filter.limsup prescribedSlope Filter.atTop ∧\n Filter.limsup prescribedSlope Filter.atTop ≤ Real.log 2) ∧\n (∀ c : ℝ, c < Real.log 2 / 257 → ∃ k0 : ℕ,\n ∀ k : ℕ, k0 ≤ k →\n Real.exp (Real.exp (c * (k : ℝ))) ≤ (v k : ℝ)) := by\n sorry\n\nend Problem337\n\nend\n\nend OAI\n", "-- ComparatorChallenges/ShortEgyptianFractions.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace ShortEgyptian\n\ndef IsExpansion (a b : ℕ) (ns : List ℕ) : Prop :=\n ns.Pairwise (· < ·) ∧ (∀ n ∈ ns, 2 ≤ n) ∧\n (ns.map (fun n => (1 : ℚ) / (n : ℚ))).sum = (a : ℚ) / (b : ℚ)\n\nnoncomputable def minLength (a b : ℕ) : ℕ :=\n sInf {k : ℕ | ∃ ns : List ℕ, IsExpansion a b ns ∧ ns.length = k}\n\nnoncomputable def maxMinLength (b : ℕ) : ℕ :=\n (Finset.Ico 1 b).sup (fun a => minLength a b)\n\ntheorem main :\n (∀ a b : ℕ, 1 ≤ a → a < b → ∃ ns : List ℕ, IsExpansion a b ns) ∧\n ∃ c₁ c₂ : ℝ, 0 < c₁ ∧ 0 < c₂ ∧ ∃ b₀ : ℕ, 2 ≤ b₀ ∧\n ∀ b : ℕ, b₀ ≤ b →\n c₁ * Real.log (Real.log (b : ℝ)) ≤ (maxMinLength b : ℝ) ∧\n (maxMinLength b : ℝ) ≤ c₂ * Real.log (Real.log (b : ℝ)) := by\n sorry\n\nend ShortEgyptian\n\nend OAI\n"], "formalization_scope": "An Egyptian-fraction expansion writes a rational number as a sum of distinct unit fractions. The formalization proves that every $a/b$ with $1\\le a0$; padding can preserve that denominator. If $v(k)$ is the least integer at least $2$ absent from all exact $k$-term expansions of $1$, then eventually $e^{e^{k/600}}\\le v(k)\\le1+k^{2^{k-1}}$, and $\\liminf_{k\\to\\infty}\\log\\log v(k)/k\\ge\\log2/257$.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The ShortEgyptianFractions.main theorem directly states that for all 1≤aD, the graph joining Gaussian primes at distance at most D has uniformly bounded finite component sizes, depending only on D, including primes on the coordinate axes.", "abstracts": ["We prove the Gaussian moat conjecture: no infinite walk through distinct Gaussian primes can have bounded steps. More strongly, for each fixed finite step bound, the connected components of the Gaussian-prime graph have uniformly bounded size. This bound applies to every starting prime, including primes on the coordinate axes, and is nonexplicit. The proof constructs a finite periodic sieve obstruction using geometric sampling and information-theoretic estimates."], "papers": ["https://github.com/openai/math/tree/main/preprints/Bounded-Step-Walks-on-Gaussian-Primes-September-26-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/GaussianMoat.lean"], "lean_statements": ["-- ComparatorChallenges/GaussianMoat.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace GaussianMoat\n\nabbrev PrimeVertex := {z : GaussianInt // Irreducible z}\n\nnoncomputable def primeGraph (D : ℝ) : SimpleGraph PrimeVertex where\n Adj p q := p ≠ q ∧ dist (p.val : ℂ) (q.val : ℂ) ≤ D\n symm := by\n constructor\n intro p q h\n exact ⟨h.1.symm, by simpa only [dist_comm] using h.2⟩\n loopless := by\n constructor\n intro p h\n exact h.1 rfl\n\ndef component (D : ℝ) (p : PrimeVertex) : Set PrimeVertex :=\n {q | (primeGraph D).Reachable p q}\n\ndef MainEndpoint : Prop :=\n ∀ (D : ℝ) (z : ℕ → GaussianInt),\n (∀ t, Irreducible (z t)) → Function.Injective z →\n (∀ t, dist (z (t + 1) : ℂ) (z t : ℂ) ≤ D) → False\n\ndef UniformEndpoint : Prop :=\n ∀ D : ℝ, ∃ B : ℕ,\n (∀ p : PrimeVertex, (component D p).Finite ∧ (component D p).ncard ≤ B) ∧\n (∀ (n : ℕ) (z : Fin n → GaussianInt),\n (∀ i, Irreducible (z i)) → Function.Injective z →\n (∀ i j : Fin n, j.val = i.val + 1 → dist (z j : ℂ) (z i : ℂ) ≤ D) →\n n ≤ B)\n\ntheorem fullMain : MainEndpoint ∧ UniformEndpoint := by\n sorry\n\nend GaussianMoat\n\nend OAI\n"], "formalization_scope": "The Gaussian moat problem asks whether an infinite walk through distinct Gaussian primes can have bounded step lengths. The formalized result gives a negative answer for every real step bound $D$. More strongly, one finite bound depending only on $D$ limits the size of every connected component of the bounded-step graph and the length of every injective bounded-step walk. Axis primes and all associates are included. No explicit function of $D$ is supplied.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement defines the Gaussian-prime graph for each real D on irreducible Gaussian integers with Euclidean distance at most D, and UniformEndpoint asserts a D-dependent natural bound on all component cardinalities, matching the stronger uniform-component claim. MainEndpoint asserts there is no injective infinite sequence of irreducible Gaussian integers with consecutive distances bounded by D, which is exactly the Gaussian moat conjecture. Using Irreducible instead of Prime is harmless in Z[i], and the additional finite-path bound is a consequence of the component bound rather than an extra hypothesis.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization accurately captures both parts of the paper's claim. `MainEndpoint` corresponds to the non-existence of an infinite walk through distinct Gaussian primes with uniformly bounded steps, and `UniformEndpoint` corresponds to the uniform boundedness of the sizes of connected components in the Gaussian-prime graph for any fixed distance bound D. The definitions of `PrimeVertex` and `primeGraph` correctly model the mathematical objects described, and no extraneous hypotheses or restrictions (such as excluding axis primes) are present.\", \"score\": 5}"}}
{"family": "073", "title": "The Falconer distance conjecture", "claim": "The Falconer distance conjecture. Resolves the Falconer distance conjecture in every dimension d ≥ 2: every compact set $`E\\subset\\mathbb R^d`$ with Hausdorff dimension greater than $`d/2`$ determines a set of Euclidean distances of positive Lebesgue measure.", "abstracts": ["We resolve the Falconer distance conjecture in every dimension. For every integer \\(d\\ge2\\), a compact subset of \\(\\R^d\\) with Hausdorff dimension greater than \\(d/2\\) determines a set of Euclidean distances of positive Lebesgue measure."], "papers": ["https://github.com/openai/math/tree/main/preprints/The-Falconer-distance-conjecture-in-all-dimensions-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/FalconerAllDimensions.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/PlanarFalconer.lean"], "lean_statements": ["-- ComparatorChallenges/FalconerAllDimensions.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace Falconer\nopen MeasureTheory\nopen scoped ENNReal\n\n/-- A compact subset of Euclidean space with Hausdorff dimension greater than\nhalf the ambient dimension determines a distance set of positive Lebesgue measure. -/\ntheorem falconer_distance_conjecture :\n ∀ (d : ℕ), 2 ≤ d → ∀ E : Set (EuclideanSpace ℝ (Fin d)), IsCompact E →\n (d : ℝ≥0∞) / 2 < dimH E →\n 0 < volume {r : ℝ | ∃ x ∈ E, ∃ y ∈ E, dist x y = r} := by\n sorry\n\nend Falconer\n\nend OAI\n", "-- ComparatorChallenges/PlanarFalconer.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace PlanarFalconer\nopen MeasureTheory Set\n\nabbrev Plane := EuclideanSpace ℝ (Fin 2)\n\ndef distanceSet (E : Set Plane) : Set ℝ :=\n {r | ∃ x ∈ E, ∃ y ∈ E, dist x y = r}\n\ndef MainTarget : Prop :=\n ∀ E : Set Plane, IsCompact E → 1 < dimH E → 0 < volume (distanceSet E)\n\nend PlanarFalconer\n\nnamespace PlanarFalconer\n\ntheorem mainTarget_proved : MainTarget := by\n sorry\n\nend PlanarFalconer\n\nend OAI\n"], "formalization_scope": "The formalization proves the Falconer distance conjecture in every dimension. For every integer $d\\ge2$ and compact set $E\\subset\\mathbb R^d$ with Hausdorff dimension greater than $d/2$, the set $\\{\\lVert x-y\\rVert:x,y\\in E\\}$ has positive Lebesgue measure. The linked statements include both this all-dimensional result and the earlier planar case.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The first Lean theorem states exactly the full Falconer distance conjecture: for every natural d ≥ 2, every compact E ⊆ ℝ^d with dimH E > d/2 has a distance set of positive Lebesgue measure. The types, quantifiers, compactness hypothesis, Hausdorff dimension threshold, and positive volume conclusion match the mathematical claim. The second file only gives the planar d = 2 special case, but the presence of the first theorem means the main claim is faithfully expressed.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully captures the Falconer distance conjecture for all dimensions d ≥ 2. It correctly uses EuclideanSpace ℝ (Fin d) for ℝ^d, requires IsCompact E, imposes the strict Hausdorff dimension condition dimH E > d/2 via (d : ℝ≥0∞) / 2 < dimH E, and concludes 0 < volume of the distance set, which corresponds to positive Lebesgue measure. All quantifiers, hypotheses, and the conclusion match the mathematical claim precisely.\", \"score\": 5}"}}
{"family": "099", "title": "The sharp exponential scale of edit-distance distortion", "claim": "The sharp exponential scale of edit-distance distortion. Determines the least distortion of embedding edit distance on words of length at most d into real ℓ1: it is $`\\exp(\\Theta(\\sqrt{\\log d\\,\\log\\log d}))`$. Insertions, deletions and substitutions have unit cost. The constants are uniform over all finite alphabets with at least two symbols, even when the alphabet grows with d; binary words already force the lower bound.", "abstracts": ["We determine the exponential scale of the least $\\ell_1$ distortion of unit-cost edit distance on all strings of length at most $d$. For every sufficiently large $d$, uniformly over finite alphabets of size at least two, the distortion lies between $\\exp(c\\sqrt{\\log d\\,\\log\\log d})$ and $\\exp(C\\sqrt{\\log d\\,\\log\\log d})$ for absolute constants $c,C>0$. The lower bound already holds on binary strings of one common length. Thus the order of logarithmic distortion is sharp up to absolute constants.", "We give two finite-circle constructions of binary strings whose least $\\ell_1$ distortion is $\\exp(\\Omega(\\sqrt{\\log d\\,\\log\\log d}))$, where $d$ bounds their length. Both constructions supply words of one common length for every sufficiently large cap. Two direct binary coding arguments transfer the constructions with absolute distortion and logarithmic block width. We also develop the overlapping-substring method of Ostrovsky and Rabani into a complete finite histogram embedding at the same exponential scale, uniformly over all finite alphabets and all words of length at most $d$, including the empty word.", "We give two independent constructions of binary words of one length at most $d$ whose ordinary edit-distance metrics require $\\ell_1$ distortion $\\exp(\\Omega(\\sqrt{\\log d\\,\\log\\log d}))$ for every sufficiently large $d$. We also prove a constant-distortion binary conversion for one prescribed input length. Together with the companion upper embedding theorem, these lower bounds determine the order of logarithmic distortion uniformly over finite alphabets with at least two symbols."], "papers": ["https://github.com/openai/math/tree/main/preprints/Edit-Distance-in-l1-Matching-Bounds-up-to-Constants-in-the-Exponent-September-27-2026", "https://github.com/openai/math/tree/main/preprints/Finite-Circle-Obstructions-Binary-Codes-and-Histogram-Embeddings-for-Edit-Distance-September-27-2026", "https://github.com/openai/math/tree/main/preprints/Tree-Constructions-for-the-l1-Distortion-of-Binary-Edit-Distance-September-27-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/BinaryEditLower.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/EditDistance.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/FiniteCircle.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/TreeEdit.lean"], "lean_statements": ["-- ComparatorChallenges/BinaryEditLower.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace TreeEdit\n\nuniverse u\n\n/-- A single unit-cost insertion, deletion, or substitution at any position. -/\ninductive EditStep {α : Type u} : List α → List α → Prop\n | insert (p q : List α) (a : α) : EditStep (p ++ q) (p ++ a :: q)\n | delete (p q : List α) (a : α) : EditStep (p ++ a :: q) (p ++ q)\n | substitute (p q : List α) (a b : α) : EditStep (p ++ a :: q) (p ++ b :: q)\n\n/-- An edit script with no restriction on intermediate word lengths. -/\ninductive EditScript {α : Type u} : List α → List α → ℕ → Prop\n | nil (x : List α) : EditScript x x 0\n | cons {x y z : List α} {n : ℕ} :\n EditStep x y → EditScript y z n → EditScript x z (n + 1)\n\nnoncomputable def ed {α : Type u} (x y : List α) : ℕ :=\n sInf {n | EditScript x y n}\n\nabbrev RealL1 := lp (fun _ : ℕ => ℝ) 1\nabbrev Word (α : Type u) (n : ℕ) := {x : List α // x.length = n}\n\nnamespace BinaryLower\n\n/-- The product of the two maximal pairwise distance ratios. -/\nnoncomputable def distortion {X : Type u} (ρ : X → X → ℝ) (f : X → RealL1) : ℝ :=\n sSup {r : ℝ | ∃ x y : X, x ≠ y ∧ r = ‖f x - f y‖ / ρ x y} *\n sSup {r : ℝ | ∃ x y : X, x ≠ y ∧ r = ρ x y / ‖f x - f y‖}\n\n/-- The infimum over every injective map into the full real sequence space ℓ₁. -/\nnoncomputable def c1 (X : Type u) (ρ : X → X → ℝ) : ℝ :=\n sInf {D : ℝ | ∃ f : X → RealL1, Function.Injective f ∧ D = distortion ρ f}\n\nnoncomputable def binarySetDistortion {n : ℕ} (W : Finset (Word Bool n)) : ℝ :=\n c1 {x : Word Bool n // x ∈ W}\n (fun x y => (ed x.val.val y.val.val : ℝ))\n\nnoncomputable def growth (c : ℝ) (d : ℕ) : ℝ :=\n Real.exp (c * Real.sqrt (Real.log (d : ℝ) * Real.log (Real.log (d : ℝ))))\n\nend BinaryLower\n\nopen BinaryLower\n\n/-- The binary lower-bound theorem of OpenAI's September 27, 2026 tree-constructions\nmanuscript: finite equal-length witnesses for every sufficiently large length cap. -/\ntheorem binary_lower_bound :\n ∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →\n ∃ n : ℕ, 1 ≤ n ∧ n ≤ d ∧\n ∃ W : Finset (Word Bool n), 2 ≤ W.card ∧\n growth c d ≤ binarySetDistortion W := by\n sorry\n\nend TreeEdit\n\nend OAI\n", "-- ComparatorChallenges/EditDistance.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace EditDistortion\n\nuniverse u\n\n/-- A single unit-cost insertion, deletion, or (when enabled) substitution. -/\ninductive Step (substitutions : Bool) {Alpha : Type u} : List Alpha → List Alpha → Prop\n | insert (p q : List Alpha) (a : Alpha) : Step substitutions (p ++ q) (p ++ a :: q)\n | delete (p q : List Alpha) (a : Alpha) : Step substitutions (p ++ a :: q) (p ++ q)\n | substitute (h : substitutions = true) (p q : List Alpha) (a b : Alpha) :\n Step substitutions (p ++ a :: q) (p ++ b :: q)\n\n/-- An unrestricted script of exactly n unit edits. -/\ninductive Script (substitutions : Bool) {Alpha : Type u} : ℕ → List Alpha → List Alpha → Prop\n | nil (x : List Alpha) : Script substitutions 0 x x\n | cons {n : ℕ} {x y z : List Alpha} (first : Step substitutions x y)\n (rest : Script substitutions n y z) : Script substitutions (n + 1) x z\n\n/-- Minimum script length. Scripts always exist (delete x and insert y). -/\nnoncomputable def edit {Alpha : Type u} (x y : List Alpha) : ℕ :=\n sInf {n | Script true n x y}\n\nabbrev L1 := lp (fun _ : ℕ => ℝ) 1\n\n/-- The product of the two maximal distance ratios. -/\nnoncomputable def distortion {X : Type u} (ρ : X → X → ℝ) (f : X ↪ L1) : ℝ :=\n sSup {r : ℝ | ∃ x y : X, x ≠ y ∧ r = ‖f x - f y‖ / ρ x y} *\n sSup {r : ℝ | ∃ x y : X, x ≠ y ∧ r = ρ x y / ‖f x - f y‖}\n\n/-- The infimum over injective maps to real absolutely summable sequences. -/\nnoncomputable def leastDistortion {X : Type u} (ρ : X → X → ℝ) : ℝ :=\n sInf (Set.range (distortion ρ))\n\nabbrev Words (Alpha : Type u) (d : ℕ) := {x : List Alpha // x.length ≤ d}\n\nnoncomputable def E (Alpha : Type u) (d : ℕ) : ℝ :=\n leastDistortion (fun x y : Words Alpha d => (edit x.val y.val : ℝ))\n\nnoncomputable def exponentScale (c : ℝ) (d : ℕ) : ℝ :=\n Real.exp (c * Real.sqrt (Real.log (d : ℝ) * Real.log (Real.log (d : ℝ))))\n\n/-- Supremum over finite alphabet cardinalities. -/\nnoncomputable def alphabetSup (d : ℕ) : ℝ :=\n sSup {r : ℝ | ∃ n : ℕ, 2 ≤ n ∧ r = E (Fin n) d}\n\n/-- A finite nonempty subset of binary words of one common length. -/\ndef BinaryWitness (c : ℝ) (d : ℕ) : Prop :=\n ∃ n : ℕ, n ≤ d ∧ ∃ S : Set (List Bool), S.Finite ∧ S.Nonempty ∧\n (∀ w ∈ S, w.length = n) ∧\n exponentScale c d ≤ leastDistortion (fun x y : S => (edit x.val y.val : ℝ))\n\n/-- Uniform two-sided bounds with common positive constants and threshold. -/\ndef MainClaim : Prop :=\n ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →\n (∀ (Alpha : Type u) [Fintype Alpha], 2 ≤ Fintype.card Alpha →\n exponentScale c d ≤ E Alpha d ∧ E Alpha d ≤ exponentScale C d) ∧\n BinaryWitness c d ∧\n exponentScale c d ≤ alphabetSup d ∧ alphabetSup d ≤ exponentScale C d\n\nend EditDistortion\n\nuniverse u\n\ntheorem edit_distance_main : EditDistortion.MainClaim.{u} := by\n sorry\n\nend OAI\n", "-- ComparatorChallenges/FiniteCircle.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace FiniteCircle\n\nopen scoped BigOperators List\n\nuniverse u v\n\ninductive EditStep {α : Type u} : List α → List α → Prop\n | insert (u v : List α) (a : α) : EditStep (u ++ v) (u ++ a :: v)\n | delete (u v : List α) (a : α) : EditStep (u ++ a :: v) (u ++ v)\n | substitute (u v : List α) (a b : α) : EditStep (u ++ a :: v) (u ++ b :: v)\n\ninductive EditScript {α : Type u} : ℕ → List α → List α → Prop\n | nil (x : List α) : EditScript 0 x x\n | cons {n : ℕ} {x y z : List α} :\n EditStep x y → EditScript n y z → EditScript (n + 1) x z\n\nnoncomputable def editDistance {α : Type u} (x y : List α) : ℕ :=\n sInf {n : ℕ | EditScript n x y}\n\nnoncomputable def lcs {α : Type u} (x y : List α) : ℕ :=\n sSup {n : ℕ | ∃ z : List α, z <+ x ∧ z <+ y ∧ z.length = n}\n\nnoncomputable def deficit {α : Type u} (x y : List α) : ℕ := x.length - lcs x y\n\nabbrev Words (α : Type u) (d : ℕ) := {x : List α // x.length ≤ d}\nabbrev RealL1 := lp (fun _ : ℕ => ℝ) 1\n\nnoncomputable def distortion {α : Type u} {X : Type v} (word : X → List α)\n (f : X → RealL1) : ℝ :=\n (sSup {r : ℝ | ∃ x y : X, x ≠ y ∧\n r = ‖f x - f y‖ / (editDistance (word x) (word y) : ℝ)}) *\n (sSup {r : ℝ | ∃ x y : X, x ≠ y ∧\n r = (editDistance (word x) (word y) : ℝ) / ‖f x - f y‖})\n\nnoncomputable def optimalDistortion {α : Type u} {X : Type v}\n (word : X → List α) : ℝ :=\n sInf {D | ∃ f : X → RealL1, Function.Injective f ∧ D = distortion word f}\n\nnoncomputable def E (α : Type u) (d : ℕ) : ℝ :=\n optimalDistortion (fun x : Words α d => x.val)\n\nnoncomputable def setDistortion (S : Set (List Bool)) : ℝ :=\n optimalDistortion (fun x : S => x.val)\n\nnoncomputable def alphabetSupremum (d : ℕ) : ℝ :=\n sSup {r | ∃ A : ℕ, 2 ≤ A ∧ r = E (Fin A) d}\n\nnoncomputable def exponentScale (d : ℕ) : ℝ :=\n Real.sqrt (Real.log d * Real.log (Real.log d))\n\ndef encode {α : Type u} {w : ℕ} (c : α → Fin w → Bool) (x : List α) : List Bool :=\n x.flatMap (fun a => List.ofFn (c a))\n\ndef interval {α : Type u} {w : ℕ} (c : α → Fin w → Bool)\n (a : α) (s len : ℕ) : List Bool :=\n ((List.ofFn (c a)).drop s).take len\n\ndef OffsetLocal {α : Type u} {w : ℕ} (δ : ℝ) (c : α → Fin w → Bool) : Prop :=\n ∀ a b : α, a ≠ b → ∀ s t : ℕ,\n s + w / 8 ≤ w → t + w / 8 ≤ w →\n (lcs (interval c a s (w / 8)) (interval c b t (w / 8)) : ℝ) ≤\n (1 - δ) * (w / 8 : ℕ)\n\ndef indexSpan {w : ℕ} (is : List (Fin w)) : ℕ :=\n match is with\n | [] => 0\n | i :: js => (js.getLastD i).val + 1 - i.val\n\ndef AnchorLocal {α : Type u} {w : ℕ} (ε : ℝ) (c : α → Fin w → Bool) : Prop :=\n ∀ a b : α, ∀ is js : List (Fin w),\n is.Pairwise (fun i j => i.val < j.val) →\n js.Pairwise (fun i j => i.val < j.val) →\n is.length = js.length → (w : ℝ) / 4 ≤ is.length →\n (indexSpan is - is.length : ℕ) ≤ ε * w →\n (indexSpan js - js.length : ℕ) ≤ ε * w →\n (∀ ij ∈ is.zip js, c a ij.1 = c b ij.2) →\n a = b ∧ ∃ i : Fin w, (i, i) ∈ is.zip js\n\ndef SubstitutionBounds {α : Type u} [Fintype α] {w : ℕ}\n (a C : ℝ) (c : α → Fin w → Bool) : Prop :=\n 0 < w ∧ (w : ℝ) ≤ C * Real.log (2 * Fintype.card α) ∧\n (∀ L : ℕ, ∀ x y : List α, x.length = L → y.length = L →\n a * w * deficit x y ≤ (deficit (encode c x) (encode c y) : ℝ) ∧\n deficit (encode c x) (encode c y) ≤ w * deficit x y) ∧\n (∀ x y : List α, editDistance (encode c x) (encode c y) ≤ w * editDistance x y)\n\ndef TwoCodes (a C δ ε : ℝ) : Prop :=\n ∀ (α : Type) [Fintype α], 2 ≤ Fintype.card α →\n (∃ (w : ℕ) (c : α → Fin w → Bool),\n SubstitutionBounds a C c ∧ OffsetLocal δ c) ∧\n (∃ (w : ℕ) (c : α → Fin w → Bool),\n SubstitutionBounds a C c ∧ AnchorLocal ε c)\n\ndef period (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) : ℕ := ∏ k : Fin h, p l k\n\ndef circleSize (h : ℕ) (p : ℕ → ℕ → ℕ) : ℕ :=\n 2 * ∏ l : Fin h, period h p (l.val + 1)\n\ndef MaskPrimes (h : ℕ) (p : ℕ → ℕ → ℕ) : Prop :=\n (∀ l k : Fin h, Nat.Prime (p (l.val + 1) k)) ∧\n Function.Injective (fun lk : Fin h × Fin h => p (lk.1.val + 1) lk.2) ∧\n ∀ l k : Fin h, h ^ 3 ≤ p (l.val + 1) k ∧ p (l.val + 1) k ≤ 2 * h ^ 3\n\ndef ExcludedPrimes (m : ℕ) (p : ℕ → ℕ → ℕ) : Prop :=\n (∀ l k : Fin m, Nat.Prime (p (l.val + 1) k)) ∧\n Function.Injective (fun lk : Fin m × Fin m => p (lk.1.val + 1) lk.2) ∧\n ∀ l k : Fin m, m ^ 3 < p (l.val + 1) k ∧ p (l.val + 1) k ≤ m ^ 5\n\nabbrev MaskTag (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) := Σ k : Fin h, Fin (p l k)\n\ndef maskTags (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) : List (MaskTag h p l) :=\n (List.ofFn fun k : Fin h => List.ofFn fun b : Fin (p l k) => Sigma.mk k b).flatten\n\ndef MaskAlphabet (h : ℕ) (p : ℕ → ℕ → ℕ) : ℕ → Type\n | 0 => Bool\n | l + 1 => MaskTag h p (l + 1) × MaskAlphabet h p l\n\ninstance maskAlphabetFintype (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) :\n Fintype (MaskAlphabet h p l) := by\n induction l with\n | zero => exact inferInstanceAs (Fintype Bool)\n | succ l ih => exact @instFintypeProd _ _ inferInstance ih\n\ndef MaskState (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ) : ℕ → Type\n | 0 => ZMod M\n | l + 1 => MaskTag h p (l + 1) → MaskState h p M l\n\ndef shiftMaskState (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ) :\n (l : ℕ) → MaskState h p M l → ZMod M → MaskState h p M l\n | 0, v, θ => (show ZMod M from v) + θ\n | l + 1, v, θ => fun j => shiftMaskState h p M l (v j) θ\n\ndef maskGamma (h : ℕ) (p : ℕ → ℕ → ℕ) (M l a : ℕ)\n (j : MaskTag h p l) : ZMod M :=\n (∑ k : Fin h, ((M / p l k * (a % p l k) : ℕ) : ZMod M)) +\n ((j.2.val * (M / p l j.1) * (a % p l j.1) : ℕ) : ZMod M)\n\ndef maskWord (h : ℕ) (p : ℕ → ℕ → ℕ) (R M : ℕ) :\n (l : ℕ) → MaskState h p M l → List (MaskAlphabet h p l)\n | 0, v => (List.range M).map (fun b => decide (((b : ZMod M) - (show ZMod M from v)).val < M / 2))\n | l + 1, v => (List.range (R * period h p (l + 1))).flatMap fun a =>\n (maskTags h p (l + 1)).flatMap fun j =>\n (maskWord h p R M l\n (shiftMaskState h p M l (v j) (maskGamma h p M (l + 1) a j))).map\n (fun x => (j, x))\n\ndef ExcludedAlphabet (m L : ℕ) : ℕ → Type\n | 0 => Fin L × Bool\n | l + 1 => Fin m × ExcludedAlphabet m L l\n\ninstance excludedAlphabetFintype (m L l : ℕ) : Fintype (ExcludedAlphabet m L l) := by\n induction l with\n | zero => exact inferInstanceAs (Fintype (Fin L × Bool))\n | succ l ih => exact @instFintypeProd _ _ inferInstance ih\n\ndef ExcludedState (m L : ℕ) : ℕ → Type\n | 0 => ZMod L\n | l + 1 => Fin m → ExcludedState m L l\n\ndef shiftExcludedState (m L : ℕ) :\n (l : ℕ) → ExcludedState m L l → ZMod L → ExcludedState m L l\n | 0, v, θ => (show ZMod L from v) + θ\n | l + 1, v, θ => fun i => shiftExcludedState m L l (v i) θ\n\ndef excludedTranslation (m : ℕ) (p : ℕ → ℕ → ℕ) (L l s : ℕ) (i : Fin m) :\n ZMod L := ∑ j ∈ Finset.univ.erase i, ((L / p l j * (s % p l j) : ℕ) : ZMod L)\n\ndef excludedWord (m : ℕ) (p : ℕ → ℕ → ℕ) (R L : ℕ) :\n (l : ℕ) → ExcludedState m L l → List (ExcludedAlphabet m L l)\n | 0, v => List.ofFn fun b : Fin L =>\n (b, decide (((b.val : ZMod L) - (show ZMod L from v)).val < L / 2))\n | l + 1, v => (List.range (R * period m p (l + 1))).flatMap fun s =>\n (List.ofFn fun i : Fin m =>\n (excludedWord m p R L l\n (shiftExcludedState m L l (v i) (excludedTranslation m p L (l + 1) s i))).map\n (fun x => (i, x))).flatten\n\ndef MaskWitness (a C δ lower : ℝ) (d : ℕ) : Prop :=\n ∃ h : ℕ, 2 ≤ h ∧ ∃ p : ℕ → ℕ → ℕ, MaskPrimes h p ∧\n ∃ (w : ℕ) (c : MaskAlphabet h p h → Fin w → Bool),\n SubstitutionBounds a C c ∧ OffsetLocal δ c ∧\n ∃ n : ℕ, 0 < n ∧ n ≤ d ∧\n (∀ v : MaskState h p (circleSize h p) h,\n (encode c (maskWord h p (h ^ (2 * h)) (circleSize h p) h v)).length = n) ∧\n Real.exp (lower * exponentScale d) ≤ setDistortion\n (Set.range fun v : MaskState h p (circleSize h p) h =>\n encode c (maskWord h p (h ^ (2 * h)) (circleSize h p) h v))\n\ndef ExcludedWitness (a C ε lower : ℝ) (d : ℕ) : Prop :=\n ∃ m : ℕ, 2 ≤ m ∧ ∃ p : ℕ → ℕ → ℕ, ExcludedPrimes m p ∧\n ∃ (w : ℕ) (c : ExcludedAlphabet m (circleSize m p) m → Fin w → Bool),\n SubstitutionBounds a C c ∧ AnchorLocal ε c ∧\n ∃ n : ℕ, 0 < n ∧ n ≤ d ∧\n (∀ v : ExcludedState m (circleSize m p) m,\n (encode c (excludedWord m p (m ^ (2 * m)) (circleSize m p) m v)).length = n) ∧\n Real.exp (lower * exponentScale d) ≤ setDistortion\n (Set.range fun v : ExcludedState m (circleSize m p) m =>\n encode c (excludedWord m p (m ^ (2 * m)) (circleSize m p) m v))\n\ndef UniformUpper (C : ℝ) (d₀ : ℕ) : Prop :=\n ∀ (α : Type) [Fintype α], 2 ≤ Fintype.card α → ∀ d : ℕ, d₀ ≤ d →\n ∃ (M : ℕ) (F : Words α d → Fin M → ℝ), ∀ x y : Words α d,\n (editDistance x.val y.val : ℝ) ≤ ∑ i, |F x i - F y i| ∧\n (∑ i, |F x i - F y i|) ≤\n Real.exp (C * exponentScale d) * editDistance x.val y.val\n\ndef FullMain : Prop :=\n ∃ c C a Ccode δ ε : ℝ, ∃ d₀ : ℕ,\n 0 < c ∧ 0 < C ∧ 0 < a ∧ 0 < Ccode ∧ 0 < δ ∧ 0 < ε ∧\n TwoCodes a Ccode δ ε ∧ UniformUpper C d₀ ∧\n (∀ (α : Type) [Fintype α], 2 ≤ Fintype.card α → ∀ d : ℕ, d₀ ≤ d →\n Real.exp (c * exponentScale d) ≤ E α d ∧\n E α d ≤ Real.exp (C * exponentScale d)) ∧\n (∀ d : ℕ, d₀ ≤ d →\n MaskWitness a Ccode δ c d ∧ ExcludedWitness a Ccode ε c d ∧\n Real.exp (c * exponentScale d) ≤ alphabetSupremum d ∧\n alphabetSupremum d ≤ Real.exp (C * exponentScale d))\n\nend FiniteCircle\n\ntheorem finiteCircle_fullMain : FiniteCircle.FullMain := by\n sorry\n\nend OAI\n", "-- ComparatorChallenges/TreeEdit.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace TreeEdit\n\nuniverse u\n\n/-- A single unit-cost insertion, deletion or substitution, at any position. -/\ninductive EditStep {α : Type u} : List α → List α → Prop\n | insert (p q : List α) (a : α) : EditStep (p ++ q) (p ++ a :: q)\n | delete (p q : List α) (a : α) : EditStep (p ++ a :: q) (p ++ q)\n | substitute (p q : List α) (a b : α) : EditStep (p ++ a :: q) (p ++ b :: q)\n\n/-- A script of precisely `n` edits. There is no restriction on its intermediate lengths. -/\ninductive EditScript {α : Type u} : List α → List α → ℕ → Prop\n | nil (x : List α) : EditScript x x 0\n | cons {x y z : List α} {n : ℕ} :\n EditStep x y → EditScript y z n → EditScript x z (n + 1)\n\n/-- Ordinary unit-cost edit distance. The set is nonempty (delete then insert). -/\nnoncomputable def ed {α : Type u} (x y : List α) : ℕ :=\n sInf {n | EditScript x y n}\n\n/-- The full infinite-dimensional real ℓ₁ space. -/\nabbrev RealL1 := lp (fun _ : ℕ => ℝ) 1\n\n/-- Product of the two maximal pairwise distance ratios. -/\nnoncomputable def distortion (W : Finset (List Bool)) (f : W → RealL1) : ℝ :=\n sSup {r : ℝ | ∃ x y : W, x ≠ y ∧\n r = dist (f x) (f y) / (ed x.val y.val : ℝ)} *\n sSup {r : ℝ | ∃ x y : W, x ≠ y ∧\n r = (ed x.val y.val : ℝ) / dist (f x) (f y)}\n\n/-- Infimum over all injective ℓ₁ maps, used on finite sets with at least two points. -/\nnoncomputable def c1 (W : Finset (List Bool)) : ℝ :=\n sInf {D : ℝ | ∃ f : W → RealL1, Function.Injective f ∧ distortion W f = D}\n\n/-- The binary main endpoint, for every sufficiently large cap (natural logarithms). -/\ndef BinaryLowerBound : Prop :=\n ∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →\n ∃ n : ℕ, n ≤ d ∧ ∃ W : Finset (List Bool),\n 2 ≤ W.card ∧ (∀ w ∈ W, w.length = n) ∧\n Real.exp (c * Real.sqrt (Real.log (d : ℝ) * Real.log (Real.log (d : ℝ)))) ≤ c1 W\n\ntheorem binary_torus : BinaryLowerBound := by\n sorry\n\nend TreeEdit\n\nend OAI\n"], "formalization_scope": "The formalization determines the exponential scale of the least $\\ell_1$ distortion of unit-cost edit distance on strings of length at most $d$. For every sufficiently large $d$, uniformly over finite alphabets with at least two symbols, the distortion lies between $\\exp(c\\sqrt{\\log d\\,\\log\\log d})$ and $\\exp(C\\sqrt{\\log d\\,\\log\\log d})$ for absolute constants $c,C>0$. The lower bound has a witness consisting of binary strings of one common length, and the same scale controls the supremum over finite alphabets.\n\nThe formalization gives two finite-circle constructions of binary strings whose least $\\ell_1$ distortion is at least $\\exp(c\\sqrt{\\log d\\,\\log\\log d})$ for all sufficiently large length caps $d$. The witnesses use strings of one common length and include the binary coding transfers with their stated uniform bounds.\n\nIt also gives a finite histogram embedding with distortion at most $\\exp(C\\sqrt{\\log d\\,\\log\\log d})$ for all strings of length at most $d$, uniformly over finite alphabets, including the empty string. Thus the lower and upper exponential scales agree up to absolute constants.\n\nThe formalization gives two lower-bound constructions for the $\\ell_1$ distortion of ordinary edit distance on binary words. For every sufficiently large length cap $d$, each construction supplies a finite set of at least two binary words of one common length at most $d$ whose least $\\ell_1$ distortion is at least $\\exp(c\\sqrt{\\log d\\,\\log\\log d})$ for an absolute $c>0$.\n\nThe selected statements are the binary lower bounds. The paper's constant-distortion binary conversion and the companion upper embedding theorem are outside them.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The EditDistance.MainClaim theorem states the full two-sided exp(sqrt(log d log log d)) bound for the least injective ℓ₁ distortion of unit-cost edit distance on all words of length ≤ d, uniformly over all finite alphabets of size at least two, and it also requires a finite binary equal-length witness for the lower bound. The definitions of edit distance, ℓ₁, and distortion (product of sup ratios with infimum over injective maps) match the usual mathematical meaning; FiniteCircle.FullMain gives an even stronger version with explicit upper embedding and witnesses. The other lower-bound-only theorems are weaker components, but the main statement is faithful.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures the main claim. The `edit_distance_main` theorem establishes uniform two-sided bounds on the least ℓ₁ distortion of unit-cost edit distance on words of length at most d, with constants c, C > 0 and threshold d₀, matching the exp(Θ(√(log d log log d))) scale. The definitions of `distortion`, `c1`/`leastDistortion`, `Words`, `edit`, `E`, `alphabetSup`, and `exponentScale` all align with the standard mathematical meaning. The `BinaryWitness` and `alphabetSup` bounds additionally capture the paper's emphasis on binary words forcing the lower bound and uniformity over alphabets. No extraneous hypotheses or weakened conclusions are present.\", \"score\": 5}"}}
{"family": "106", "title": "Hardness of coloring three-colorable graphs", "claim": "Hardness of coloring three-colorable graphs. It is NP-hard to color a three-colorable graph using any fixed number c ≥ 3 of colors. More strongly, for every fixed $`0\\lt \\delta\\lt 1/3`$, a deterministic polynomial-time reduction from 3SAT produces simple unweighted graphs that are three-colorable in the satisfiable case and have no independent set of size $`\\delta n`$ otherwise, where n is the number of vertices.", "abstracts": ["We prove that, for every fixed $0<\\delta<1/3$, it is NP-hard to distinguish three-colorable graphs from graphs in which every independent set has fewer than $\\delta$ times the number of vertices. Consequently, for every fixed integer $c\\ge3$, finding a proper $c$-coloring of a three-colorable graph is NP-hard."], "papers": ["https://github.com/openai/math/tree/main/preprints/Hardness-of-finding-large-independent-sets-in-three-colorable-graphs-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/IndependentSets.lean"], "lean_statements": ["-- ComparatorChallenges/IndependentSets.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace LargeIndependentSets\n\nstructure Literal where\n name : ℕ\n positive : Bool\n deriving DecidableEq\n\nstructure Formula where\n clauses : List (List Literal)\n width : ∀ C ∈ clauses, C.length ≤ 3\n\ndef Formula.Satisfiable (φ : Formula) : Prop :=\n ∃ assignment : ℕ → Bool, ∀ C ∈ φ.clauses,\n ∃ l ∈ C, assignment l.name = l.positive\n\n/-- Binary framing: `true,b` for a payload bit and `false` as terminator. -/\ndef frame : List Bool → List Bool\n | [] => [false]\n | b :: bs => true :: b :: frame bs\n\ndef nameBits (n : ℕ) : List Bool := frame n.bits\n\ndef literalBits (l : Literal) : List Bool := l.positive :: nameBits l.name\n\ndef clauseBits (C : List Literal) : List Bool :=\n nameBits C.length ++ C.flatMap literalBits\n\ndef formulaBits (φ : Formula) : List Bool :=\n nameBits φ.clauses.length ++ φ.clauses.flatMap clauseBits\n\n/-- A nonempty, finite, simple, undirected, unweighted graph. -/\nstructure Graph where\n vertices : ℕ\n nonempty : 0 < vertices\n adj : Fin vertices → Fin vertices → Bool\n symm : ∀ u v, adj u v = adj v u\n loopless : ∀ u, adj u u = false\n\ndef Graph.Independent (G : Graph) (S : Finset (Fin G.vertices)) : Prop :=\n ∀ u ∈ S, ∀ v ∈ S, u ≠ v → G.adj u v = false\n\ninstance (G : Graph) (S : Finset (Fin G.vertices)) : Decidable (G.Independent S) :=\n inferInstanceAs (Decidable (∀ u ∈ S, ∀ v ∈ S, u ≠ v → G.adj u v = false))\n\ndef Graph.independenceNumber (G : Graph) : ℕ :=\n ((Finset.univ : Finset (Fin G.vertices)).powerset.filter G.Independent).sup Finset.card\n\ndef Graph.ThreeColorable (G : Graph) : Prop :=\n ∃ color : Fin G.vertices → Fin 3,\n ∀ u v, G.adj u v = true → color u ≠ color v\n\n/-- Full explicit adjacency matrix, row-major, with binary vertex count. -/\ndef graphBits (G : Graph) : List Bool :=\n nameBits G.vertices ++ (List.finRange G.vertices).flatMap\n (fun u => (List.finRange G.vertices).map (G.adj u))\n\nopen scoped Classical\nnoncomputable section\n\n/-- Polynomial-time graph reduction with a real independence-ratio threshold. -/\nstructure RealGraphReduction (δ : ℝ) where\n reduce : List Bool → Graph\n computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool) graphBits reduce\n finiteAlphabets : ∀ k : computation.tm.K, Finite (computation.tm.Γ k)\n outputBound : Polynomial ℕ\n outputSize : ∀ b, (graphBits (reduce b)).length ≤ outputBound.eval b.length\n completeness : ∀ φ : Formula, φ.Satisfiable → (reduce (formulaBits φ)).ThreeColorable\n soundness : ∀ φ : Formula, ¬φ.Satisfiable →\n ((reduce (formulaBits φ)).independenceNumber : ℝ) <\n δ * (reduce (formulaBits φ)).vertices\n\n/-- Real-threshold graph reduction with explicit binary runtime and output-size bounds. -/\ntheorem mainTheoremReal :\n ∀ δ : ℝ, 0 < δ → δ < 1 / 3 → Nonempty (RealGraphReduction δ) := by\n sorry\n\nend\nend LargeIndependentSets\n\nend OAI\n"], "formalization_scope": "The formalized result shows hardness of finding large independent sets even under a three-colorability promise. For every fixed $0<\\delta<1/3$, a deterministic polynomial-time reduction maps binary 3SAT formulas to nonempty finite simple graphs. Satisfiable formulas produce three-colorable graphs; unsatisfiable formulas produce graphs whose largest independent set has fewer than $\\delta$ times the number of vertices. The complete adjacency-matrix output is included in the runtime bound.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement formalizes the stronger gap reduction: for every real δ with 0<δ<1/3 there exists a deterministic polynomial-time reduction from encoded 3SAT formulas to finite simple unweighted graphs, with satisfiable formulas mapped to 3-colorable graphs and unsatisfiable ones having independence number strictly less than δn. The graph definitions match simple finite undirected unweighted graphs, and the completeness, soundness, and output-bound fields capture the required properties. It does not explicitly state the c-coloring corollary, but that follows by choosing δ<1/c and observing that a c-coloring would yield an independent set of size at least n/c. Thus the statement is essentially the same as, or stronger than, the paper's main claim.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully formalizes the core technical result of the main claim: the existence of a deterministic polynomial-time reduction from 3SAT that produces three-colorable graphs for satisfiable instances and graphs with independence number < δn for unsatisfiable instances, for every fixed δ ∈ (0, 1/3). The definitions of Formula, Graph, ThreeColorable, and independenceNumber match standard mathematical meaning. The RealGraphReduction structure captures all required properties (polynomial-time computability, completeness, soundness, output bounds). While the abstract mentions the NP-hardness consequence for c-coloring, this follows from the reduction, so formalizing the reduction itself is the appropriate and complete formalization of the main claim's technical content.\", \"score\": 5}"}}
{"family": "108", "title": "A cubic permanent–determinant lower bound", "claim": "A cubic permanent–determinant lower bound. Proves an $`\\Omega(n^3)`$ lower bound for the border determinantal complexity of the $`n\\times n`$ permanent over ℂ. Even coefficientwise limits of determinants of affine-linear matrices require matrix size at least $`cn^3`$, for an absolute c > 0 and all sufficiently large n; the same bound therefore holds for exact representations.", "abstracts": ["We prove that the complex border determinantal complexity of the $m\\times m$ permanent is $\\Omega(m^3)$, allowing arbitrary affine-linear determinant representations and coefficientwise limits. It also gives cubic lower bounds for exact determinantal complexity and for the numbers of vertices and edges in affine-linear algebraic branching programs, including coefficientwise limits with a fixed vertex or edge budget."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-cubic-lower-bound-for-border-determinantal-complexity-of-the-permanent-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/PermanentCubic.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SmoothInitialForm.lean"], "lean_statements": ["-- ComparatorChallenges/PermanentCubic.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace PermanentBorder\n\nopen Filter\nopen scoped Topology\n\nabbrev Variables (m : ℕ) := Fin m × Fin m\nabbrev Poly (σ : Type*) := MvPolynomial σ ℂ\n\nnoncomputable def permanentPolynomial (m : ℕ) : Poly (Variables m) :=\n ∑ τ : Equiv.Perm (Fin m), ∏ i : Fin m, MvPolynomial.X (i, τ i)\n\nnoncomputable def affineMatrixPolynomial {σ : Type*} [Fintype σ] (n : ℕ)\n (A₀ : Matrix (Fin n) (Fin n) ℂ)\n (A : σ → Matrix (Fin n) (Fin n) ℂ) : Poly σ :=\n Matrix.det (fun i j => MvPolynomial.C (A₀ i j) +\n ∑ v : σ, MvPolynomial.C (A v i j) * MvPolynomial.X v)\n\ndef HasBorderDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop :=\n 0 < n ∧ ∃ (A₀ : ℕ → Matrix (Fin n) (Fin n) ℂ)\n (A : ℕ → σ → Matrix (Fin n) (Fin n) ℂ),\n ∀ d : σ →₀ ℕ, Tendsto\n (fun j => (affineMatrixPolynomial n (A₀ j) (A j)).coeff d)\n atTop (𝓝 (p.coeff d))\n\ndef HasExactDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop :=\n 0 < n ∧ ∃ (A₀ : Matrix (Fin n) (Fin n) ℂ)\n (A : σ → Matrix (Fin n) (Fin n) ℂ), affineMatrixPolynomial n A₀ A = p\n\ntheorem permanent_cubic_lower_bounds :\n (∀ (m n : ℕ), 1408 ≤ m → HasBorderDeterminant n (permanentPolynomial m) →\n (m : ℝ)^3 / (5529600 * Real.exp 1) ≤ (n : ℝ)) ∧\n (∀ (m n : ℕ), 1408 ≤ m → HasExactDeterminant n (permanentPolynomial m) →\n (m : ℝ)^3 / (5529600 * Real.exp 1) ≤ (n : ℝ)) := by\n sorry\n\nend PermanentBorder\n\nend OAI\n", "-- ComparatorChallenges/SmoothInitialForm.lean\nimport Mathlib\n\nnamespace OAI\n\nopen MvPolynomial\nnamespace PermanentBorder\n\nopen Filter\nopen scoped Topology\n\nabbrev Poly (σ : Type*) := MvPolynomial σ ℂ\n\nnoncomputable def affineMatrixPolynomial {σ : Type*} [Fintype σ] (n : ℕ)\n (A₀ : Matrix (Fin n) (Fin n) ℂ)\n (A : σ → Matrix (Fin n) (Fin n) ℂ) : Poly σ :=\n Matrix.det (fun i j => MvPolynomial.C (A₀ i j) +\n ∑ v : σ, MvPolynomial.C (A v i j) * MvPolynomial.X v)\n\ndef HasBorderDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop :=\n 0 < n ∧ ∃ (A₀ : ℕ → Matrix (Fin n) (Fin n) ℂ)\n (A : ℕ → σ → Matrix (Fin n) (Fin n) ℂ),\n ∀ d : σ →₀ ℕ, Tendsto\n (fun j => (affineMatrixPolynomial n (A₀ j) (A j)).coeff d)\n atTop (𝓝 (p.coeff d))\n\ndef HasExactDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop :=\n 0 < n ∧ ∃ (A₀ : Matrix (Fin n) (Fin n) ℂ)\n (A : σ → Matrix (Fin n) (Fin n) ℂ), affineMatrixPolynomial n A₀ A = p\n\nnoncomputable def affineSubstitution {σ τ : Type*} [Fintype τ]\n (b : σ → ℂ) (B : σ → τ → ℂ) : Poly σ →ₐ[ℂ] Poly τ :=\n MvPolynomial.aeval (fun v => MvPolynomial.C (b v) +\n ∑ w : τ, MvPolynomial.C (B v w) * MvPolynomial.X w)\n\ntheorem smooth_initial_form_lower_bound (d r : ℕ) (g : Poly (Fin d))\n (a : Fin d → ℂ) (hd : 2 ≤ d) (hr : 2 ≤ r)\n (hG : homogeneousComponent r\n (affineSubstitution a (fun i j : Fin d => if i = j then 1 else 0) g) ≠ 0)\n (hlow : ∀ j < r, homogeneousComponent j\n (affineSubstitution a (fun i j : Fin d => if i = j then 1 else 0) g) = 0)\n (hs : ∀ y : Fin d → ℂ,\n eval y (homogeneousComponent r\n (affineSubstitution a (fun i j : Fin d => if i = j then 1 else 0) g)) = 0 →\n (∀ i, eval y (pderiv i (homogeneousComponent r\n (affineSubstitution a (fun i j : Fin d => if i = j then 1 else 0) g))) = 0) →\n y = 0) :\n ∀ n : ℕ,\n (HasBorderDeterminant n g →\n ((r - 1 : ℕ) : ℝ) * ((d - 1 : ℕ) : ℝ) / (4 * Real.exp 1) ≤ (n : ℝ)) ∧\n (HasExactDeterminant n g →\n ((r - 1 : ℕ) : ℝ) * ((d - 1 : ℕ) : ℝ) / (4 * Real.exp 1) ≤ (n : ℝ)) := by\n sorry\n\nend PermanentBorder\n\nend OAI\n"], "formalization_scope": "The formalization proves a cubic lower bound for both exact and border determinantal representations of the complex $m\\times m$ permanent. For $m\\ge1408$, every affine-linear determinant representation of size $n$, including coefficientwise limits, satisfies $n\\ge m^3/(5529600e)$.\n\nA general supporting theorem applies to a polynomial in $d\\ge2$ variables whose first nonzero homogeneous Taylor term has degree $r\\ge2$ and no nonzero singular zero. Its exact and border determinantal sizes are at least $(r-1)(d-1)/(4e)$. The paper's algebraic-branching-program consequences are outside these statements.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The main Lean theorem exactly formalizes the stated border and exact cubic lower bounds for the permanent: if an affine-linear determinant representation or coefficientwise limit of size n exists, then n is at least a positive constant times m^3 for all m≥1408. The definitions match affine-linear determinant matrices and coefficientwise convergence over ℂ, and the explicit constant makes the statement at least as strong as the Ω(m^3) claim. The additional smooth-initial-form theorem is an auxiliary general result, not a weakening of the main claim.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully expresses the main claim. The `permanent_cubic_lower_bounds` theorem directly addresses the Ω(m³) lower bound for the border and exact determinantal complexity of the permanent over ℂ, with the correct asymptotic form n ≥ cm³ (where c = 1/(5529600·e) > 0) for sufficiently large m (m ≥ 1408). The definitions of `HasBorderDeterminant` and `HasExactDeterminant` correctly capture coefficientwise limits and exact representations respectively, and `permanentPolynomial` is the standard definition. The additional `smooth_initial_form_lower_bound` theorem provides a more general result consistent with the abstract's mention of cubic bounds for algebraic branching programs, but the core claim about the permanent is fully captured by `permanent_cubic_lower_bounds`.\", \"score\": 5}"}}
{"family": "118", "title": "Bin packing and unbounded configuration-LP gaps", "claim": "Bin packing and unbounded configuration-LP gaps. Disproves the modified integer round-up conjecture of Scheithauer and Terno: the integral bin-packing optimum can exceed its configuration linear-programming value by an arbitrarily large additive constant. Approximating the optimum within any fixed additive constant is also NP-hard, even when every item exceeds 1/6 and each bin holds at most five items.", "abstracts": ["We disprove the Modified Integer Round-Up Conjecture for bin packing by constructing instances with arbitrarily large additive gaps between the configuration-LP value and the integral optimum. We also prove that, for every fixed nonnegative integer $c$, distinguishing instances that fit in $B$ bins from those requiring more than $B+c$ bins is NP-hard. Both results hold with rational item sizes greater than $1/6$, so each bin contains at most five items."], "papers": ["https://github.com/openai/math/tree/main/preprints/Additive-hardness-and-unbounded-configuration-gaps-in-bin-packing-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/BinPackingGap.lean"], "lean_statements": ["-- ComparatorChallenges/BinPackingGap.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace BinPackingGames.Foundations.Complexity\n\ndef encodeWord (n : Nat) : List Bool := List.replicate n true ++ [false]\n\nend BinPackingGames.Foundations.Complexity\n\nnamespace BinPackingGames.Foundations.Complexity.MachineFiniteAlphabet\n\nopen Turing\n\ndef FiniteAlphabet (M : FinTM2) : Prop := ∀ k, Finite (M.Γ k)\n\nend BinPackingGames.Foundations.Complexity.MachineFiniteAlphabet\n\nnamespace BinPackingGames.Foundations.Complexity.CookLevin\n\ndef pairBits (input : List Bool × List Bool) : List Bool :=\n encodeWord input.1.length ++ input.1 ++ input.2\n\nstructure NPVerifier where\n witnessBound : Polynomial Nat\n verify : (List Bool × List Bool) → Bool\n computation : Turing.TM2ComputableInPolyTime pairBits (fun bit => [bit]) verify\n finiteAlphabet : (k : computation.tm.K) → Fintype (computation.tm.Γ k)\n\ndef NPVerifier.Accepts (verifier : NPVerifier) (input : List Bool) : Prop :=\n ∃ witness : List Bool,\n witness.length ≤ verifier.witnessBound.eval input.length ∧\n verifier.verify (input, witness) = true\n\ndef InNP (language : List Bool → Prop) : Prop :=\n ∃ verifier : NPVerifier, ∀ input, language input ↔ verifier.Accepts input\n\nend BinPackingGames.Foundations.Complexity.CookLevin\n\nnamespace BinPackingCompleteness.BinaryEncoding\n\ndef bitsValue : List Bool → Nat\n | [] => 0\n | b :: bits => Nat.bit b (bitsValue bits)\n\ndef frame : List Bool → List Bool\n | [] => [false]\n | b :: bits => true :: b :: frame bits\n\ndef parseFrame : List Bool → Option (List Bool × List Bool)\n | false :: rest => some ([], rest)\n | true :: b :: rest => do\n let (bits, trailing) ← parseFrame rest\n return (b :: bits, trailing)\n | _ => none\n\ndef nameBits (name : Nat) : List Bool := frame name.bits\n\ndef parseName (input : List Bool) : Option (Nat × List Bool) := do\n let (digits, rest) ← parseFrame input\n let name := bitsValue digits\n if digits = name.bits then some (name, rest) else none\n\nend BinPackingCompleteness.BinaryEncoding\n\nnamespace BinPackingGap\n\nopen scoped BigOperators\n\nstructure Instance where\n n : ℕ\n size : Fin n → ℚ\n size_pos : ∀ i, 0 < size i\n size_le_one : ∀ i, size i ≤ 1\n\nnamespace Instance\n\nabbrev Item (I : Instance) := Fin I.n\n\nend Instance\n\nstructure Packing (I : Instance) (b : ℕ) where\n assignment : I.Item → Fin b\n capacity : ∀ j, (∑ i, if assignment i = j then I.size i else 0) ≤ 1\n\ndef HasPacking (I : Instance) (b : ℕ) : Prop := Nonempty (Packing I b)\n\ndef singletonPacking (I : Instance) : Packing I I.n where\n assignment i := i\n capacity j := by\n have hsum : (∑ i, if i = j then I.size i else 0) = I.size j := by\n calc\n (∑ i, if i = j then I.size i else 0) =\n (if j = j then I.size j else 0) :=\n Finset.sum_eq_single j (fun i _ hij => ite_eq_right hij)\n (fun h => False.elim (h (Finset.mem_univ _)))\n _ = I.size j := ite_eq_left rfl\n rw [hsum]\n exact I.size_le_one j\n\ntheorem exists_packing (I : Instance) : ∃ b, HasPacking I b :=\n ⟨I.n, ⟨singletonPacking I⟩⟩\n\nnoncomputable def opt (I : Instance) : ℕ := by\n classical\n exact Nat.find (exists_packing I)\n\ndef IndividualConfiguration (I : Instance) :=\n {H : Finset I.Item // ∑ i ∈ H, I.size i ≤ 1}\n\nnoncomputable instance (I : Instance) : Fintype (IndividualConfiguration I) :=\n inferInstanceAs (Fintype {H : Finset I.Item // ∑ i ∈ H, I.size i ≤ 1})\n\ndef NumericalSize (I : Instance) := ↥(Finset.univ.image I.size)\n\ninstance (I : Instance) : Fintype (NumericalSize I) :=\n inferInstanceAs (Fintype ↥(Finset.univ.image I.size))\n\nnamespace NumericalSize\n\nvariable {I : Instance}\n\ntheorem positive (s : NumericalSize I) : 0 < s.val := by\n obtain ⟨i, _, hi⟩ := Finset.mem_image.mp s.property\n rw [← hi]\n exact I.size_pos i\n\ndef multiplicity (s : NumericalSize I) : ℕ :=\n (Finset.univ.filter fun i : I.Item => I.size i = s.val).card\n\ndef capacityBound (s : NumericalSize I) : ℕ :=\n Classical.choose (exists_nat_gt (1 / s.val))\n\ntheorem capacityBound_spec (s : NumericalSize I) : 1 / s.val < (s.capacityBound : ℚ) :=\n Classical.choose_spec (exists_nat_gt (1 / s.val))\n\nend NumericalSize\n\ndef TypeConfiguration (I : Instance) :=\n {c : NumericalSize I → ℕ // ∑ s, s.val * (c s : ℚ) ≤ 1}\n\nnamespace TypeConfiguration\n\nvariable {I : Instance}\n\ntheorem count_lt_bound (c : TypeConfiguration I) (s : NumericalSize I) :\n c.val s < s.capacityBound := by\n have hterm : s.val * (c.val s : ℚ) ≤ ∑ t, t.val * (c.val t : ℚ) := by\n exact Finset.single_le_sum (fun t _ => mul_nonneg (le_of_lt t.positive) (Nat.cast_nonneg _))\n (Finset.mem_univ s)\n have hquot : (c.val s : ℚ) ≤ 1 / s.val := by\n apply (le_div_iff₀ s.positive).mpr\n simpa [mul_comm] using hterm.trans c.property\n have hlt := hquot.trans_lt s.capacityBound_spec\n exact_mod_cast hlt\n\ndef boundedCounts (c : TypeConfiguration I) : ∀ s : NumericalSize I, Fin s.capacityBound :=\n fun s => ⟨c.val s, c.count_lt_bound s⟩\n\ntheorem boundedCounts_injective :\n Function.Injective\n (boundedCounts : TypeConfiguration I → ∀ s : NumericalSize I, Fin s.capacityBound) := by\n intro c d h\n apply Subtype.ext\n funext s\n exact congrArg Fin.val (congrFun h s)\n\ninstance : Finite (TypeConfiguration I) := by\n classical\n exact Finite.of_injective boundedCounts boundedCounts_injective\n\ninstance : Fintype (TypeConfiguration I) := Fintype.ofFinite _\n\nend TypeConfiguration\n\nnamespace FractionalCover\n\nopen Set\nvariable {I C : Type*} [Fintype I] [Fintype C]\n\ndef Feasible (a : C → I → ℝ) (d : I → ℝ) (w : C → ℝ) : Prop :=\n (∀ c, 0 ≤ w c) ∧ ∀ i, d i ≤ ∑ c, a c i * w c\n\ndef objective (w : C → ℝ) : ℝ := ∑ c, w c\n\ndef objectiveSet (a : C → I → ℝ) (d : I → ℝ) : Set ℝ :=\n {v | ∃ w, Feasible a d w ∧ objective w = v}\n\ndef value (a : C → I → ℝ) (d : I → ℝ) : ℝ :=\n sInf (objectiveSet a d)\n\nend FractionalCover\n\ndef individualMatrix (I : Instance) (H : IndividualConfiguration I) (i : I.Item) : ℝ :=\n if i ∈ H.val then 1 else 0\n\ndef individualLP (I : Instance) : ℝ :=\n FractionalCover.value (individualMatrix I) (fun _ => 1)\n\ndef typeMatrix (I : Instance) (c : TypeConfiguration I) (s : NumericalSize I) : ℝ :=\n c.val s\n\ndef typeLP (I : Instance) : ℝ :=\n FractionalCover.value (typeMatrix I) (fun s => (s.multiplicity : ℝ))\n\nabbrev RawInstance := List (ℕ × ℕ)\n\nabbrev RawReductionOutput := ℕ × RawInstance\n\nnamespace RawInstance\n\ndef Valid (r : RawInstance) : Prop :=\n ∀ q ∈ r, 0 < q.1 ∧ q.1 ≤ q.2\n\ndef ratValue (q : ℕ × ℕ) : ℚ := (q.1 : ℚ) / (q.2 : ℚ)\n\ntheorem den_pos {r : RawInstance} (hr : r.Valid) {q : ℕ × ℕ} (hq : q ∈ r) :\n 0 < q.2 := lt_of_lt_of_le (hr q hq).1 (hr q hq).2\n\ndef toInstance (r : RawInstance) (hr : r.Valid) : Instance where\n n := r.length\n size i := ratValue (r.get i)\n size_pos i := div_pos (Nat.cast_pos.mpr (hr _ (List.get_mem r i)).1)\n (Nat.cast_pos.mpr (den_pos hr (List.get_mem r i)))\n size_le_one i := (div_le_one₀ (Nat.cast_pos.mpr (den_pos hr (List.get_mem r i)))).mpr\n (Nat.cast_le.mpr (hr _ (List.get_mem r i)).2)\n\nend RawInstance\n\nstructure RawPacking where\n bins : ℕ\n assignments : List ℕ\n\nnamespace RawPacking\n\ndef load (r : RawInstance) (a : List ℕ) (j : ℕ) : ℚ :=\n ((r.zip a).map fun qa =>\n if qa.2 = j then RawInstance.ratValue qa.1 else 0).sum\n\ndef Feasible (r : RawInstance) (p : RawPacking) : Prop :=\n p.assignments.length = r.length ∧\n (∀ j ∈ p.assignments, j < p.bins) ∧\n ∀ j < p.bins, load r p.assignments j ≤ 1\n\nend RawPacking\n\nnamespace BinaryEncoding\n\nabbrev natBits := BinPackingCompleteness.BinaryEncoding.nameBits\n\nabbrev parseNat := BinPackingCompleteness.BinaryEncoding.parseName\n\ndef listBits {α : Type} (encode : α → List Bool) : List α → List Bool\n | [] => [false]\n | a :: rest => true :: (encode a ++ listBits encode rest)\n\ndef pairBits {α β : Type} (ea : α → List Bool) (eb : β → List Bool)\n (p : α × β) : List Bool := ea p.1 ++ eb p.2\n\ndef optionBits {α : Type} (encode : α → List Bool) : Option α → List Bool\n | none => [false]\n | some a => true :: encode a\n\nabbrev Parser (α : Type) := List Bool → Option (α × List Bool)\n\ndef parsePair {α β : Type} (pa : Parser α) (pb : Parser β) : Parser (α × β) :=\n fun input => do\n let (a, rest) ← pa input\n let (b, suffix) ← pb rest\n return ((a, b), suffix)\n\ndef parseListAux {α : Type} (parse : Parser α) : Nat → Parser (List α)\n | 0, _ => none\n | _ + 1, [] => none\n | _ + 1, false :: rest => some ([], rest)\n | fuel + 1, true :: rest => do\n let (a, rest) ← parse rest\n let (as, suffix) ← parseListAux parse fuel rest\n return (a :: as, suffix)\n\ndef parseList {α : Type} (parse : Parser α) : Parser (List α) :=\n fun input => parseListAux parse input.length input\n\ndef decode {α : Type} (parse : Parser α) (input : List Bool) : Option α := do\n let (a, rest) ← parse input\n if rest.isEmpty then some a else none\n\ndef rawInstanceBits (r : RawInstance) : List Bool :=\n listBits (pairBits natBits natBits) r\n\ndef assignmentBits (a : List Nat) : List Bool := listBits natBits a\n\ndef rawPackingBits (p : RawPacking) : List Bool :=\n natBits p.bins ++ assignmentBits p.assignments\n\ndef packingResultBits (p : Option RawPacking) : List Bool := optionBits rawPackingBits p\n\ndef rawReductionOutputBits (out : RawReductionOutput) : List Bool :=\n natBits out.1 ++ rawInstanceBits out.2\n\ndef parseRawInstance : Parser RawInstance := parseList (parsePair parseNat parseNat)\n\ndef decodeRawInstance := decode parseRawInstance\n\nend BinaryEncoding\n\nsection\n\nopen Turing BinPackingGames.Foundations.Complexity\n\nabbrev BitLanguage := List Bool → Prop\n\ndef InP (L : BitLanguage) : Prop :=\n ∃ decider : List Bool → Bool,\n ∃ computation : TM2ComputableInPolyTime\n (id : List Bool → List Bool) (fun b => [b]) decider,\n MachineFiniteAlphabet.FiniteAlphabet computation.tm ∧\n ∀ x, L x ↔ decider x = true\n\ndef ClassP : Set BitLanguage := {L | InP L}\n\ndef ClassNP : Set BitLanguage := {L | CookLevin.InNP L}\n\ndef PEqualsNP : Prop := ClassP = ClassNP\n\nstructure AbsoluteAdditiveAlgorithm (c : Nat) where\n run : List Bool → Option RawPacking\n computation : TM2ComputableInPolyTime (id : List Bool → List Bool)\n BinaryEncoding.packingResultBits run\n finiteAlphabet : MachineFiniteAlphabet.FiniteAlphabet computation.tm\n guarantee : ∀ (r : RawInstance) (hr : r.Valid), ∃ p : RawPacking,\n run (BinaryEncoding.rawInstanceBits r) = some p ∧\n RawPacking.Feasible r p ∧ p.bins ≤ opt (r.toInstance hr) + c\n\nstructure PackingGapReduction (c : Nat) (L : BitLanguage) where\n reduce : List Bool → RawReductionOutput\n computation : TM2ComputableInPolyTime (id : List Bool → List Bool)\n BinaryEncoding.rawReductionOutputBits reduce\n finiteAlphabet : MachineFiniteAlphabet.FiniteAlphabet computation.tm\n valid : ∀ x, (reduce x).2.Valid\n itemCount : ∀ x, (reduce x).2.length = 5 * (reduce x).1\n itemLower : ∀ x i,\n (1 / 6 : ℚ) < ((reduce x).2.toInstance (valid x)).size i\n completeness : ∀ x, L x →\n HasPacking ((reduce x).2.toInstance (valid x)) (reduce x).1\n soundness : ∀ x, ¬L x →\n ¬HasPacking ((reduce x).2.toInstance (valid x)) ((reduce x).1 + c)\n\ndef PackingGapNPHard (c : Nat) : Prop :=\n ∀ L : BitLanguage, CookLevin.InNP L → Nonempty (PackingGapReduction c L)\n\nend\n\ntheorem main_results :\n (∀ c : ℕ, ∃ I : Instance, ∃ B : ℕ,\n I.n = 5 * B ∧\n (∀ i, (1 / 6 : ℚ) < I.size i ∧ I.size i < 1) ∧\n B + c < opt I ∧ individualLP I = (B : ℝ) ∧ typeLP I = (B : ℝ)) ∧\n (∀ c : Nat, PackingGapNPHard c) ∧\n ((∃ c : Nat, Nonempty (AbsoluteAdditiveAlgorithm c)) ↔ PEqualsNP) ∧\n (PEqualsNP → ∃ algorithm : AbsoluteAdditiveAlgorithm 0,\n (∀ (items : RawInstance) (valid : items.Valid), ∃ packing : RawPacking,\n algorithm.run (BinaryEncoding.rawInstanceBits items) = some packing ∧\n packing.Feasible items ∧ packing.bins = opt (items.toInstance valid)) ∧\n algorithm.run (BinaryEncoding.rawInstanceBits []) = some ⟨0, []⟩ ∧\n (∀ input : List Bool, BinaryEncoding.decodeRawInstance input = none →\n algorithm.run input = none) ∧\n (∀ items : RawInstance, ¬ items.Valid →\n algorithm.run (BinaryEncoding.rawInstanceB"], "formalization_scope": "The formalized results rule out a universal additive bound for the configuration linear program in bin packing. For every integer $c\\ge0$, there are an integer $B$ and a rational instance with $5B$ items whose individual-copy and size-type configuration-LP values both equal $B$, but whose integral optimum is greater than $B+c$. Distinguishing a packing in $B$ bins from the absence of one in $B+c$ bins is NP-hard for each fixed $c$. A deterministic polynomial-time algorithm with a fixed absolute additive allowance exists exactly when $P=NP$; under that equality, an optimal algorithm is constructed.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The first conjunct gives arbitrarily large gaps: for every c there is an instance with 5B items, sizes >1/6, both individual and type configuration-LP values equal to B, and integral optimum > B+c. The second conjunct formalizes NP-hardness of the B vs B+c bin-packing gap for every c, with rational sizes >1/6 and exactly 5B items, matching the restricted NP-hardness claim. The remaining conjuncts express additive approximation hardness in a P=NP form and add extra exact-algorithm/invalid-input conditions, which are stronger rather than weakening the claim. The definitions of packing, optimum, configuration LPs, and NP/P are standard enough for the intended meaning.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures all components of the paper's main claim. The `main_results` theorem asserts: (1) for every c, there exist instances with n=5B items, each size in (1/6, 1), where opt I > B + c while both individualLP and typeLP equal B (disproving the modified integer round-up conjecture with arbitrarily large additive gaps); (2) for every c, PackingGapNPHard c holds, meaning distinguishing instances fitting in B bins from those requiring > B+c bins is NP-hard under the same size constraints; (3) the existence of an absolute additive algorithm is equivalent to P=NP; and (4) if P=NP, an exact algorithm exists. All definitions (Instance, Packing, opt, individualLP, typeLP, PackingGapReduction) correctly model the mathematical concepts, and the quantifiers/constraints match the claim precisely.\", \"score\": 5}"}}
{"family": "125", "title": "The metric k-median approximation threshold and recovery", "claim": "The metric k-median approximation threshold and recovery. Gives a deterministic polynomial-time $`(1+2/e+\\varepsilon)`$-approximation for finite rational metric k-median with specified candidate facilities, for every fixed ε > 0. Assuming $`P\\ne NP`$, the optimal infimum approximation factor is $`1+2/e`$.", "abstracts": ["We give an exact-budget recovery algorithm for metric $k$-median with single-exponential dependence on the number of comparison clusters without accurate, distinct proxies in a supplied anchor solution. On positive integral metrics of polynomially bounded diameter, a sufficiently small total proxy error and logarithmically many such clusters yield a $(1+2/e+\\varepsilon)$ approximation in polynomial time with arbitrarily high success probability. We also prove bounded-price strictness for one compatible execution of the logarithmic-surplus construction. Together the recovery and payment arguments give a randomized $(2-\\sigma)$ approximation, for an absolute $\\sigma>0$, on arbitrary finite rational metrics, both with high probability and in expectation, while opening at most $k$ facilities on every output.", "For every fixed \\(\\varepsilon>0\\), we give a deterministic polynomial-time \\((1+2/e+\\varepsilon)\\)-approximation for finite rational metric \\(k\\)-median with specified candidate facilities, opening at most \\(k\\) facilities. Under \\(P\\ne NP\\), the infimum approximation factor in this model is therefore \\(1+2/e\\)."], "papers": ["https://github.com/openai/math/tree/main/preprints/Single-Exponential-Recovery-and-Bounded-Price-Strictness-for-Metric-k-Median-September-24-2026", "https://github.com/openai/math/tree/main/preprints/The-Approximation-Threshold-for-Metric-k-Median-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/KMedianRecovery.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/KMedianRefinedRecovery.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/KMedianThreshold.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/MetricKMedian.lean"], "lean_statements": ["-- ComparatorChallenges/KMedianRecovery.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace MetricKMedianRecovery\n\nstructure RationalMetricInput where\n pointCount : ℕ\n distance : Fin pointCount → Fin pointCount → ℚ\n clients : Finset (Fin pointCount)\n facilities : Finset (Fin pointCount)\n budget : ℕ\n facilities_nonempty : facilities.Nonempty\n budget_pos : 0 < budget\n covered : clients ∪ facilities = Finset.univ\n distance_nonneg : ∀ x y, 0 ≤ distance x y\n distance_self : ∀ x, distance x x = 0\n distance_symm : ∀ x y, distance x y = distance y x\n distance_triangle : ∀ x y z, distance x z ≤ distance x y + distance y z\n\nnamespace RationalMetricInput\n\ndef size (I : RationalMetricInput) : ℕ := I.clients.card + I.facilities.card\n\ndef Feasible (I : RationalMetricInput) (S : Finset (Fin I.pointCount)) : Prop :=\n S ⊆ I.facilities ∧ S.card ≤ I.budget ∧ (I.clients.Nonempty → S.Nonempty)\n\ndef cost (I : RationalMetricInput) (S : Finset (Fin I.pointCount)) : ℚ :=\n if hS : S.Nonempty then ∑ p ∈ I.clients, S.inf' hS (I.distance p) else 0\n\ndef comparisonSets (I : RationalMetricInput) : Finset (Finset (Fin I.pointCount)) :=\n I.facilities.powerset.filter (fun S => S.Nonempty ∧ S.card ≤ I.budget)\n\nlemma comparisonSets_nonempty (I : RationalMetricInput) : I.comparisonSets.Nonempty := by\n obtain ⟨i, hi⟩ := I.facilities_nonempty\n refine ⟨{i}, ?_⟩\n simp only [comparisonSets, Finset.mem_filter, Finset.mem_powerset,\n Finset.singleton_subset_iff, Finset.singleton_nonempty, Finset.card_singleton, true_and]\n exact ⟨hi, I.budget_pos⟩\n\ndef optimum (I : RationalMetricInput) : ℚ :=\n I.comparisonSets.inf' I.comparisonSets_nonempty I.cost\n\ndef natBits (n : ℕ) : List Bool :=\n List.replicate (Nat.bits n).length true ++ [false] ++ Nat.bits n\n\ndef rationalBits (r : ℚ) : List Bool :=\n [decide (r < 0)] ++ natBits r.num.natAbs ++ natBits r.den\n\ndef bits (I : RationalMetricInput) : List Bool :=\n natBits I.pointCount ++ natBits I.budget ++\n List.ofFn (fun i : Fin I.pointCount => decide (i ∈ I.clients)) ++\n List.ofFn (fun i : Fin I.pointCount => decide (i ∈ I.facilities)) ++\n (List.ofFn (fun i : Fin I.pointCount =>\n (List.ofFn (fun j : Fin I.pointCount => rationalBits (I.distance i j))).flatten)).flatten\n\ndef decodeOutput (I : RationalMetricInput) (out : List Bool) : Finset (Fin I.pointCount) :=\n I.facilities.filter (fun i => out[i.val]?.getD false = true)\n\nend RationalMetricInput\n\ndef pairBits (p : List Bool × List Bool) : List Bool :=\n p.1.flatMap (fun b => [true, b]) ++ [false] ++ p.2\n\nstructure BinaryRandomizedAlgorithm where\n randomBits : Polynomial ℕ\n run : List Bool × List Bool → List Bool\n computation : Turing.TM2ComputableInPolyTime pairBits id run\n finiteWorkAlphabet : ∀ k : computation.tm.K, Finite (computation.tm.Γ k)\n\nnamespace BinaryRandomizedAlgorithm\n\ndef bitCount (A : BinaryRandomizedAlgorithm) (I : RationalMetricInput) : ℕ :=\n A.randomBits.eval I.bits.length\n\nabbrev Seed (A : BinaryRandomizedAlgorithm) (I : RationalMetricInput) :=\n Fin (A.bitCount I) → Bool\n\ndef output (A : BinaryRandomizedAlgorithm) (I : RationalMetricInput) (s : A.Seed I) :\n Finset (Fin I.pointCount) :=\n I.decodeOutput (A.run (I.bits, List.ofFn s))\n\nnoncomputable def successProbability (A : BinaryRandomizedAlgorithm) (I : RationalMetricInput)\n (bound : ℝ) : ℝ := by\n classical\n exact ((Finset.univ.filter (fun s : A.Seed I => (I.cost (A.output I s) : ℝ) ≤ bound)).card : ℝ) /\n 2 ^ (A.bitCount I)\n\nnoncomputable def expectedCost (A : BinaryRandomizedAlgorithm) (I : RationalMetricInput) : ℝ :=\n (∑ s : A.Seed I, (I.cost (A.output I s) : ℝ)) / 2 ^ (A.bitCount I)\n\nend BinaryRandomizedAlgorithm\n\ndef globalApplicationClaim : Prop :=\n ∃ σ : ℝ, 0 < σ ∧ ∀ a : ℝ, 0 < a → ∃ A : BinaryRandomizedAlgorithm,\n (∀ (I : RationalMetricInput) (s : A.Seed I), I.Feasible (A.output I s)) ∧\n (∀ I : RationalMetricInput,\n 1 - Real.rpow ((I.size : ℝ) + 2) (-a) ≤\n A.successProbability I ((2 - σ) * (I.optimum : ℝ))) ∧\n (∀ I : RationalMetricInput, A.expectedCost I ≤ (2 - σ) * (I.optimum : ℝ))\n\ntheorem global_application : globalApplicationClaim := by\n sorry\n\nend MetricKMedianRecovery\n\nend OAI\n", "-- ComparatorChallenges/KMedianRefinedRecovery.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace MetricKMedianRecovery\n\nstructure RationalMetricInput where\n pointCount : ℕ\n distance : Fin pointCount → Fin pointCount → ℚ\n clients : Finset (Fin pointCount)\n facilities : Finset (Fin pointCount)\n budget : ℕ\n facilities_nonempty : facilities.Nonempty\n budget_pos : 0 < budget\n covered : clients ∪ facilities = Finset.univ\n distance_nonneg : ∀ x y, 0 ≤ distance x y\n distance_self : ∀ x, distance x x = 0\n distance_symm : ∀ x y, distance x y = distance y x\n distance_triangle : ∀ x y z, distance x z ≤ distance x y + distance y z\n\nnamespace RationalMetricInput\n\ndef size (I : RationalMetricInput) : ℕ := I.clients.card + I.facilities.card\n\ndef Feasible (I : RationalMetricInput) (S : Finset (Fin I.pointCount)) : Prop :=\n S ⊆ I.facilities ∧ S.card ≤ I.budget ∧ (I.clients.Nonempty → S.Nonempty)\n\ndef cost (I : RationalMetricInput) (S : Finset (Fin I.pointCount)) : ℚ :=\n if hS : S.Nonempty then ∑ p ∈ I.clients, S.inf' hS (I.distance p) else 0\n\ndef natBits (n : ℕ) : List Bool :=\n List.replicate (Nat.bits n).length true ++ [false] ++ Nat.bits n\n\ndef rationalBits (r : ℚ) : List Bool :=\n [decide (r < 0)] ++ natBits r.num.natAbs ++ natBits r.den\n\ndef bits (I : RationalMetricInput) : List Bool :=\n natBits I.pointCount ++ natBits I.budget ++\n List.ofFn (fun i : Fin I.pointCount => decide (i ∈ I.clients)) ++\n List.ofFn (fun i : Fin I.pointCount => decide (i ∈ I.facilities)) ++\n (List.ofFn (fun i : Fin I.pointCount =>\n (List.ofFn (fun j : Fin I.pointCount => rationalBits (I.distance i j))).flatten)).flatten\n\ndef decodeOutput (I : RationalMetricInput) (out : List Bool) : Finset (Fin I.pointCount) :=\n I.facilities.filter (fun i => out[i.val]?.getD false = true)\n\nend RationalMetricInput\n\ndef pairBits (p : List Bool × List Bool) : List Bool :=\n p.1.flatMap (fun b => [true, b]) ++ [false] ++ p.2\n\nstructure BinaryRandomizedAlgorithm where\n randomBits : Polynomial ℕ\n run : List Bool × List Bool → List Bool\n computation : Turing.TM2ComputableInPolyTime pairBits id run\n finiteWorkAlphabet : ∀ k : computation.tm.K, Finite (computation.tm.Γ k)\n\n\nend MetricKMedianRecovery\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace MetricKMedianRecovery.RefinedRecovery\n\nstructure Input where\n metric : RationalMetricInput\n disjoint : Disjoint metric.clients metric.facilities\n integral : ∀ x y, ∃ z : ℕ, metric.distance x y = (z : ℚ)\n positive : ∀ x y, x ≠ y → 0 < metric.distance x y\n anchor : Finset (Fin metric.pointCount)\n anchor_subset : anchor ⊆ metric.facilities\n anchor_card : anchor.card = metric.budget\n\nnamespace Input\nabbrev Point (I : Input) := Fin I.metric.pointCount\n\ndef size (I : Input) : ℕ := I.metric.size\n\ndef Bounded (I : Input) (bound : Polynomial ℕ) : Prop :=\n ∀ x y, I.metric.distance x y ≤ ((bound.eval I.size : ℕ) : ℚ)\n\nnoncomputable def assign (I : Input) (O : Finset I.Point) (p : I.Point) : I.Point :=\n if h : O.Nonempty then\n Classical.choose (Finset.exists_min_image O\n (fun i => toLex (I.metric.distance p i, i)) h)\n else p\n\nnoncomputable def cluster (I : Input) (O : Finset I.Point) (i : I.Point) : Finset I.Point :=\n I.metric.clients.filter (fun p => I.assign O p = i)\n\nnoncomputable def clusterCost (I : Input) (O : Finset I.Point) (i : I.Point) : ℝ :=\n ∑ p ∈ I.cluster O i, (I.metric.distance p i : ℝ)\n\ndef anchorBits (I : Input) : List Bool :=\n List.ofFn (fun i : I.Point => decide (i ∈ I.anchor))\n\nend Input\n\nstructure Certificate (I : Input) (μ : ℚ) (L₀ : ℝ) where\n centers : Finset I.Point\n centers_subset : centers ⊆ I.metric.facilities\n same_card : centers.card = I.anchor.card\n positive_cost : 0 < (I.metric.cost centers : ℝ)\n good : Finset I.Point\n good_subset : good ⊆ centers\n proxy : I.Point → I.Point\n proxy_mem : ∀ i ∈ good, proxy i ∈ I.anchor\n proxy_inj : Set.InjOn proxy (↑good)\n proxy_cost : (∑ i ∈ good, ∑ p ∈ I.cluster centers i,\n (I.metric.distance p (proxy i) : ℝ)) ≤\n (∑ i ∈ good, I.clusterCost centers i) + (μ : ℝ) * (I.metric.cost centers : ℝ)\n few_bad : (((centers \\ good).card : ℕ) : ℝ) ≤ L₀ * Real.log (I.size : ℝ)\n\nnoncomputable def precision (ζ : ℝ) : ℕ :=\n ⌈Real.log (1 / ζ) / Real.log 2⌉₊\n\nnoncomputable def queryBits (I : Input) (ζ : ℝ) : List Bool :=\n pairBits (I.metric.bits, I.anchorBits ++ List.replicate (precision ζ) true)\n\nnoncomputable def seedLength (A : BinaryRandomizedAlgorithm) (I : Input) (ζ : ℝ) : ℕ :=\n A.randomBits.eval (queryBits I ζ).length\n\nabbrev Seed (A : BinaryRandomizedAlgorithm) (I : Input) (ζ : ℝ) :=\n Fin (seedLength A I ζ) → Bool\n\nnoncomputable def output (A : BinaryRandomizedAlgorithm) (I : Input) (ζ : ℝ)\n (s : Seed A I ζ) : Finset I.Point :=\n I.metric.decodeOutput (A.run (queryBits I ζ, List.ofFn s))\n\nnoncomputable def successProbability (A : BinaryRandomizedAlgorithm) (I : Input)\n (ζ target : ℝ) : ℝ := by\n classical\n exact ((Finset.univ.filter (fun s : Seed A I ζ =>\n (I.metric.cost (output A I ζ s) : ℝ) ≤ target)).card : ℝ) /\n 2 ^ seedLength A I ζ\n\nnoncomputable def workBound (A : BinaryRandomizedAlgorithm) (I : Input) (ζ : ℝ) : ℕ :=\n (queryBits I ζ).length + seedLength A I ζ +\n A.computation.time.eval (pairBits\n (queryBits I ζ, List.replicate (seedLength A I ζ) false)).length\n\ndef PolynomialWork (A : BinaryRandomizedAlgorithm) (bound : Polynomial ℕ) : Prop :=\n ∃ c : ℝ, 0 < c ∧ ∃ d : ℕ,\n ∀ I : Input, I.Bounded bound → ∀ ζ : ℝ, 0 < ζ → ζ < 1 →\n (workBound A I ζ : ℝ) ≤\n c * ((I.size : ℝ) + 1) ^ d * (1 + Real.log (1 / ζ)) ^ d\n\n\nend MetricKMedianRecovery.RefinedRecovery\n\nnamespace MetricKMedianRecovery.RefinedRecovery\n\ntheorem refined_recovery :\n ∀ (bound : Polynomial ℕ) (ε L₀ : ℝ) (μ : ℚ),\n 0 < ε → 0 < L₀ → 0 < μ → μ ≤ 1/4 → (μ : ℝ) ≤ ε/12 →\n ∃ A : BinaryRandomizedAlgorithm,\n PolynomialWork A bound ∧\n ∀ I : Input, I.Bounded bound → ∀ ζ : ℝ, 0 < ζ → ζ < 1 →\n (∀ s : Seed A I ζ, I.metric.Feasible (output A I ζ s)) ∧\n (∀ C : Certificate I μ L₀,\n 1 - ζ ≤ successProbability A I ζ\n ((1 + 2 / Real.exp 1 + ε) * (I.metric.cost C.centers : ℝ))) := by\n sorry\n\nend MetricKMedianRecovery.RefinedRecovery\n\nend OAI\n", "-- ComparatorChallenges/KMedianThreshold.lean\nimport Mathlib\n\nnamespace OAI\n\nsection\nsection\nnamespace MetricKMedian\n\nstructure Instance where\n n : ℕ\n distance : Fin n → Fin n → ℚ\n clients : Finset (Fin n)\n facilities : Finset (Fin n)\n k : ℕ\n distance_nonneg : ∀ i j, 0 ≤ distance i j\n distance_eq_zero : ∀ i j, distance i j = 0 ↔ i = j\n distance_symm : ∀ i j, distance i j = distance j i\n distance_triangle : ∀ i j h, distance i h ≤ distance i j + distance j h\n k_pos : 1 ≤ k\n k_le : k ≤ facilities.card\n\ndef encodeNat (n : ℕ) : List Bool :=\n List.replicate n.bits.length true ++ [false] ++ n.bits\n\ndef encodeRat (q : ℚ) : List Bool :=\n [decide (q.num < 0)] ++ encodeNat q.num.natAbs ++ encodeNat q.den\n\ndef encodeInstance (I : Instance) : List Bool :=\n encodeNat I.n ++ encodeNat I.k ++\n List.ofFn (fun i : Fin I.n => decide (i ∈ I.clients)) ++\n List.ofFn (fun i : Fin I.n => decide (i ∈ I.facilities)) ++\n (List.ofFn (fun i : Fin I.n =>\n (List.ofFn (fun j : Fin I.n => encodeRat (I.distance i j))).flatten)).flatten\n\nnoncomputable def nearest (I : Instance) (j : Fin I.n) (S : Finset (Fin I.n)) : ℝ :=\n if h : S.Nonempty then\n (S.image (fun i => (I.distance j i : ℝ))).min' (h.image _)\n else 0\n\nnoncomputable def cost (I : Instance) (S : Finset (Fin I.n)) : ℝ :=\n ∑ j ∈ I.clients, nearest I j S\n\ndef feasibleSets (I : Instance) : Finset (Finset (Fin I.n)) :=\n I.facilities.powerset.filter (fun S => S.Nonempty ∧ S.card ≤ I.k)\n\nnoncomputable def optimum (I : Instance) : ℝ :=\n if h : (feasibleSets I).Nonempty then\n ((feasibleSets I).image (cost I)).min' (h.image _)\n else 0\n\ndef Correct (epsilon : ℝ) (I : Instance) (output : List Bool) : Prop :=\n ∃ S : Finset (Fin I.n), S ⊆ I.facilities ∧ S.Nonempty ∧ S.card ≤ I.k ∧\n output = List.ofFn (fun i : Fin I.n => decide (i ∈ S)) ∧\n cost I S ≤ (1 + 2 / Real.exp 1 + epsilon) * optimum I\n\nend MetricKMedian\nend\nend\n\nnamespace MetricKMedian\nnamespace Complexity\n/-- Polynomial-time computation with every physical work alphabet finite. -/\ndef FinitePolyTime {α β : Type} (ea : α → List Bool) (eb : β → List Bool)\n (f : α → β) : Prop :=\n ∃ p : Turing.TM2ComputableInPolyTime ea eb f,\n ∀ k : p.tm.K, Finite (p.tm.Γ k)\n\nabbrev Word := List Bool\nabbrev Language := Set Word\n\ndef encodeBit (b : Bool) : Word := [b]\n\ndef encodePair (x : Word × Word) : Word :=\n encodeNat x.1.length ++ x.1 ++ x.2\n\ndef P : Set Language := {L | ∃ decideL : Word → Bool,\n FinitePolyTime id encodeBit decideL ∧ ∀ x, decideL x = true ↔ x ∈ L}\n\ndef NP : Set Language := {L | ∃ (verify : Word × Word → Bool) (p : Polynomial ℕ),\n FinitePolyTime encodePair encodeBit verify ∧\n ∀ x, x ∈ L ↔ ∃ w : Word, w.length ≤ p.eval x.length ∧ verify (x, w) = true}\n\n/-- Separation of deterministic polynomial time from finite-verifier nondeterministic polynomial time. -/\ndef PNeNP : Prop := P ≠ NP\n\nend Complexity\n/-- An actual nonempty feasible facility set, encoded by its membership mask. -/\ndef FactorCorrect (α : ℝ) (I : Instance) (output : List Bool) : Prop :=\n ∃ S : Finset (Fin I.n), S ⊆ I.facilities ∧ S.Nonempty ∧ S.card ≤ I.k ∧\n output = List.ofFn (fun i : Fin I.n => decide (i ∈ S)) ∧\n cost I S ≤ α * optimum I\n\n/-- Deterministic polynomial-time approximation factors for arbitrary specified clients and facilities. -/\ndef approximationFactors : Set ℝ := {α | ∃ algorithm : Instance → List Bool,\n Complexity.FinitePolyTime encodeInstance id algorithm ∧\n ∀ I, FactorCorrect α I (algorithm I)}\n\nend MetricKMedian\n\nnamespace MetricKMedian\n/-- The deterministic approximation threshold is an infimum; its attainment is not asserted. -/\ntheorem threshold (h : Complexity.PNeNP) :\n sInf approximationFactors=1+2/Real.exp 1 := by\n sorry\nend MetricKMedian\n\nend OAI\n", "-- ComparatorChallenges/MetricKMedian.lean\nimport Mathlib\n\nnamespace OAI\n\n\n\n\nsection\nsection\nnamespace MetricKMedian\n\nstructure Instance where\n n : ℕ\n distance : Fin n → Fin n → ℚ\n clients : Finset (Fin n)\n facilities : Finset (Fin n)\n k : ℕ\n distance_nonneg : ∀ i j, 0 ≤ distance i j\n distance_eq_zero : ∀ i j, distance i j = 0 ↔ i = j\n distance_symm : ∀ i j, distance i j = distance j i\n distance_triangle : ∀ i j h, distance i h ≤ distance i j + distance j h\n k_pos : 1 ≤ k\n k_le : k ≤ facilities.card\n\ndef encodeNat (n : ℕ) : List Bool :=\n List.replicate n.bits.length true ++ [false] ++ n.bits\n\ndef encodeRat (q : ℚ) : List Bool :=\n [decide (q.num < 0)] ++ encodeNat q.num.natAbs ++ encodeNat q.den\n\ndef encodeInstance (I : Instance) : List Bool :=\n encodeNat I.n ++ encodeNat I.k ++\n List.ofFn (fun i : Fin I.n => decide (i ∈ I.clients)) ++\n List.ofFn (fun i : Fin I.n => decide (i ∈ I.facilities)) ++\n (List.ofFn (fun i : Fin I.n =>\n (List.ofFn (fun j : Fin I.n => encodeRat (I.distance i j))).flatten)).flatten\n\nnoncomputable def nearest (I : Instance) (j : Fin I.n) (S : Finset (Fin I.n)) : ℝ :=\n if h : S.Nonempty then\n (S.image (fun i => (I.distance j i : ℝ))).min' (h.image _)\n else 0\n\nnoncomputable def cost (I : Instance) (S : Finset (Fin I.n)) : ℝ :=\n ∑ j ∈ I.clients, nearest I j S\n\ndef feasibleSets (I : Instance) : Finset (Finset (Fin I.n)) :=\n I.facilities.powerset.filter (fun S => S.Nonempty ∧ S.card ≤ I.k)\n\nnoncomputable def optimum (I : Instance) : ℝ :=\n if h : (feasibleSets I).Nonempty then\n ((feasibleSets I).image (cost I)).min' (h.image _)\n else 0\n\ndef Correct (epsilon : ℝ) (I : Instance) (output : List Bool) : Prop :=\n ∃ S : Finset (Fin I.n), S ⊆ I.facilities ∧ S.Nonempty ∧ S.card ≤ I.k ∧\n output = List.ofFn (fun i : Fin I.n => decide (i ∈ S)) ∧\n cost I S ≤ (1 + 2 / Real.exp 1 + epsilon) * optimum I\n\ntheorem main_finite_work : ∀ ε : ℝ, 0 < ε →\n ∃ (algorithm : Instance → List Bool) (P : Turing.TM2ComputableInPolyTime encodeInstance id algorithm),\n (∀ k : P.tm.K, Finite (P.tm.Γ k)) ∧ ∀ I, Correct ε I (algorithm I) := by\n sorry\n\nend MetricKMedian\nend\nend\n\nend OAI\n"], "formalization_scope": "The formalization gives an exact-budget recovery algorithm for metric $k$-median on the stated polynomially bounded integral metrics. Suppose a supplied anchor represents all but logarithmically many comparison clusters by distinct proxies, with total proxy cost at most the comparison cost plus a sufficiently small relative error. The algorithm always opens at most $k$ facilities and, with any requested confidence, attains a $(1+2/e+\\varepsilon)$ factor relative to those comparison centers in polynomial time.\n\nThe linked final approximation result applies to arbitrary finite rational metrics. For one absolute $\\sigma>0$, a polynomial-time fair-bit algorithm always returns a feasible solution, has expected cost at most $(2-\\sigma)\\mathrm{OPT}$, and attains the same factor with arbitrarily high polynomial confidence.\n\nThe formalization gives, for every fixed $\\varepsilon>0$, a deterministic polynomial-time $(1+2/e+\\varepsilon)$-approximation for metric $k$-median on finite rational metrics with specified candidate facilities. Every output is a nonempty subset of the candidate facilities and opens at most $k$ of them.\n\nAssuming $P\\ne NP$, it also proves that the infimum of all polynomial-time approximation factors in this model is exactly $1+2/e$.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The statements main_finite_work and threshold together capture the catalogue claim: for every ε>0 there is a deterministic finite-alphabet polynomial-time algorithm outputting a feasible set of at most k candidate facilities with cost ≤(1+2/e+ε)OPT, and under a formal P≠NP the infimum of deterministic polynomial-time approximation factors is 1+2/e. The definitions of instance, feasible sets, cost, optimum, and polynomial-time computation match the usual finite rational metric k-median model. The only deviations are standard WLOG restrictions such as k≤|F|, positive metric distances, and nonempty feasible outputs, plus additional recovery theorems, so the main claim is faithfully expressed.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures both parts of the main claim: (1) the deterministic polynomial-time (1+2/e+ε)-approximation is expressed by `main_finite_work` in `MetricKMedian.lean`, which asserts existence of a deterministic poly-time algorithm achieving the approximation for every ε > 0; (2) the hardness result that the infimum approximation factor is 1+2/e under P≠NP is expressed by `threshold` in `KMedianThreshold.lean`. The definitions of `Instance`, `cost`, `optimum`, and `Correct` align with the standard k-median problem formulation with specified candidate facilities. The complexity class formalization via `FinitePolyTime` appropriately models deterministic polynomial-time computation. No extraneous hypotheses or weakened bounds are present.\", \"score\": 5}"}}
{"family": "134", "title": "Generalized star height at most three", "claim": "Generalized star height at most three. Every regular language over a finite alphabet has a generalized regular expression with at most three nested Kleene stars, allowing union, concatenation and complement over the same alphabet. This establishes an absolute bound independent of automaton size, resolving the uniform-boundedness version of the generalized star-height problem.", "abstracts": ["Every regular language over a finite alphabet has a generalized regular expression of star height at most thirteen over that same alphabet. We prove this uniform bound by representing finite monoid computations as affine updates and recovering them through twelve successive split constructions.", "Every regular language over a finite alphabet has generalized star height at most four over that same alphabet. We give a complete construction using an affine correction that hides one interval product, a finite clock, and several scales for moving boundaries through periodic words.", "Every regular language over a finite alphabet has generalized star height at most three, with complement taken in the same free monoid. We express finite-monoid computations using a prefix code of word pieces."], "papers": ["https://github.com/openai/math/tree/main/preprints/Finite-Monoid-Computations-and-a-Uniform-Generalized-Star-Height-Bound-September-25-2026", "https://github.com/openai/math/tree/main/preprints/Generalized-Star-Height-at-Most-Four-September-25-2026", "https://github.com/openai/math/tree/main/preprints/Generalized-Star-Height-at-Most-Three-September-25-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/GeneralizedStarHeight.lean"], "lean_statements": ["-- ComparatorChallenges/GeneralizedStarHeight.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace GeneralizedStarHeight\n\nuniverse u\n\ninductive Expression (Alphabet : Type u) : Type u\n | zero : Expression Alphabet\n | one : Expression Alphabet\n | letter : Alphabet → Expression Alphabet\n | union : Expression Alphabet → Expression Alphabet → Expression Alphabet\n | concat : Expression Alphabet → Expression Alphabet → Expression Alphabet\n | compl : Expression Alphabet → Expression Alphabet\n | star : Expression Alphabet → Expression Alphabet\n\nnamespace Expression\n\nopen scoped Computability\n\ndef language {Alphabet : Type u} : Expression Alphabet → Language Alphabet\n | .zero => 0\n | .one => 1\n | .letter a => {[a]}\n | .union P Q => P.language + Q.language\n | .concat P Q => P.language * Q.language\n | .compl P => P.languageᶜ\n | .star P => P.language∗\n\ndef height {Alphabet : Type u} : Expression Alphabet → ℕ\n | .zero | .one | .letter _ => 0\n | .union P Q | .concat P Q => max P.height Q.height\n | .compl P => P.height\n | .star P => 1 + P.height\n\nend Expression\n\ndef HasHeightAtMost {Alphabet : Type u} (L : Language Alphabet) (n : ℕ) : Prop :=\n ∃ P : Expression Alphabet, P.language = L ∧ P.height ≤ n\n\ntheorem main {Alphabet : Type u} [Finite Alphabet] (L : Language Alphabet) (hL : L.IsRegular) :\n HasHeightAtMost L 3 := by\n sorry\n\nend GeneralizedStarHeight\n\nend OAI\n"], "formalization_scope": "Generalized star height measures the nesting of Kleene stars in regular expressions that also allow Boolean operations. The formalization proves that every regular language over a finite alphabet has a generalized expression over the same alphabet of star height at most three. This is stronger than the bound of thirteen in the accompanying finite-monoid paper. The selected statement asserts the uniform expression bound, without separately encoding every construction step of that paper.\n\nThe formalization proves that every regular language over a finite alphabet has a generalized regular expression over that same alphabet with star height at most three. Generalized expressions allow Boolean operations as well as concatenation and Kleene star. The bound of three implies the accompanying paper's bound of four; the selected statement concerns the expression bound itself.\n\nGeneralized star height measures the nesting of Kleene stars in regular expressions that also allow Boolean operations. The formalization proves that every regular language over a finite alphabet has a generalized regular expression over that same alphabet of star height at most three. Complements are taken in the same free monoid. This is the paper's uniform bound.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement quantifies over every finite alphabet and every regular language L, and asserts the existence of an expression whose denoted language is exactly L and whose star height is at most 3. The Expression language includes union, concatenation, complement, and Kleene star over the same alphabet, and the height definition counts nested stars in the standard way, with complement not increasing height. This matches the main claim of a uniform generalized star-height bound of three.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean theorem `main` precisely formalizes the main claim. It asserts that for any finite alphabet and any regular language over it, there exists an expression in the defined `Expression` type with star height at most 3 (measured by the `height` function, where `star` adds 1 to the height of its subexpression) that denotes exactly that language. The definitions of `Expression`, `language`, and `height` align with the standard mathematical definitions of generalized regular expressions and star height, including support for union, concatenation, and complement. The hypothesis `[Finite Alphabet]` and `hL : L.IsRegular` correctly capture the constraints on the alphabet and the language class.\", \"score\": 5}"}}
{"family": "139", "title": "Subpolynomial query complexity for log-concave sampling", "claim": "Subpolynomial query complexity for log-concave sampling. For C2 potentials with a supplied minimizer and $`I\\preceq\\nabla^2V\\preceq2I`$, proves that sampling within total variation 1/10 requires only $`C_\\varepsilon d^\\varepsilon`$ exact value-and-gradient queries for every fixed ε > 0. The bound holds on every run, with unrestricted computation between queries. A logarithmic lower bound also holds, so the optimal power-law exponent in this oracle model is zero.", "abstracts": ["For every fixed $\\varepsilon>0$, we give a sampling algorithm using at most $C_\\varepsilon d^\\varepsilon$ exact first-order queries on every execution for $C^2$ potentials on $\\R^d$ with a known minimizer and Hessian between $I_d$ and $2I_d$. The output has total-variation distance at most $1/10$ from the target Gibbs law. Computation between queries is unrestricted. We also prove an $\\Omega(\\log d)$ query lower bound for arbitrary randomized adaptive algorithms, determining the optimal dimension exponent to be zero."], "papers": ["https://github.com/openai/math/tree/main/preprints/Subpolynomial-query-complexity-for-well-conditioned-log-concave-sampling-September-26-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/LogConcaveQuery.lean"], "lean_statements": ["-- ComparatorChallenges/LogConcaveQuery.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nopen MeasureTheory Filter\nopen scoped ENNReal NNReal Topology\n\nnamespace LogConcaveSampling\n\nabbrev Point (d : ℕ) := EuclideanSpace ℝ (Fin d)\nabbrev Reply (d : ℕ) := ℝ × Point d\nabbrev Transcript (d q : ℕ) := Fin q → Reply d\n\n/-- Normalized twice continuously differentiable potentials with Hessian between the identity and twice the identity. -/\nstructure Admissible {d : ℕ} (V : Point d → ℝ) : Prop where\n smooth : ContDiff ℝ 2 V\n value_zero : V 0 = 0\n gradient_zero : gradient V 0 = 0\n hessian_bounds : ∀ x v : Point d,\n ‖v‖ ^ 2 ≤ inner ℝ v (fderiv ℝ (gradient V) x v) ∧\n inner ℝ v (fderiv ℝ (gradient V) x v) ≤ 2 * ‖v‖ ^ 2\n\n/-- The unnormalized Gibbs density relative to Euclidean volume. -/\ndef gibbsDensity {d : ℕ} (V : Point d → ℝ) (x : Point d) : ℝ≥0∞ :=\n ENNReal.ofReal (Real.exp (-V x))\n\ndef partition {d : ℕ} (V : Point d → ℝ) : ℝ≥0∞ :=\n ∫⁻ x, gibbsDensity V x ∂volume\n\n/-- The Gibbs probability law, normalized by its partition function. -/\ndef gibbs {d : ℕ} (V : Point d → ℝ) : Measure (Point d) :=\n (partition V)⁻¹ • volume.withDensity (gibbsDensity V)\n\ndef TVAtMost {E : Type*} [MeasurableSpace E]\n (μ ν : Measure E) (ε : ℝ) : Prop :=\n ∀ s : Set E, MeasurableSet s → |μ.real s - ν.real s| ≤ ε\n\ndef firstOrderReply {d : ℕ} (V : Point d → ℝ) (x : Point d) : Reply d :=\n (V x, gradient V x)\n\n/-- Measurable adaptive queries and output, parametrized by private randomness. -/\nstructure OracleAlgorithm (Ω : Type*) [MeasurableSpace Ω] (d q : ℕ) where\n query : Fin q → Ω × Transcript d q → Point d\n query_measurable : ∀ i, Measurable (query i)\n output : Ω × Transcript d q → Point d\n output_measurable : Measurable output\n\ndef OracleAlgorithm.history {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}\n (A : OracleAlgorithm Ω d q) (V : Point d → ℝ) (ω : Ω) : ℕ → Transcript d q\n | 0 => 0\n | n + 1 =>\n let h := A.history V ω n\n if hn : n < q then\n Function.update h ⟨n, hn⟩ (firstOrderReply V (A.query ⟨n, hn⟩ (ω, h)))\n else h\n\ndef OracleAlgorithm.run {Ω : Type*} [MeasurableSpace Ω] {d q : ℕ}\n (A : OracleAlgorithm Ω d q) (V : Point d → ℝ) (ω : Ω) : Point d :=\n A.output (ω, A.history V ω q)\n\n/-- A uniform sampler with a deterministic query budget on every execution and total-variation error at most one tenth. -/\ndef CanSample (d q : ℕ) : Prop :=\n ∃ (Ω : Type) (_ : MeasurableSpace Ω) (μ : Measure Ω)\n (_ : IsProbabilityMeasure μ) (A : OracleAlgorithm Ω d q),\n ∀ V : Point d → ℝ, Admissible V →\n Measurable (A.run V) ∧ TVAtMost (μ.map (A.run V)) (gibbs V) (1 / 10)\n\n/-- The smallest feasible integer query budget, or infinity when no budget is feasible. -/\ndef queryComplexity (d : ℕ) : ℕ∞ :=\n sInf ((fun q : ℕ => (q : ℕ∞)) '' {q | CanSample d q})\n\n/-- The quantified dimension-exponent upper bound with every positive exponent slack. -/\ndef ExponentBound (γ : ℝ) : Prop :=\n 0 ≤ γ ∧ ∀ ε : ℝ, 0 < ε → ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →\n (queryComplexity d).toENNReal ≤ ENNReal.ofReal ((d : ℝ) ^ (γ + ε))\n\ndef gammaStar : ℝ := sInf {γ : ℝ | ExponentBound γ}\n\ntheorem exact_source_main :\n (∀ ε : ℝ, 0 < ε → ∃ C : ℝ, ∀ d : ℕ, 2 ≤ d →\n (queryComplexity d).toENNReal ≤ ENNReal.ofReal (C * (d : ℝ) ^ ε)) ∧\n (∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, 2 ≤ d₀ ∧ ∀ d : ℕ, d₀ ≤ d →\n ENNReal.ofReal (c * Real.log (d : ℝ)) ≤ (queryComplexity d).toENNReal) ∧\n gammaStar = 0 := by\n sorry\n\nend LogConcaveSampling\n\nend\n\nend OAI\n"], "formalization_scope": "The formalized result determines the dimension exponent of exact value-and-gradient query complexity for well-conditioned log-concave sampling. For potentials with $V(0)=0$, $\\nabla V(0)=0$, and $I\\le\\nabla^2V\\le2I$, the least worst-case query budget achieving total-variation error at most $1/10$ is at most $C_\\varepsilon d^\\varepsilon$ for every $\\varepsilon>0$, and at least $c\\log d$ eventually. Hence the infimal polynomial exponent is zero. Algorithms may be measurable, randomized, and adaptive; arithmetic and bit costs are not bounded.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement formalizes adaptive randomized algorithms with a fixed deterministic query budget, exact value-and-gradient replies, admissible C^2 potentials with Hessian bounds, and TV error 1/10. It states the desired C_ε d^ε upper bound via the minimal feasible query budget, an Ω(log d) lower bound, and gammaStar=0. The only notable difference is normalizing the supplied minimizer to 0 and V(0)=0, which is an innocuous coordinate/constant normalization. Thus it faithfully captures the main claim up to minor technical conventions.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures the main claim. The `Admissible` structure correctly encodes C² potentials with a known minimizer (at 0) and Hessian bounded between I and 2I. The `CanSample` definition properly models randomized adaptive algorithms with a fixed query budget q and TV distance ≤ 1/10. The `queryComplexity` is defined as the infimum of feasible query budgets, and the `exact_source_main` theorem combines the upper bound (C_ε d^ε for every ε > 0), the logarithmic lower bound (Ω(log d)), and the conclusion that the optimal exponent gammaStar = 0. All definitions match the mathematical claim without extra hypotheses or weakening of bounds.\", \"score\": 5}"}}
{"family": "158", "title": "The Euclidean plane cannot be colored with five colors", "claim": "The Euclidean plane cannot be colored with five colors. Proves that every five-coloring of the Euclidean plane has a monochromatic pair at distance one, with no restriction on the color classes. This advances the Hadwiger–Nelson problem: together with the classical seven-coloring, only six and seven remain possible chromatic numbers of the plane.", "abstracts": ["We prove that every coloring of the Euclidean plane with five colors has a monochromatic unit-distance pair, with no regularity assumption on the color classes. Consequently, the chromatic number of the plane is either six or seven."], "papers": ["https://github.com/openai/math/tree/main/preprints/The-Euclidean-plane-is-not-five-colorable-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/EuclideanFiveColor.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/PlaneColoring.lean"], "lean_statements": ["-- ComparatorChallenges/EuclideanFiveColor.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace EuclideanFiveColor\n\ndef ProperColoring (colorCount : ℕ) (coloring : ℂ → Fin colorCount) : Prop :=\n ∀ point otherPoint : ℂ, ‖point - otherPoint‖ = 1 → coloring point ≠ coloring otherPoint\n\ntheorem no_proper_five_coloring : ¬ ∃ coloring : ℂ → Fin 5, ProperColoring 5 coloring := by\n sorry\n\nend EuclideanFiveColor\n\nend OAI\n", "-- ComparatorChallenges/PlaneColoring.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace Problem160\n\nabbrev Plane := EuclideanSpace ℝ (Fin 2)\n\ndef ProperColoring (k : ℕ) : Prop :=\n ∃ c : Plane → Fin k,\n ∀ x y : Plane, dist x y = 1 → c x ≠ c y\n\ntheorem properColoring_seven : ProperColoring 7 := by sorry\n\nend Problem160\n\nend\n\nend OAI\n"], "formalization_scope": "The Hadwiger–Nelson problem asks for the fewest colors needed to color the plane so that points at distance one have different colors. The formalized results prove that five colors do not suffice and that seven colors do suffice. The lower bound applies to arbitrary colorings, with no measurability or continuity assumption; the upper bound includes every boundary point of the coloring regions.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The theorem no_proper_five_coloring states that there is no map ℂ → Fin 5 such that all unit-distance pairs receive different colors, which is exactly the claim that every five-coloring of the Euclidean plane has a monochromatic unit-distance pair. The definition of ProperColoring uses the Euclidean norm/dist and imposes no regularity assumptions on color classes. The additional properColoring_seven supplies the classical upper bound, so together the statements imply the chromatic number is 6 or 7. Any differences, such as using ℂ versus EuclideanSpace ℝ (Fin 2) or negated existence versus a direct ∀∃ formulation, are only technical.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement in EuclideanFiveColor.lean precisely formalizes the main claim: it asserts that no proper 5-coloring of the Euclidean plane exists (¬∃ coloring : ℂ → Fin 5, ProperColoring 5 coloring), which is logically equivalent to 'every five-coloring has a monochromatic unit-distance pair.' The definition of ProperColoring correctly captures the standard meaning (no two points at distance 1 share the same color). The use of ℂ as the domain is isomorphic to ℝ² and correctly represents the Euclidean plane with the Euclidean norm. The second file (PlaneColoring.lean) provides context about the 7-coloring but does not affect the faithfulness of the main claim. There are no extra hypotheses, no vacuousness, and no weakening of the claim.\", \"score\": 5}"}}
{"family": "162", "title": "Counterexamples to Ryser’s covering conjecture", "claim": "Counterexamples to Ryser’s covering conjecture. Disproves Ryser's covering conjecture by constructing intersecting $`(q+1)`$-partite, $`(q+1)`$-uniform hypergraphs with covering number $`q+1`$, rather than the predicted bound q, for every sufficiently large prime q. A separate construction over extension fields also disproves Gyárfás's monochromatic tree-cover conjecture.", "abstracts": ["For every sufficiently large prime $s\\equiv2\\pmod3$ and every sufficiently large odd integer $n$, with the threshold depending on $s$, we construct an intersecting $(s^n+1)$-partite $(s^n+1)$-uniform hypergraph with covering number $s^n+1$. This disproves Ryser's covering conjecture in its intersecting case.", "For every sufficiently large prime $q$, we construct a finite intersecting $(q+1)$-partite $(q+1)$-uniform hypergraph with covering number $q+1$ and exactly $q+1$ nonisolated vertices in each part. This disproves Ryser's covering conjecture, even for intersecting hypergraphs with equally sized parts."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-Counterexample-to-Rysers-Covering-Conjecture-September-23-2026", "https://github.com/openai/math/tree/main/preprints/Balanced-Counterexamples-to-Rysers-Conjecture-at-Prime-Orders-September-27-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/BalancedRyser.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/RyserCovering.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/RyserOddExtensions.lean"], "lean_statements": ["-- ComparatorChallenges/BalancedRyser.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace Balanced\nopen scoped _root_.Balanced\n\nstructure PartiteHypergraph (r n : ℕ) where\n edges : Finset (Fin r → Fin n)\n\nnamespace PartiteHypergraph\n\nvariable {r n : ℕ}\n\nabbrev Vertex (r n : ℕ) := Fin r × Fin n\n\ndef Covers (H : PartiteHypergraph r n) (C : Finset (Vertex r n)) : Prop :=\n ∀ e ∈ H.edges, ∃ i, (i, e i) ∈ C\n\ndef Intersecting (H : PartiteHypergraph r n) : Prop :=\n H.edges.Nonempty ∧ ∀ e ∈ H.edges, ∀ f ∈ H.edges, ∃ i, e i = f i\n\ndef Nonisolated (H : PartiteHypergraph r n) : Prop :=\n ∀ i v, ∃ e ∈ H.edges, e i = v\n\ndef HasCoverNumber (H : PartiteHypergraph r n) (k : ℕ) : Prop :=\n (∃ C : Finset (Vertex r n), H.Covers C ∧ C.card = k) ∧\n ∀ C : Finset (Vertex r n), H.Covers C → k ≤ C.card\n\nend PartiteHypergraph\n\ndef BalancedCounterexample (q : ℕ) : Prop :=\n ∃ H : PartiteHypergraph (q + 1) (q + 1),\n H.Intersecting ∧ H.Nonisolated ∧ H.HasCoverNumber (q + 1)\n\ndef MainResult : Prop :=\n ∃ q₀ : ℕ, ∀ q : ℕ, q₀ ≤ q → q.Prime → BalancedCounterexample q\n\ntheorem main_result : MainResult := by\n sorry\n\nend Balanced\n\nend OAI\n", "-- ComparatorChallenges/RyserCovering.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace RyserCoveringCounterexample\n\nabbrev Hypergraph (V : Type*) := Finset (Finset V)\n\nsection\n\nvariable {V : Type*} [DecidableEq V]\n\ndef IsCover (H : Hypergraph V) (C : Finset V) : Prop :=\n ∀ e ∈ H, ∃ v ∈ C, v ∈ e\n\ndef Intersecting (H : Hypergraph V) : Prop :=\n ∀ e ∈ H, ∀ f ∈ H, e ≠ f → (e ∩ f).Nonempty\n\nattribute [-instance] instDecidablePairwiseCoeFinsetOfDecidableEqOfDecidableRel in\ndef matchings (H : Hypergraph V) : Finset (Hypergraph V) := by\n classical\n exact H.powerset.filter fun M => (M : Set (Finset V)).Pairwise Disjoint\n\ndef matchingNumber (H : Hypergraph V) : ℕ := (matchings H).sup Finset.card\n\ndef coverCardinalities (H : Hypergraph V) : Set ℕ :=\n {n | ∃ C : Finset V, IsCover H C ∧ C.card = n}\n\ndef coverNumber (H : Hypergraph V) : ℕ := sInf (coverCardinalities H)\n\ndef PartiteUniform {I : Type*} (part : V → I) (H : Hypergraph V) : Prop :=\n ∀ e ∈ H, ∀ i : I, ∃! v : V, v ∈ e ∧ part v = i\n\ndef RPartiteUniform (r : ℕ) (H : Hypergraph V) : Prop :=\n ∃ part : V → Fin r, PartiteUniform part H\n\nend\n\ndef CounterexampleRank (r : ℕ) : Prop :=\n ∃ (V : Type) (fin : Fintype V) (dec : DecidableEq V),\n letI : Fintype V := fin\n letI : DecidableEq V := dec\n ∃ H : Hypergraph V,\n 0 < r ∧ H.Nonempty ∧ RPartiteUniform r H ∧ Intersecting H ∧\n (∃ C : Finset V, IsCover H C) ∧ matchingNumber H = 1 ∧ coverNumber H = r\n\ntheorem exists_prime_eventually_counterexampleRank :\n ∃ p : ℕ, p.Prime ∧ 5 < p ∧ p % 3 = 2 ∧\n ∃ N : ℕ, ∀ n : ℕ, N ≤ n → n.Prime → 2 < n →\n CounterexampleRank (p ^ n + 1) := by\n sorry\n\nend RyserCoveringCounterexample\n\nend\n\nend OAI\n", "-- ComparatorChallenges/RyserOddExtensions.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace RyserCoveringCounterexample\n\nabbrev Hypergraph (Vertex : Type*) := Finset (Finset Vertex)\n\nvariable {Vertex : Type*} [DecidableEq Vertex]\n\ndef IsCover (hypergraph : Hypergraph Vertex) (cover : Finset Vertex) : Prop :=\n ∀ edge ∈ hypergraph, ∃ vertex ∈ cover, vertex ∈ edge\n\ndef Intersecting (hypergraph : Hypergraph Vertex) : Prop :=\n ∀ edge ∈ hypergraph, ∀ other ∈ hypergraph, edge ≠ other → (edge ∩ other).Nonempty\n\nattribute [-instance] instDecidablePairwiseCoeFinsetOfDecidableEqOfDecidableRel in\ndef matchings (hypergraph : Hypergraph Vertex) : Finset (Hypergraph Vertex) := by\n classical\n exact hypergraph.powerset.filter fun matching =>\n (matching : Set (Finset Vertex)).Pairwise Disjoint\n\ndef matchingNumber (hypergraph : Hypergraph Vertex) : ℕ :=\n (matchings hypergraph).sup Finset.card\n\ndef coverCardinalities (hypergraph : Hypergraph Vertex) : Set ℕ :=\n {size | ∃ cover : Finset Vertex, IsCover hypergraph cover ∧ cover.card = size}\n\ndef coverNumber (hypergraph : Hypergraph Vertex) : ℕ := sInf (coverCardinalities hypergraph)\n\ndef Uniform (rank : ℕ) (hypergraph : Hypergraph Vertex) : Prop :=\n ∀ edge ∈ hypergraph, edge.card = rank\n\ndef PartiteUniform {Index : Type*} (part : Vertex → Index)\n (hypergraph : Hypergraph Vertex) : Prop :=\n ∀ edge ∈ hypergraph, ∀ index : Index,\n ∃! vertex : Vertex, vertex ∈ edge ∧ part vertex = index\n\ndef RPartiteUniform (rank : ℕ) (hypergraph : Hypergraph Vertex) : Prop :=\n ∃ part : Vertex → Fin rank, PartiteUniform part hypergraph\n\nend RyserCoveringCounterexample\n\nnamespace RyserOdd\n\nopen RyserCoveringCounterexample\n\ndef Specification.ExplicitFailureAt (rank : ℕ) : Prop :=\n ∃ (Vertex : Type) (finiteVertices : Fintype Vertex) (decidableVertices : DecidableEq Vertex),\n letI : Fintype Vertex := finiteVertices\n letI : DecidableEq Vertex := decidableVertices\n ∃ hypergraph : RyserCoveringCounterexample.Hypergraph Vertex,\n 0 < rank ∧ hypergraph.Nonempty ∧ RPartiteUniform rank hypergraph ∧\n Uniform rank hypergraph ∧ Intersecting hypergraph ∧\n (∃ cover : Finset Vertex, IsCover hypergraph cover) ∧\n matchingNumber hypergraph = 1 ∧ coverNumber hypergraph = rank ∧\n (rank - 1) * matchingNumber hypergraph < coverNumber hypergraph\n\ntheorem eventualOddFailures_and_infinite :\n (∃ primeThreshold : ℕ, ∀ prime : ℕ, primeThreshold ≤ prime →\n prime.Prime → prime % 3 = 2 →\n ∃ degreeThreshold : ℕ, 3 ≤ degreeThreshold ∧\n ∀ degree : ℕ, degreeThreshold ≤ degree → Odd degree →\n Specification.ExplicitFailureAt (prime ^ degree + 1)) ∧\n Set.Infinite {rank : ℕ | Specification.ExplicitFailureAt rank} := by\n sorry\n\nend RyserOdd\n\nend\n\nend OAI\n"], "formalization_scope": "Ryser's covering conjecture predicts that an intersecting $r$-partite hypergraph has a vertex cover of size at most $r-1$. The formalization proves that every sufficiently large prime $q$ has a finite intersecting $(q+1)$-partite, $(q+1)$-uniform hypergraph with covering number $q+1$ and exactly $q+1$ nonisolated vertices in each part. Thus the conjecture fails even with equal part sizes. The prime threshold is existential.\n\nRyser's covering conjecture predicts $\\tau\\le(r-1)\\nu$ for an $r$-partite hypergraph, where $\\tau$ and $\\nu$ are its covering and matching numbers. The formalized constructions give finite intersecting $r$-partite $r$-uniform hypergraphs with $\\nu=1$ and $\\tau=r$, contradicting the bound. The ranks have the form $r=p^n+1$: one fixed prime $p\\equiv2\\pmod3$ works for all sufficiently large prime degrees $n$, and a second result covers every sufficiently large such prime $p$ and every sufficiently large odd $n$, with the degree threshold allowed to depend on $p$. Infinitely many ranks occur. Equal part sizes and numerical thresholds are not asserted.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The core theorem BalancedRyser.main_result exactly formalizes the main Ryser counterexample: for all sufficiently large primes q it asserts a finite (q+1)-partite, (q+1)-uniform hypergraph, encoded as a Finset of functions Fin (q+1) → Fin (q+1), that is intersecting, has all q+1 vertices in each part nonisolated, and has cover number q+1. The definitions of cover, intersecting, and cover number match the usual meanings, and the additional odd-exponent statement captures the first abstract's s^n+1 family. The separate Gyárfás result is not formalized, but the stated main Ryser claim is faithfully expressed.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean theorem statements faithfully express the main claim and the supporting constructions described in the abstracts. The `Balanced.lean` file correctly formalizes the main claim: for every sufficiently large prime $q$, there exists an intersecting $(q+1)$-partite $(q+1)$-uniform hypergraph with covering number $q+1$. The `RyserOddExtensions.lean` file correctly formalizes the secondary construction for primes $s \\\\equiv 2 \\\\pmod 3$ and odd integers $n$, asserting counterexamples for rank $s^n+1$. The definitions of `Intersecting`, `Nonisolated`, `HasCoverNumber`, `PartiteUniform`, and `Uniform` align with the standard mathematical definitions required to disprove Ryser's covering conjecture. While `RyserCovering.lean` contains a weaker statement (fixing one prime $p$ instead of quantifying over all sufficiently large primes), the presence of the correct formalization in `RyserOddExtensions.lean` ensures the overall formalization is faithful to the paper's claims.\", \"score\": 5}"}}
{"family": "173", "title": "Seymour’s second-neighborhood conjecture", "claim": "Seymour’s second-neighborhood conjecture. Proves Seymour's second-neighborhood conjecture: every nonempty finite oriented graph has a vertex with at least as many vertices at directed distance exactly two as at directed distance one. Oriented graphs may be arbitrary apart from the exclusion of loops and oppositely directed edge pairs.", "abstracts": ["We prove that every nonempty finite oriented graph has a vertex with at least as many vertices at directed distance two as at directed distance one. This resolves Seymour's second neighborhood conjecture positively."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-proof-of-Seymours-second-neighborhood-conjecture-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SeymourSecondNeighborhood.lean"], "lean_statements": ["-- ComparatorChallenges/SeymourSecondNeighborhood.lean\nimport Mathlib.Data.Fintype.Card\nimport Mathlib.Data.Finset.Union\n\nnamespace OAI\n\nnamespace SeymourSecondNeighborhood\n\nvariable {V : Type*}\n\nstructure IsOriented (r : V → V → Prop) : Prop where\n loopless : ∀ v, ¬ r v v\n asymmetric : ∀ {u v}, r u v → ¬ r v u\n\nvariable [Fintype V] [DecidableEq V]\n\nnoncomputable section\n\ndef firstNeighbors (r : V → V → Prop) (v : V) : Finset V := by\n classical\n exact Finset.univ.filter (r v)\n\ndef secondNeighbors (r : V → V → Prop) (v : V) : Finset V := by\n classical\n exact Finset.univ.filter (fun w =>\n w ≠ v ∧ ¬ r v w ∧ ∃ u, r v u ∧ r u w)\n\ndef GoodVertex (r : V → V → Prop) (v : V) : Prop :=\n (firstNeighbors r v).card ≤ (secondNeighbors r v).card\n\nend\n\nvariable [Nonempty V]\n\ntheorem exists_goodVertex (r : V → V → Prop) (hr : IsOriented r) :\n ∃ v, GoodVertex r v := by\n sorry\n\nend SeymourSecondNeighborhood\n\nend OAI\n"], "formalization_scope": "Seymour's second-neighborhood conjecture asserts that every nonempty finite oriented graph has a vertex with at least as many second out-neighbors as first out-neighbors. The formalized result proves this assertion, where the second neighborhood consists of vertices at directed distance exactly two. The initial vertex and first neighbors are excluded from that count, and sinks are included.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean theorem quantifies over an arbitrary finite nonempty type V and an arbitrary relation r satisfying loopless and asymmetric, which exactly captures finite oriented graphs. firstNeighbors is the out-neighborhood, and secondNeighbors is the set of vertices distinct from v, not directly reachable from v, and reachable by a directed path of length two, matching directed distance exactly two. The conclusion asserts existence of a vertex v with |N^+(v)| ≤ |N_2^+(v)|, which is precisely Seymour's second-neighborhood conjecture. No extra substantive assumptions or weakened bounds are present.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement accurately formalizes Seymour's second-neighborhood conjecture. The definitions of `firstNeighbors` and `secondNeighbors` correctly capture the sets of vertices at directed distance exactly one and exactly two, respectively, with `secondNeighbors` properly excluding vertices at distance one (via `¬ r v w`). The `GoodVertex` predicate expresses the required inequality $|N_2(v)| \\\\ge |N_1(v)|$, and the theorem quantifies over all nonempty finite oriented graphs, matching the claim's scope and conditions precisely.\", \"score\": 5}"}}
{"family": "181", "title": "The Erdős–Gallai cycle-decomposition conjecture", "claim": "The Erdős–Gallai cycle-decomposition conjecture. Proves that the edges of every finite simple undirected graph on n vertices can be partitioned into at most $`Cn`$ simple cycles and single edges, for an absolute constant C. This resolves the Erdős–Gallai cycle-decomposition conjecture, bounding the number of pieces linearly even for dense graphs.", "abstracts": ["We prove that every finite simple undirected graph on \\(n\\) vertices has an edge partition into at most \\(Cn\\) simple cycles and single edges, for an absolute constant \\(C\\). This resolves the Erd\\H{o}s--Gallai cycle decomposition conjecture positively."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-linear-cycle-and-edge-decomposition-of-every-graph-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/CycleDecomposition.lean"], "lean_statements": ["-- ComparatorChallenges/CycleDecomposition.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\n\nopen Filter Asymptotics Real\nopen scoped Topology\n\nopen MeasureTheory ProbabilityTheory Finset\n\nnamespace ErdosGallai\n\ndef CycleOrSingleEdge {V : Type} (G : SimpleGraph V)\n (s : Set (Sym2 V)) : Prop :=\n (∃ (v : V) (p : G.Walk v v), p.IsCycle ∧ s = p.edgeSet) ∨\n ∃ e ∈ G.edgeSet, s = {e}\n\ndef EdgeDecomposition {V : Type} (G : SimpleGraph V) (k : ℕ) : Prop :=\n ∃ parts : Fin k → Set (Sym2 V),\n (∀ i, CycleOrSingleEdge G (parts i)) ∧\n Pairwise (fun i j => Disjoint (parts i) (parts j)) ∧\n (⋃ i, parts i) = G.edgeSet\n\n\ndef MainStatement : Prop :=\n ∃ C : ℝ, 0 < C ∧ ∀ (n : ℕ) (G : SimpleGraph (Fin n)),\n ∃ k : ℕ, EdgeDecomposition G k ∧ (k : ℝ) ≤ C * n\n\ntheorem erdos_gallai : MainStatement := by\n sorry\n\nend ErdosGallai\n\nend\n\nend OAI\n"], "formalization_scope": "The Erdős–Gallai cycle-decomposition conjecture asks for a linear bound on the number of cycles and single edges needed to partition a graph's edges. The formalized result gives one absolute constant $C>0$ such that every finite simple graph on $n$ vertices has an edge-disjoint decomposition into at most $Cn$ cycles or singleton edges. Edgeless and small graphs are included. The optimal value of $C$ is not determined.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement quantifies over all simple graphs on Fin n and asserts the existence of a positive real constant C, independent of the graph, such that the edge set can be covered by k pairwise disjoint sets, each either the edge set of a cycle walk or a singleton edge, with k ≤ Cn. This matches the Erdős–Gallai cycle-decomposition claim. Allowing empty parts or using Set rather than Finset is a harmless technical artifact that does not weaken the bound.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures the Erdős–Gallai cycle-decomposition conjecture. The definition `CycleOrSingleEdge` correctly characterizes a set of edges as either a simple cycle or a single edge. The `EdgeDecomposition` definition properly encodes an edge partition into k such pieces that are pairwise disjoint and cover all edges. The `MainStatement` asserts the existence of an absolute constant C > 0 such that for every n and every simple graph on n vertices, there is a decomposition into at most Cn pieces, which exactly matches the paper's claim. All quantifiers, types, and conditions align with the mathematical statement.\", \"score\": 5}"}}
{"family": "187", "title": "Snaky in 21 Maker moves", "claim": "Snaky in 21 Maker moves. Settles the Snaky achievement problem: Maker can force the six-cell Snaky shape within 21 of its own moves on the initially empty infinite square board. Maker moves first, each player claims one free cell per turn, and translations, rotations and reflections count as wins.", "abstracts": ["We prove that Maker can achieve the Snaky hexomino within 21 actual Maker moves against arbitrary legal Breaker play on the initially empty infinite square board. The same bound holds on a $17\\times17$ square; in fact, Maker can confine its claims to a fixed $251$-cell board."], "papers": ["https://github.com/openai/math/tree/main/preprints/Snaky-in-21-Maker-moves-September-25-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SnakyCertificate.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SnakyConditional.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SnakyTwentyOne.lean"], "lean_statements": ["-- ComparatorChallenges/SnakyCertificate.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace SnakyCertificate\n\ninstance rotationModulus_neZero : NeZero 8 := @Nat.instNeZeroSucc 7\n\ninstance digitModulus_neZero : NeZero 10 := @Nat.instNeZeroSucc 9\n\nabbrev Cell := ℤ × ℤ\n\ndef origin : Cell := (0, 0)\n\ndef snaky : Finset Cell := {(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)}\n\ndef orient (r : Fin 8) (p : Cell) : Cell :=\n match r.val with\n | 0 => (p.1, p.2)\n | 1 => (p.2, p.1)\n | 2 => (p.1, -p.2)\n | 3 => (-p.2, p.1)\n | 4 => (-p.1, p.2)\n | 5 => (p.2, -p.1)\n | 6 => (-p.1, -p.2)\n | _ => (-p.2, -p.1)\n\ndef placement (r : Fin 8) (t p : Cell) : Cell := orient r p + t\n\ndef basePoint (i : Fin 6) : Cell := ![(0,0),(1,0),(2,0),(3,0),(3,1),(4,1)] i\n\ndef baseEnvelope (i : Fin 6) : Finset Cell :=\n snaky.image (placement 0 (-basePoint i))\n\ndef baseRequired (i : Fin 6) : Finset Cell := (baseEnvelope i).erase origin\n\nstructure Term where\n child : ℕ\n rotation : Fin 8\n xDigit : Fin 10\n yDigit : Fin 10\n deriving DecidableEq, Repr\n\ndef Term.shift (t : Term) : Cell := ((t.xDigit.val : ℤ) - 4, (t.yDigit.val : ℤ) - 4)\n\nstructure Entry where\n index : ℕ\n terms : List Term\n deriving DecidableEq, Repr\n\ndef emptyEntry : Entry := ⟨0, []⟩\n\ndef entry_6 : Entry := ⟨6, [⟨0, 0, 0, 3⟩]⟩\n\ndef entry_7 : Entry := ⟨7, [⟨4, 0, 3, 4⟩, ⟨6, 0, 5, 4⟩]⟩\n\ndef entry_8 : Entry := ⟨8, [⟨0, 4, 8, 3⟩, ⟨6, 4, 3, 4⟩]⟩\n\ndef entry_9 : Entry := ⟨9, [⟨0, 4, 5, 4⟩, ⟨6, 4, 0, 5⟩]⟩\n\ndef entry_10 : Entry := ⟨10, [⟨2, 0, 2, 3⟩, ⟨2, 6, 2, 4⟩]⟩\n\ndef entry_11 : Entry := ⟨11, [⟨6, 4, 2, 5⟩, ⟨6, 6, 2, 3⟩]⟩\n\ndef entry_12 : Entry := ⟨12, [⟨0, 6, 5, 4⟩, ⟨0, 0, 0, 3⟩]⟩\n\ndef entry_13 : Entry := ⟨13, [⟨6, 6, 0, 3⟩, ⟨6, 4, 0, 5⟩]⟩\n\ndef entry_14 : Entry := ⟨14, [⟨0, 6, 5, 4⟩, ⟨3, 6, 1, 4⟩]⟩\n\ndef entry_15 : Entry := ⟨15, [⟨0, 6, 6, 4⟩, ⟨3, 6, 2, 4⟩]⟩\n\ndef entry_16 : Entry := ⟨16, [⟨3, 6, 3, 4⟩, ⟨0, 6, 7, 4⟩]⟩\n\ndef entry_17 : Entry := ⟨17, [⟨0, 6, 5, 4⟩, ⟨3, 0, 3, 3⟩]⟩\n\ndef entry_18 : Entry := ⟨18, [⟨3, 6, 2, 4⟩, ⟨3, 0, 4, 3⟩]⟩\n\ndef entry_19 : Entry := ⟨19, [⟨6, 4, 1, 5⟩, ⟨6, 0, 6, 5⟩]⟩\n\ndef entry_20 : Entry := ⟨20, [⟨6, 4, 0, 5⟩, ⟨6, 0, 5, 5⟩]⟩\n\ndef entry_21 : Entry := ⟨21, [⟨4, 6, 2, 3⟩, ⟨6, 0, 6, 5⟩]⟩\n\ndef entry_22 : Entry := ⟨22, [⟨0, 6, 7, 5⟩, ⟨3, 0, 5, 4⟩]⟩\n\ndef entry_23 : Entry := ⟨23, [⟨0, 6, 6, 4⟩, ⟨0, 0, 1, 3⟩]⟩\n\ndef entry_24 : Entry := ⟨24, [⟨0, 0, 0, 3⟩, ⟨17, 0, 5, 4⟩]⟩\n\ndef entry_25 : Entry := ⟨25, [⟨0, 0, 0, 3⟩, ⟨14, 0, 5, 4⟩]⟩\n\ndef entry_26 : Entry := ⟨26, [⟨0, 4, 6, 4⟩, ⟨6, 0, 6, 5⟩]⟩\n\ndef entry_27 : Entry := ⟨27, [⟨0, 6, 5, 4⟩, ⟨6, 4, 0, 5⟩]⟩\n\ndef entry_28 : Entry := ⟨28, [⟨6, 1, 4, 5⟩, ⟨0, 6, 6, 4⟩]⟩\n\ndef entry_29 : Entry := ⟨29, [⟨1, 4, 7, 3⟩, ⟨6, 3, 4, 5⟩]⟩\n\ndef entry_30 : Entry := ⟨30, [⟨0, 0, 1, 3⟩, ⟨14, 0, 6, 4⟩]⟩\n\ndef entry_31 : Entry := ⟨31, [⟨0, 0, 1, 4⟩, ⟨17, 0, 6, 5⟩]⟩\n\ndef entry_32 : Entry := ⟨32, [⟨0, 4, 8, 3⟩, ⟨6, 3, 4, 5⟩]⟩\n\ndef entry_33 : Entry := ⟨33, [⟨0, 0, 2, 4⟩, ⟨17, 0, 7, 5⟩]⟩\n\ndef entry_34 : Entry := ⟨34, [⟨6, 1, 4, 5⟩, ⟨1, 6, 5, 4⟩]⟩\n\ndef entry_35 : Entry := ⟨35, [⟨0, 0, 2, 4⟩, ⟨14, 0, 7, 5⟩]⟩\n\ndef entry_36 : Entry := ⟨36, [⟨0, 0, 3, 4⟩, ⟨17, 0, 8, 5⟩]⟩\n\ndef entry_37 : Entry := ⟨37, [⟨6, 3, 4, 5⟩, ⟨2, 4, 6, 3⟩]⟩\n\ndef entry_38 : Entry := ⟨38, [⟨3, 0, 3, 3⟩, ⟨16, 0, 2, 4⟩]⟩\n\ndef entry_39 : Entry := ⟨39, [⟨0, 0, 1, 3⟩, ⟨17, 0, 6, 4⟩]⟩\n\ndef entry_40 : Entry := ⟨40, [⟨3, 0, 4, 3⟩, ⟨16, 0, 3, 4⟩]⟩\n\ndef entry_41 : Entry := ⟨41, [⟨6, 3, 3, 5⟩, ⟨1, 4, 6, 3⟩]⟩\n\ndef entry_42 : Entry := ⟨42, [⟨0, 6, 6, 4⟩, ⟨6, 4, 1, 5⟩]⟩\n\ndef entry_43 : Entry := ⟨43, [⟨2, 4, 5, 3⟩, ⟨6, 3, 3, 5⟩]⟩\n\ndef entry_44 : Entry := ⟨44, [⟨4, 4, 1, 5⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_45 : Entry := ⟨45, [⟨6, 4, 0, 5⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_46 : Entry := ⟨46, [⟨6, 6, 0, 3⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_47 : Entry := ⟨47, [⟨6, 3, 3, 5⟩, ⟨6, 2, 7, 3⟩]⟩\n\ndef entry_48 : Entry := ⟨48, [⟨6, 3, 4, 5⟩, ⟨6, 2, 8, 3⟩]⟩\n\ndef entry_49 : Entry := ⟨49, [⟨4, 7, 3, 1⟩, ⟨7, 1, 5, 4⟩]⟩\n\ndef entry_50 : Entry := ⟨50, [⟨6, 3, 3, 5⟩, ⟨7, 1, 5, 4⟩]⟩\n\ndef entry_51 : Entry := ⟨51, [⟨10, 2, 5, 3⟩, ⟨10, 0, 5, 4⟩, ⟨26, 2, 3, 4⟩, ⟨26, 0, 3, 3⟩]⟩\n\ndef entry_52 : Entry := ⟨52, [⟨0, 0, 0, 3⟩, ⟨0, 4, 7, 3⟩]⟩\n\ndef entry_53 : Entry := ⟨53, [⟨6, 4, 3, 4⟩, ⟨3, 1, 4, 5⟩]⟩\n\ndef entry_54 : Entry := ⟨54, [⟨22, 0, 2, 3⟩, ⟨3, 6, 1, 4⟩]⟩\n\ndef entry_55 : Entry := ⟨55, [⟨7, 4, 0, 5⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_56 : Entry := ⟨56, [⟨7, 4, 0, 5⟩, ⟨7, 6, 0, 3⟩]⟩\n\ndef entry_57 : Entry := ⟨57, [⟨0, 6, 5, 4⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_58 : Entry := ⟨58, [⟨0, 4, 5, 4⟩, ⟨7, 0, 4, 5⟩]⟩\n\ndef entry_59 : Entry := ⟨59, [⟨0, 6, 5, 4⟩, ⟨7, 4, 0, 5⟩]⟩\n\ndef entry_60 : Entry := ⟨60, [⟨6, 6, 1, 3⟩, ⟨49, 1, 6, 4⟩]⟩\n\ndef entry_61 : Entry := ⟨61, [⟨6, 0, 5, 4⟩, ⟨14, 1, 4, 5⟩]⟩\n\ndef entry_62 : Entry := ⟨62, [⟨6, 6, 0, 3⟩, ⟨53, 0, 1, 5⟩]⟩\n\ndef entry_63 : Entry := ⟨63, [⟨4, 3, 4, 3⟩, ⟨50, 0, 5, 4⟩]⟩\n\ndef entry_64 : Entry := ⟨64, [⟨6, 6, 3, 4⟩, ⟨49, 1, 8, 5⟩]⟩\n\ndef entry_65 : Entry := ⟨65, [⟨6, 6, 0, 3⟩, ⟨49, 1, 5, 4⟩]⟩\n\ndef entry_66 : Entry := ⟨66, [⟨6, 3, 4, 5⟩, ⟨53, 5, 6, 4⟩]⟩\n\ndef entry_67 : Entry := ⟨67, [⟨6, 1, 4, 5⟩, ⟨9, 2, 5, 4⟩]⟩\n\ndef entry_68 : Entry := ⟨68, [⟨6, 4, 0, 5⟩, ⟨44, 0, 5, 4⟩]⟩\n\ndef entry_69 : Entry := ⟨69, [⟨6, 3, 4, 5⟩, ⟨34, 0, 6, 5⟩]⟩\n\ndef entry_70 : Entry := ⟨70, [⟨4, 3, 4, 3⟩, ⟨41, 0, 5, 4⟩]⟩\n\ndef entry_71 : Entry := ⟨71, [⟨6, 1, 4, 5⟩, ⟨23, 2, 4, 3⟩]⟩\n\ndef entry_72 : Entry := ⟨72, [⟨0, 5, 3, 8⟩, ⟨8, 6, 5, 4⟩]⟩\n\ndef entry_73 : Entry := ⟨73, [⟨4, 3, 3, 4⟩, ⟨50, 0, 4, 5⟩]⟩\n\ndef entry_74 : Entry := ⟨74, [⟨2, 7, 4, 3⟩, ⟨53, 0, 3, 3⟩]⟩\n\ndef entry_75 : Entry := ⟨75, [⟨0, 0, 1, 3⟩, ⟨9, 0, 7, 3⟩]⟩\n\ndef entry_76 : Entry := ⟨76, [⟨0, 7, 5, 7⟩, ⟨14, 0, 7, 5⟩]⟩\n\ndef entry_77 : Entry := ⟨77, [⟨0, 5, 3, 7⟩, ⟨12, 0, 5, 4⟩]⟩\n\ndef entry_78 : Entry := ⟨78, [⟨6, 4, 3, 4⟩, ⟨52, 0, 5, 4⟩]⟩\n\ndef entry_79 : Entry := ⟨79, [⟨6, 1, 5, 5⟩, ⟨48, 0, 3, 4⟩]⟩\n\ndef entry_80 : Entry := ⟨80, [⟨0, 6, 6, 4⟩, ⟨13, 4, 2, 4⟩]⟩\n\ndef entry_81 : Entry := ⟨81, [⟨4, 3, 4, 3⟩, ⟨43, 0, 5, 4⟩]⟩\n\ndef entry_82 : Entry := ⟨82, [⟨6, 1, 4, 5⟩, ⟨36, 0, 1, 3⟩]⟩\n\ndef entry_83 : Entry := ⟨83, [⟨0, 7, 5, 7⟩, ⟨67, 2, 6, 3⟩]⟩\n\ndef entry_84 : Entry := ⟨84, [⟨6, 3, 4, 5⟩, ⟨67, 0, 6, 4⟩]⟩\n\ndef entry_85 : Entry := ⟨85, [⟨9, 0, 6, 3⟩, ⟨8, 4, 5, 4⟩]⟩\n\ndef entry_86 : Entry := ⟨86, [⟨0, 6, 5, 4⟩, ⟨67, 3, 1, 5⟩]⟩\n\ndef entry_87 : Entry := ⟨87, [⟨0, 5, 3, 7⟩, ⟨24, 2, 5, 3⟩]⟩\n\ndef entry_88 : Entry := ⟨88, [⟨0, 6, 6, 4⟩, ⟨67, 3, 2, 5⟩]⟩\n\ndef entry_89 : Entry := ⟨89, [⟨8, 3, 3, 1⟩, ⟨7, 1, 5, 4⟩]⟩\n\ndef entry_90 : Entry := ⟨90, [⟨31, 0, 3, 3⟩, ⟨54, 6, 0, 3⟩, ⟨54, 0, 5, 4⟩, ⟨31, 6, 2, 4⟩]⟩\n\ndef entry_91 : Entry := ⟨91, [⟨6, 3, 4, 5⟩, ⟨74, 5, 7, 3⟩]⟩\n\ndef entry_92 : Entry := ⟨92, [⟨6, 1, 4, 5⟩, ⟨33, 0, 2, 3⟩]⟩\n\ndef entry_93 : Entry := ⟨93, [⟨4, 3, 4, 3⟩, ⟨47, 0, 5, 4⟩]⟩\n\ndef entry_94 : Entry := ⟨94, [⟨6, 1, 4, 5⟩, ⟨27, 3, 3, 6⟩]⟩\n\ndef entry_95 : Entry := ⟨95, [⟨0, 5, 3, 7⟩, ⟨29, 0, 2, 5⟩]⟩\n\ndef entry_96 : Entry := ⟨96, [⟨6, 1, 5, 5⟩, ⟨70, 0, 3, 5⟩]⟩\n\ndef entry_97 : Entry := ⟨97, [⟨6, 6, 0, 3⟩, ⟨44, 0, 5, 4⟩]⟩\n\ndef entry_98 : Entry := ⟨98, [⟨6, 6, 2, 3⟩, ⟨44, 0, 7, 4⟩]⟩\n\ndef entry_99 : Entry := ⟨99, [⟨2, 1, 3, 2⟩, ⟨24, 0, 5, 4⟩]⟩\n\ndef entry_100 : Entry := ⟨100, [⟨0, 6, 5, 4⟩, ⟨48, 0, 1, 4⟩]⟩\n\ndef entry_101 : Entry := ⟨101, [⟨0, 7, 4, 6⟩, ⟨24, 0, 5, 4⟩]⟩\n\ndef entry_102 : Entry := ⟨102, [⟨6, 3, 4, 5⟩, ⟨25, 2, 6, 3⟩]⟩\n\ndef entry_103 : Entry := ⟨103, [⟨6, 3, 4, 5⟩, ⟨71, 0, 6, 4⟩]⟩\n\ndef entry_104 : Entry := ⟨104, [⟨6, 0, 5, 4⟩, ⟨75, 0, 3, 4⟩]⟩\n\ndef entry_105 : Entry := ⟨105, [⟨6, 5, 4, 3⟩, ⟨77, 0, 4, 5⟩]⟩\n\ndef entry_106 : Entry := ⟨106, [⟨6, 1, 4, 5⟩, ⟨36, 6, 5, 4⟩]⟩\n\ndef entry_107 : Entry := ⟨107, [⟨6, 6, 0, 3⟩, ⟨63, 1, 5, 3⟩]⟩\n\ndef entry_108 : Entry := ⟨108, [⟨4, 6, 1, 3⟩, ⟨63, 1, 5, 3⟩]⟩\n\ndef entry_109 : Entry := ⟨109, [⟨4, 6, 1, 3⟩, ⟨55, 0, 5, 4⟩]⟩\n\ndef entry_110 : Entry := ⟨110, [⟨6, 6, 1, 3⟩, ⟨63, 1, 6, 3⟩]⟩\n\ndef entry_111 : Entry := ⟨111, [⟨6, 7, 4, 3⟩, ⟨83, 0, 4, 5⟩]⟩\n\ndef entry_112 : Entry := ⟨112, [⟨4, 1, 5, 4⟩, ⟨93, 0, 3, 5⟩]⟩\n\ndef entry_113 : Entry := ⟨113, [⟨1, 6, 6, 4⟩, ⟨36, 6, 7, 5⟩]⟩\n\ndef entry_114 : Entry := ⟨114, [⟨6, 0, 6, 5⟩, ⟨67, 3, 2, 5⟩]⟩\n\ndef entry_115 : Entry := ⟨115, [⟨6, 2, 7, 3⟩, ⟨70, 7, 2, 5⟩]⟩\n\ndef entry_116 : Entry := ⟨116, [⟨0, 7, 4, 6⟩, ⟨24, 2, 5, 4⟩]⟩\n\ndef entry_117 : Entry := ⟨117, [⟨6, 1, 4, 5⟩, ⟨100, 0, 5, 4⟩]⟩\n\ndef entry_118 : Entry := ⟨118, [⟨4, 7, 3, 1⟩, ⟨61, 1, 5, 4⟩]⟩\n\ndef entry_119 : Entry := ⟨119, [⟨6, 6, 1, 3⟩, ⟨55, 0, 6, 4⟩]⟩\n\ndef entry_120 : Entry := ⟨120, [⟨4, 0, 4, 5⟩, ⟨58, 2, 5, 4⟩]⟩\n\ndef entry_121 : Entry := ⟨121, [⟨9, 3, 4, 5⟩, ⟨7, 1, 5, 4⟩]⟩\n\ndef entry_122 : Entry := ⟨122, [⟨6, 6, 3, 3⟩, ⟨105, 1, 4, 5⟩]⟩\n\ndef entry_123 : Entry := ⟨123, [⟨6, 6, 1, 3⟩, ⟨64, 2, 2, 5⟩]⟩\n\ndef entry_124 : Entry := ⟨124, [⟨6, 1, 4, 5⟩, ⟨31, 2, 5, 4⟩]⟩\n\ndef entry_125 : Entry := ⟨125, [⟨3, 0, 4, 3⟩, ⟨31, 2, 4, 5⟩]⟩\n\ndef entry_126 : Entry := ⟨126, [⟨6, 3, 4, 5⟩, ⟨46, 1, 5, 7⟩]⟩\n\ndef entry_127 : Entry := ⟨127, [⟨7, 0, 4, 5⟩, ⟨44, 2, 5, 4⟩]⟩\n\ndef entry_128 : Entry := ⟨128, [⟨9, 6, 1, 5⟩, ⟨57, 0, 6, 5⟩]⟩\n\ndef entry_129 : Entry := ⟨129, [⟨6, 4, 2, 5⟩, ⟨58, 1, 3, 6⟩]⟩\n\ndef entry_130 : Entry := ⟨130, [⟨6, 1, 4, 5⟩, ⟨60, 0, 5, 4⟩]⟩\n\ndef entry_131 : Entry := ⟨131, [⟨45, 3, 4, 5⟩, ⟨7, 1, 5, 4⟩]⟩\n\ndef entry_132 : Entry := ⟨132, [⟨6, 3, 4, 5⟩, ⟨89, 0, 5, 6⟩]⟩\n\ndef entry_133 : Entry := ⟨133, [⟨6, 7, 3, 1⟩, ⟨92, 0, 5, 5⟩]⟩\n\ndef entry_134 : Entry := ⟨134, [⟨6, 7, 3, 0⟩, ⟨82, 0, 5, 4⟩]⟩\n\ndef entry_135 : Entry := ⟨135, [⟨7, 0, 4, 5⟩, ⟨75, 4, 2, 5⟩, ⟨44, 0, 5, 4⟩]⟩\n\ndef entry_136 : Entry := ⟨136, [⟨6, 3, 3, 7⟩, ⟨102, 2, 3, 3⟩]⟩\n\ndef entry_137 : Entry := ⟨137, [⟨4, 1, 4, 3⟩, ⟨96, 0, 3, 4⟩]⟩\n\ndef entry_138 : Entry := ⟨138, [⟨27, 0, 5, 4⟩, ⟨10, 1, 4, 7⟩]⟩\n\ndef entry_139 : Entry := ⟨139, [⟨28, 1, 4, 5⟩, ⟨27, 0, 5, 4⟩]⟩\n\ndef entry_140 : Entry := ⟨140, [⟨6, 7, 3, 2⟩, ⟨82, 0, 5, 6⟩]⟩\n\ndef entry_141 : Entry := ⟨141, [⟨7, 0, 4, 5⟩, ⟨78, 2, 1, 3⟩]⟩\n\ndef entry_142 : Entry := ⟨142, [⟨72, 4, 2, 3⟩, ⟨32, 1, 4, 3⟩, ⟨55, 2, 5, 4⟩]⟩\n\ndef entry_143 : Entry := ⟨143, [⟨6, 6, 3, 4⟩, ⟨108, 0, 8, 5⟩]⟩\n\ndef entry_144 : Entry := ⟨144, [⟨7, 0, 4, 5⟩, ⟨104, 4, 1, 5⟩, ⟨55, 0, 5, 4⟩]⟩\n\ndef entry_145 : Entry := ⟨145, [⟨0, 5, 4, 5⟩, ⟨91, 0, 3, 4⟩]⟩\n\ndef entry_146 : Entry := ⟨146, [⟨36, 6, 5, 4⟩, ⟨24, 1, 4, 5⟩]⟩\n\ndef entry_147 : Entry := ⟨147, [⟨53, 0, 1, 5⟩, ⟨44, 2, 5, 4⟩]⟩\n\ndef entry_148 : Entry := ⟨148, [⟨7, 1, 5, 4⟩, ⟨46, 1, 4, 5⟩, ⟨94, 0, 5, 3⟩, ⟨97, 1, 4, 5⟩]⟩\n\ndef entry_149 : Entry := ⟨149, [⟨16, 1, 4, 3⟩, ⟨24, 2, 5, 4⟩]⟩\n\ndef entry_150 : Entry := ⟨150, [⟨4, 6, 1, 3⟩, ⟨126, 5, 2, 5⟩]⟩\n\ndef entry_151 : Entry := ⟨151, [⟨2, 1, 4, 3⟩, ⟨101, 2, 6, 3⟩]⟩\n\ndef entry_152 : Entry := ⟨152, [⟨6, 3, 4, 5⟩, ⟨73, 1, 7, 4⟩]⟩\n\ndef entry_153 : Entry := ⟨153, [⟨59, 4, 0, 4⟩, ⟨27, 0, 5, 4⟩]⟩\n\ndef entry_154 : Entry := ⟨154, [⟨7, 6, 4, 3⟩, ⟨104, 0, 7, 5⟩]⟩\n\ndef entry_155 : Entry := ⟨155, [⟨7, 1, 5, 4⟩, ⟨55, 3, 4, 5⟩]⟩\n\ndef entry_156 : Entry := ⟨156, [⟨11, 0, 2, 4⟩, ⟨98, 2, 2, 4⟩, ⟨33, 0, 2, 3⟩]⟩\n\ndef entry_157 : Entry := ⟨157, [⟨6, 3, 4, 5⟩, ⟨57, 1, 5, 6⟩]⟩\n\ndef entry_158 : Entry := ⟨158, [⟨66, 0, 3, 4⟩, ⟨45, 1, 4, 5⟩, ⟨46, 3, 4, 5⟩]⟩\n\ndef entry_159 : Entry := ⟨159, [⟨45, 3, 4, 5⟩, ⟨65, 1, 4, 5⟩, ⟨7, 3, 3, 4⟩]⟩\n\ndef entry_160 : Entry := ⟨160, [⟨63, 1, 8, 3⟩, ⟨32, 3, 4, 3⟩]⟩\n\ndef entry_161 : Entry := ⟨161, [⟨15, 1, 4, 5⟩, ⟨86, 0, 5, 4⟩]⟩\n\ndef entry_162 : Entry := ⟨162, [⟨7, 3, 3, 4⟩, ⟨127, 1, 4, 5⟩, ⟨63, 0, 3, 5⟩, ⟨157, 0, 3, 3⟩]⟩\n\ndef entry_163 : Entry := ⟨163, [⟨44, 2, 5, 4⟩, ⟨49, 1, 5, 4⟩, ⟨56, 4, 0, 4⟩]⟩\n\ndef entry_164 : Entry := ⟨164, [⟨6, 1, 4, 5⟩, ⟨110, 0, 5, 4⟩]⟩\n\ndef entry_165 : Entry := ⟨165, [⟨0, 7, 5, 8⟩, ⟨107, 0, 7, 5⟩]⟩\n\ndef entry_166 : Entry := ⟨166, [⟨2, 7, 4, 5⟩, ⟨107, 0, 6, 4⟩]⟩\n\ndef entry_167 : Entry := ⟨167, [⟨57, 0, 5, 4⟩, ⟨57, 4, 0, 4⟩]⟩\n\ndef entry_168 : Entry := ⟨168, [⟨6, 1, 5, 5⟩, ⟨152, 0, 3, 4⟩]⟩\n\ndef entry_169 : Entry := ⟨169, [⟨28, 3, 4, 5⟩, ⟨63, 1, 8, 3⟩]⟩\n\ndef entry_170 : Entry := ⟨170, [⟨4, 6, 1, 3⟩, ⟨127, 2, 5, 4⟩]⟩\n\ndef entry_171 : Entry := ⟨171, [⟨6, 0, 5, 4⟩, ⟨91, 0, 0, 5⟩]⟩\n\ndef entry_172 : Entry := ⟨172, [⟨63, 1, 5, 3⟩, ⟨55, 6, 0, 4⟩, ⟨64, 0, 1, 3⟩]⟩\n\ndef entry_173 : Entry := ⟨173, [⟨63, 1, 5, 3⟩, ⟨64, 6, 4, 5⟩, ⟨55, 6, 0, 4⟩]⟩\n\ndef entry_174 : Entry := ⟨174, [⟨58, 3, 4, 5⟩, ⟨57, 1, 4, 5⟩, ⟨84, 0, 3, 4⟩]⟩\n\ndef entry_175 : Entry := ⟨175, [⟨141, 0, 5, 4⟩, ⟨7, 2, 4, 3⟩, ⟨63, 1, 5, 3⟩]⟩\n\ndef entry_176 : Entry := ⟨176, [⟨63, 1, ", "-- ComparatorChallenges/SnakyConditional.lean\nimport Mathlib\n\nnamespace OAI.SnakyConditional\n\nabbrev Cell := ℤ × ℤ\ndef snaky : Finset Cell := {(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)}\ndef orient (r : Fin 8) (p : Cell) : Cell :=\n match r.val with\n | 0 => (p.1, p.2)\n | 1 => (p.2, p.1)\n | 2 => (p.1, -p.2)\n | 3 => (-p.2, p.1)\n | 4 => (-p.1, p.2)\n | 5 => (p.2, -p.1)\n | 6 => (-p.1, -p.2)\n | _ => (-p.2, -p.1)\ndef placement (r : Fin 8) (t p : Cell) : Cell := orient r p + t\ndef HasSnaky (M : Finset Cell) : Prop :=\n ∃ (r : Fin 8) (t : Cell), snaky.image (placement r t) ⊆ M\n\nnamespace OrdinaryStrategy\n\nvariable {α : Type*} [DecidableEq α]\n\nabbrev Policy (α : Type*) := ℕ → Finset α → Finset α → α\ndef playState (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) :\n ℕ → Finset α × Finset α\n | 0 => (M₀, B₀)\n | k + 1 =>\n let state := playState σ N β M₀ B₀ k\n (insert (σ (N - k) state.1 state.2) state.1, insert (β k) state.2)\ndef makerAt (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) (k : ℕ) : α :=\n let state := playState σ N β M₀ B₀ k\n σ (N - k) state.1 state.2\ndef LegalRepliesBeforeFinal (σ : Policy α) (N : ℕ) (β : ℕ → α)\n (M₀ B₀ : Finset α) : Prop :=\n ∀ k, k + 1 < N →\n β k ∉ insert (makerAt σ N β M₀ B₀ k) (playState σ N β M₀ B₀ k).1 ∧\n β k ∉ (playState σ N β M₀ B₀ k).2\nend OrdinaryStrategy\n\nopen OrdinaryStrategy\n\ntheorem snaky_winning_strategy_with_legal_states :\n ∃ σ : Policy Cell,\n (∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) ∧\n ∀ β : ℕ → Cell, LegalRepliesBeforeFinal σ 35 β ∅ ∅ →\n HasSnaky (playState σ 35 β ∅ ∅ 35).1 ∧\n (playState σ 35 β ∅ ∅ 35).1.card = 35 ∧\n Disjoint (playState σ 35 β ∅ ∅ 35).1 (playState σ 35 β ∅ ∅ 34).2 ∧\n ∀ k, k < 35 →\n Disjoint (playState σ 35 β ∅ ∅ k).1 (playState σ 35 β ∅ ∅ k).2 ∧\n (playState σ 35 β ∅ ∅ k).2.card = k := by\n sorry\n\nend OAI.SnakyConditional\n", "-- ComparatorChallenges/SnakyTwentyOne.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace SnakyPrototype\nvariable {α : Type*} [DecidableEq α]\nabbrev Cell := ℤ × ℤ\ndef snaky : Finset Cell := {(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)}\ndef orient (r : Fin 8) (p : Cell) : Cell :=\n match r.val with\n | 0 => (p.1, p.2)\n | 1 => (p.2, p.1)\n | 2 => (p.1, -p.2)\n | 3 => (-p.2, p.1)\n | 4 => (-p.1, p.2)\n | 5 => (p.2, -p.1)\n | 6 => (-p.1, -p.2)\n | _ => (-p.2, -p.1)\ndef placement (r : Fin 8) (t p : Cell) : Cell := orient r p + t\ndef HasSnaky (M : Finset Cell) : Prop :=\n ∃ (r : Fin 8) (t : Cell), snaky.image (placement r t) ⊆ M\nend SnakyPrototype\nnamespace SnakyPrototype.OrdinaryStrategy\nvariable {α : Type*} [DecidableEq α] [Infinite α]\nabbrev Policy (α : Type*) := ℕ → Finset α → Finset α → α\ndef playState (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) :\n ℕ → Finset α × Finset α\n | 0 => (M₀, B₀)\n | k + 1 =>\n let state := playState σ N β M₀ B₀ k\n (insert (σ (N - k) state.1 state.2) state.1, insert (β k) state.2)\ndef makerAt (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) (k : ℕ) : α :=\n let state := playState σ N β M₀ B₀ k\n σ (N - k) state.1 state.2\ndef LegalRepliesBeforeFinal (σ : Policy α) (N : ℕ) (β : ℕ → α)\n (M₀ B₀ : Finset α) : Prop :=\n ∀ k, k + 1 < N →\n β k ∉ insert (makerAt σ N β M₀ B₀ k) (playState σ N β M₀ B₀ k).1 ∧\n β k ∉ (playState σ N β M₀ B₀ k).2\nend SnakyPrototype.OrdinaryStrategy\n\nnamespace SnakyPrototype\nopen OrdinaryStrategy\n\ntheorem snaky_winning_strategy_21_with_legal_states :\n ∃ σ : Policy Cell,\n (∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) ∧\n ∀ β : ℕ → Cell, LegalRepliesBeforeFinal σ 21 β ∅ ∅ →\n HasSnaky (playState σ 21 β ∅ ∅ 21).1 ∧\n (playState σ 21 β ∅ ∅ 21).1.card = 21 ∧\n Disjoint (playState σ 21 β ∅ ∅ 21).1 (playState σ 21 β ∅ ∅ 20).2 ∧\n ∀ k, k < 21 →\n Disjoint (playState σ 21 β ∅ ∅ k).1 (playState σ 21 β ∅ ∅ k).2 ∧\n (playState σ 21 β ∅ ∅ k).2.card = k := by\n sorry\n\nend SnakyPrototype\n\nend OAI\n"], "formalization_scope": "In the Snaky Maker–Breaker game, the players alternately claim cells of $\\mathbb Z^2$, and Maker seeks a translated, rotated, or reflected copy of the six-cell Snaky shape. The formalization gives a legal strategy that wins within $21$ actual Maker moves against every legal Breaker play from the empty infinite board. The selected theorem checks disjointness and the move counts throughout play; it does not impose the paper's smaller finite-board restriction.\n\nThe linked supplements reconstruct the older $35$-move appendix's finite recursive certificate and prove four conditional winning templates from partial positions, assuming the required Maker cells are present and Breaker avoids the corresponding finite envelope.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The 21-move theorem exactly asserts a Maker strategy on ℤ² such that, for every Breaker sequence whose first 20 replies are legal, after 21 Maker moves the Maker set contains a translated/rotated/reflected copy of the six-cell snaky. The definitions of Cell, snaky, orient, placement, and HasSnaky match the infinite board and the allowed symmetries, while the legality and cardinality clauses encode one free cell per turn with Maker moving first. The separate 35-move theorem is weaker, but the 21-move statement captures the main claim; it omits only the abstract's additional 17×17/251-cell strengthening.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The main claim asserts that Maker can force the Snaky shape within 21 of its own moves. The Lean file `SnakyTwentyOne.lean` contains the theorem `snaky_winning_strategy_21_with_legal_states`, which formally states the existence of a strategy `σ` such that for any legal Breaker response `β`, Maker's set after 21 moves contains the Snaky shape (`HasSnaky`). The definitions of `Cell`, `snaky`, `orient`, `placement`, `HasSnaky`, `Policy`, `playState`, and `LegalRepliesBeforeFinal` are consistent with the standard formalization of this Maker-Breaker game. While `SnakyConditional.lean` contains a theorem for 35 moves (a weaker/supplementary result), the presence of the 21-move theorem in `SnakyTwentyOne.lean` ensures the formalization faithfully expresses the main claim. The minor technical detail that `LegalRepliesBeforeFinal` checks `k + 1 < N` (leaving the last Breaker move un-checked for legality in the hypothesis) is a common convention in such certificate-based proofs and does not substantially weaken the expression of the claim.\", \"score\": 5}"}}
{"family": "196", "title": "A counterexample to Kaplansky’s zero-divisor conjecture", "claim": "A counterexample to Kaplansky’s zero-divisor conjecture. Constructs a finitely presented torsion-free group G whose group algebra $`\\mathbb F_2[G]`$ has nonzero zero divisors, disproving Kaplansky's zero-divisor conjecture. The group has a finite two-dimensional classifying space.", "abstracts": ["We disprove Kaplansky's zero-divisor conjecture by constructing a finitely presented torsion-free group \\(G\\) for which \\(\\mathbb F_2[G]\\) has nonzero zero divisors. The group admits a finite two-dimensional classifying space."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-Torsion-Free-Group-Algebra-with-Zero-Divisors-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/TorsionFreeZeroDivisors.lean"], "lean_statements": ["-- ComparatorChallenges/TorsionFreeZeroDivisors.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace TorsionFreeZeroDivisors\n\n/-- Ordinary group torsion-freeness, without requiring uniqueness of all roots. -/\ndef TorsionFree (G : Type) [Group G] : Prop :=\n ∀ (g : G) (n : ℕ), 0 < n → g ^ n = 1 → g = 1\n\n/-- A connected finite Hausdorff 2-dimensional CW K(G,1). -/\ndef HasFiniteTwoDimensionalClassifyingSpace (G : Type) [Group G] : Prop :=\n ∃ (X : Type) (topX : TopologicalSpace X),\n letI : TopologicalSpace X := topX\n ∃ (_hausdorff : T2Space X) (_connected : PathConnectedSpace X)\n (cw : Topology.CWComplex (Set.univ : Set X)),\n letI : Topology.CWComplex (Set.univ : Set X) := cw\n Topology.CWComplex.Finite (Set.univ : Set X) ∧\n (∀ n : ℕ, 2 < n → IsEmpty (Topology.CWComplex.cell (Set.univ : Set X) n)) ∧\n Nonempty (Topology.CWComplex.cell (Set.univ : Set X) 2) ∧\n ∃ (x : X), Nonempty (G ≃* FundamentalGroup X x) ∧\n ∃ (E : Type) (topE : TopologicalSpace E),\n letI : TopologicalSpace E := topE\n ContractibleSpace E ∧\n ∃ p : E → X, IsCoveringMap p ∧ Function.Surjective p\n\n/-- The entire main theorem, including its \"Moreover\" clause. -/\ndef MainTheorem : Prop :=\n ∃ (G : Type) (inst : Group G),\n letI : Group G := inst\n Group.IsFinitelyPresented G ∧ TorsionFree G ∧\n HasFiniteTwoDimensionalClassifyingSpace G ∧\n ∃ α β : MonoidAlgebra (ZMod 2) G, α ≠ 0 ∧ β ≠ 0 ∧ α * β = 0\n\ntheorem main : MainTheorem := by\n sorry\n\nend TorsionFreeZeroDivisors\n\nend OAI\n"], "formalization_scope": "Kaplansky's zero-divisor conjecture asserts that the group algebra of a torsion-free group over a field has no zero divisors. The formalized result constructs a finitely presented torsion-free group $G$ and nonzero elements $\\alpha,\\beta\\in\\mathbb F_2[G]$ with $\\alpha\\beta=0$, giving a counterexample.\n\nThe same group admits a finite two-dimensional classifying space $K(G,1)$.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement asserts the existence of a group G that is finitely presented, torsion-free, has a finite 2-dimensional CW complex with fundamental group isomorphic to G and a contractible covering space (equivalently a K(G,1)), and has nonzero elements α,β in MonoidAlgebra (ZMod 2) G with αβ=0. This matches the paper's claim of a finitely presented torsion-free group with nonzero zero divisors in F_2[G] and a finite two-dimensional classifying space. The only differences are technical encoding choices, such as stating existence rather than naming the constructed group and defining the classifying space via a contractible covering, which are semantically equivalent in this CW setting.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization accurately captures all components of the mathematical claim. The `MainTheorem` asserts the existence of a group G that is finitely presented, torsion-free, admits a finite two-dimensional classifying space (formalized via a finite 2-dimensional K(G,1) space with a contractible universal cover), and whose group algebra over ZMod 2 (isomorphic to F_2) contains nonzero zero divisors. The definitions of `TorsionFree` and `HasFiniteTwoDimensionalClassifyingSpace` align with standard mathematical terminology and the specific constraints mentioned in the abstract. There are no extra hypotheses or missing conditions.\", \"score\": 5}"}}
{"family": "198", "title": "A counterexample to finitistic-dimension finiteness", "claim": "A counterexample to finitistic-dimension finiteness. Constructs a finite-dimensional complex algebra whose finite-dimensional modules have unbounded finite projective dimensions. This disproves the little finitistic-dimension conjecture.", "abstracts": ["We construct a finite-dimensional complex algebra whose finite-dimensional modules have unbounded finite projective dimensions. This disproves the little finitistic-dimension conjecture."], "papers": ["https://github.com/openai/math/tree/main/preprints/An-algebra-of-infinite-little-finitistic-dimension-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/FinitisticAsymmetry.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/LittleFinitistic.lean"], "lean_statements": ["-- ComparatorChallenges/FinitisticAsymmetry.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nopen CategoryTheory\n\nnamespace LittleFinitistic\nuniverse u\nvariable (A : Type u) [Ring A]\n\nattribute [-instance] CompletePartialOrder.toSupSet in\ndef littleFinitisticDimension : WithBot ℕ∞ :=\n ⨆ (M : ModuleCat.{u} A) (_ : Module.Finite A M) (_ : projectiveDimension M < ⊤),\n projectiveDimension M\n\ndef bigFinitisticDimension : WithBot ℕ∞ :=\n ⨆ (M : ModuleCat.{u} A) (_ : projectiveDimension M < ⊤), projectiveDimension M\n\ndef InjectivesGenerate : Prop :=\n letI := HasDerivedCategory.standard (ModuleCat.{u} A)\n ∀ (P : ObjectProperty (DerivedCategory (ModuleCat.{u} A))),\n P.IsClosedUnderIsomorphisms → P.IsTriangulated →\n (∀ I : Type u, P.IsClosedUnderColimitsOfShape (Discrete I)) →\n (∀ (M : ModuleCat.{u} A), Injective M →\n P ((DerivedCategory.singleFunctor (ModuleCat.{u} A) 0).obj M)) →\n ∀ X, P X\n\ntheorem extreme_left_right_asymmetry :\n ∃ (Λ : Type) (_ : Ring Λ) (_ : Algebra ℂ Λ),\n FiniteDimensional ℂ Λ ∧\n littleFinitisticDimension Λ = ⊤ ∧ bigFinitisticDimension Λ = ⊤ ∧\n littleFinitisticDimension Λᵐᵒᵖ = 0 ∧ bigFinitisticDimension Λᵐᵒᵖ = 0 ∧\n ¬ InjectivesGenerate Λ ∧ InjectivesGenerate Λᵐᵒᵖ := by\n sorry\n\nend LittleFinitistic\n\nend\n\nend OAI\n", "-- ComparatorChallenges/LittleFinitistic.lean\nimport Mathlib.Algebra.Category.ModuleCat.Abelian\nimport Mathlib.CategoryTheory.Abelian.Projective.Dimension\nimport Mathlib.Basic.Complex.Basic\nimport Mathlib.LinearAlgebra.FiniteDimensional.Defs\nimport Mathlib.RingTheory.Finiteness.Defs\n\nnamespace OAI\n\nnoncomputable section\n\nopen CategoryTheory\n\nnamespace LittleFinitistic\n\nuniverse u\n\ndef littleFinitisticDimension (A : Type u) [Ring A] : WithBot ℕ∞ :=\n ⨆ (M : ModuleCat.{u} A) (_ : Module.Finite A M) (_ : projectiveDimension M < ⊤),\n projectiveDimension M\n\nnamespace Main\n\ntheorem exists_counterexample :\n ∃ (A : Type) (_ : Ring A) (_ : Algebra ℂ A),\n FiniteDimensional ℂ A ∧ littleFinitisticDimension A = ⊤ ∧\n ∀ m : ℕ, 0 < m → ∃ N : ModuleCat.{0} A, Module.Finite A N ∧\n ((2*m-2 : ℕ) : WithBot ℕ∞) ≤ projectiveDimension N ∧\n projectiveDimension N < ⊤ := by\n sorry\n\nend Main\n\nend LittleFinitistic\n\nend\n\nend OAI\n"], "formalization_scope": "The little finitistic-dimension conjecture predicts that finitely generated modules of finite projective dimension over a fixed finite-dimensional algebra have bounded projective dimensions. The formalized counterexample is a finite-dimensional complex algebra with a finitely generated module of projective dimension at least $2m-2$ and still finite for every $m\\ge1$.\n\nA separate formalized result gives a finite-dimensional complex algebra whose little and big finitistic dimensions are infinite on the left and zero on the right. Injectives fail to generate its unbounded derived category on the left and generate it on the right.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The definition of littleFinitisticDimension matches the usual supremum over finitely generated modules with finite projective dimension, and for a finite-dimensional complex algebra finite generation is equivalent to finite-dimensionality. The theorem exists_counterexample directly asserts a finite-dimensional complex algebra with little finitistic dimension top and explicitly unbounded finite projective dimensions. The other theorem is stronger, adding big finitistic dimension and opposite-algebra asymmetry, but still implies the main claim. Therefore the Lean statements faithfully express the paper's main claim.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement `exists_counterexample` in `LittleFinitistic.lean` faithfully formalizes the main claim. It asserts the existence of a finite-dimensional complex algebra $A$ such that `littleFinitisticDimension A = ⊤` (meaning the supremum of finite projective dimensions of finite-dimensional modules is infinite) and explicitly provides the unboundedness condition via `∀ m, 0 < m → ∃ N, ... projectiveDimension N ≥ 2*m - 2`. This directly captures 'finite-dimensional modules have unbounded finite projective dimensions'. The `extreme_left_right_asymmetry` theorem in the other file also captures the core claim (`littleFinitisticDimension Λ = ⊤`) while adding further properties about the opposite algebra, which does not contradict the main claim. The definitions align with standard interpretations of finitistic dimension.\", \"score\": 5}"}}
{"family": "213", "title": "Critical percolation on every quasi-transitive graph", "claim": "Critical percolation on every quasi-transitive graph. Resolves the Benjamini–Schramm criticality conjecture for bond percolation on every infinite connected locally finite quasi-transitive graph with $`p_c\\lt 1`$: at the critical probability, there is almost surely no infinite cluster. The family also establishes this conclusion for both nearest-neighbor bond and site percolation on ℤ3.", "abstracts": ["We prove that nearest-neighbor Bernoulli bond and site percolation on $\\mathbb Z^3$ have no infinite cluster at their respective critical parameters. The proof combines a finite connection inequality for independent hyperedges with a finite-scale extension estimate and an adaptive exploration.", "We prove that critical Bernoulli bond percolation has no infinite cluster on any infinite connected locally finite quasi-transitive graph with critical probability less than one. This resolves the bond form of the criticality conjecture of Benjamini and Schramm."], "papers": ["https://github.com/openai/math/tree/main/preprints/Critical-bond-and-site-percolation-on-the-cubic-lattice-September-24-2026", "https://github.com/openai/math/tree/main/preprints/No-percolation-at-criticality-on-quasi-transitive-graphs-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/CriticalPercolation.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/CriticalZ3.lean"], "lean_statements": ["-- ComparatorChallenges/CriticalPercolation.lean\nimport Mathlib\n\nnamespace OAI\n\nopen Set MeasureTheory ProbabilityTheory\n\nnamespace CriticalPercolation\n\n/-- An undirected graph with labelled bonds, including loops and parallel bonds. -/\nstructure BondGraph (V E : Type*) where\n ends : E → Sym2 V\n\nnamespace BondGraph\nvariable {V E : Type*} (G : BondGraph V E)\n\n/-- The graph of retained bonds. `fromEdgeSet` discards loops. -/\ndef openGraph (ω : Set E) : SimpleGraph V :=\n SimpleGraph.fromEdgeSet (G.ends '' ω)\n\n/-- The underlying connectivity graph with every bond retained. -/\ndef fullGraph : SimpleGraph V := G.openGraph Set.univ\n\n/-- Local finiteness counts bonds, not just distinct neighbors. -/\ndef LocallyFinite : Prop := ∀ v : V, {e : E | v ∈ G.ends e}.Finite\n\n/-- Automorphisms preserve the vertex and bond structure, including multiplicities. -/\nstructure Aut where\n vertex : V ≃ V\n edge : E ≃ E\n preserves : ∀ e, G.ends (edge e) = Sym2.map vertex (G.ends e)\n\n/-- Finitely many vertex orbits under the full automorphism group. -/\ndef QuasiTransitive : Prop :=\n ∃ S : Set V, S.Finite ∧ ∀ v : V, ∃ s ∈ S, ∃ φ : G.Aut, φ.vertex s = v\n\n/-- Finite open paths, including the path of length zero, define the open cluster. -/\ndef cluster (ω : Set E) (v : V) : Set V := {w | (G.openGraph ω).Reachable v w}\n\n/-- The event that at least one open cluster is infinite. -/\ndef percolates : Set (Set E) := {ω | ∃ v : V, (G.cluster ω v).Infinite}\n\n/-- Independent retention with parameter `p ∈ [0,1]` of each labelled bond. -/\nnoncomputable def law (_G : BondGraph V E) (p : unitInterval) : Measure (Set E) :=\n ProbabilityTheory.setBernoulli Set.univ p\n\n/-- The infimum of parameters with positive probability of an infinite cluster. -/\nnoncomputable def criticalProbability : unitInterval :=\n sInf {p : unitInterval | 0 < G.law p G.percolates}\n\n/-- Critical Bernoulli bond percolation has no infinite cluster when the critical\nprobability is below one. -/\ntheorem no_percolation_at_criticality [Infinite V]\n (hconnected : G.fullGraph.Connected)\n (hlocal : G.LocallyFinite)\n (hquasi : G.QuasiTransitive)\n (hpc : G.criticalProbability < 1) :\n G.law G.criticalProbability G.percolates = 0 := by\n sorry\n\nend BondGraph\nend CriticalPercolation\n\nend OAI\n", "-- ComparatorChallenges/CriticalZ3.lean\nimport Mathlib\n\nnamespace OAI\n\nopen MeasureTheory ProbabilityTheory\n\nnamespace CriticalZ3\n\nabbrev Vertex := Fin 3 → ℤ\nabbrev Bond := Vertex × Fin 3\nabbrev BondConfig := Bond → Bool\nabbrev SiteConfig := Vertex → Bool\n\ndef step (x : Vertex) (i : Fin 3) : Vertex := fun j => x j + if i = j then 1 else 0\n\ndef NearestNeighbor (x y : Vertex) : Prop :=\n ∃ i : Fin 3, y = step x i ∨ x = step y i\n\ndef BondOpen (ω : BondConfig) (x y : Vertex) : Prop :=\n (∃ i : Fin 3, y = step x i ∧ ω (x, i) = true) ∨\n (∃ i : Fin 3, x = step y i ∧ ω (y, i) = true)\n\ndef SiteOpen (ω : SiteConfig) (x y : Vertex) : Prop :=\n NearestNeighbor x y ∧ ω x = true ∧ ω y = true\n\ndef BondConnected (ω : BondConfig) (x y : Vertex) : Prop :=\n Relation.ReflTransGen (BondOpen ω) x y\n\ndef SiteConnected (ω : SiteConfig) (x y : Vertex) : Prop :=\n ω x = true ∧ Relation.ReflTransGen (SiteOpen ω) x y\n\ndef bondCluster (ω : BondConfig) (x : Vertex) : Set Vertex :=\n {y | BondConnected ω x y}\n\ndef siteCluster (ω : SiteConfig) (x : Vertex) : Set Vertex :=\n {y | SiteConnected ω x y}\n\ndef bondInfiniteAt (x : Vertex) : Set BondConfig := {ω | (bondCluster ω x).Infinite}\ndef siteInfiniteAt (x : Vertex) : Set SiteConfig := {ω | (siteCluster ω x).Infinite}\n\nnoncomputable def parameter (p : ℝ) : Set.Icc (0 : ℝ) 1 :=\n ⟨max 0 (min 1 p), le_max_left _ _, max_le (by norm_num) (min_le_left _ _)⟩\n\nnoncomputable def bondLaw (p : ℝ) : Measure BondConfig :=\n Measure.infinitePi (fun _ : Bond => bernoulliMeasure true false (parameter p))\n\nnoncomputable def siteLaw (p : ℝ) : Measure SiteConfig :=\n Measure.infinitePi (fun _ : Vertex => bernoulliMeasure true false (parameter p))\n\nnoncomputable def bondCritical : ℝ :=\n sInf {p : ℝ | p ∈ Set.Icc (0 : ℝ) 1 ∧ 0 < bondLaw p (bondInfiniteAt 0)}\n\nnoncomputable def siteCritical : ℝ :=\n sInf {p : ℝ | p ∈ Set.Icc (0 : ℝ) 1 ∧ 0 < siteLaw p (siteInfiniteAt 0)}\n\ntheorem critical_no_infinite :\n (∀ᵐ ω ∂bondLaw bondCritical, ∀ x : Vertex, (bondCluster ω x).Finite) ∧\n (∀ᵐ ω ∂siteLaw siteCritical, ∀ x : Vertex, (siteCluster ω x).Finite) := by\n sorry\n\nend CriticalZ3\n\nend OAI\n"], "formalization_scope": "The critical-percolation question asks whether an infinite cluster can remain at the threshold. The formalized result proves that, at their respective critical probabilities, nearest-neighbor bond and site percolation on $\\mathbb Z^3$ almost surely have no infinite cluster. Equivalently, almost surely every vertex belongs to a finite cluster in each model.\n\nThe formalization proves absence of an infinite cluster at criticality for Bernoulli bond percolation on every infinite connected locally finite quasi-transitive graph with critical probability $p_c<1$. At $p=p_c$, the probability that any infinite cluster exists is zero. The graph model permits bond multiplicities.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The general theorem exactly formalizes the quasi-transitive bond percolation claim: it assumes an infinite, connected, locally finite, quasi-transitive graph with critical probability below one and concludes that the critical Bernoulli measure of the event of an infinite open cluster is zero. The definitions of automorphism, local finiteness, clusters, and critical probability match the usual mathematical meanings. The Z3 theorem correctly formalizes nearest-neighbor bond and site percolation and asserts almost sure finiteness of all clusters at the respective critical parameters. No substantive extra hypotheses or weakening of the conclusion are present.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully expresses the main claim. The first file's theorem states that for any infinite connected locally finite quasi-transitive graph with critical probability less than 1, the probability of percolation (existence of at least one infinite cluster) at criticality is exactly 0, matching 'almost surely no infinite cluster.' The second file's theorem for ℤ³ establishes that almost surely all clusters are finite at the critical parameter for both bond and site percolation, which is equivalent to the claim. Definitions of critical probability, percolation events, and connectivity align with standard mathematical meaning, and no extraneous hypotheses are present.\", \"score\": 5}"}}
{"family": "214", "title": "The Benjamini–Schramm nonuniqueness conjecture", "claim": "The Benjamini–Schramm nonuniqueness conjecture. Proves $`p_c\\lt p_u`$ for Bernoulli bond percolation on every infinite connected locally finite nonamenable quasi-transitive graph, resolving the Benjamini–Schramm nonuniqueness conjecture. Thus there is a nonempty range of probabilities with infinitely many infinite clusters. A stronger operator bound also establishes the critical triangle condition.", "abstracts": ["We prove the bond-percolation nonuniqueness conjecture of Benjamini and Schramm: every infinite connected, locally finite, nonamenable quasi-transitive graph has a nonempty interval of parameters for which Bernoulli bond percolation almost surely has infinitely many infinite clusters. We also prove Hutchcroft's stronger operator-threshold conjecture, establishing $p_c ∃ e ∈ ω, G e = s(a, b)) x y\n\ndef cluster (G : BondGraph V E) (ω : Set E) (x : V) : Set V :=\n {y | Conn G ω x y}\n\ndef infiniteClusters (G : BondGraph V E) (ω : Set E) : Set (Set V) :=\n {C | C.Infinite ∧ ∃ x, C = cluster G ω x}\n\nnoncomputable def law (p : unitInterval) : Measure (Set E) :=\n setBernoulli Set.univ p\n\nnoncomputable def pc (G : BondGraph V E) : unitInterval :=\n sInf {p | 0 < law p {ω | (infiniteClusters G ω).Nonempty}}\n\nnoncomputable def pu (G : BondGraph V E) : unitInterval :=\n sInf {p | law p {ω | ∃! C, C ∈ infiniteClusters G ω} = 1}\n\nnoncomputable def twoPoint (G : BondGraph V E) (p : unitInterval) (x y : V) : ℝ :=\n (law p {ω | Conn G ω x y}).toReal\n\nnoncomputable abbrev Hilbert (V : Type u) := lp (fun _ : V => ℂ) 2\n\nnoncomputable def HasKernel [DecidableEq V]\n (G : BondGraph V E) (p : unitInterval)\n (A : Hilbert V →L[ℂ] Hilbert V) : Prop :=\n ∀ x y, (A (lp.single 2 y (1 : ℂ))) x = (twoPoint G p x y : ℂ)\n\nnoncomputable def OperatorBounded (G : BondGraph V E) (p : unitInterval) : Prop := by\n classical\n exact ∃ A : Hilbert V →L[ℂ] Hilbert V, HasKernel G p A\n\nnoncomputable def operatorNorm (G : BondGraph V E) (p : unitInterval) : ℝ≥0∞ := by\n classical\n exact sInf {r | ∃ A : Hilbert V →L[ℂ] Hilbert V,\n HasKernel G p A ∧ r = ENNReal.ofReal ‖A‖}\n\nnoncomputable def ptwo (G : BondGraph V E) : unitInterval :=\n sSup {p | OperatorBounded G p}\n\nnoncomputable def labelLaw : Measure (E → unitInterval) :=\n Measure.infinitePi (fun _ => (volume : Measure unitInterval))\n\ndef openEdges (labels : E → unitInterval) (p : unitInterval) : Set E :=\n {e | labels e ≤ p}\n\ndef MainConclusion (G : BondGraph V E) : Prop :=\n (sSup {r | ∃ p : unitInterval, p < pc G ∧ r = operatorNorm G p} =\n operatorNorm G (pc G)) ∧\n operatorNorm G (pc G) < ⊤ ∧\n pc G < ptwo G ∧ ptwo G ≤ pu G ∧\n ∃ p₁ p₂ : unitInterval, pc G < p₁ ∧ p₁ < p₂ ∧ p₂ < 1 ∧\n ∀ᵐ labels ∂(labelLaw : Measure (E → unitInterval)),\n ∀ p ∈ Set.Icc p₁ p₂, (infiniteClusters G (openEdges labels p)).Infinite\n\nend Percolation\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace Percolation\nuniverse u v\nvariable {V : Type u} {E : Type v}\nattribute [local instance] Classical.propDecidable\n\ndef openSimpleGraph (G : BondGraph V E) (ω : Set E) : SimpleGraph V where\n Adj x y := x ≠ y ∧ ∃ e ∈ ω, G e = s(x,y)\n symm := ⟨by\n rintro x y ⟨hxy, e, he, h⟩\n exact ⟨hxy.symm, e, he, h.trans (Sym2.eq_swap ..)⟩⟩\n loopless := ⟨by simp⟩\n\nend Percolation\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace Percolation\nuniverse u v\nvariable {V : Type u} {E : Type v}\nattribute [local instance] Classical.propDecidable Classical.decEq\n\nnoncomputable def susceptibility (G : BondGraph V E) (p : unitInterval) (x : V) : ℝ :=\n ∑' y, twoPoint G p x y\n\nend Percolation\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace Percolation.BenjaminiSchramm\nuniverse u v\nvariable {V : Type u} {E : Type v}\nattribute [local instance] Classical.decEq\n\nnoncomputable def triangleDiagram (G : BondGraph V E) (p : unitInterval) (x : V) : ℝ≥0∞ :=\n ∑' ab : V × V, ENNReal.ofReal\n (twoPoint G p x ab.1 * twoPoint G p ab.1 ab.2 * twoPoint G p ab.2 x)\n\nnoncomputable def graphDistance (G : BondGraph V E) (x y : V) : ℕ :=\n (openSimpleGraph G Set.univ).dist x y\n\ndef ExponentialDecay (G : BondGraph V E) (p : unitInterval) : Prop :=\n ∃ A a : ℝ, 0 < A ∧ 0 < a ∧ ∀ x y,\n twoPoint G p x y ≤ A * Real.exp (-a * graphDistance G x y)\n\nnoncomputable def pexp (G : BondGraph V E) : unitInterval :=\n sSup {p | ExponentialDecay G p}\n\ndef PowerTail (f : ℕ → ℝ) (exponent : ℝ) : Prop :=\n ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∀ n : ℕ, 0 < n →\n c * (n : ℝ) ^ (-exponent) ≤ f n ∧ f n ≤ C * (n : ℝ) ^ (-exponent)\n\ndef volumeEvent (G : BondGraph V E) (x : V) (n : ℕ) : Set (Set E) :=\n {ω | (n : ℕ∞) ≤ (cluster G ω x).encard}\n\ndef intrinsicRadiusEvent (G : BondGraph V E) (x : V) (n : ℕ) : Set (Set E) :=\n {ω | ∃ y ∈ cluster G ω x, n ≤ (openSimpleGraph G ω).dist x y}\n\ndef extrinsicRadiusEvent (G : BondGraph V E) (x : V) (n : ℕ) : Set (Set E) :=\n {ω | ∃ y ∈ cluster G ω x, n ≤ graphDistance G x y}\n\nnoncomputable def criticalTail (G : BondGraph V E)\n (A : V → ℕ → Set (Set E)) (x : V) (n : ℕ) : ℝ :=\n (law (pc G) (A x n)).toReal\n\ndef CriticalTailLaws (G : BondGraph V E) : Prop :=\n ∀ x, PowerTail (criticalTail G (volumeEvent G) x) (1 / 2) ∧\n PowerTail (criticalTail G (intrinsicRadiusEvent G) x) 1 ∧\n PowerTail (criticalTail G (extrinsicRadiusEvent G) x) 1\n\ndef SusceptibilityLaw (G : BondGraph V E) : Prop :=\n ∀ x, ∃ c C δ : ℝ, 0 < c ∧ 0 < C ∧ 0 < δ ∧\n ∀ p : unitInterval, p < pc G → (pc G : ℝ) - p < δ →\n c / ((pc G : ℝ) - p) ≤ susceptibility G p x ∧\n susceptibility G p x ≤ C / ((pc G : ℝ) - p)\n\nnoncomputable def percolationProbability (G : BondGraph V E) (p : unitInterval)\n (x : V) : ℝ := (law p {ω | (cluster G ω x).Infinite}).toReal\n\ndef PercolationProbabilityLaw (G : BondGraph V E) : Prop :=\n ∀ x, ∃ c C δ : ℝ, 0 < c ∧ 0 < C ∧ 0 < δ ∧\n ∀ p : unitInterval, pc G < p → (p : ℝ) - pc G < δ →\n c * ((p : ℝ) - pc G) ≤ percolationProbability G p x ∧\n percolationProbability G p x ≤ C * ((p : ℝ) - pc G)\n\nend Percolation.BenjaminiSchramm\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace Percolation.BenjaminiSchramm\nuniverse u v\nvariable {V : Type u} {E : Type v}\n\ndef CriticalLawsConclusion (G : BondGraph V E) : Prop :=\n (∀ x, triangleDiagram G (pc G) x ≤ operatorNorm G (pc G) ^ 3 ∧\n triangleDiagram G (pc G) x < ⊤) ∧\n SusceptibilityLaw G ∧ PercolationProbabilityLaw G ∧ CriticalTailLaws G ∧\n (pc G < ptwo G ∧ ptwo G ≤ pexp G) ∧\n ∀ p : unitInterval, p < ptwo G → ExponentialDecay G p\n\nend Percolation.BenjaminiSchramm\n\nrun_elab Lean.modifyEnv fun environment => Lean.Meta.auxLemmasExt.setState environment {}\n\nnamespace Percolation.BenjaminiSchramm\nuniverse u\nvariable {Λ : Type u} [Group Λ]\nattribute [local instance] Classical.decEq\n\nabbrev CayleyEdge (S : Finset Λ) := (SimpleGraph.mulCayley (S : Set Λ)).edgeSet\n\ndef cayleyBond (S : Finset Λ) : BondGraph Λ (CayleyEdge S) := Subtype.val\n\ndef FolnerAmenable (Λ : Type u) [Group Λ] : Prop :=\n ∀ K : Finset Λ, ∀ ε : ℝ, 0 < ε → ∃ A : Finset Λ, A.Nonempty ∧\n ∀ k ∈ K, (((A.image (fun x => x * k)) \\ A).card : ℝ) < ε * A.card\n\nend Percolation.BenjaminiSchramm\n\nnamespace Percolation.BenjaminiSchramm\n\nuniverse u v\n\n/-- Critical operator boundedness, the threshold gap, and simultaneous nonuniqueness. -/\ntheorem full_main {V : Type u} {E : Type v} [Infinite V]\n (G : BondGraph V E) (hc : Connected G) (hl : LocallyFinite G)\n (hq : QuasiTransitive G) (hh : 0 < hV G) : MainConclusion G := by\n sorry\n\n/-- Critical mean-field laws and uniform exponential connectivity below the operator threshold. -/\ntheorem critical_laws {V : Type u} {E : Type v} [Infinite V]\n (G : BondGraph V E) (hc : Connected G) (hl : LocallyFinite G)\n (hq : QuasiTransitive G) (hh : 0 < hV G) : CriticalLawsConclusion G := by\n sorry\n\n/-- Nonuniqueness for every prescribed finite symmetric Cayley generating set. -/\ntheorem cayley_main {Λ : Type u} [Group Λ]\n (S : Finset Λ) (hsym : ∀ s ∈ S, s⁻¹ ∈ S) (_hone : 1 ∉ S)\n (hgen : Subgroup.closure (S : Set Λ) = ⊤) (hna : ¬ FolnerAmenable Λ) :\n OperatorBounded (cayleyBond S) (pc (cayleyBond S)) ∧\n MainConclusion (cayleyBond S) ∧\n ∀ p : unitInterval, pc (cayleyBond S) < p → p < pu (cayleyBond S) →\n ∀ᵐ ω ∂law p, (infiniteClusters (cayleyBond S) ω).Infinite := by\n sorry\n\nend Percolation.BenjaminiSchramm\n\nend OAI\n", "-- ComparatorChallenges/CayleyPercolation.lean\nimport Mathlib\n\nnamespace OAI\n\n/-! Nonuniqueness of Bernoulli bond percolation on arbitrary Cayley graphs. -/\n\nopen MeasureTheory ProbabilityTheory\nopen scoped ENNReal NNReal\n\nnamespace Percolation\nuniverse u v\nvariable {V : Type u} {E : Type v}\n\nabbrev BondGraph (V : Type u) (E : Type v) := E → Sym2 V\n\ndef Conn (G : BondGraph V E) (ω : Set E) (x y : V) : Prop :=\n Relation.ReflTransGen (fun a b => ∃ e ∈ ω, G e = s(a, b)) x y\n\ndef cluster (G : BondGraph V E) (ω : Set E) (x : V) : Set V :=\n {y | Conn G ω x y}\n\ndef infiniteClusters (G : BondGraph V E) (ω : Set E) : Set (Set V) :=\n {C | C.Infinite ∧ ∃ x, C = cluster G ω x}\n\nnoncomputable def law (p : unitInterval) : Measure (Set E) :=\n setBernoulli Set.univ p\n\nnoncomputable def pc (G : BondGraph V E) : unitInterval :=\n sInf {p | 0 < law p {ω | (infiniteClusters G ω).Nonempty}}\n\nnoncomputable def pu (G : BondGraph V E) : unitInterval :=\n sInf {p | law p {ω | ∃! C, C ∈ infiniteClusters G ω} = 1}\n\nnoncomputable def twoPoint (G : BondGraph V E) (p : unitInterval) (x y : V) : ℝ :=\n (law p {ω | Conn G ω x y}).toReal\n\nnoncomputable abbrev Hilbert (V : Type u) := lp (fun _ : V => ℂ) 2\n\nnoncomputable def HasKernel [DecidableEq V]\n (G : BondGraph V E) (p : unitInterval)\n (A : Hilbert V →L[ℂ] Hilbert V) : Prop :=\n ∀ x y, (A (lp.single 2 y (1 : ℂ))) x = (twoPoint G p x y : ℂ)\n\nnoncomputable def OperatorBounded (G : BondGraph V E) (p : unitInterval) : Prop := by\n classical\n exact ∃ A : Hilbert V →L[ℂ] Hilbert V, HasKernel G p A\n\nnoncomputable def ptwo (G : BondGraph V E) : unitInterval :=\n sSup {p | OperatorBounded G p}\n\nnoncomputable def labelLaw : Measure (E → unitInterval) :=\n Measure.infinitePi (fun _ => (volume : Measure unitInterval))\n\ndef openEdges (labels : E → unitInterval) (p : unitInterval) : Set E :=\n {e | labels e ≤ p}\n\nnoncomputable def AmenableGroup (Λ : Type u) [Group Λ] : Prop := by\n classical\n exact ∀ K : Finset Λ, ∀ ε : ℝ, 0 < ε → ∃ A : Finset Λ, A.Nonempty ∧\n ∀ g ∈ K, (((A.image (fun x => x * g)) \\ A).card : ℝ) < ε * A.card\n\ndef CayleyEdge {Λ : Type u} [Group Λ] (S : Finset Λ) :=\n {e : Sym2 Λ // ∃ x : Λ, ∃ s ∈ S, e = s(x, x * s)}\n\ndef cayleyGraph {Λ : Type u} [Group Λ] (S : Finset Λ) :\n BondGraph Λ (CayleyEdge S) := Subtype.val\n\ntheorem arbitrary_cayley {Λ : Type u} [Group Λ] [Group.FG Λ]\n (hna : ¬ AmenableGroup Λ) (S : Finset Λ)\n (hsym : ∀ s ∈ S, s⁻¹ ∈ S) (hgen : Subgroup.closure (S : Set Λ) = ⊤)\n (h1 : 1 ∉ S) :\n OperatorBounded (cayleyGraph S) (pc (cayleyGraph S)) ∧\n pc (cayleyGraph S) < ptwo (cayleyGraph S) ∧\n ptwo (cayleyGraph S) ≤ pu (cayleyGraph S) ∧\n (∃ p₁ p₂ : unitInterval, pc (cayleyGraph S) < p₁ ∧ p₁ < p₂ ∧ p₂ < 1 ∧\n ∀ᵐ labels ∂(labelLaw : Measure (CayleyEdge S → unitInterval)),\n ∀ p ∈ Set.Icc p₁ p₂, (infiniteClusters (cayleyGraph S) (openEdges labels p)).Infinite) ∧\n (∀ p : unitInterval, pc (cayleyGraph S) < p → p < pu (cayleyGraph S) →\n ∀ᵐ ω ∂law p, (infiniteClusters (cayleyGraph S) ω).Infinite) := by\n sorry\n\nend Percolation\n\nend OAI\n"], "formalization_scope": "The formalization proves the nonuniqueness phase conjecture for Bernoulli bond percolation on infinite connected locally finite nonamenable quasi-transitive graphs. It establishes $p_c Part.some (if A n then 1 else 0)\n\ndef Reduces (A B : Oracle) : Prop := TuringReducible (oracleFunction A) (oracleFunction B)\n\ninstance : IsPreorder Oracle Reduces where\n refl A := TuringReducible.refl (oracleFunction A)\n trans _ _ _ h k := TuringReducible.trans h k\n\ndef Degree := Antisymmetrization Oracle Reduces\n\ninstance : PartialOrder Degree :=\n @instPartialOrderAntisymmetrization Oracle\n { le := Reduces\n lt A B := Reduces A B ∧ ¬ Reduces B A\n lt_iff_le_not_ge _ _ := Iff.rfl\n le_refl A := TuringReducible.refl (oracleFunction A)\n le_trans _ _ _ h k := TuringReducible.trans h k }\n\nprivate instance oraclePreorder : Preorder Oracle where\n le := Reduces\n lt A B := Reduces A B ∧ ¬ Reduces B A\n lt_iff_le_not_ge _ _ := Iff.rfl\n le_refl A := TuringReducible.refl (oracleFunction A)\n le_trans _ _ _ h k := TuringReducible.trans h k\n\ndef MainTheorem : Prop := ∀ π : Degree ≃o Degree, ∀ a : Degree, π a = a\n\nnamespace ManuscriptMain\n\ntheorem rigidity : MainTheorem := by\n sorry\n\nend ManuscriptMain\nend TuringRigidity\n\nend OAI\n"], "formalization_scope": "The rigidity problem asks whether the ordering of Turing degrees by relative computability has any nontrivial automorphism. The formalized result gives a negative answer: every order automorphism of the full Turing degrees of subsets of $\\mathbb N$ fixes every degree, with no definability or genericity assumption. The additional representation corollaries are not included.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean code defines a type `Degree` as the antisymmetrization of all oracles `ℕ → Bool` under the relation `TuringReducible` of their characteristic functions, which is the standard quotient defining Turing degrees. `MainTheorem` then states that every order isomorphism `Degree ≃o Degree` is pointwise equal to the identity, exactly the claimed rigidity of the full Turing degrees. The technical choices (characteristic functions as total partial functions and `Antisymmetrization`) are faithful encodings rather than weakenings.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement `MainTheorem` formalizes exactly the main claim: every order automorphism of the Turing degrees is the identity. The type `Degree ≃o Degree` represents order isomorphisms (automorphisms) of the partial order of Turing degrees, and the conclusion `π a = a` states that each such automorphism fixes every element. The definitions of `Oracle`, `Reduces`, and `Degree` correctly model the Turing degrees as a partial order. There are no extra hypotheses, no weakening of the claim, and the statement is non-vacuous.\", \"score\": 5}"}}
{"family": "245", "title": "Weak normalization implies strong normalization in pure type systems", "claim": "Weak normalization implies strong normalization in pure type systems. Proves that weak normalization implies strong normalization for every pure type system: if every legal expression in every valid context has a β-normal form, every β-reduction sequence terminates. This resolves the β-Barendregt–Geuvers–Klop conjecture, including nonfunctional rules and open contexts.", "abstracts": ["We prove that every weakly $\\beta$-normalizing pure type system is strongly $\\beta$-normalizing. Both properties quantify over all legal expressions in all valid contexts, and reduction acts inside type annotations. No functionality hypothesis is required. This resolves the $\\beta$-Barendregt--Geuvers--Klop conjecture."], "papers": ["https://github.com/openai/math/tree/main/preprints/Weak-and-strong-normalization-in-pure-type-systems-September-25-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/TypeSystemNormalization.lean"], "lean_statements": ["-- ComparatorChallenges/TypeSystemNormalization.lean\nimport Mathlib\n\nnamespace OAI\n\n/-!\nFull annotated PTS syntax, modulo alpha-renaming via de Bruijn indices.\nContexts are stored newest-first, each declaration in its prefix context.\nNo functionality assumptions on axioms or product rules.\n-/\n\nnamespace PureTypeSystem\n\nuniverse u\n\ninductive Expr (Sorts : Type u) : Type u\n | var : Nat → Expr Sorts\n | sort : Sorts → Expr Sorts\n | app : Expr Sorts → Expr Sorts → Expr Sorts\n | lam : Expr Sorts → Expr Sorts → Expr Sorts\n | pi : Expr Sorts → Expr Sorts → Expr Sorts\n deriving DecidableEq\n\nnamespace Expr\n\nvariable {S : Type u}\n\ndef liftRen (ρ : Nat → Nat) : Nat → Nat\n | 0 => 0\n | n + 1 => ρ n + 1\n\ndef rename (ρ : Nat → Nat) : Expr S → Expr S\n | var n => var (ρ n)\n | sort s => sort s\n | app f a => app (rename ρ f) (rename ρ a)\n | lam A b => lam (rename ρ A) (rename (liftRen ρ) b)\n | pi A B => pi (rename ρ A) (rename (liftRen ρ) B)\n\ndef liftSub (σ : Nat → Expr S) : Nat → Expr S\n | 0 => var 0\n | n + 1 => rename Nat.succ (σ n)\n\ndef subst (σ : Nat → Expr S) : Expr S → Expr S\n | var n => σ n\n | sort s => sort s\n | app f a => app (subst σ f) (subst σ a)\n | lam A b => lam (subst σ A) (subst (liftSub σ) b)\n | pi A B => pi (subst σ A) (subst (liftSub σ) B)\n\ndef single (a : Expr S) : Nat → Expr S\n | 0 => a\n | n + 1 => var n\n\ndef instantiate (b a : Expr S) : Expr S := subst (single a) b\n\nend Expr\n\nstructure Specification (S : Type u) where\n axioms : S → S → Prop\n rule : S → S → S → Prop\n\ninductive Beta {S : Type u} : Expr S → Expr S → Prop\n | head (A b a) : Beta (.app (.lam A b) a) (b.instantiate a)\n | app_left {f f' a} : Beta f f' → Beta (.app f a) (.app f' a)\n | app_right {f a a'} : Beta a a' → Beta (.app f a) (.app f a')\n | lam_domain {A A' b} : Beta A A' → Beta (.lam A b) (.lam A' b)\n | lam_body {A b b'} : Beta b b' → Beta (.lam A b) (.lam A b')\n | pi_domain {A A' B} : Beta A A' → Beta (.pi A B) (.pi A' B)\n | pi_body {A B B'} : Beta B B' → Beta (.pi A B) (.pi A B')\n\ndef Converts {S : Type u} : Expr S → Expr S → Prop := Relation.EqvGen Beta\n\ndef Normal {S : Type u} (M : Expr S) : Prop := ∀ N, ¬ Beta M N\n\ndef WeaklyNormalizing {S : Type u} (M : Expr S) : Prop :=\n ∃ N, Relation.ReflTransGen Beta M N ∧ Normal N\n\n/-- Accessibility for the converse of reduction: strong normalization,\nincluding reductions in all type annotations. -/\ndef StronglyNormalizing {S : Type u} (M : Expr S) : Prop :=\n Acc (fun N M : Expr S => Beta M N) M\n\ninductive HasType {S : Type u} (P : Specification S) :\n List (Expr S) → Expr S → Expr S → Prop\n | ax {s t} : P.axioms s t → HasType P [] (.sort s) (.sort t)\n | var {Γ A s} : HasType P Γ A (.sort s) →\n HasType P (A :: Γ) (.var 0) (A.rename Nat.succ)\n | weaken {Γ M B A s} : HasType P Γ M B → HasType P Γ A (.sort s) →\n HasType P (A :: Γ) (M.rename Nat.succ) (B.rename Nat.succ)\n | product {Γ A B s₁ s₂ s₃} : HasType P Γ A (.sort s₁) →\n HasType P (A :: Γ) B (.sort s₂) → P.rule s₁ s₂ s₃ →\n HasType P Γ (.pi A B) (.sort s₃)\n | abstraction {Γ A b B s} : HasType P (A :: Γ) b B →\n HasType P Γ (.pi A B) (.sort s) →\n HasType P Γ (.lam A b) (.pi A B)\n | application {Γ f a A B} : HasType P Γ f (.pi A B) →\n HasType P Γ a A → HasType P Γ (.app f a) (B.instantiate a)\n | conversion {Γ M A B s} : HasType P Γ M A → HasType P Γ B (.sort s) →\n Converts A B → HasType P Γ M B\n\ninductive ValidContext {S : Type u} (P : Specification S) : List (Expr S) → Prop\n | nil : ValidContext P []\n | cons {Γ A s} : ValidContext P Γ → HasType P Γ A (.sort s) →\n ValidContext P (A :: Γ)\n\ndef Legal {S : Type u} (P : Specification S) (Γ : List (Expr S)) (M : Expr S) : Prop :=\n ∃ A, HasType P Γ M A ∨ HasType P Γ A M\n\ndef SystemWeaklyNormalizing {S : Type u} (P : Specification S) : Prop :=\n ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → WeaklyNormalizing M\n\ndef SystemStronglyNormalizing {S : Type u} (P : Specification S) : Prop :=\n ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → StronglyNormalizing M\n\n/-- System-wide weak normalization implies strong normalization for every PTS,\nincluding arbitrary sort types, nonfunctional rules and annotated terms. -/\ntheorem weak_implies_strong {S : Type u} (P : Specification S)\n (h : SystemWeaklyNormalizing P) : SystemStronglyNormalizing P := by\n sorry\n\nend PureTypeSystem\n\nend OAI\n"], "formalization_scope": "The formalization proves the $\\beta$-Barendregt–Geuvers–Klop conjecture for pure type systems: if every legal expression in every valid context has some terminating $\\beta$-reduction sequence, then every $\\beta$-reduction sequence from every such expression terminates. Reduction is allowed inside type annotations, and the specification may have arbitrary sorts and nonfunctional axioms or rules.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The theorem quantifies over an arbitrary PTS specification with no functionality and over all valid contexts and legal expressions, matching the paper's scope. Weak normalization is exactly existence of a β-normal reduct, and strong normalization is Acc of the converse β relation, which with Lean's Acc convention rules out infinite forward β-reduction sequences. The β-relation also reduces under λ/π type annotations, and contexts are open. Thus the statement is the same claim, up to standard de Bruijn/Lean encoding.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization accurately captures the main claim. The definitions of `WeaklyNormalizing` (existence of a normal form) and `StronglyNormalizing` (termination of all reduction sequences via `Acc`) match the mathematical concepts. The system-wide predicates correctly quantify over all valid contexts and legal expressions. Crucially, the `Beta` relation includes reductions inside type annotations (e.g., `lam_domain`, `pi_domain`), and the `Specification` imposes no functionality assumptions, aligning perfectly with the claim's requirements regarding nonfunctional rules and open contexts.\", \"score\": 5}"}}
{"family": "253", "title": "An infinite finitely presented simple amenable group", "claim": "An infinite finitely presented simple amenable group. Constructs an infinite finitely presented simple amenable group, answering the longstanding question of whether these properties can occur simultaneously.", "abstracts": ["We construct an infinite finitely presented simple amenable group, giving a positive answer to the finite-presentation existence question for simple amenable groups."], "papers": ["https://github.com/openai/math/tree/main/preprints/An-Infinite-Finitely-Presented-Simple-Amenable-Group-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/SimpleAmenable.lean"], "lean_statements": ["-- ComparatorChallenges/SimpleAmenable.lean\nimport Mathlib\n\nnamespace OAI\n\nopen scoped symmDiff\n\nnamespace SimpleAmenable\n\nnoncomputable def FolnerAmenable (G : Type*) [Group G] : Prop := by\n classical\n exact ∀ K : Finset G, ∀ ε : ℝ, 0 < ε →\n ∃ D : Finset G, D.Nonempty ∧ ∀ g ∈ K,\n (((D.image (fun d => g * d)) ∆ D).card : ℝ) < ε * D.card\n\ntheorem main : ∃ (G : Type) (_ : Group G),\n Infinite G ∧ Group.IsFinitelyPresented G ∧ IsSimpleGroup G ∧ FolnerAmenable G := by\n sorry\n\nend SimpleAmenable\n\nend OAI\n"], "formalization_scope": "The formalized result answers the existence question affirmatively: there is one group that is infinite, finitely presented, simple, and amenable. Amenability is expressed by the Følner condition.\n\nThe later general claims about central kernels and enlargements across families are not included.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean theorem asserts the existence of a group G that is infinite, finitely presented, simple, and satisfies the standard Følner condition for every finite subset K and every ε > 0. This Følner condition is the usual equivalent characterization of amenability for discrete groups, so the statement matches the claimed infinite finitely presented simple amenable group. The existential form is appropriate for the mathematical claim, and no extra assumptions or weakened bounds are present.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully expresses the main claim. It asserts the existence of a group G that is infinite, finitely presented, simple, and amenable (via the Folner condition). All four properties from the paper's claim are present with correct mathematical meaning: 'Infinite G' matches 'infinite', 'Group.IsFinitelyPresented G' matches 'finitely presented', 'IsSimpleGroup G' matches 'simple', and 'FolnerAmenable G' correctly formalizes amenability using the standard Folner condition. No extra hypotheses or weaker bounds are introduced.\", \"score\": 5}"}}
{"family": "274", "title": "Parity is not in QAC0", "claim": "Parity is not in QAC0. Resolves Moore's parity conjecture in the measured-output model: constant-depth quantum circuits with arbitrary one-qubit gates, unbounded-arity Toffoli gates and polynomially many total qubits cannot compute parity with any fixed positive worst-case advantage. Ancillas start in zero, one output qubit is measured, and all other registers may be discarded. Xu–Li's reductions give the same bounded-error obstruction for strict majority.", "abstracts": ["We prove that constant-depth quantum circuits with arbitrary one-qubit and unbounded-arity Toffoli gates cannot compute parity with any fixed positive worst-case advantage using polynomially many qubits. Ancillas start in zero, only one output qubit is measured, and all final garbage is unrestricted. This resolves Moore's parity conjecture in the measured-output model.", "We prove that constant-depth quantum circuits with arbitrary one-qubit gates and unbounded-arity Toffoli gates cannot compute parity with any fixed positive worst-case advantage using polynomially many total qubits. Ancillary qubits are initialized to $|0\\rangle$, one output qubit is measured, and all other final registers may be discarded without restriction. This resolves Moore's parity conjecture in the measured-output model."], "papers": ["https://github.com/openai/math/tree/main/preprints/Product-projection-localization-and-the-QAC0-parity-lower-bound-September-24-2026", "https://github.com/openai/math/tree/main/preprints/Regular-trajectories-pruning-and-quantum-parity-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/QACParity.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/RegularParity.lean"], "lean_statements": ["-- ComparatorChallenges/QACParity.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nopen scoped BigOperators Matrix.Norms.L2Operator\n\nnamespace QAC\n\nabbrev Bit := Fin 2\nabbrev Word (N : ℕ) := Fin N → Bit\nabbrev Operator (N : ℕ) := Matrix (Word N) (Word N) ℂ\nabbrev QubitOperator := Matrix Bit Bit ℂ\n\n/-- Tensor product in the computational basis. -/\ndef tensorMatrix {N : ℕ} (a : Fin N → QubitOperator) : Operator N :=\n fun x y => ∏ i, a i (x i) (y i)\n\n/-- A one-qubit unitary or an unbounded-arity Toffoli gate. -/\ninductive Gate (N : ℕ) where\n | local (q : Fin N) (u : Matrix.unitaryGroup Bit ℂ)\n | toffoli (controls : Finset (Fin N)) (target : Fin N) (hne : target ∉ controls)\n\nnamespace Gate\n\ndef support {N : ℕ} : Gate N → Finset (Fin N)\n | .local q _ => {q}\n | .toffoli c t _ => insert t c\n\n/-- A Toffoli flips its target iff all controls are one. -/\ndef toffoliWord {N : ℕ} (c : Finset (Fin N)) (t : Fin N) (x : Word N) : Word N :=\n if ∀ i ∈ c, x i = 1 then Function.update x t (1 - x t) else x\n\ndef matrix {N : ℕ} : Gate N → Operator N\n | .local q u => tensorMatrix fun i => if i = q then (u : QubitOperator) else 1\n | .toffoli c t _ => fun x y => if x = toffoliWord c t y then 1 else 0\n\nend Gate\n\nstructure PhysicalLayer (N : ℕ) where\n gates : List (Gate N)\n disjoint : gates.Pairwise (fun A B => Disjoint A.support B.support)\n\ndef physicalLayerMatrix {N : ℕ} (L : PhysicalLayer N) : Operator N :=\n (L.gates.map Gate.matrix).prod\n\n/-- Chronological order: the rightmost matrix acts first. -/\ndef physicalCircuitMatrix {N : ℕ} (layers : List (PhysicalLayer N)) : Operator N :=\n ((layers.map physicalLayerMatrix).reverse).prod\n\n/-- The computational-basis input with the remaining qubits initialized to zero. -/\ndef inputWord {n N : ℕ} (x : Word n) : Word N :=\n fun i => if h : i.val < n then x ⟨i.val, h⟩ else 0\n\ndef parity {n : ℕ} (x : Word n) : Bit := ∑ i, x i\n\n/-- Born probability, summing all final garbage with no cleanliness assumption. -/\ndef successProbability {n N : ℕ} (W : Operator N) (out : Fin N) (x : Word n) : ℝ :=\n ∑ y : Word N, if y out = parity x then Complex.normSq (W y (inputWord x)) else 0\n\n/-- The literal measured-output, polynomial-total-qubit parity lower bound. -/\ndef ParityStatement : Prop :=\n ∀ (d : ℕ) (c ε : ℝ), 1 ≤ c → 0 < ε → ε ≤ 1 / 2 →\n ∃ n₀ : ℕ, ∀ n ≥ n₀, ∀ N : ℕ, n ≤ N → (N : ℝ) ≤ (n : ℝ) ^ c →\n ∀ layers : List (PhysicalLayer N), layers.length ≤ d →\n ∀ out : Fin N, ¬ (∀ x : Word n,\n 1 / 2 + ε ≤ successProbability (physicalCircuitMatrix layers) out x)\n\nend QAC\n\ntheorem QAC.parity_lower_bound : QAC.ParityStatement := by\n sorry\n\nend\n\nend OAI\n", "-- ComparatorChallenges/RegularParity.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nopen scoped BigOperators Matrix.Norms.L2Operator\n\nnamespace QAC\n\nabbrev Bit := Fin 2\nabbrev Word (N : ℕ) := Fin N → Bit\nabbrev Operator (N : ℕ) := Matrix (Word N) (Word N) ℂ\nabbrev QubitOperator := Matrix Bit Bit ℂ\n\n/-- Tensor product in the computational basis. -/\ndef tensorMatrix {N : ℕ} (a : Fin N → QubitOperator) : Operator N :=\n fun x y => ∏ i, a i (x i) (y i)\n\n/-- A one-qubit unitary or an unbounded-arity Toffoli gate. -/\ninductive Gate (N : ℕ) where\n | local (q : Fin N) (u : Matrix.unitaryGroup Bit ℂ)\n | toffoli (controls : Finset (Fin N)) (target : Fin N) (hne : target ∉ controls)\n\nnamespace Gate\n\ndef support {N : ℕ} : Gate N → Finset (Fin N)\n | .local q _ => {q}\n | .toffoli c t _ => insert t c\n\n/-- A Toffoli flips its target iff all controls are one. -/\ndef toffoliWord {N : ℕ} (c : Finset (Fin N)) (t : Fin N) (x : Word N) : Word N :=\n if ∀ i ∈ c, x i = 1 then Function.update x t (1 - x t) else x\n\ndef matrix {N : ℕ} : Gate N → Operator N\n | .local q u => tensorMatrix fun i => if i = q then (u : QubitOperator) else 1\n | .toffoli c t _ => fun x y => if x = toffoliWord c t y then 1 else 0\n\nend Gate\n\nstructure PhysicalLayer (N : ℕ) where\n gates : List (Gate N)\n disjoint : gates.Pairwise (fun A B => Disjoint A.support B.support)\n\ndef physicalLayerMatrix {N : ℕ} (L : PhysicalLayer N) : Operator N :=\n (L.gates.map Gate.matrix).prod\n\n/-- Chronological order: the rightmost matrix acts first. -/\ndef physicalCircuitMatrix {N : ℕ} (layers : List (PhysicalLayer N)) : Operator N :=\n ((layers.map physicalLayerMatrix).reverse).prod\n\n/-- The computational-basis input with the remaining qubits initialized to zero. -/\ndef inputWord {n N : ℕ} (x : Word n) : Word N :=\n fun i => if h : i.val < n then x ⟨i.val, h⟩ else 0\n\ndef parity {n : ℕ} (x : Word n) : Bit := ∑ i, x i\n\n/-- Born probability, summing all final garbage with no cleanliness assumption. -/\ndef successProbability {n N : ℕ} (W : Operator N) (out : Fin N) (x : Word n) : ℝ :=\n ∑ y : Word N, if y out = parity x then Complex.normSq (W y (inputWord x)) else 0\n\n/-- Fixed-depth circuits with polynomially many total qubits cannot compute parity\nwith worst-case success at least two thirds. -/\ntheorem parity_lower_bound_polynomial_size (d k C : ℕ)\n (_hd : 0 < d) (_hk : 0 < k) (_hC : 0 < C) :\n ∃ n₀ : ℕ, ∀ n ≥ n₀, ∀ N : ℕ, n ≤ N → N ≤ C * (n + 1) ^ k →\n ∀ layers : List (PhysicalLayer N), layers.length ≤ d →\n ∀ out : Fin N, ∃ x : Word n,\n successProbability (physicalCircuitMatrix layers) out x < (2 : ℝ) / 3 := by\n sorry\n\nend QAC\n\nend\n\nend OAI\n"], "formalization_scope": "The formalization rules out bounded-error parity computation by constant-depth quantum circuits with polynomially many zero-initialized ancillary qubits. For every fixed depth, polynomial bound on the total number of qubits, and $0<\\varepsilon\\le1/2$, every sufficiently large input length has an input on which the measured-output parity success probability is less than $1/2+\\varepsilon$. A companion specialization gives success strictly below $2/3$. The formalization also includes the product-projection localization estimate supporting this bound.\n\nThe formalized result supplies the polynomial-size parity consequence of the paper. For every fixed circuit depth and polynomial bound on the number of qubits, all sufficiently large input lengths have an input on which any such circuit computes measured-output parity with probability strictly below $2/3$. Ancillary qubits start at zero. The formalization also contains the general positive-advantage parity bound and its product-projection localization estimate; regular-trajectory propagation and pruning are not separate formalized statements here.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The `ParityStatement` theorem captures the measured-output parity claim: for fixed depth, polynomial total-qubit bound, and any fixed positive advantage ε, no choice of output qubit can have worst-case success probability at least 1/2+ε. The definitions initialize ancillas to zero, allow arbitrary one-qubit unitaries and disjoint unbounded-arity Toffoli gates in constant depth, and sum over all final garbage, matching the model. The additional `parity_lower_bound_polynomial_size` is a weaker bounded-error corollary, but the main any-fixed-advantage statement is present; the majority corollary is not separately formalized but is not the central parity claim.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization accurately captures the main claim. It defines the circuit model (constant-depth, one-qubit + Toffoli gates), the input/ancilla setup (ancillas zero-initialized), the measurement model (summing over garbage for a single output qubit), and the success criterion (worst-case advantage ε > 0). The quantifiers correctly express 'for any depth d, any polynomial size bound N ≤ n^c, and any advantage ε, there exists an input size n₀ such that for all larger n, no circuit of depth ≤ d on N qubits achieves success ≥ 1/2 + ε on all inputs.' This matches the paper's claim of resolving Moore's parity conjecture in the measured-output model.\", \"score\": 5}"}}
{"family": "279", "title": "Exact quantum factoring over a fixed finite gate set", "claim": "Exact quantum factoring over a fixed finite gate set. Gives a polynomial-time uniform quantum circuit family that outputs the complete prime factorization of every integer with probability one. Both gate count and qubit count are polynomial in the input length, and one fixed finite gate set suffices.", "abstracts": ["We give a polynomial-time uniform quantum circuit family that outputs the complete prime factorization of every integer $N\\ge2$ with probability one. A fixed finite set of bounded-arity gates suffices, and both the gate count and the number of qubits have polynomial worst-case bounds in the input length."], "papers": ["https://github.com/openai/math/tree/main/preprints/Exact-quantum-factoring-over-a-fixed-finite-gate-set-September-25-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/ExactQuantumFactoring.lean"], "lean_statements": ["-- ComparatorChallenges/ExactQuantumFactoring.lean\nimport Mathlib\n\nnamespace OAI\n\n\n\nnamespace ExactQuantumFactoring\n\nopen scoped BigOperators\n\n/-- The five primitive gates exactly as in Section 2. -/\ninductive Primitive where\n | not | cnot | toffoli | hadamard | phase\n deriving DecidableEq\n\ndef Primitive.arity : Primitive → ℕ\n | .not | .hadamard | .phase => 1\n | .cnot => 2\n | .toffoli => 3\n\ndef Primitive.code : Primitive → ℕ\n | .not => 0 | .cnot => 1 | .toffoli => 2 | .hadamard => 3 | .phase => 4\n\n/-- An inverse and/or one added control. This is a fixed set of 20 gate names,\nnot an unbounded-control or arbitrary-angle gate model. -/\nstructure Gate where\n primitive : Primitive\n inverse : Bool\n controlled : Bool\n deriving DecidableEq\n\ndef Gate.arity (g : Gate) : ℕ := g.primitive.arity + if g.controlled then 1 else 0\n\n/-- Matrix entries are indexed by lists in wire order (row first, column second).\nEntries on ill-sized lists are irrelevant and set to zero. -/\nnoncomputable def Primitive.matrix : Primitive → List Bool → List Bool → ℂ\n | .not, [a], [b] => if a = !b then 1 else 0\n | .cnot, [a,b], [c,d] => if a = c ∧ b = Bool.xor c d then 1 else 0\n | .toffoli, [a,b,c], [d,e,f] =>\n if a = d ∧ b = e ∧ c = Bool.xor f (d && e) then 1 else 0\n | .hadamard, [a], [b] =>\n (if a && b then -1 else 1) / (Real.sqrt 2 : ℂ)\n | .phase, [a], [b] => if a = b then (if b then Complex.I else 1) else 0\n | _, _, _ => 0\n\nnoncomputable def Gate.baseMatrix (g : Gate) (a b : List Bool) : ℂ :=\n if g.inverse then star (g.primitive.matrix b a) else g.primitive.matrix a b\n\nnoncomputable def Gate.matrix (g : Gate) (a b : List Bool) : ℂ :=\n if g.controlled then\n match a, b with\n | false :: a', false :: b' => if a' = b' then 1 else 0\n | true :: a', true :: b' => g.baseMatrix a' b'\n | _, _ => 0\n else g.baseMatrix a b\n\n/-- A primitive is placed on distinct actual wires, with no operation of\nunbounded arity hidden in a circuit instruction. -/\nstructure Instruction (q : ℕ) where\n gate : Gate\n wire : Fin gate.arity → Fin q\n distinct : Function.Injective wire\n\nabbrev Basis (q : ℕ) := Fin q → Bool\nabbrev State (q : ℕ) := Basis q → ℂ\n\nnoncomputable def Instruction.matrix {q : ℕ} (o : Instruction q) :\n Matrix (Basis q) (Basis q) ℂ := by\n classical\n exact fun a b =>\n if ∀ i : Fin q, (∀ j, o.wire j ≠ i) → a i = b i then\n o.gate.matrix (List.ofFn (a ∘ o.wire)) (List.ofFn (b ∘ o.wire))\n else 0\n\nstructure Circuit where\n qubits : ℕ\n instructions : List (Instruction qubits)\n\nnoncomputable def Circuit.apply (c : Circuit) (ψ : State c.qubits) : State c.qubits :=\n c.instructions.foldl (fun v o => o.matrix.mulVec v) ψ\n\n/-- Input wires are first, least significant bit first; all other wires start zero. -/\ndef inputBasis (q ℓ N : ℕ) : Basis q :=\n fun i => if i.val < ℓ then N.testBit i.val else false\n\nnoncomputable def Circuit.outputState (c : Circuit) (ℓ N : ℕ) : State c.qubits := by\n classical\n exact c.apply (fun x => if x = inputBasis c.qubits ℓ N then 1 else 0)\n\n/-- The cutoff and padding are the standing parameters in Section 2. -/\ndef paddedLength (ℓ : ℕ) : ℕ := max 128 ℓ\n\ndef readBit {q : ℕ} (x : Basis q) (i : ℕ) : Bool :=\n if h : i < q then x ⟨i,h⟩ else false\n\n/-- n entries of n bits each, in the n² wires immediately after the input. -/\ndef outputList {q : ℕ} (ℓ : ℕ) (x : Basis q) : List ℕ :=\n let n := paddedLength ℓ\n List.ofFn (fun a : Fin n =>\n ∑ j ∈ Finset.range n, if readBit x (ℓ + a.val * n + j) then 2^j else 0)\n\n/-- Complete nondecreasing prime factorization, multiplicities included,\npadded by zeros, as in Section 6. There is no primality oracle in the circuit. -/\ndef CorrectEncoding (N n : ℕ) (xs : List ℕ) : Prop :=\n ∃ ps : List ℕ, (∀ p ∈ ps, Nat.Prime p) ∧ ps.Pairwise (· ≤ ·) ∧\n ps.prod = N ∧ ps.length ≤ n ∧ xs = ps ++ List.replicate (n - ps.length) 0\n\n/-- Unnormalized Born sum on correct outputs; success is exactly one,\nnot positivity, postselection, or a limiting high probability. -/\nnoncomputable def Circuit.correctProbability (c : Circuit) (ℓ N : ℕ) : ℝ := by\n classical\n exact ∑ x : Basis c.qubits,\n if CorrectEncoding N (paddedLength ℓ) (outputList ℓ x) then\n Complex.normSq (c.outputState ℓ N x) else 0\n\n/-- Unary natural words with delimiters make the circuit description explicit.\nUnary wire addresses cause at most polynomial overhead when width is polynomial. -/\ndef natWord (k : ℕ) : List Bool := List.replicate k true ++ [false]\n\ndef Instruction.encode {q : ℕ} (o : Instruction q) : List Bool :=\n natWord o.gate.primitive.code ++ [o.gate.inverse, o.gate.controlled] ++\n (List.ofFn (fun i => o.wire i |>.val)).flatMap natWord\n\ndef Circuit.encode (c : Circuit) : List Bool :=\n natWord c.qubits ++ natWord c.instructions.length ++\n c.instructions.flatMap Instruction.encode\n\n/-- A single finite-alphabet classical generator receives only the INPUT LENGTH.\nAll stack alphabets, states and labels are finite: no large-integer unit-cost\noracle is hidden in TM2 push/branch functions. -/\ndef Uniform (family : ℕ → Circuit) : Prop :=\n ∃ generator : Turing.TM2ComputableInPolyTime\n (fun ℓ => List.replicate ℓ true) Circuit.encode family,\n ∀ k, Finite (generator.tm.Γ k)\n\ndef PolynomialResources (family : ℕ → Circuit) : Prop :=\n ∃ bound : Polynomial ℕ, ∀ ℓ,\n (family ℓ).qubits ≤ bound.eval ℓ ∧\n (family ℓ).instructions.length ≤ bound.eval ℓ\n\n/-- Literal main endpoint: one length-uniform family, exact output for EVERY\nbinary integer N≥2, and worst-case polynomial gates AND qubits. -/\ndef MainTheorem : Prop :=\n ∃ family : ℕ → Circuit, Uniform family ∧ PolynomialResources family ∧\n ∀ (ℓ N : ℕ), 2 ≤ N → N.size = ℓ →\n ℓ + (paddedLength ℓ)^2 ≤ (family ℓ).qubits ∧\n (family ℓ).correctProbability ℓ N = 1\n\ntheorem exact_quantum_factoring : MainTheorem := by\n sorry\n\nend ExactQuantumFactoring\n\nend OAI\n"], "formalization_scope": "The formalization constructs a polynomial-time uniform quantum circuit family that outputs the complete prime factorization of every integer $N\\ge2$ with probability exactly one. The circuits use one fixed finite set of bounded-arity gates, and both the gate count and number of qubits have polynomial worst-case bounds in the bit length of $N$. The probability-one conclusion is exact, rather than an asymptotic or bounded-error guarantee.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean statement asserts a length-uniform family over a fixed finite 20-gate set, with a single polynomial bound on qubits and instruction count, and for every N≥2 of bit length ℓ it requires the total Born probability of basis states whose designated output wires encode a sorted prime factorization of N to be exactly 1. This matches the paper's claim of exact, probability-one, polynomial-resource quantum factoring. The specific output layout, bit order, and concrete gate set are technical formalization choices that make the statement more specific rather than weaker.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully captures all key aspects of the main claim: a uniform quantum circuit family (via the Uniform definition using polynomial-time TM2 generation), polynomial bounds on both qubit count and gate/instruction count (via PolynomialResources and the explicit qubit bound in MainTheorem), exact probability one for complete prime factorization of every N≥2 (via correctProbability = 1), and a fixed finite gate set (5 primitives). The definitions match the mathematical meaning, and the quantifiers/hypotheses are appropriately scoped.\", \"score\": 5}"}}
{"family": "288", "title": "Kadison's similarity conjecture", "claim": "Kadison's similarity conjecture. Proves Kadison's similarity conjecture: every bounded complex-linear unital algebra homomorphism from a unital complex C∗-algebra to operators on a Hilbert space becomes a $`*`$-homomorphism after conjugation by a bounded invertible operator.", "abstracts": ["We prove that every bounded complex-linear unital algebra homomorphism from a unital complex $C^*$-algebra into the bounded operators on an arbitrary Hilbert space is similar to a $*$-homomorphism. This resolves Kadison's similarity conjecture positively. We also obtain one universal hyperreflexivity constant for all unital von Neumann algebras on arbitrary complex Hilbert spaces."], "papers": ["https://github.com/openai/math/tree/main/preprints/Kadisons-similarity-theorem-through-uniform-derivation-estimates-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/KadisonSimilarity.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/UniformCommutator.lean"], "lean_statements": ["-- ComparatorChallenges/KadisonSimilarity.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace KadisonSimilarity\n\nuniverse u v\n\nsection Homomorphisms\n\nvariable (A H : Type*) [CStarAlgebra A]\n [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]\n\nabbrev BoundedUnitalHom :=\n {π : A →ₐ[ℂ] (H →L[ℂ] H) // Continuous π}\n\ndef SimilarToStar (π : BoundedUnitalHom A H) : Prop :=\n ∃ S : (H →L[ℂ] H)ˣ, ∀ a : A,\n (S : H →L[ℂ] H) * π.1 (star a) * (↑S⁻¹ : H →L[ℂ] H) =\n star ((S : H →L[ℂ] H) * π.1 a * (↑S⁻¹ : H →L[ℂ] H))\n\nend Homomorphisms\n\nsection Commutators\n\nvariable {R : Type*} [NormedRing R]\n\ndef commutator (S T : R) : R := S * T - T * S\n\nend Commutators\n\nvariable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n\nsection\n\nattribute [-instance] NonUnitalCStarAlgebra.toNormedSpace\n\nrun_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}\n\nabbrev HilbertCopies (H : Type u) (n : ℕ) := PiLp 2 (fun _ : Fin n => H)\n\ndef matrixOperator {n : ℕ} (X : Matrix (Fin n) (Fin n) (H →L[ℂ] H)) :\n HilbertCopies H n →L[ℂ] HilbertCopies H n :=\n (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin n => H)).symm.toContinuousLinearMap.comp\n (ContinuousLinearMap.pi fun i =>\n ∑ j : Fin n, (X i j).comp (PiLp.proj 2 (fun _ : Fin n => H) j))\n\ndef amplify (Y : H →L[ℂ] H) (n : ℕ) :\n HilbertCopies H n →L[ℂ] HilbertCopies H n :=\n (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin n => H)).symm.toContinuousLinearMap.comp\n (ContinuousLinearMap.pi fun i => Y.comp (PiLp.proj 2 (fun _ : Fin n => H) i))\n\ndef innerDerivation (Y : H →L[ℂ] H) :\n (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H) :=\n ContinuousLinearMap.mul ℂ (H →L[ℂ] H) Y -\n (ContinuousLinearMap.mul ℂ (H →L[ℂ] H)).flip Y\n\nvariable [CompleteSpace H]\n\ndef scalarCommutatorNorm (P : VonNeumannAlgebra H) (Y : H →L[ℂ] H) : ℝ := by\n let : SeminormedAddCommGroup P.toStarSubalgebra.toSubalgebra.toSubmodule := inferInstance\n let : NormedSpace ℂ P.toStarSubalgebra.toSubalgebra.toSubmodule := inferInstance\n exact ‖(innerDerivation Y).comp P.toStarSubalgebra.toSubalgebra.toSubmodule.subtypeL‖\n\ndef CommutatorEstimate (P : VonNeumannAlgebra H) (C : ℝ) : Prop :=\n ∀ (Y : H →L[ℂ] H) (n : ℕ) (X : Matrix (Fin n) (Fin n) (H →L[ℂ] H)),\n (∀ i j, X i j ∈ P) →\n ‖commutator (amplify Y n) (matrixOperator X)‖ ≤\n C * scalarCommutatorNorm P Y * ‖matrixOperator X‖\n\ndef UniformCommutatorEstimate (C : ℝ) : Prop :=\n ∀ (K : Type u) [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]\n (P : VonNeumannAlgebra K), CommutatorEstimate P C\n\ndef UniversalCommutatorTheorem : Prop := ∃ C : ℝ, 0 ≤ C ∧ UniformCommutatorEstimate.{u} C\n\ndef SimilarityTheorem : Prop :=\n ∀ (A : Type u) [CStarAlgebra A] (K : Type v) [NormedAddCommGroup K]\n [InnerProductSpace ℂ K] [CompleteSpace K] (π : BoundedUnitalHom A K),\n SimilarToStar A K π\n\nabbrev CommutantProjection (M : VonNeumannAlgebra H) :=\n {e : H →L[ℂ] H // e ∈ M.commutant ∧ star e = e ∧ e * e = e}\n\ndef offDiagonalSeminorm (M : VonNeumannAlgebra H) (T : H →L[ℂ] H) : ℝ :=\n sSup (Set.range fun e : CommutantProjection M =>\n ‖(1 - (e : H →L[ℂ] H)) * T * (e : H →L[ℂ] H)‖)\n\ndef UniversalHyperreflexivity (C : ℝ) : Prop :=\n ∀ (K : Type u) [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]\n (M : VonNeumannAlgebra K) (T : K →L[ℂ] K),\n Metric.infDist T (M : Set (K →L[ℂ] K)) ≤ 2 * C * offDiagonalSeminorm M T\n\nend\n\nrun_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}\n\ndef rowConstant : ℝ := 4 * Real.sqrt 2\ndef cyclicConstant : ℝ := (1 + 4 * rowConstant) ^ 2\ndef cornerConstant : ℝ := 6 * Real.pi ^ 2 * (1 + 4 * cyclicConstant)\ndef factorConstant : ℝ := max (max (3 * cornerConstant + 2) (1 + 2 * rowConstant)) 2\ndef universalConstant : ℝ := 3 * factorConstant + 2\n\n/-- One absolute constant controls every finite matrix commutator. -/\ntheorem universalCommutatorTheorem : UniversalCommutatorTheorem.{u} := by\n sorry\n\n/-- Every von Neumann algebra has hyperreflexivity constant at most `2 * universalConstant`. -/\ntheorem universalHyperreflexivity : UniversalHyperreflexivity.{u} universalConstant := by\n sorry\n\n/-- Every bounded unital representation is similar to a star representation. -/\ntheorem similarityTheorem : SimilarityTheorem.{u,v} := by\n sorry\n\nend KadisonSimilarity\n\nend\n\nend OAI\n", "-- ComparatorChallenges/UniformCommutator.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nuniverse u v\nnamespace Kadison\n\nvariable {K : Type u} [NormedAddCommGroup K] [InnerProductSpace ℂ K]\n [CompleteSpace K]\n\ndef commutatorSeminorm (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K) : ℝ :=\n sSup {r : ℝ | ∃ a : K →L[ℂ] K, a ∈ P ∧ ‖a‖ ≤ 1 ∧ r = ‖Y * a - a * Y‖}\n\ndef matrixOperator (h : ℕ) (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)) :\n (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=\n (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp\n (ContinuousLinearMap.pi (fun i => ∑ j : Fin h,\n (X i j).comp (PiLp.proj 2 (fun _ : Fin h => K) j)))\n\ndef diagonalAmplification (h : ℕ) (Y : K →L[ℂ] K) :\n (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=\n (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp\n (ContinuousLinearMap.pi (fun i => Y.comp (PiLp.proj 2 (fun _ : Fin h => K) i)))\n\ntheorem uniform_commutator :\n ∃ C : ℝ, 0 ≤ C ∧ ∀ (K : Type u) [NormedAddCommGroup K] [InnerProductSpace ℂ K]\n [CompleteSpace K] (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K)\n (h : ℕ), 1 ≤ h → ∀ (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)),\n (∀ i j, X i j ∈ P) →\n ‖diagonalAmplification h Y * matrixOperator h X -\n matrixOperator h X * diagonalAmplification h Y‖ ≤\n C * commutatorSeminorm P Y * ‖matrixOperator h X‖ := by\n sorry\n\nend Kadison\n\nend\n\nend OAI\n"], "formalization_scope": "Kadison's similarity problem asks whether every bounded unital homomorphism from a unital complex $C^*$-algebra into operators on a Hilbert space is similar to a $*$-homomorphism. The formalization proves this for arbitrary Hilbert spaces. It also gives one universal hyperreflexivity constant for all unital von Neumann algebras.\n\nThe linked commutator estimate is uniform over all finite matrix amplifications: its constant is independent of the algebra, Hilbert space, and amplification size. This is the quantitative derivation estimate supporting the similarity result.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean `similarityTheorem` quantifies over a C*-algebra `A`, a Hilbert space `K`, and a continuous (hence bounded) complex algebra homomorphism `π : A → B(K)`, and asserts the existence of a unit `S` in the bounded operators such that `S π(star a) S⁻¹ = star(S π(a) S⁻¹)` for all `a`. Since `π` is already an algebra homomorphism, the conjugated map is automatically an algebra homomorphism, so this is exactly the statement that it is similar to a *-homomorphism. The unit `S` is precisely a bounded invertible operator, and the hypotheses match the unital C*-algebra/Hilbert-space setting. Thus the formalization faithfully captures the main claim.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement `similarityTheorem` faithfully expresses Kadison's similarity conjecture. It quantifies over all unital C*-algebras A and Hilbert spaces K, and asserts that every bounded unital algebra homomorphism π from A to B(K) is similar to a *-homomorphism (defined via the existence of an invertible S such that the conjugated map satisfies the *-property). The definitions of `BoundedUnitalHom` (unital algebra homomorphism + continuity) and `SimilarToStar` (existence of invertible S making the conjugate a *-homomorphism) match the mathematical claim exactly. The additional theorems in the file correspond to secondary results mentioned in the abstract and do not alter the faithfulness of the main claim.\", \"score\": 5}"}}
{"family": "295", "title": "The Kadison–Ringrose cohomology conjecture", "claim": "The Kadison–Ringrose cohomology conjecture. Proves that every bounded Hochschild cocycle of degree at least two on a complex von Neumann algebra, with coefficients in the algebra itself, has a bounded primitive. Equivalently, all higher bounded Hochschild cohomology groups vanish, resolving the Kadison–Ringrose conjecture.", "abstracts": ["We prove that every bounded Hochschild cocycle of degree at least two on a complex von Neumann algebra, with values in the algebra itself, has a bounded primitive. Together with the established degree-one inner-derivation theorem, this resolves the Kadison--Ringrose cohomology conjecture positively."], "papers": ["https://github.com/openai/math/tree/main/preprints/Vanishing-of-higher-bounded-Hochschild-cohomology-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/KadisonRingrose.lean"], "lean_statements": ["-- ComparatorChallenges/KadisonRingrose.lean\nimport Mathlib\n\nnamespace OAI\n\n/-! Every ordinary bounded higher Hochschild cocycle of a complex von Neumann\nalgebra is the coboundary of a bounded cochain with values in the same algebra. -/\n\nnoncomputable section\n\nnamespace BoundedHochschild\n\nabbrev Cochain (M : Type*) [NormedAddCommGroup M] [NormedSpace ℂ M] (n : ℕ) :=\n ContinuousMultilinearMap ℂ (fun _ : Fin n => M) M\n\ndef mergeInputs {M : Type*} [Mul M] {n : ℕ}\n (v : Fin (n + 1) → M) (j : Fin n) : Fin n → M :=\n fun i => if i < j then v i.castSucc\n else if i = j then v i.castSucc * v i.succ else v i.succ\n\nnoncomputable def differentialValue {M : Type*} [NormedRing M] [NormedAlgebra ℂ M]\n {n : ℕ} (f : Cochain M n) (v : Fin (n + 1) → M) : M :=\n v 0 * f (fun i => v i.succ) +\n ∑ j : Fin n, ((-1 : ℂ) ^ (j.val + 1)) • f (mergeInputs v j) +\n ((-1 : ℂ) ^ (n + 1)) • (f (fun i => v i.castSucc) * v (Fin.last n))\n\nnamespace KadisonRingrose\n\nuniverse u\n\ntheorem main_result\n {M : Type u} [CStarAlgebra M] [PartialOrder M] [StarOrderedRing M] [WStarAlgebra M]\n (n : ℕ) (f : Cochain M (n + 2))\n (hf : ∀ x : Fin (n + 3) → M, differentialValue f x = 0) :\n ∃ g : Cochain M (n + 1), ∀ x : Fin (n + 2) → M,\n differentialValue g x = f x := by\n sorry\n\nend KadisonRingrose\nend BoundedHochschild\n\nend\n\nend OAI\n"], "formalization_scope": "The formalization proves vanishing of bounded Hochschild cohomology in every degree at least two for a complex von Neumann algebra with coefficients in itself. Every bounded multilinear cocycle of such a degree is the Hochschild differential of a bounded multilinear cochain one degree lower. No separability or type restriction is imposed. The degree-one inner-derivation theorem is outside this selected statement.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean theorem quantifies over a W*-algebra M (the formalization of a complex von Neumann algebra), an arbitrary n, and a continuous multilinear Hochschild cocycle f of degree n+2 ≥ 2 with values in M. The differential definition matches the standard Hochschild differential, and continuous multilinear maps are exactly bounded cochains. The conclusion asserts a continuous, hence bounded, primitive g of degree n+1, which is precisely the claimed vanishing of higher bounded Hochschild cohomology. Any differences are only routine typeclass packaging, not a change in mathematical content.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully formalizes the Kadison–Ringrose conjecture. The type `Cchain` uses `ContinuousMultilinearMap`, which for Banach spaces (and thus von Neumann algebras) corresponds exactly to bounded multilinear maps, satisfying the 'bounded' requirement of the claim. The theorem assumes a cocycle of degree `n+2` (covering degrees ≥ 2) and concludes the existence of a primitive `g` of degree `n+1`, matching the claim's assertion that every such cocycle has a bounded primitive. The differential definition aligns with the standard Hochschild coboundary operator. No hypotheses are missing or extraneous.\", \"score\": 5}"}}
{"family": "322", "title": "Tingley’s sphere-isometry problem", "claim": "Tingley’s sphere-isometry problem. Resolves Tingley's problem: every surjective isometry between the unit spheres of nonzero real Banach spaces extends uniquely to a surjective real-linear isometry of the whole spaces. No dimension restriction is imposed, so the metric geometry of the unit sphere determines the Banach space up to linear isometry.", "abstracts": ["Every surjective isometry between the unit spheres of real Banach spaces extends uniquely to a surjective real-linear isometry, giving an affirmative solution to Tingley's problem. If distances between different radii are not preserved, we realize the positive maximal defect in a possibly enlarged pair of Banach spaces. We then align extremal chords using common supports and Darbo's fixed-point theorem and obtain a contradiction from support and convexity estimates."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-positive-solution-to-Tingleys-problem-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/TingleySphereIsometry.lean"], "lean_statements": ["-- ComparatorChallenges/TingleySphereIsometry.lean\nimport Mathlib.Analysis.Normed.Module.RCLike.Basic\nimport Mathlib.Topology.MetricSpace.Isometry\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace Tingley\n\nuniverse u v\n\nabbrev UnitSphere (X : Type u) [NormedAddCommGroup X] := {x : X // ‖x‖ = 1}\n\nvariable {X : Type u} {Y : Type v}\nvariable [NormedAddCommGroup X] [NormedSpace ℝ X]\nvariable [NormedAddCommGroup Y] [NormedSpace ℝ Y]\n\ndef normalize (x : X) (hx : x ≠ 0) : UnitSphere X :=\n ⟨‖x‖⁻¹ • x, norm_smul_inv_norm hx⟩\n\n/-- Radial formula, surjectivity, and uniqueness among all real-linear extensions. -/\ntheorem tingley_sphere_isometry_full\n {X : Type u} {Y : Type v}\n [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace X]\n [NormedAddCommGroup Y] [NormedSpace ℝ Y] [CompleteSpace Y]\n [Nontrivial X] [Nontrivial Y]\n (f : UnitSphere X → UnitSphere Y) (hf : Isometry f) (hs : Function.Surjective f) :\n ∃ T : X ≃ₗᵢ[ℝ] Y,\n (∀ u : UnitSphere X, T (u : X) = (f u : Y)) ∧\n T 0 = 0 ∧\n (∀ x : X, ∀ hx : x ≠ 0, T x = ‖x‖ • (f (normalize x hx) : Y)) ∧\n Function.Surjective T ∧\n (∀ L : X →ₗ[ℝ] Y, (∀ u : UnitSphere X, L (u : X) = (f u : Y)) →\n L = T.toLinearEquiv.toLinearMap) := by\n sorry\n\nend Tingley\n\nend\n\nend OAI\n"], "formalization_scope": "Tingley's problem asks whether a surjective isometry between the unit spheres of Banach spaces extends to a linear isometry of the spaces. The formalized result gives a unique surjective real-linear isometric extension for arbitrary nonzero real Banach spaces, with no finite-dimensionality, separability, reflexivity, or convexity assumptions. For complex spaces viewed as real spaces, the conclusion is real linearity rather than complex linearity.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean theorem quantifies over arbitrary nontrivial complete real normed spaces, i.e. nonzero real Banach spaces, and a surjective metric isometry between their unit spheres. It concludes that there exists a real-linear isometry equivalence extending the sphere map, with the usual radial formula and uniqueness among linear extensions. This matches the main Tingley claim, with only redundant or consequence-level additions, and no dimension restriction or missing core hypotheses.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully expresses the main claim. It correctly formalizes that every surjective isometry between unit spheres of nonzero real Banach spaces extends uniquely to a surjective real-linear isometry of the whole spaces. The hypotheses (complete normed spaces, nontriviality) match the Banach space setting, and the conclusion provides both existence and uniqueness of the extension, with the radial formula explicitly characterizing the extension. The uniqueness condition (any real-linear map agreeing with f on the sphere equals T) is consistent with 'extends uniquely' and actually stronger than needed, which is acceptable.\", \"score\": 5}"}}
{"family": "324", "title": "Lipschitz equivalent Banach spaces need not be linearly isomorphic", "claim": "Lipschitz equivalent Banach spaces need not be linearly isomorphic. Constructs separable real Banach spaces that are globally bi-Lipschitz equivalent but not linearly isomorphic, resolving the separable Lipschitz-isomorphism problem negatively. Thus even the complete metric structure up to bi-Lipschitz equivalence does not determine a separable Banach space's linear isomorphism class.", "abstracts": ["We construct a separable real Banach space \\(Z\\) that contains no linear copy of \\(c_0\\), yet is bi-Lipschitz equivalent to \\(Z\\oplus_\\infty c_0\\). The same space contains a bi-Lipschitz image of every separable metric space.", "There are separable real Banach spaces that are globally bi-Lipschitz equivalent but not linearly isomorphic. This gives a negative answer to the separable Banach-space Lipschitz-isomorphism problem."], "papers": ["https://github.com/openai/math/tree/main/preprints/Bi-Lipschitz-Absorption-of-c0-Without-a-Linear-Copy-of-c0-September-26-2026", "https://github.com/openai/math/tree/main/preprints/Lipschitz-Equivalent-Separable-Banach-Spaces-Need-Not-Be-Linearly-Isomorphic-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/C0Absorption.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/LipschitzEquivalence.lean"], "lean_statements": ["-- ComparatorChallenges/C0Absorption.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace C0Absorption\n\nopen scoped ZeroAtInfty\n\nabbrev C0 := C₀(ℕ, ℝ)\n\ndef BiLip {X Y : Type*} [MetricSpace X] [MetricSpace Y] (f : X → Y) : Prop :=\n ∃ c C : ℝ, 0 < c ∧ c ≤ C ∧\n ∀ x y, c * dist x y ≤ dist (f x) (f y) ∧ dist (f x) (f y) ≤ C * dist x y\n\ndef NoLinearC0 (Z : Type*) [NormedAddCommGroup Z] [NormedSpace ℝ Z] : Prop :=\n ∀ T : C0 →L[ℝ] Z, ¬ ∃ c : ℝ, 0 < c ∧ ∀ x, c * ‖x‖ ≤ ‖T x‖\n\ndef MetricUniversal (Z : Type*) [MetricSpace Z] : Prop :=\n ∀ (M : Type) [MetricSpace M] [TopologicalSpace.SeparableSpace M],\n ∃ f : M → Z, BiLip f\n\ndef MainConclusion : Prop :=\n ∃ (Z : Type) (_ : NormedAddCommGroup Z) (_ : NormedSpace ℝ Z),\n CompleteSpace Z ∧ TopologicalSpace.SeparableSpace Z ∧ NoLinearC0 Z ∧\n (∃ F : Z × C0 → Z, Function.Surjective F ∧ BiLip F) ∧\n (∃ f : C0 → Z, BiLip f) ∧ MetricUniversal Z ∧\n ¬ Nonempty ((Z × C0) ≃L[ℝ] Z)\n\ntheorem main_result : MainConclusion := by sorry\n\nend C0Absorption\n\nend OAI\n", "-- ComparatorChallenges/LipschitzEquivalence.lean\nimport Mathlib\n\nnamespace OAI\n\nuniverse uE uF\n\nnoncomputable section\nnamespace LipschitzCounterexample\n\nabbrev RealL2 := lp (fun _ : ℕ => ℝ) 2\nabbrev C0L2 := ZeroAtInftyContinuousMap ℕ RealL2\n\nstructure SeparableRealBanach where\n Carrier : Type\n [normedAddCommGroup : NormedAddCommGroup Carrier]\n [normedSpace : NormedSpace ℝ Carrier]\n [completeSpace : CompleteSpace Carrier]\n [separableSpace : TopologicalSpace.SeparableSpace Carrier]\n\nattribute [instance] SeparableRealBanach.normedAddCommGroup\n SeparableRealBanach.normedSpace SeparableRealBanach.completeSpace\n SeparableRealBanach.separableSpace\n\ndef ContainsLinearCopy (E : Type uE) (F : Type uF) [NormedAddCommGroup E] [NormedSpace ℝ E]\n [NormedAddCommGroup F] [NormedSpace ℝ F] : Prop :=\n ∃ (T : E →L[ℝ] F) (a : ℝ), 0 < a ∧ ∀ x : E, a * ‖x‖ ≤ ‖T x‖\n\ndef MainClaim : Prop :=\n ∃ X Y : SeparableRealBanach,\n ∃ Ψ : X.Carrier ≃ Y.Carrier,\n (∀ s t : X.Carrier,\n (4 / 21 : ℝ) * ‖s - t‖ ≤ ‖Ψ s - Ψ t‖ ∧\n ‖Ψ s - Ψ t‖ ≤ (76 / 25 : ℝ) * ‖s - t‖) ∧\n IsEmpty (X.Carrier ≃L[ℝ] Y.Carrier) ∧\n Nonempty (C0L2 →ₗᵢ[ℝ] X.Carrier) ∧\n ¬ ContainsLinearCopy C0L2 Y.Carrier\n\ntheorem main : MainClaim := by\n sorry\n\nend LipschitzCounterexample\nend\n\nend OAI\n"], "formalization_scope": "The formalized counterexample gives separable real Banach spaces $X,Y$ that are bi-Lipschitz equivalent but not linearly isomorphic. The bijection has lower Lipschitz bound $4/21$ and upper bound $76/25$. The linear obstruction is explicit: $X$ contains a linear isometric copy of $c_0(\\ell_2)$, whereas $Y$ contains no bounded linear copy of that space.\n\nThe formalized result constructs one separable real Banach space $X$ that is bi-Lipschitz equivalent to $X\\times c_0$ but contains no closed linear subspace isomorphic to $c_0$. The same space contains a bi-Lipschitz copy of $c_0$, is bi-Lipschitz universal for separable metric spaces, and is not linearly isomorphic to $X\\times c_0$. Thus nonlinear absorption of $c_0$ does not force a linear copy of it.", "judge_qwen3_8_27b": {"score": 5, "reason": "quivalent. Good.\n\nPotential issue: The first's `MainConclusion` does not assert `Z` is a `Type` with `MetricSpace` but NormedAddCommGroup gives. Good.\n\nNow, let's consider if the second's `MainClaim` could be considered not faithful because it does not assert the two spaces are \"Lipschitz equivalent\" in the sense of bi-Lipschitz homeomorphism but only a bijection with norm inequalities. That's exactly. Good.\n\nPotential issue: The second's `MainClaim` uses `IsEmpty (X.Carrier ≃L[ℝ] Y.Carrier)`, which is a type-level negation of existence of linear isomorphism. Good.\n\nPotential issue: The second's `MainClaim` uses `Nonempty (C0L2 →ₗᵢ[ℝ] X.Carrier)`. If `→ₗᵢ` is algebraic, this is not a Banach-space property, but the core remains. If the benchmark expects checking definitions, they might penalize. But the first is enough. If they judge all, maybe score 4 due to this definition mismatch. Let's weigh.\n\nThe prompt says \"Check the definitions, quantifiers, hypotheses and conclusions carefully. Typical problems: ... definitions that do not match the usual mathematical meaning\". The second's `C0L2` and `→ₗᵢ` may be definitions that do not match usual meaning if the intended is c0 linear copy. But the first's definitions match. If we score 5, we might ignore a definition mismatch in second. But if the second is part of the formalization, a definition mismatch could be a problem. However, the second's `C0L2` is not supposed to be c0? It's an auxiliary. The main claim doesn't mention it."}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"Both Lean files faithfully express the main claim. The first file (C0Absorption) directly formalizes the abstract's construction: a separable Banach space Z with no linear copy of c₀ that is bi-Lipschitz equivalent to Z ⊕_∞ c₀, plus metric universality and non-linear-isomorphism. The second file (LipschitzEquivalence) gives a slightly more general but still faithful formulation: two bi-Lipschitz equivalent but not linearly isomorphic spaces, with additional properties (X contains c₀, Y doesn't) that strengthen but don't contradict the claim. All definitions (BiLip, NoLinearC0, MetricUniversal, ContainsLinearCopy) match standard mathematical meanings, and the quantifiers/hypotheses correctly capture the existence of such counterexamples.\", \"score\": 5}"}}
{"family": "325", "title": "The complete Crouzeix conjecture", "claim": "The complete Crouzeix conjecture. Resolves the complete Crouzeix conjecture: for every bounded operator A on a complex Hilbert space and every finite matrix-valued polynomial P, one has $`\\lVert P[A]\\rVert\\le2\\sup_{z\\in W(A)}\\lVert P(z)\\rVert`$, where $`W(A)`$ is the numerical range. The constant 2 is sharp, independent of the matrix size, and valid in infinite dimensions.", "abstracts": ["We give a direct proof of the sharp constant-two numerical-range inequality for matrix-valued polynomials in all finite base and coefficient dimensions. This resolves the complete Crouzeix conjecture in its matrix formulation, including matrices whose numerical ranges are points or line segments.", "We resolve the complete Crouzeix conjecture by proving the sharp constant-two numerical-range inequality for every bounded operator on a complex Hilbert space and every matrix-valued polynomial. No separability assumption is needed. The closure of the numerical range is a complete $2$-spectral set, and the bound extends to finite matrix-valued functions holomorphic near that closure. For a finite matrix and a bounded convex domain containing its numerical range with regular real-analytic Jordan boundary, the optimal similarity making its conformal disk image contractive is attained with condition number at most two. For the similar matrix, one continuous positive boundary density of mass the identity represents the evaluation of every matrix-valued function holomorphic near the closed domain."], "papers": ["https://github.com/openai/math/tree/main/preprints/A-direct-proof-of-the-complete-Crouzeix-inequality-September-26-2026", "https://github.com/openai/math/tree/main/preprints/The-complete-Crouzeix-theorem-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/CompleteCrouzeix.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/CrouzeixHilbert.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/DirectCrouzeix.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/HilbertCrouzeix.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/StructuralCrouzeix.lean"], "lean_statements": ["-- ComparatorChallenges/CompleteCrouzeix.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nopen scoped BigOperators Matrix.Norms.L2Operator ComplexOrder\n\nnamespace CompleteCrouzeix\n\ndef numericalRange {n : ℕ} (A : Matrix (Fin n) (Fin n) ℂ) : Set ℂ :=\n {z | ∃ x : EuclideanSpace ℂ (Fin n), ‖x‖ = 1 ∧\n inner ℂ x (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℂ) A x) = z}\n\ndef polynomialValue {m d : ℕ} (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ)\n (z : ℂ) : Matrix (Fin m) (Fin m) ℂ :=\n ∑ k : Fin (d + 1), (z ^ (k : ℕ)) • B k\n\ndef polynomialAt {n m d : ℕ} (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ) :\n Matrix (Fin n × Fin m) (Fin n × Fin m) ℂ :=\n ∑ k : Fin (d + 1), Matrix.kronecker (A ^ (k : ℕ)) (B k)\n\ndef rangeMaximum {n m d : ℕ} (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ) : ℝ :=\n sSup ((fun z => ‖polynomialValue B z‖) '' numericalRange A)\n\ndef UniversalBound (C : ℝ) : Prop :=\n ∀ (n m d : ℕ), 0 < n → 0 < m →\n ∀ (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ),\n ‖polynomialAt A B‖ ≤ C * rangeMaximum A B\n\ntheorem main : UniversalBound 2 ∧ ∀ C : ℝ, UniversalBound C → 2 ≤ C := by\n sorry\n\nend CompleteCrouzeix\nend\n\nend OAI\n", "-- ComparatorChallenges/CrouzeixHilbert.lean\nimport Mathlib\n\nnamespace OAI\n\n/-! The sharp complete inequality for bounded operators on complex Hilbert spaces. -/\n\nnoncomputable section\n\nopen scoped TensorProduct Matrix.Norms.L2Operator InnerProductSpace\nopen Set\n\nnamespace CrouzeixHilbert\n\nuniverse u\n\nabbrev Operator (H : Type u) [NormedAddCommGroup H] [NormedSpace ℂ H] := H →L[ℂ] H\nabbrev Coeff (m : ℕ) := Matrix (Fin m) (Fin m) ℂ\n\nvariable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n\ndef numericalRange (A : Operator H) : Set ℂ :=\n {z | ∃ x : H, ‖x‖ = 1 ∧ ⟪x, A x⟫_ℂ = z}\n\ndef numericalClosure (A : Operator H) : Set ℂ := closure (numericalRange A)\n\ndef supNorm {E : Type*} [NormedAddCommGroup E] (S : Set ℂ) (F : ℂ → E) : ℝ :=\n sSup (insert 0 ((fun z => ‖F z‖) '' S))\n\nabbrev Amplification (H : Type u) [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n (m : ℕ) := UniformSpace.Completion (H ⊗[ℂ] EuclideanSpace ℂ (Fin m))\n\ndef tensorOperator (A : Operator H) {m : ℕ} (B : Coeff m) :\n Operator (Amplification H m) :=\n (TensorProduct.mapL A (Matrix.toEuclideanCLM (𝕜 := ℂ) (n := Fin m) B)).completion\n\ndef matrixPolynomial {m d : ℕ} (B : Fin (d + 1) → Coeff m) (z : ℂ) : Coeff m :=\n ∑ k : Fin (d + 1), z ^ (k : ℕ) • B k\n\ndef polynomialEval (A : Operator H) {m d : ℕ} (B : Fin (d + 1) → Coeff m) :\n Operator (Amplification H m) :=\n ∑ k : Fin (d + 1), tensorOperator (A ^ (k : ℕ)) (B k)\n\nstructure SmoothContour where\n path : ℝ → ℂ\n smooth : ContDiff ℝ 1 path\n closed : path 0 = path 1\n\ndef SmoothContour.index (Γ : SmoothContour) (z : ℂ) : ℂ :=\n (2 * (Real.pi : ℂ) * Complex.I)⁻¹ *\n ∫ t in (0 : ℝ)..1, deriv Γ.path t / (Γ.path t - z)\n\nstructure CalculusContour (K U : Set ℂ) extends SmoothContour where\n avoids : ∀ t ∈ Icc (0 : ℝ) 1, path t ∈ U \\ K\n index_inside : ∀ z ∈ K, toSmoothContour.index z = 1\n index_outside : ∀ z ∉ U, toSmoothContour.index z = 0\n\ndef contourEval (A : Operator H) (Γ : SmoothContour) (f : ℂ → ℂ) : Operator H :=\n (2 * (Real.pi : ℂ) * Complex.I)⁻¹ •\n ∫ t in (0 : ℝ)..1, (deriv Γ.path t * f (Γ.path t)) •\n Ring.inverse (algebraMap ℂ (Operator H) (Γ.path t) - A)\n\ndef holomorphicEval (A : Operator H) (U : Set ℂ) (f : ℂ → ℂ) : Operator H := by\n classical\n exact if h : Nonempty (CalculusContour (numericalClosure A) U) then\n contourEval A (Classical.choice h).toSmoothContour f\n else 0\n\ndef matrixHolomorphicEval (A : Operator H) {m : ℕ} (U : Set ℂ)\n (F : ℂ → Coeff m) : Operator (Amplification H m) :=\n ∑ i, ∑ j, tensorOperator (holomorphicEval A U (fun z => F z i j))\n (Matrix.single i j 1)\n\ndef EntrywiseHolomorphic {m : ℕ} (U : Set ℂ) (F : ℂ → Coeff m) : Prop :=\n ∀ i j, DifferentiableOn ℂ (fun z => F z i j) U\n\nabbrev RationalMatrix (m : ℕ) := Matrix (Fin m) (Fin m) (RatFunc ℂ)\n\ndef PolesOutside {m : ℕ} (K : Set ℂ) (R : RationalMatrix m) : Prop :=\n ∀ i j z, z ∈ K → (R i j).denom.eval z ≠ 0\n\ndef matrixRationalFunction {m : ℕ} (R : RationalMatrix m) (z : ℂ) : Coeff m :=\n fun i j => RatFunc.eval (RingHom.id ℂ) z (R i j)\n\ndef rationalEval (A : Operator H) (r : RatFunc ℂ) : Operator H :=\n (Polynomial.aeval A r.num) * Ring.inverse (Polynomial.aeval A r.denom)\n\ndef matrixRationalEval (A : Operator H) {m : ℕ} (R : RationalMatrix m) :\n Operator (Amplification H m) :=\n ∑ i, ∑ j, tensorOperator (rationalEval A (R i j)) (Matrix.single i j 1)\n\ndef NonzeroConclusion (A : Operator H) : Prop :=\n IsCompact (numericalClosure A) ∧\n Convex ℝ (numericalClosure A) ∧\n spectrum ℂ A ⊆ numericalClosure A ∧\n (∀ (m : ℕ), 0 < m → ∀ (d : ℕ) (B : Fin (d + 1) → Coeff m),\n ‖polynomialEval A B‖ ≤ 2 * supNorm (numericalRange A) (matrixPolynomial B) ∧\n supNorm (numericalRange A) (matrixPolynomial B) =\n supNorm (numericalClosure A) (matrixPolynomial B) ∧\n ∃ z ∈ numericalClosure A,\n supNorm (numericalClosure A) (matrixPolynomial B) = ‖matrixPolynomial B z‖) ∧\n (∀ (m : ℕ), 0 < m → ∀ (U : Set ℂ) (F : ℂ → Coeff m),\n IsOpen U → numericalClosure A ⊆ U → EntrywiseHolomorphic U F →\n Nonempty (CalculusContour (numericalClosure A) U) ∧\n (∀ Γ : CalculusContour (numericalClosure A) U, ∀ i j,\n holomorphicEval A U (fun z => F z i j) =\n contourEval A Γ.toSmoothContour (fun z => F z i j)) ∧\n ‖matrixHolomorphicEval A U F‖ ≤ 2 * supNorm (numericalClosure A) F ∧\n ∃ z ∈ numericalClosure A, supNorm (numericalClosure A) F = ‖F z‖) ∧\n (∀ (m : ℕ), 0 < m → ∀ (R : RationalMatrix m),\n PolesOutside (numericalClosure A) R →\n (∀ i j, IsUnit (Polynomial.aeval A (R i j).denom)) ∧\n ‖matrixRationalEval A R‖ ≤\n 2 * supNorm (numericalClosure A) (matrixRationalFunction R) ∧\n (∃ z ∈ numericalClosure A,\n supNorm (numericalClosure A) (matrixRationalFunction R) =\n ‖matrixRationalFunction R z‖) ∧\n ∃ U : Set ℂ, IsOpen U ∧ numericalClosure A ⊆ U ∧\n EntrywiseHolomorphic U (matrixRationalFunction R) ∧\n matrixRationalEval A R = matrixHolomorphicEval A U (matrixRationalFunction R))\n\ndef ZeroConclusion (A : Operator H) : Prop :=\n numericalRange A = ∅ ∧\n (∀ (m d : ℕ) (B : Fin (d + 1) → Coeff m),\n polynomialEval A B = 0 ∧\n supNorm (numericalRange A) (matrixPolynomial B) = 0 ∧\n ‖polynomialEval A B‖ ≤ 2 * supNorm (numericalRange A) (matrixPolynomial B)) ∧\n (∀ (m : ℕ) (U : Set ℂ) (F : ℂ → Coeff m),\n matrixHolomorphicEval A U F = 0 ∧\n supNorm (numericalRange A) F = 0 ∧\n ‖matrixHolomorphicEval A U F‖ ≤ 2 * supNorm (numericalRange A) F) ∧\n (∀ (m : ℕ) (R : RationalMatrix m),\n matrixRationalEval A R = 0 ∧\n supNorm (numericalRange A) (matrixRationalFunction R) = 0 ∧\n ‖matrixRationalEval A R‖ ≤\n 2 * supNorm (numericalRange A) (matrixRationalFunction R))\n\ndef SharpConstant : Prop :=\n ∃ (A : Operator (EuclideanSpace ℂ (Fin 2))) (B : Fin 2 → Coeff 1),\n supNorm (numericalRange A) (matrixPolynomial (d := 1) B) = 1 ∧\n ‖polynomialEval A (d := 1) B‖ = 2\n\nend CrouzeixHilbert\n\nnamespace CrouzeixHilbert\n\nuniverse u\n\ntheorem hilbert (H : Type u) [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n [CompleteSpace H] (A : Operator H) :\n (Nontrivial H → NonzeroConclusion A) ∧\n (Subsingleton H → ZeroConclusion A) ∧ SharpConstant := by\n sorry\n\nend CrouzeixHilbert\n\nend\n\nend OAI\n", "-- ComparatorChallenges/DirectCrouzeix.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nopen scoped Matrix Matrix.Norms.L2Operator Kronecker\n\nnamespace DirectCrouzeix\n\ndef numericalRange {n : ℕ} (A : Matrix (Fin n) (Fin n) ℂ) : Set ℂ :=\n {z | ∃ u : EuclideanSpace ℂ (Fin n), ‖u‖ = 1 ∧\n inner ℂ u (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℂ) A u) = z}\n\ndef polynomialValue {m d : ℕ} (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ)\n (z : ℂ) : Matrix (Fin m) (Fin m) ℂ :=\n ∑ k : Fin (d + 1), z ^ (k : ℕ) • B k\n\ndef tensorEvaluation {n m d : ℕ} (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ) :\n Matrix (Fin n × Fin m) (Fin n × Fin m) ℂ :=\n ∑ k : Fin (d + 1), (A ^ (k : ℕ)) ⊗ₖ (B k)\n\ndef rangeMaximum {n m d : ℕ} (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ) : ℝ :=\n sSup ((fun z => ‖polynomialValue B z‖) '' numericalRange A)\n\ndef UniversalBound (c : ℝ) : Prop :=\n ∀ (n m d : ℕ), 0 < n → 0 < m →\n ∀ (A : Matrix (Fin n) (Fin n) ℂ)\n (B : Fin (d + 1) → Matrix (Fin m) (Fin m) ℂ),\n ‖tensorEvaluation A B‖ ≤ c * rangeMaximum A B\n\ntheorem complete_crouzeix : UniversalBound 2 := by\n sorry\n\ntheorem uniform_sharpness (c : ℝ) (hc : UniversalBound c) : 2 ≤ c := by\n sorry\n\nend DirectCrouzeix\n\nend\n\nend OAI\n", "-- ComparatorChallenges/HilbertCrouzeix.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nopen Complex Set\nopen scoped TensorProduct Matrix.Norms.L2Operator Classical ComplexConjugate\n\nnamespace HilbertCrouzeix\n\nuniverse u\n\nabbrev Coeff (m : ℕ) := Matrix (Fin m) (Fin m) ℂ\nabbrev CoeffSpace (m : ℕ) := EuclideanSpace ℂ (Fin m)\n\nvariable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n\ndef numericalRange (A : H →L[ℂ] H) : Set ℂ :=\n {z | ∃ x : H, ‖x‖ = 1 ∧ inner ℂ x (A x) = z}\n\ndef numericalClosure (A : H →L[ℂ] H) : Set ℂ := closure (numericalRange A)\n\nabbrev Amplification (H : Type u) [NormedAddCommGroup H] [InnerProductSpace ℂ H]\n (m : ℕ) := UniformSpace.Completion (H ⊗[ℂ] CoeffSpace m)\n\ndef tensorOp {m : ℕ} (A : H →L[ℂ] H) (B : Coeff m) :\n Amplification H m →L[ℂ] Amplification H m :=\n (TensorProduct.mapL A (Matrix.toEuclideanCLM (n := Fin m) (𝕜 := ℂ) B)).completion\n\ndef matrixPolynomial {m d : ℕ} (B : Fin (d + 1) → Coeff m) (z : ℂ) : Coeff m :=\n ∑ k : Fin (d + 1), z ^ k.val • B k\n\ndef polynomialEval {m d : ℕ} (A : H →L[ℂ] H) (B : Fin (d + 1) → Coeff m) :\n Amplification H m →L[ℂ] Amplification H m :=\n ∑ k : Fin (d + 1), tensorOp (A ^ k.val) (B k)\n\ndef normSup {E : Type*} [Norm E] (S : Set ℂ) (f : ℂ → E) : ℝ :=\n if S.Nonempty then sSup ((fun z => ‖f z‖) '' S) else 0\ndef contourIntegral {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]\n (γ : ℝ → ℂ) (f : ℂ → E) : E :=\n ∫ t : ℝ in (0 : ℝ)..1, deriv γ t • f (γ t)\n\ndef contourIndex (γ : ℝ → ℂ) (z : ℂ) : ℂ :=\n (2 * (Real.pi : ℂ) * Complex.I)⁻¹ * contourIntegral γ (fun w => (w - z)⁻¹)\n\ndef IsCauchyContour (K U : Set ℂ) (γ : ℝ → ℂ) : Prop :=\n ContDiff ℝ 1 γ ∧ γ 0 = γ 1 ∧\n (∀ t ∈ Set.Icc (0 : ℝ) 1, γ t ∈ U \\ K) ∧\n (∀ z ∈ K, contourIndex γ z = 1) ∧\n (∀ z ∉ U, contourIndex γ z = 0)\n\ndef chosenContour (K U : Set ℂ) : ℝ → ℂ :=\n Classical.epsilon (IsCauchyContour K U)\n\nvariable [CompleteSpace H]\n\ndef dunfordIntegral (A : H →L[ℂ] H) (γ : ℝ → ℂ) (f : ℂ → ℂ) : H →L[ℂ] H :=\n (2 * (Real.pi : ℂ) * Complex.I)⁻¹ •\n contourIntegral γ (fun z => f z • resolvent A z)\n\ndef holomorphicCalculus (A : H →L[ℂ] H) (U : Set ℂ) (f : ℂ → ℂ) : H →L[ℂ] H :=\n dunfordIntegral A (chosenContour (numericalClosure A) U) f\n\ndef matrixUnit {m : ℕ} (i j : Fin m) : Coeff m := Matrix.single i j 1\n\ndef holomorphicEval {m : ℕ} (A : H →L[ℂ] H) (U : Set ℂ) (F : ℂ → Coeff m) :\n Amplification H m →L[ℂ] Amplification H m :=\n ∑ i : Fin m, ∑ j : Fin m,\n tensorOp (holomorphicCalculus A U (fun z => F z i j)) (matrixUnit i j)\nabbrev RationalMatrix (m : ℕ) := Matrix (Fin m) (Fin m) (RatFunc ℂ)\n\ndef poleFreeSet {m : ℕ} (R : RationalMatrix m) : Set ℂ :=\n {z | ∀ i j, (R i j).denom.eval z ≠ 0}\n\ndef rationalFunction {m : ℕ} (R : RationalMatrix m) (z : ℂ) : Coeff m :=\n fun i j => RatFunc.eval (RingHom.id ℂ) z (R i j)\n\ndef rationalCalculus (A : H →L[ℂ] H) (r : RatFunc ℂ) : H →L[ℂ] H :=\n Polynomial.aeval A r.num * Ring.inverse (Polynomial.aeval A r.denom)\n\ndef rationalEval {m : ℕ} (A : H →L[ℂ] H) (R : RationalMatrix m) :\n Amplification H m →L[ℂ] Amplification H m :=\n ∑ i : Fin m, ∑ j : Fin m, tensorOp (rationalCalculus A (R i j)) (matrixUnit i j)\ndef ZeroConclusion (A : H →L[ℂ] H) : Prop :=\n numericalRange A = ∅ ∧\n (∀ (m : ℕ) (F : ℂ → Coeff m), normSup (numericalRange A) F = 0) ∧\n ∀ (m : ℕ), 0 < m →\n (∀ T : Amplification H m →L[ℂ] Amplification H m, T = 0) ∧\n (∀ (d : ℕ) (B : Fin (d + 1) → Coeff m), polynomialEval A B = 0 ∧\n ‖polynomialEval A B‖ ≤ 2 * normSup (numericalRange A) (matrixPolynomial B)) ∧\n (∀ (U : Set ℂ) (F : ℂ → Coeff m), holomorphicEval A U F = 0 ∧\n ‖holomorphicEval A U F‖ ≤ 2 * normSup (numericalRange A) F) ∧\n (∀ (R : RationalMatrix m), rationalEval A R = 0 ∧\n ‖rationalEval A R‖ ≤ 2 * normSup (numericalRange A) (rationalFunction R))\n\nsection CompressionDefinitions\nomit [CompleteSpace H]\n\ndef compression (A : H →L[ℂ] H) (E : Submodule ℂ H) [E.HasOrthogonalProjection] :\n E →L[ℂ] E := E.orthogonalProjectionOnto.comp (A.comp E.subtypeL)\ndef completedIsometry {V : Type*} {W : Type*}\n [NormedAddCommGroup V] [NormedAddCommGroup W] [NormedSpace ℂ V] [NormedSpace ℂ W]\n (f : V →ₗᵢ[ℂ] W) : UniformSpace.Completion V →ₗᵢ[ℂ] UniformSpace.Completion W :=\n { f.toContinuousLinearMap.completion.toLinearMap with\n norm_map' := f.isometry.completion_map.norm_map_of_map_zero\n (f.toContinuousLinearMap.completion.map_zero) }\n\ndef tensorInclusion (E : Submodule ℂ H) (m : ℕ) :\n Amplification E m →ₗᵢ[ℂ] Amplification H m :=\n completedIsometry (TensorProduct.mapIsometry E.subtypeₗᵢ (.id : CoeffSpace m →ₗᵢ[ℂ] CoeffSpace m))\n\nend CompressionDefinitions\n\ntheorem numericalClosure_geometry (A : H →L[ℂ] H) :\n IsCompact (numericalClosure A) ∧ Convex ℝ (numericalClosure A) ∧\n spectrum ℂ A ⊆ numericalClosure A := by\n sorry\n\nomit [CompleteSpace H] in\ntheorem exists_finite_compression {m d : ℕ} (A : H →L[ℂ] H)\n (B : Fin (d + 1) → Coeff m) (ξ : H ⊗[ℂ] CoeffSpace m) :\n ∃ (E : Submodule ℂ H) (hE : FiniteDimensional ℂ E),\n letI : FiniteDimensional ℂ E := hE\n ∃ η : Amplification E m,\n tensorInclusion E m η = (↑ξ : Amplification H m) ∧\n tensorInclusion E m (polynomialEval (compression A E) B η) =\n polynomialEval A B (↑ξ) := by\n sorry\n\ntheorem rational_denominator_isUnit [Nontrivial H] (A : H →L[ℂ] H)\n {m : ℕ} (R : RationalMatrix m) (hR : numericalClosure A ⊆ poleFreeSet R)\n (i j : Fin m) : IsUnit (Polynomial.aeval A (R i j).denom) := by\n sorry\n\ntheorem zeroConclusion [Subsingleton H] (A : H →L[ℂ] H) : ZeroConclusion A := by\n sorry\n\nend HilbertCrouzeix\n\nend\n\nend OAI\n", "-- ComparatorChallenges/StructuralCrouzeix.lean\nimport Mathlib\n\nnamespace OAI\n\nuniverse u_61 u_63 u_67 u_83 u_84 u_181\n\nnoncomputable section\nopen scoped BigOperators Matrix.Norms.L2Operator ComplexOrder\n\nnamespace CompleteCrouzeix\n\n\n\ndef numericalRange {n : ℕ} (A : Matrix (Fin n) (Fin n) ℂ) : Set ℂ :=\n {z | ∃ x : EuclideanSpace ℂ (Fin n), ‖x‖ = 1 ∧\n inner ℂ x (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℂ) A x) = z}\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen Set Filter Metric Complex\nopen scoped Topology\n\n\nstructure DiskCoordinate (U : Set ℂ) (a : ℂ) where\n outer : Set ℂ\n outer_open : IsOpen outer\n closure_subset : closure U ⊆ outer\n toDisk : ℂ → ℂ\n fromDisk : ℂ → ℂ\n analytic_to : AnalyticOnNhd ℂ toDisk outer\n injective_to : InjOn toDisk outer\n noncritical_to : ∀ z ∈ outer, deriv toDisk z ≠ 0\n image_open : IsOpen (toDisk '' outer)\n analytic_from : AnalyticOnNhd ℂ fromDisk (toDisk '' outer)\n inverse_map : MapsTo fromDisk (toDisk '' outer) outer\n left_inverse : ∀ z ∈ outer, fromDisk (toDisk z) = z\n right_inverse : ∀ w ∈ toDisk '' outer, toDisk (fromDisk w) = w\n closedDisk_subset : closedBall 0 1 ⊆ toDisk '' outer\n image_domain : toDisk '' U = ball 0 1\n base_zero : toDisk a = 0\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen Set Filter Metric Complex\nopen scoped Topology\n\n\ndef exteriorMap (a b : ℂ) (h : ℂ → ℂ) (t : ℂ) : ℂ := a*t+b+h t⁻¹\n\nstructure ExteriorCoordinate (U : Set ℂ) where\n radius : ℝ\n radius_gt : 1 < radius\n leading : ℂ\n constant : ℂ\n regular : ℂ → ℂ\n leading_ne : leading ≠ 0\n analytic_regular : AnalyticOnNhd ℂ regular (ball 0 radius)\n injective : InjOn (exteriorMap leading constant regular) {t | radius⁻¹ < ‖t‖}\n noncritical : ∀ t, radius⁻¹ < ‖t‖ → deriv (exteriorMap leading constant regular) t ≠ 0\n boundary_image : exteriorMap leading constant regular '' sphere 0 1 = frontier U\n interior_iff : ∀ t, radius⁻¹ < ‖t‖ →\n (exteriorMap leading constant regular t ∈ U ↔ t ∈ ball 0 1)\n outside : ∀ t, 1 < ‖t‖ → exteriorMap leading constant regular t ∉ closure U\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen Polynomial Finset\nvariable {A : Type u_61} [Ring A] [Algebra ℂ A]\n\ndef scalarJetEval (β : ℂ) (N : A) (s : ℕ) (f : ℂ → ℂ) : A :=\n ∑ i ∈ range s, (iteratedDeriv i f β / (i.factorial : ℂ)) • N ^ i\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen Module Set\nopen scoped DirectSum\nvariable {V : Type u_63} [AddCommGroup V] [Module ℂ V] [instFiniteDimensionalℂV : FiniteDimensional ℂ V]\n\nnoncomputable def primaryEquiv (T : Module.End ℂ V) :\n V ≃ₗ[ℂ] ⨁ β : ℂ, T.maxGenEigenspace β := by\n classical\n exact (LinearEquiv.ofBijective (DirectSum.coeLinearMap T.maxGenEigenspace)\n (DirectSum.isInternal_submodule_of_iSupIndep_of_iSup_eq_top\n T.independent_maxGenEigenspace T.iSup_maxGenEigenspace_eq_top)).symm\n\nnoncomputable def primaryNilpotent (T : Module.End ℂ V) (β : ℂ) :\n Module.End ℂ (T.maxGenEigenspace β) :=\n (T - algebraMap ℂ (Module.End ℂ V) β).restrict\n (fun x hx => T.mapsTo_maxGenEigenspace_of_comm\n (Algebra.mul_sub_algebraMap_commutes T β) β (show x ∈ T.maxGenEigenspace β from hx))\n\nnoncomputable def primaryEval (T : Module.End ℂ V) (f : ℂ → ℂ) : Module.End ℂ V :=\n (primaryEquiv T).symm.toLinearMap ∘ₗ\n (DirectSum.lmap fun β => scalarJetEval β (primaryNilpotent T β) (finrank ℂ V) f) ∘ₗ\n (primaryEquiv T).toLinearMap\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen Filter Topology Set Module\nvariable {n : Type u_67} [Fintype n] [DecidableEq n]\n\nnoncomputable def matrixAnalyticEval (A : Matrix n n ℂ) (f : ℂ → ℂ) : Matrix n n ℂ :=\n Matrix.toLinAlgEquiv'.symm (primaryEval (Matrix.toLinAlgEquiv' A) f)\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen scoped ENNReal NNReal Matrix.Norms.L2Operator MatrixOrder Kronecker\nvariable {n : Type u_83} {m : Type u_84} [Fintype n] [DecidableEq n] [instFintypeM : Fintype m] [instDecidableEqM : DecidableEq m]\n\ndef completeAnalyticEval (D : Matrix n n ℂ) (F : ℂ → Matrix m m ℂ) :\n Matrix (n×m) (n×m) ℂ :=\n fun i j => matrixAnalyticEval D (fun z => F z i.2 j.2) i.1 j.1\n\nend CompleteCrouzeix\n\nnamespace CompleteCrouzeix\nopen scoped Matrix MatrixOrder\nvariable {n : Type u_181} [Fintype n] [DecidableEq n] [Nonempty n]\n\ndef MetricFeasible (T : Matrix n n ℂ) (τ : ℝ) (H : Matrix n n ℂ) : Prop :=\n 1 ≤ H ∧ H ≤ algebraMap ℝ (Matrix n n ℂ) τ ∧ Tᴴ * H * T ≤ H\n\nend CompleteCrouzeix\n\nend\n\nnoncomputable section\nopen Set Filter Metric Complex MeasureTheory\nopen scoped Matrix Topology ComplexConjugate ComplexOrder MatrixOrder\n Matrix.Norms.L2Operator Kronecker\n\nnamespace StructuralCrouzeix\nopen CompleteCrouzeix\n\ndef RegularAnalyticBoundaryAt (U : Set ℂ) (p : ℂ) : Prop :=\n ∃ χ : ℂ → ℂ, χ 0 = p ∧ AnalyticAt ℂ χ 0 ∧ deriv χ 0 ≠ 0 ∧\n (∀ᶠ z : ℂ in 𝓝 0, χ z ∈ frontier U ↔ z.im = 0)\n\nstructure IsAdmissible (U : Set ℂ) : Prop where\n isOpen : IsOpen U\n bounded : Bornology.IsBounded U\n convex : Convex ℝ U\n nonempty : U.Nonempty\n jordan : Nonempty (Circle ≃ₜ ↥(frontier U))\n regular : ∀ p ∈ frontier U, RegularAnalyticBoundaryAt U p\n\ndef IsMinimizing {n : ℕ} (T : Matrix (Fin n) (Fin n) ℂ)\n (τ : ℝ) (H : Matrix (Fin n) (Fin n) ℂ) : Prop :=\n MetricFeasible T τ H ∧\n ∀ (σ : ℝ) (J : Matrix (Fin n) (Fin n) ℂ),\n MetricFeasible T σ J → τ ≤ σ\n\ndef StrictlyFeasible {n : ℕ} (T : Matrix (Fin n) (Fin n) ℂ) : Prop :=\n ∃ (τ : ℝ) (H : Matrix (Fin n) (Fin n) ℂ), H.IsHermitian ∧\n (H - 1).PosDef ∧\n (algebraMap ℝ (Matrix (Fin n) (Fin n) ℂ) τ - H).PosDef ∧\n (H - Tᴴ * H * T).PosDef\n\ndef analyticSupNorm {m : ℕ} (U : Set ℂ)\n (v : ℂ → Matrix (Fin m) (Fin m) ℂ) : ℝ :=\n sSup ((fun z => ‖v z‖) '' closure U)\n\ndef boundaryPoint {U : Set ℂ} (G : ExteriorCoordinate U) (t : UnitAddCircle) : ℂ :=\n exteriorMap G.leading G.constant G.regular (t.toCircle : ℂ)\n\ndef FullEndpoint : Prop :=\n ∀ (U : Set ℂ), IsAdmissible U →\n (∀ a ∈ U, Nonempty (DiskCoordinate U a)) ∧\n Nonempty (ExteriorCoordinate U) ∧\n ∀ (a : ℂ), a ∈ U → ∀ (f : DiskCoordinate U a) (G : ExteriorCoordinate U),\n ∀ (n : ℕ), 0 < n → ∀ (A : Matrix (Fin n) (Fin n) ℂ),\n numericalRange A ⊆ U →\n let T := matrixAnalyticEval A f.toDisk\n StrictlyFeasible T ∧\n ∃ κ : ℝ, 1 ≤ κ ∧ κ ≤ 2 ∧\n (∃ H : Matrix (Fin n) (Fin n) ℂ, IsMinimizing T (κ ^ 2) H) ∧\n ∀ H : Matrix (Fin n) (Fin n) ℂ, IsMinimizing T (κ ^ 2) H →\n let S := CFC.sqrt H\n let A' := S * A * S⁻¹\n let D := S * T * S⁻¹\n H.PosDef ∧ IsUnit S ∧\n D = matrixAnalyticEval A' f.toDisk ∧\n Dᴴ * D ≤ 1 ∧ spectralRadius ℂ D < 1 ∧\n ‖S‖ * ‖S⁻¹‖ = κ ∧\n (∀ R : Matrix (Fin n) (Fin n) ℂ, IsUnit R →\n (R * T * R⁻¹)ᴴ * (R * T * R⁻¹) ≤ 1 →\n κ ≤ ‖R‖ * ‖R⁻¹‖) ∧\n ∃ Λ : C(UnitAddCircle, Matrix (Fin n) (Fin n) ℂ),\n (∀ t, (Λ t).PosSemidef) ∧\n (∫ t, Λ t ∂AddCircle.haarAddCircle) = 1 ∧\n ∀ (m : ℕ), 0 < m →\n ∀ v : ℂ → Matrix (Fin m) (Fin m) ℂ,\n AnalyticOnNhd ℂ v (closure U) →\n completeAnalyticEval A' v =\n (∫ t, Λ t ⊗ₖ v (boundaryPoint G t) ∂AddCircle.haarAddCircle) ∧\n ‖completeAnalyticEval A v‖ ≤ κ * analyticSupNorm U v\n\nend StructuralCrouzeix\nend\n\nnamespace StructuralCrouzeixReference\n\n/-- Intrinsic structural representation and admissibility of the unit disk. -/\ntheorem challenge : StructuralCrouzeix.FullEndpoint ∧\n StructuralCrouzeix.IsAdmissible (Metric.ball (0 : ℂ) 1) := by\n sorry\n\nend StructuralCrouzeixReference\n\nend OAI\n"], "formalization_scope": "The complete Crouzeix inequality bounds a matrix-valued polynomial evaluated at a matrix by its maximum norm on the numerical range. The formalized result proves the bound with constant $2$ for every positive matrix and coefficient size, every polynomial degree, and arbitrary complex coefficients. It also proves that no smaller universal constant works. Normality of the matrix and nonempty interior of its numerical range are not assumed.\n\nThe formalization proves the complete Crouzeix inequality with sharp constant two for every bounded operator on an arbitrary complex Hilbert space. For every matrix-valued polynomial, its operator evaluation has norm at most twice its supremum norm on the numerical range. The same bound holds for finite matrix-valued functions holomorphic near the closure of the numerical range and for rational functions with poles outside that closure. No separability assumption is required.\n\nFor finite matrices in a bounded convex domain with regular real-analytic Jordan boundary, the structural result gives an attained optimal similarity with condition number at most two and one continuous positive boundary density of mass the identity representing every matrix-valued analytic test. The linked supporting statements include numerical-range geometry and finite-compression identities.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\n \"reason\": \"The Hilbert-space file states the full infinite-dimensional claim: for every complete complex inner-product space and bounded operator, all matrix sizes and polynomial degrees satisfy the norm inequality with constant 2, and it includes a sharpness example attaining ratio 2. The finite-matrix files are special cases or auxiliary statements, and the Hilbert statement adds extra geometric/holomorphic conclusions, but these do not weaken the main claim. The definitions of numerical range, matrix-valued polynomial evaluation, and operator norms match the intended meanings.\",\n \"score\": 5\n}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully expresses the main claim. The theorem `hilbert` in CrouzeixHilbert.lean states that for every bounded operator A on a complex Hilbert space (complete inner product space), the inequality ‖polynomialEval A B‖ ≤ 2 * supNorm (numericalRange A) (matrixPolynomial B) holds for all matrix sizes m and polynomial degrees d, which matches the claim's core inequality. The SharpConstant proposition demonstrates that the constant 2 is sharp. Additional results about holomorphic and rational functions extend the claim but do not contradict it. The definitions of numericalRange, polynomialEval, and supNorm align with standard mathematical meanings.\", \"score\": 5}"}}
{"family": "328", "title": "Nonexpansive fixed points in reflexive Banach spaces", "claim": "Nonexpansive fixed points in reflexive Banach spaces. Resolves Kirk's reflexive-space fixed-point problem: every nonexpansive selfmap of a nonempty closed bounded convex subset of a real reflexive Banach space has a fixed point. The result uses the original norm, without assuming uniform convexity.", "abstracts": ["Every nonexpansive selfmap of a nonempty closed bounded convex subset of a real reflexive Banach space has a fixed point. This resolves the reflexive-space fixed point problem for the given norm."], "papers": ["https://github.com/openai/math/tree/main/preprints/Fixed-Points-of-Nonexpansive-Maps-in-Reflexive-Banach-Spaces-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/ReflexiveFixedPoints.lean"], "lean_statements": ["-- ComparatorChallenges/ReflexiveFixedPoints.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\n\nnamespace ReflexiveFixedPoints\n\nuniverse u\n\nvariable (X : Type u) [NormedAddCommGroup X] [NormedSpace ℝ X]\n\n/-- Surjectivity of the canonical map into the continuous bidual. -/\ndef CanonicallyReflexive : Prop :=\n Function.Surjective (NormedSpace.inclusionInDoubleDual ℝ X)\n\nvariable {X}\n\n/-- Every nonexpansive selfmap of a nonempty closed bounded convex set has\nan actual fixed point, with nonexpansiveness stated in the original norm. -/\ntheorem exists_fixedPoint_of_canonicallyReflexive\n {X : Type u} [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace X]\n (hX : CanonicallyReflexive X) (C : Set X)\n (hne : C.Nonempty) (hclosed : IsClosed C)\n (hbounded : Bornology.IsBounded C) (hconvex : Convex ℝ C)\n (F : C → C)\n (hF : ∀ a b : C, ‖(F a : X) - (F b : X)‖ ≤ ‖(a : X) - (b : X)‖) :\n ∃ a : C, F a = a := by\n sorry\n\nend ReflexiveFixedPoints\n\nend\n\nend OAI\n"], "formalization_scope": "The fixed-point question asks whether reflexivity suffices for nonexpansive maps on bounded convex sets. The formalized result gives an affirmative answer: every nonexpansive self-map of a nonempty closed bounded convex subset of a real reflexive Banach space has a fixed point in the original norm. Zero and nonseparable spaces are included, with no uniform convexity, normal structure, or weak-continuity assumption.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The Lean theorem quantifies over a real normed space with CompleteSpace and surjectivity of the canonical map into the continuous bidual, which matches a real reflexive Banach space. It assumes C is nonempty, closed, bounded (via the normed-space bornology), and convex, and F is a self-map of C that is nonexpansive in the original norm. The conclusion is exactly the existence of a fixed point in C, with no substantive extra hypotheses or weakening.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean statement faithfully captures the main claim. It assumes X is a real Banach space (CompleteSpace, NormedSpace ℝ) that is reflexive (CanonicallyReflexive, which for Banach spaces is equivalent to the canonical embedding into the double dual being surjective), C is a nonempty closed bounded convex subset, and F is a nonexpansive selfmap. The conclusion asserts the existence of a fixed point. Crucially, no extra assumptions like uniform convexity are made, consistent with the abstract's claim that the result uses the original norm without assuming uniform convexity.\", \"score\": 5}"}}
{"family": "329", "title": "A counterexample to metric-entropy duality", "claim": "A counterexample to metric-entropy duality. Disproves Pietsch's dimension-free duality conjecture for metric entropy. Origin-symmetric convex bodies violate every proposed choice of universal constants in the conjectured comparison between covering numbers and those of the polar bodies, even when the covering body is a cube.", "abstracts": ["We disprove Pietsch's dimension-free duality conjecture for metric entropy. For every proposed pair of universal constants, we construct origin-symmetric convex bodies that violate the corresponding covering-entropy inequality, already when the covering body is a cube."], "papers": ["https://github.com/openai/math/tree/main/preprints/Counterexamples-to-the-duality-conjecture-for-metric-entropy-September-24-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/MetricEntropyDuality.lean"], "lean_statements": ["-- ComparatorChallenges/MetricEntropyDuality.lean\nimport Mathlib.Analysis.Convex.Topology\nimport Mathlib.Analysis.Normed.Group.Constructions\nimport Mathlib.Order.Lattice.Nat\nimport Mathlib.Analysis.SpecialFunctions.Log.Basic\n\nnamespace OAI\n\nuniverse u\n\nnoncomputable section\n\nnamespace MetricEntropyDuality\n\nopen Filter Topology\nopen scoped BigOperators Pointwise\n\nabbrev RealSpace (ι : Type u) := ι → ℝ\n\ndef pairing {ι : Type u} [Fintype ι] (x y : RealSpace ι) : ℝ :=\n ∑ i, x i * y i\n\ndef cube (ι : Type u) : Set (RealSpace ι) :=\n {x | ∀ i, |x i| ≤ 1}\n\ndef polar {ι : Type u} [Fintype ι] (K : Set (RealSpace ι)) : Set (RealSpace ι) :=\n {y | ∀ x ∈ K, pairing x y ≤ 1}\n\ndef Covers {ι : Type u} {M : ℕ} (A B : Set (RealSpace ι))\n (centers : Fin M → RealSpace ι) : Prop :=\n ∀ x ∈ A, ∃ j, x - centers j ∈ B\n\ndef Coverable {ι : Type u} (A B : Set (RealSpace ι)) : Prop :=\n ∃ M : ℕ, ∃ centers : Fin M → RealSpace ι, Covers A B centers\n\ndef coveringNumber {ι : Type u} (A B : Set (RealSpace ι)) : ℕ :=\n sInf {M : ℕ | ∃ centers : Fin M → RealSpace ι, Covers A B centers}\n\nstructure IsSymmetricConvexBody {ι : Type u} [Fintype ι]\n (K : Set (RealSpace ι)) : Prop where\n isCompact : IsCompact K\n convex : Convex ℝ K\n symmetric : ∀ x, x ∈ K ↔ -x ∈ K\n interior_nonempty : (interior K).Nonempty\n\ntheorem exists_entropy_duality_counterexample_with_covers\n (a b : ℝ) (ha : 1 ≤ a) (hb : 1 ≤ b) :\n ∃ n : ℕ, 0 < n ∧ ∃ K : Set (RealSpace (Fin n)),\n IsSymmetricConvexBody K ∧\n Coverable K (cube (Fin n)) ∧\n Coverable (polar (cube (Fin n))) (a⁻¹ • polar K) ∧\n b * Real.log (coveringNumber (polar (cube (Fin n))) (a⁻¹ • polar K) : ℝ) <\n Real.log (coveringNumber K (cube (Fin n)) : ℝ) := by\n sorry\n\nend MetricEntropyDuality\n\nend\n\nend OAI\n"], "formalization_scope": "Metric-entropy duality predicts a universal comparison between covering numbers of convex bodies and their polars. The formalized result disproves such a comparison: for every $a,b\\ge1$, there is an origin-symmetric convex body $K$ in a positive finite dimension with $\\log N(K,B_\\infty)>b\\log N(B_\\infty^\\circ,a^{-1}K^\\circ)$, where $N$ is the least number of translates in a finite cover. A further construction makes the dual-to-primal logarithmic entropy ratio tend to zero as the dimension grows.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The theorem quantifies over arbitrary constants a,b in the natural regime a,b≥1 and produces a positive dimension and an origin-symmetric compact convex body K. Its definitions of cube, polar, and finite covering number match the usual notions, and the conclusion asserts the opposite of the conjectured log-covering inequality with the cube as the covering body. The added coverability assumptions only ensure the covering numbers are finite and do not add substantive hypotheses. Thus the statement faithfully formalizes the claimed counterexample.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean theorem faithfully expresses the main claim. It states that for any proposed universal constants a, b ≥ 1, there exists a finite-dimensional origin-symmetric convex body K such that the covering-number inequality is violated, with the covering body being a cube (as required by 'even when the covering body is a cube'). The inequality b * log N(polar(cube), a⁻¹ • polar K) < log N(K, cube) correctly captures the violation of the conjectured duality relation, showing that the covering number of K grows faster than any power b of the covering number of the polar cube. Definitions of polar body, covering number, and symmetric convex body match standard mathematical usage.\", \"score\": 5}"}}
{"family": "330", "title": "A uniformly discrete counterexample to bounded approximation in Lipschitz-free spaces", "claim": "A uniformly discrete counterexample to bounded approximation in Lipschitz-free spaces. Constructs a countable uniformly discrete metric space whose real Lipschitz-free Banach space has the approximation property but not the bounded approximation property, answering Kalton's question negatively. Finite-rank operators approximate the identity on every compact set, but their norms cannot share a finite bound.", "abstracts": ["We construct a countable uniformly discrete metric space whose real Lipschitz-free space has the approximation property but fails the bounded approximation property, answering Kalton's question negatively. The identity can be approximated on every compact set by finite-rank operators, but no uniform bound on their norms is possible."], "papers": ["https://github.com/openai/math/tree/main/preprints/Failure-of-Bounded-Approximation-in-a-Lipschitz-Free-Space-over-a-Uniformly-Discrete-Metric-Space-September-26-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/DiscreteLipschitzFree.lean", "https://github.com/openai/math/blob/main/lean/ComparatorChallenges/RealL1Renorming.lean"], "lean_statements": ["-- ComparatorChallenges/DiscreteLipschitzFree.lean\nimport Mathlib\n\nnamespace OAI\n\n/-!\n# Real Lipschitz-free spaces and approximation properties\n-/\n\nnoncomputable section\nopen scoped BigOperators ENNReal\n\nnamespace DiscreteFree\n\nvariable {M : Type*} [MetricSpace M]\n\ndef lipSubmodule (o : M) : Submodule ℝ (M → ℝ) where\n carrier := {f | f o = 0 ∧ ∃ C : ℝ, 0 ≤ C ∧\n ∀ x y, |f x - f y| ≤ C * dist x y}\n zero_mem' := by\n refine ⟨rfl, 0, le_rfl, ?_⟩\n intro x y\n simp\n add_mem' := by\n rintro f g ⟨hfo, C, hC, hf⟩ ⟨hgo, D, hD, hg⟩\n refine ⟨by simpa using congrArg₂ (· + ·) hfo hgo,\n C + D, add_nonneg hC hD, ?_⟩\n intro x y\n change |f x + g x - (f y + g y)| ≤ (C + D) * dist x y\n calc\n _ = |(f x - f y) + (g x - g y)| := by ring_nf\n _ ≤ |f x - f y| + |g x - g y| := abs_add_le _ _\n _ ≤ C * dist x y + D * dist x y := add_le_add (hf x y) (hg x y)\n _ = _ := by ring\n smul_mem' := by\n rintro c f ⟨hfo, C, hC, hf⟩\n refine ⟨by simp [hfo], |c| * C, mul_nonneg (abs_nonneg c) hC, ?_⟩\n intro x y\n change |c * f x - c * f y| ≤ (|c| * C) * dist x y\n calc\n _ = |c| * |f x - f y| := by rw [← mul_sub, abs_mul]\n _ ≤ |c| * (C * dist x y) := mul_le_mul_of_nonneg_left (hf x y) (abs_nonneg c)\n _ = _ := by ring\n\ndef Lip0 (o : M) := ↥(lipSubmodule o)\n\nnamespace Lip0\n\nvariable {o : M}\n\ninstance : AddCommGroup (Lip0 o) := inferInstanceAs (AddCommGroup ↥(lipSubmodule o))\ninstance : Module ℝ (Lip0 o) := inferInstanceAs (Module ℝ ↥(lipSubmodule o))\n\ninstance : CoeFun (Lip0 o) (fun _ => M → ℝ) := ⟨fun f => f.val⟩\n\ndef slope (o : M) : Lip0 o →ₗ[ℝ] lp (fun _ : M × M => ℝ) ∞ where\n toFun f := ⟨fun z : M × M => (f z.1 - f z.2) / dist z.1 z.2, by\n obtain ⟨C, hC, hf⟩ := f.property.2\n apply memℓp_infty\n refine ⟨C, ?_⟩\n rintro r ⟨⟨x, y⟩, rfl⟩\n change ‖(f x - f y) / dist x y‖ ≤ C\n rw [Real.norm_eq_abs, abs_div, abs_of_nonneg dist_nonneg]\n by_cases hxy : x = y\n · simp [hxy, hC]\n · exact (div_le_iff₀ (dist_pos.mpr hxy)).2 (hf x y)⟩\n map_add' f g := by\n apply lp.ext\n funext z\n change ((f z.1 + g z.1) - (f z.2 + g z.2)) / dist z.1 z.2 =\n (f z.1 - f z.2) / dist z.1 z.2 + (g z.1 - g z.2) / dist z.1 z.2\n ring\n map_smul' c f := by\n apply lp.ext\n funext z\n change (c * f z.1 - c * f z.2) / dist z.1 z.2 =\n c * ((f z.1 - f z.2) / dist z.1 z.2)\n ring\n\ninstance (o : M) : NormedAddCommGroup (Lip0 o) :=\n NormedAddCommGroup.induced _ _ (slope o).toAddMonoidHom (by\n intro f g h\n apply Subtype.ext\n funext x\n have hx := congrArg (fun q : lp (fun _ : M × M => ℝ) ∞ => q (x, o)) h\n change (f x - f o) / dist x o = (g x - g o) / dist x o at hx\n rw [f.property.1, g.property.1, sub_zero, sub_zero] at hx\n by_cases hxo : x = o\n · rw [hxo, f.property.1, g.property.1]\n · exact (div_left_inj' (ne_of_gt (dist_pos.mpr hxo))).mp hx)\n\ninstance (o : M) : NormedSpace ℝ (Lip0 o) :=\n NormedSpace.induced ℝ _ _ (slope o)\n\nend Lip0\n\ndef evaluation (o x : M) : (Lip0 o →L[ℝ] ℝ) :=\n LinearMap.mkContinuous\n ({ toFun := fun f : Lip0 o => f x\n map_add' := fun _ _ => rfl\n map_smul' := fun _ _ => rfl } : Lip0 o →ₗ[ℝ] ℝ)\n (dist x o) (fun f => by\n change ‖f x‖ ≤ dist x o * ‖f‖\n rw [mul_comm]\n have hx := lp.norm_apply_le_norm (by simp : (∞ : ℝ≥0∞) ≠ 0)\n (Lip0.slope o f) (x, o)\n change ‖(f x - f o) / dist x o‖ ≤ ‖f‖ at hx\n rw [f.property.1, sub_zero, norm_div, Real.norm_of_nonneg dist_nonneg] at hx\n by_cases hxo : x = o\n · rw [hxo, f.property.1, norm_zero, dist_self, mul_zero]\n · exact (div_le_iff₀ (dist_pos.mpr hxo)).mp hx)\n\ndef freeSubmodule (o : M) : Submodule ℝ ((Lip0 o →L[ℝ] ℝ)) :=\n (Submodule.span ℝ (Set.range (evaluation o))).topologicalClosure\n\ndef FreeSpace (o : M) := ↥(freeSubmodule o)\n\ninstance (o : M) : NormedAddCommGroup (FreeSpace o) :=\n inferInstanceAs (NormedAddCommGroup ↥(freeSubmodule o))\n\ninstance (o : M) : NormedSpace ℝ (FreeSpace o) :=\n inferInstanceAs (NormedSpace ℝ ↥(freeSubmodule o))\n\ndef delta (o x : M) : FreeSpace o :=\n ⟨evaluation o x, Submodule.le_topologicalClosure _\n (Submodule.subset_span ⟨x, rfl⟩)⟩\n\ndef HasAP (X : Type*) [NormedAddCommGroup X] [NormedSpace ℝ X] : Prop :=\n ∀ C : Set X, IsCompact C → ∀ ε : ℝ, 0 < ε →\n ∃ T : X →L[ℝ] X, Module.Finite ℝ (LinearMap.range T.toLinearMap) ∧\n ∃ η : ℝ, η < ε ∧ ∀ u ∈ C, ‖T u - u‖ ≤ η\n\ndef HasBAP (X : Type*) [NormedAddCommGroup X] [NormedSpace ℝ X] (Λ : ℝ) : Prop :=\n ∀ C : Set X, IsCompact C → ∀ ε : ℝ, 0 < ε →\n ∃ T : X →L[ℝ] X, Module.Finite ℝ (LinearMap.range T.toLinearMap) ∧\n ‖T‖ ≤ Λ ∧ ∃ η : ℝ, η < ε ∧ ∀ u ∈ C, ‖T u - u‖ ≤ η\n\ndef blockBound (p : ℕ) : ℝ := 300 * (p : ℝ)^2 + 150 * (p : ℝ) + 5\n\ndef BlockStatement : Prop :=\n ∀ p : ℕ, 1 ≤ p → ∃ (M : Type) (d : MetricSpace M) (o : M),\n letI := d\n Countable M ∧ (∀ x y : M, x ≠ y → 1 ≤ dist x y) ∧\n (∀ x y : M, dist x y ≤ blockBound p) ∧\n ∃ A : Finset M, o ∈ A ∧ ∀ T : FreeSpace o →L[ℝ] FreeSpace o,\n Module.Finite ℝ (LinearMap.range T.toLinearMap) → ‖T‖ ≤ (p : ℝ) →\n ∃ a ∈ A, (1 / 2 : ℝ) ≤ ‖T (delta o a) - delta o a‖\n\ndef MainStatement : Prop :=\n ∃ (M : Type) (d : MetricSpace M) (o : M),\n letI := d\n Countable M ∧ (∀ x y : M, x ≠ y → 1 ≤ dist x y) ∧\n (¬ Bornology.IsBounded (Set.univ : Set M)) ∧\n (¬ ProperSpace M) ∧ HasAP (FreeSpace o) ∧\n ∀ Λ : ℝ, 1 ≤ Λ → ¬ HasBAP (FreeSpace o) Λ\n\ntheorem source_endpoints : BlockStatement ∧ MainStatement := by\n sorry\n\nend DiscreteFree\n\nend\n\nend OAI\n", "-- ComparatorChallenges/RealL1Renorming.lean\nimport Mathlib.Analysis.Normed.Lp.lpSpace\nimport Mathlib.Analysis.Normed.Operator.Basic\nimport Mathlib.RingTheory.Finiteness.Defs\n\nnamespace OAI\n\nnoncomputable section\n\n/-!\n# Quantitative renorming of real ℓ¹ with fixed vector-space operations\n-/\n\nopen scoped BigOperators ENNReal\n\nnamespace DiscreteFree\n\nvariable {M : Type*} [MetricSpace M]\n\ndef HasBAP (X : Type*) [NormedAddCommGroup X] [NormedSpace ℝ X] (Λ : ℝ) : Prop :=\n ∀ C : Set X, IsCompact C → ∀ ε : ℝ, 0 < ε →\n ∃ T : X →L[ℝ] X, Module.Finite ℝ (LinearMap.range T.toLinearMap) ∧\n ‖T‖ ≤ Λ ∧ ∃ η : ℝ, η < ε ∧ ∀ u ∈ C, ‖T u - u‖ ≤ η\n\ndef blockBound (p : ℕ) : ℝ := 300 * (p : ℝ)^2 + 150 * (p : ℝ) + 5\n\nopen scoped BigOperators ENNReal\n\ndef RealL1 : Type := lp (fun _ : ℕ => ℝ) (1 : ENNReal)\n\nnoncomputable instance : NormedAddCommGroup RealL1 :=\n inferInstanceAs (NormedAddCommGroup (lp (fun _ : ℕ => ℝ) (1 : ENNReal)))\n\nnoncomputable instance : NormedSpace ℝ RealL1 :=\n inferInstanceAs (NormedSpace ℝ (lp (fun _ : ℕ => ℝ) (1 : ENNReal)))\n\ndef RealL1RenormingStatement : Prop :=\n ∀ p : ℕ, 1 ≤ p → ∃ N : AddGroupNorm RealL1,\n (∀ (r : ℝ) (c : RealL1), N (r • c) = |r| * N c) ∧\n (∀ c : RealL1, (1 / 2 : ℝ) * ‖c‖ ≤ N c ∧ N c ≤ blockBound p * ‖c‖) ∧\n (let m : Module ℝ RealL1 := inferInstance\n letI : NormedAddCommGroup RealL1 := N.toNormedAddCommGroup\n ∃ s : NormedSpace ℝ RealL1, s.toModule = m ∧\n letI := s\n CompleteSpace RealL1 ∧\n HasBAP RealL1 (2 * blockBound p) ∧ ¬ HasBAP RealL1 (p : ℝ) ∧\n (p = 1 → ¬ HasBAP RealL1 1))\n\ntheorem real_l1_quantitative_renorming : RealL1RenormingStatement := by\n sorry\n\nend DiscreteFree\n\nend\n\nend OAI\n"], "formalization_scope": "Kalton's question asks whether uniform discreteness of a metric space forces its Lipschitz-free space to have the bounded approximation property. The formalization constructs a countable metric space with all distinct points at distance at least one whose real Lipschitz-free space has the approximation property but fails every bounded approximation bound. The metric space is unbounded and not proper.\n\nThe earlier quantitative renorming result for real $\\ell_1$ is retained: for each integer $p\\ge1$, an equivalent complete norm has the $2B_p$-bounded approximation property but fails the $p$-bounded approximation property, where $B_p=300p^2+150p+5$.", "judge_qwen3_8_27b": {"score": 5, "reason": "{\"reason\": \"The first file's MainStatement asserts the claimed counterexample: a countable uniformly discrete metric space (with the stronger extra properties of being unbounded and non-proper) whose real Lipschitz-free space FreeSpace o has HasAP and fails HasBAP for every bound Λ≥1. The definitions of Lip0, FreeSpace, HasAP, and HasBAP match the standard real Lipschitz-free space and compact approximation/bounded approximation properties. The additional BlockStatement and the separate ℓ¹ renorming theorem are extra, but the main claim is faithfully expressed, indeed in a stronger normalized form.\", \"score\": 5}"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures the main claim. The HasAP and HasBAP definitions match the standard mathematical definitions of the approximation property and bounded approximation property. The FreeSpace construction (as the closed span of evaluation functionals) is the standard Lipschitz-free space. The MainStatement correctly asserts the existence of a countable uniformly discrete metric space whose free space has AP but fails BAP for every Λ ≥ 1. The additional hypotheses (¬ ProperSpace M, ¬ Bornology.IsBounded) are natural constraints for the specific construction and do not contradict the claim. The BlockStatement provides a quantitative technical tool consistent with the paper's approach.\", \"score\": 5}"}}
{"family": "343", "title": "Symplectic ball packing in higher dimensions", "claim": "Symplectic ball packing in higher dimensions. Resolves the Siegel–Yao conjecture for arbitrary capacities in every dimension $`2n\\ge6`$. Finitely many closed symplectic balls of capacities $`R_1,\\ldots,R_k`$ embed disjointly into an open ball of capacity R exactly when $`\\sum_iR_i^n\\lt R^n`$ and $`R_i+R_j\\lt R`$ for every distinct pair i, j.", "abstracts": ["We prove that, for all integers \\(n\\ge3\\) and \\(k\\ge1\\) and all positive real capacities \\(R_1,\\ldots,R_k\\), the closed standard symplectic \\(2n\\)-balls of these capacities embed disjointly into the interior of a ball of capacity \\(R>0\\) if and only if \\[ \\sum_{i=1}^k R_i^n f x) ∧\n ∀ x ∈ U, ∀ u v : Phase n,\n standardForm (fderiv ℝ f x u) (fderiv ℝ f x v) = standardForm u v\n\ndef HasPacking (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=\n ∃ (U : Fin k → Set (Phase n)) (f : Fin k → Phase n → Phase n),\n (∀ i, closedBall n (r i) ⊆ U i ∧ SymplecticOn (U i) (f i) ∧\n Set.MapsTo (f i) (closedBall n (r i)) (openBall n R)) ∧\n (∀ i j, i ≠ j →\n Disjoint (f i '' closedBall n (r i)) (f j '' closedBall n (r j)))\n\ndef PackingInequalities (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=\n (∑ i, r i ^ n) < R ^ n ∧ ∀ i j, i ≠ j → r i + r j < R\n\ntheorem main_theorem (n k : ℕ) (hn : 3 ≤ n) (hk : 1 ≤ k)\n (R : ℝ) (r : Fin k → ℝ) (hR : 0 < R) (hr : ∀ i, 0 < r i) :\n HasPacking n k R r ↔ PackingInequalities n k R r := by\n sorry\n\nend HigherDimensionalBallPacking\n\nend OAI\n", "-- ComparatorChallenges/BallPackingNecessity.lean\nimport Mathlib\n\nnamespace OAI\n\nnamespace HigherDimensionalBallPacking\nopen scoped ContDiff\n\nabbrev Phase (n : ℕ) := Fin n → ℂ\n\nnoncomputable def capacity {n : ℕ} (z : Phase n) : ℝ :=\n Real.pi * ∑ j, Complex.normSq (z j)\n\ndef closedBall (n : ℕ) (r : ℝ) : Set (Phase n) := {z | capacity z ≤ r}\n\ndef openBall (n : ℕ) (r : ℝ) : Set (Phase n) := {z | capacity z < r}\n\nnoncomputable def standardForm {n : ℕ} (u v : Phase n) : ℝ :=\n ∑ j, ((u j).re * (v j).im - (u j).im * (v j).re)\n\n \ndef SymplecticOn {n : ℕ} (U : Set (Phase n)) (f : Phase n → Phase n) : Prop :=\n IsOpen U ∧ ContDiffOn ℝ ∞ f U ∧\n Topology.IsEmbedding (fun x : U => f x) ∧\n ∀ x ∈ U, ∀ u v : Phase n,\n standardForm (fderiv ℝ f x u) (fderiv ℝ f x v) = standardForm u v\n\n \ndef HasPacking (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=\n ∃ (U : Fin k → Set (Phase n)) (f : Fin k → Phase n → Phase n),\n (∀ i, closedBall n (r i) ⊆ U i ∧ SymplecticOn (U i) (f i) ∧\n Set.MapsTo (f i) (closedBall n (r i)) (openBall n R)) ∧\n (∀ i j, i ≠ j →\n Disjoint (f i '' closedBall n (r i)) (f j '' closedBall n (r j)))\n\ndef PackingInequalities (n k : ℕ) (R : ℝ) (r : Fin k → ℝ) : Prop :=\n (∑ i, r i ^ n) < R ^ n ∧ ∀ i j, i ≠ j → r i + r j < R\n\ntheorem packing_necessity (n k : ℕ) (hn : 3 ≤ n) (hk : 1 ≤ k)\n (R : ℝ) (r : Fin k → ℝ) (hR : 0 < R) (hr : ∀ i, 0 < r i)\n (hp : HasPacking n k R r) : PackingInequalities n k R r := by\n sorry\n\nend HigherDimensionalBallPacking\n\nend OAI\n"], "formalization_scope": "The formalization proves Siegel and Yao's ball-packing criterion in every symplectic dimension $2n$ with $n\\ge3$. For $k\\ge1$ closed standard balls of positive capacities $R_1,\\ldots,R_k$, disjoint symplectic embeddings into the interior of a ball of capacity $R$ exist exactly when\n$\\sum_i R_i^n0, and positive r_i, and states the equivalence with ∑ r_i^n 0, r_i > 0).\", \"score\": 5}"}}
{"family": "362", "title": "Global smoothness for relativistic Vlasov–Maxwell", "claim": "Global smoothness for relativistic Vlasov–Maxwell. Proves large-data global existence and uniqueness for the three-dimensional, one-species relativistic Vlasov–Maxwell system. Smooth admissible initial data may be arbitrary provided the particle density is compactly supported and the electromagnetic fields have finite energy and bounded derivatives of every order; the solution remains smooth on every finite time interval.", "abstracts": ["We prove global existence and uniqueness for arbitrary smooth admissible initial data in the three-dimensional, one-species relativistic Vlasov--Maxwell system. The particle density is initially compactly supported, and the electromagnetic fields have finite energy and bounded derivatives of all orders. The solution remains smooth on every finite time interval. This resolves the large-data global classical regularity problem for this model, without size or symmetry restrictions on the data."], "papers": ["https://github.com/openai/math/tree/main/preprints/Global-classical-solutions-of-the-three-dimensional-relativistic-Vlasov-Maxwell-system-September-23-2026"], "lean_files": ["https://github.com/openai/math/blob/main/lean/ComparatorChallenges/VlasovMaxwell.lean"], "lean_statements": ["-- ComparatorChallenges/VlasovMaxwell.lean\nimport Mathlib\n\nnamespace OAI\n\nnoncomputable section\nopen MeasureTheory Set\nopen scoped ContDiff\nnamespace RVM\n\nabbrev Vec := EuclideanSpace ℝ (Fin 3)\nabbrev Phase := Vec × Vec\nabbrev Particle := ℝ × Phase → ℝ\nabbrev Field := ℝ × Vec → Vec\n\ndef q (v : Vec) : ℝ := Real.sqrt (1 + ‖v‖ ^ 2)\ndef velocity (v : Vec) : Vec := (q v)⁻¹ • v\n\ndef basis (i : Fin 3) : Vec := WithLp.toLp 2 (Pi.single i (1 : ℝ))\ndef dot (a b : Vec) : ℝ := ∑ i : Fin 3, a i * b i\ndef cross (a b : Vec) : Vec := WithLp.toLp 2\n ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2,\n a 0 * b 1 - a 1 * b 0]\n\ndef spatialPartial (g : Vec → ℝ) (x : Vec) (i : Fin 3) : ℝ :=\n fderiv ℝ g x (basis i)\ndef divergence (F : Vec → Vec) (x : Vec) : ℝ :=\n ∑ i : Fin 3, spatialPartial (fun y => F y i) x i\n\ndef curl (F : Vec → Vec) (x : Vec) : Vec := WithLp.toLp 2\n ![spatialPartial (fun y => F y 2) x 1 - spatialPartial (fun y => F y 1) x 2,\n spatialPartial (fun y => F y 0) x 2 - spatialPartial (fun y => F y 2) x 0,\n spatialPartial (fun y => F y 1) x 0 - spatialPartial (fun y => F y 0) x 1]\n\ndef rho (g : Phase → ℝ) (x : Vec) : ℝ := ∫ v : Vec, g (x, v)\ndef current (g : Phase → ℝ) (x : Vec) : Vec :=\n ∫ v : Vec, g (x, v) • velocity v\n\nstructure Datum where\n f₀ : Phase → ℝ\n E₀ : Vec → Vec\n B₀ : Vec → Vec\n\ndef BoundedSmooth (F : Vec → Vec) : Prop :=\n ContDiff ℝ ∞ F ∧ ∀ n : ℕ, ∃ C : ℝ, ∀ x : Vec,\n ‖iteratedFDeriv ℝ n F x‖ ≤ C\n\ndef Admissible (d : Datum) : Prop :=\n ContDiff ℝ ∞ d.f₀ ∧ HasCompactSupport d.f₀ ∧ (∀ z, 0 ≤ d.f₀ z) ∧\n BoundedSmooth d.E₀ ∧ BoundedSmooth d.B₀ ∧\n MemLp d.E₀ 2 volume ∧ MemLp d.B₀ 2 volume ∧\n (∀ x, divergence d.E₀ x = rho d.f₀ x) ∧\n (∀ x, divergence d.B₀ x = 0)\n\nstructure Solution where\n f : Particle\n E : Field\n B : Field\n\ndef particleHalfSpace : Set (ℝ × Phase) := {z | 0 ≤ z.1}\ndef fieldHalfSpace : Set (ℝ × Vec) := {z | 0 ≤ z.1}\ndef particleSlab (T : ℝ) : Set (ℝ × Phase) := {z | z.1 ∈ Icc 0 T}\ndef fieldSlab (T : ℝ) : Set (ℝ × Vec) := {z | z.1 ∈ Icc 0 T}\n\ndef TimeContinuousL2 (F : Field) : Prop :=\n ∃ F₂ : ℝ → Lp Vec 2 (volume : Measure Vec),\n ContinuousOn F₂ (Ici 0) ∧\n ∀ t, 0 ≤ t → (F₂ t : Vec → Vec) =ᵐ[volume] (fun x => F (t, x))\n\ndef Equations (s : Solution) : Prop := ∀ t, 0 ≤ t →\n (∀ x v,\n derivWithin (fun t' => s.f (t', x, v)) (Ici 0) t +\n (∑ i : Fin 3, velocity v i * spatialPartial (fun y => s.f (t, y, v)) x i) +\n (∑ i : Fin 3, (s.E (t, x) + cross (velocity v) (s.B (t, x))) i *\n spatialPartial (fun v' => s.f (t, x, v')) v i) = 0) ∧\n (∀ x, derivWithin (fun t' => s.E (t', x)) (Ici 0) t -\n curl (fun y => s.B (t, y)) x = -current (fun z => s.f (t, z)) x) ∧\n (∀ x, derivWithin (fun t' => s.B (t', x)) (Ici 0) t +\n curl (fun y => s.E (t, y)) x = 0) ∧\n (∀ x, divergence (fun y => s.E (t, y)) x = rho (fun z => s.f (t, z)) x) ∧\n (∀ x, divergence (fun y => s.B (t, y)) x = 0)\n\ndef CompactOnFiniteHorizons (s : Solution) : Prop :=\n ∀ T : ℝ, 0 ≤ T → ∃ K : Set Phase, IsCompact K ∧\n ∀ t ∈ Icc 0 T, tsupport (fun z => s.f (t, z)) ⊆ K\n\ndef Classical (d : Datum) (s : Solution) : Prop :=\n ContDiffOn ℝ 1 s.f particleHalfSpace ∧\n ContDiffOn ℝ 1 s.E fieldHalfSpace ∧ ContDiffOn ℝ 1 s.B fieldHalfSpace ∧\n (∀ t, 0 ≤ t → ∀ z, 0 ≤ s.f (t, z)) ∧\n TimeContinuousL2 s.E ∧ TimeContinuousL2 s.B ∧\n CompactOnFiniteHorizons s ∧ Equations s ∧\n (∀ z, s.f (0, z) = d.f₀ z) ∧\n (∀ x, s.E (0, x) = d.E₀ x) ∧ (∀ x, s.B (0, x) = d.B₀ x)\n\ndef SmoothOnFiniteHorizons (s : Solution) : Prop := ∀ T : ℝ, 0 ≤ T →\n ContDiffOn ℝ ∞ s.f (particleSlab T) ∧\n ContDiffOn ℝ ∞ s.E (fieldSlab T) ∧ ContDiffOn ℝ ∞ s.B (fieldSlab T)\n\ndef SameNonnegativeTime (s s' : Solution) : Prop := ∀ t, 0 ≤ t →\n (∀ z, s.f (t, z) = s'.f (t, z)) ∧\n (∀ x, s.E (t, x) = s'.E (t, x)) ∧ (∀ x, s.B (t, x) = s'.B (t, x))\n\ntheorem global_classical_solution (d : Datum) (hd : Admissible d) :\n ∃ s : Solution, Classical d s ∧ SmoothOnFiniteHorizons s ∧\n ∀ s' : Solution, Classical d s' → SameNonnegativeTime s s' := by\n sorry\n\nend RVM\n\nend\n\nend OAI\n"], "formalization_scope": "The formalized result gives global existence and uniqueness for the three-dimensional one-species relativistic Vlasov–Maxwell system. The initial particle density is nonnegative, smooth, and compactly supported; the initial fields have bounded derivatives of all orders, finite energy, and satisfy both Gauss constraints. The solution is smooth on every finite time interval, has compact particle phase support there, and is unique among classical solutions. No smallness, symmetry, or neutrality assumption is imposed.", "judge_qwen3_8_27b": {"score": 5, "reason": "ns:\n5 = the same claim as the paper's main claim (or stronger)\n4 = essentially the same claim, with only minor technical differences in how it is stated\n3 = a substantial special case or a clearly weaker version of the claim\n2 = only loosely related to the claim, or much weaker\n1 = does not express the claim (unrelated, vacuous, or trivially true)\n\nThe Lean statement is not just \"essentially same with minor technical differences\"; it is stronger. So 5. The minor technical differences are not in how it is stated but additional properties. But 5 allows stronger. So 5.\n\nHowever, if the Lp definitions are ill-typed, it's not a valid stronger claim. But we can assume intended. The reason can say \"modulo routine Lean encoding\". The score 5 still.\n\nLet's consider if the theorem's `Admissible` requires `BoundedSmooth` for E0/B0, which is stronger than \"bounded derivatives of every order\"? It is exactly. It also requires `ContDiff ℝ ∞`, which follows from bounded derivatives? Bounded derivatives of every order usually implies smooth. Good.\n\nThe theorem's `Admissible` requires `MemLp` for E0/B0. The claim says finite energy. Good.\n\nThe theorem's `Admissible` requires `divergence E0 = rho f0`, `divergence B0=0`. The claim says admissible initial data, likely includes constraints. If the main claim didn't explicitly mention constraints, adding them is an extra hypothesis. But for Vlasov-Maxwell, admissible data must satisfy constraints; otherwise the PDE cannot hold at t=0. The theorem's"}, "judge_neohorse_code": {"score": 5, "reason": "{\"reason\": \"The Lean formalization faithfully captures the main claim. The `Admissible` predicate correctly encodes the initial data conditions: smooth particle density with compact support, electromagnetic fields with finite energy (L²) and bounded derivatives of all orders (via `BoundedSmooth`). The `Solution` structure and `Classical` predicate define a classical solution satisfying the Vlasov-Maxwell equations with proper initial conditions. Crucially, `SmoothOnFiniteHorizons` asserts that for every finite time T ≥ 0, the solution is C^∞ on the corresponding space-time slab, which precisely matches the claim that 'the solution remains smooth on every finite time interval.' The uniqueness quantifier is also correctly stated. There are no extra hypotheses or missing conditions that would make the statement significantly weaker or vacuous.\", \"score\": 5}"}}