Datasets:

FineEnvs
/

openai-math

Context: this statement belongs to family 238 of the release, Optimal logarithmic mixing of the Thorp shuffle (Probability and statistical mechanics). The family as a whole: Proves that the Thorp shuffle randomizes $N=2^d$ labeled cards in $\Theta(\log N)$ physical shuffles, settling its optimal mixing order for power-of-two deck sizes. Convergence is in total variation from the worst initial ordering and concerns the entire permutation, not just individual card positions.

The challenge is BinarySweep, also at /opt/openai-math/challenges/BinarySweep.lean:

import Mathlib

namespace OAI

noncomputable section
open scoped BigOperators
namespace BinaryCoordinateSweeps

/-- The positions of a binary deck of dimension d. -/
abbrev Slot (d : ℕ) := Fin d → Bool

/-- Independent switches on the edges parallel to one coordinate. -/
def coordinateLayer (d : ℕ) (j : Fin d)
    (c : (({i : Fin d // i ≠ j} → Bool)) → Bool) : Equiv.Perm (Slot d) :=
  let e := Equiv.piSplitAt j (fun _ : Fin d => Bool)
  let sw : Equiv.Perm (Bool × ({i : Fin d // i ≠ j} → Bool)) :=
    { toFun := fun x => (x.1 ^^ c x.2, x.2)
      invFun := fun x => (x.1 ^^ c x.2, x.2)
      left_inv := fun x => by simp
      right_inv := fun x => by simp }
  e.trans (sw.trans e.symm)

abbrev SweepCoins (d : ℕ) :=
  (j : Fin d) → ({i : Fin d // i ≠ j} → Bool) → Bool

/-- The coordinate layers are applied in increasing coordinate order. -/
def binarySweep (d : ℕ) (c : SweepCoins d) : Equiv.Perm (Slot d) :=
  (List.ofFn (fun j => coordinateLayer d j (c j))).reverse.prod

def finiteLaw {Ω G : Type*} [Fintype Ω] [Fintype G] (f : Ω → G) (g : G) : ℝ := by
  classical
  exact ∑ ω, if f ω = g then (Fintype.card Ω : ℝ)⁻¹ else 0

/-- Half the unnormalized sum of absolute probability-mass differences. -/
def totalVariation {G : Type*} [Fintype G] (p q : G → ℝ) : ℝ :=
  (1 / ((2 : ℕ) : ℝ)) * ∑ g, |p g - q g|

def uniformLaw (G : Type*) [Fintype G] : G → ℝ :=
  fun _ => (Fintype.card G : ℝ)⁻¹

def binaryLaw (d : ℕ) : Equiv.Perm (Slot d) → ℝ :=
  finiteLaw (binarySweep d)

abbrev RepSpace (D : ℕ) := EuclideanSpace ℂ (Fin D)

def IsUnitaryRep {G : Type*} [Monoid G]
    {D : ℕ} (ρ : Representation ℂ G (RepSpace D)) : Prop :=
  ∀ g x, ‖ρ g x‖ = ‖x‖

def averageOperator {G : Type*} [Fintype G] [Monoid G] {D : ℕ}
    (p : G → ℝ) (ρ : Representation ℂ G (RepSpace D)) :
    RepSpace D →L[ℂ] RepSpace D :=
  LinearMap.toContinuousLinearMap (∑ g, (p g : ℂ) • ρ g)

def BinaryContractionTarget : Prop :=
  ∃ g : ℝ, 0 < g ∧ ∃ d₀ : ℕ, ∀ d ≥ d₀, ∀ D : ℕ,
    ∀ ρ : Representation ℂ (Equiv.Perm (Slot d)) (RepSpace D),
      ρ.IsIrreducible → IsUnitaryRep ρ →
      ‖averageOperator (binaryLaw d) ρ‖ ≤ (D : ℝ) ^ (-g)

def realSign {α : Type*} [Fintype α] [DecidableEq α] : Equiv.Perm α →* ℝ :=
  (Int.castRingHom ℝ).toMonoidHom.comp ((Units.coeHom ℤ).comp Equiv.Perm.sign)

section FiniteLaws
variable {G : Type*} [Fintype G] [Group G]

def convolution (p q : G → ℝ) (g : G) : ℝ := ∑ x, p x * q (x⁻¹ * g)

def pointMassOne (g : G) : ℝ := by
  classical
  exact if g = 1 then 1 else 0

/-- The law of independent repetitions, with the empty product at the identity. -/
def convolutionPower (p : G → ℝ) : ℕ → G → ℝ
  | 0 => pointMassOne
  | n + 1 => convolution p (convolutionPower p n)

end FiniteLaws

def sweepLaw (d t : ℕ) : Equiv.Perm (Slot d) → ℝ :=
  convolutionPower (binaryLaw d) t

/-- A single number of sweeps works uniformly over deterministic initial decks. -/
def UniformSweepMixingTarget : Prop :=
  ∃ w : ℕ, ∀ ε : ℝ, 0 < ε → ∃ d₀ : ℕ, ∀ d ≥ d₀,
    ∀ τ : Equiv.Perm (Slot d),
      totalVariation (fun g => sweepLaw d w (g * τ⁻¹))
        (uniformLaw (Equiv.Perm (Slot d))) ≤ ε

end BinaryCoordinateSweeps
end

open scoped BigOperators

theorem binary_sweep_contraction_and_mixing :
    BinaryCoordinateSweeps.BinaryContractionTarget ∧
    (∀ d : ℕ, 0 < d → ∑ g : Equiv.Perm (BinaryCoordinateSweeps.Slot d),
      BinaryCoordinateSweeps.binaryLaw d g * BinaryCoordinateSweeps.realSign g = 0) ∧
    BinaryCoordinateSweeps.UniformSweepMixingTarget := by
  sorry

end OAI

What to submit

Write /workspace/Submission.lean. Start from a copy of the challenge:

cp /opt/openai-math/challenges/BinarySweep.lean /workspace/Submission.lean

then replace every sorry with a proof. The file is graded on three things:

Same statements. The theorem OAI.binary_sweep_contraction_and_mixing must keep exactly the statement shown above: same names, namespaces, binders and types. Every definition the statements use must stay exactly as written. Change nothing except the proofs.
Standard axioms only. Proofs may use only propext, Quot.sound and Classical.choice. sorry, admit, new axioms and native_decide (it introduces an axiom of its own) are rejected.
Keep the challenge's declarations as they are. Put new lemmas and instances after the definitions the statements use, or in a separate Submission/*.lean module. A declaration added before them can change how they elaborate, and then they no longer match the challenge.
Kernel-checked. The proofs are re-checked by the Lean kernel, not just the elaborator.

Long proofs can be split into modules under /workspace/Submission/ (module names Submission.Foo, Submission.Foo.Bar) imported from Submission.lean. Only .lean files at those two paths are graded.

Environment

Lean v4.34.1 and Mathlib at commit d13f23b are installed and prebuilt; /workspace is a Lake project.
The sandbox has 4 CPUs and 8 GB of memory; LEAN_NUM_THREADS=3 keeps lake build to three parallel jobs. Check your work with cd /workspace && lake build Submission. Add #print axioms <name> to see which axioms a proof uses.
There is no internet access. OpenAI's own proofs are not installed.

Grading

When you finish, Submission.lean and Submission/**.lean are copied to a fresh machine and checked with Comparator, the Lean FRO's proof checker. The reward is 1 if Comparator accepts the proof and 0 otherwise. A partial proof scores 0.

openai/math challenge BinarySweep (family 238)

What to submit

Environment

Grading

openai/math challenge `BinarySweep` (family 238)