Add lean source and binary files (part 126)

lean/OAI/Probability/MatroidSecretary/Secretary/SourcePrefixLaw.lean

@@ -0,0 +1,108 @@
+import OAI.Probability.MatroidSecretary.Secretary.PrefixObservationModel
+import OAI.Probability.MatroidSecretary.Secretary.SourceMask
+import OAI.Probability.MatroidSecretary.Secretary.Prefix
+import OAI.Probability.MatroidSecretary.Secretary.BinomialMixture
+import Mathlib.MeasureTheory.Integral.Prod
+
+namespace OAI
+
+/-!
+# The concrete source observation law after a uniform random prefix
+
+The initially sampled source seed determines the branch and prefix length.
+An independent uniform permutation supplies the actual observed prefix.
+Averaging the length, rather than conditioning on the complete initial seed,
+recovers the full joint law of the branch and sacrificed source mask.
+
+This is the actual source-law input to conditional-table reconstruction in
+`sections/secretary.tex`, equations `eq:secretary-prefix-mask` and its following
+kernel argument (SHA256
+`3554fe0f7296782edf63cc7f1305c377e7a7b9d8f8948b9510ea4ad02a702d63`).
+It does not assume a caller-given source transport law.
+-/
+
+namespace MatroidProphet.Secretary
+
+open MeasureTheory Finset
+
+/-- A predrawn Bernoulli mask supplies only the length; the independent random
+prefix has the original product-mask law after averaging that length. -/
+theorem predrawn_mask_prefix_integral {n : ℕ} (p : ℝ)
+    (f : Finset (Fin n) → ℝ) :
+    bitsExpectation (fun _ : Fin n => p) univ (fun B =>
+      ∫ σ : ArrivalOrder n,
+        f (univ.filter fun e : Fin n => (σ.symm e).val < B.card)
+        ∂(PMF.uniformOfFintype (ArrivalOrder n)).toMeasure) =
+      bitsExpectation (fun _ : Fin n => p) univ f := by
+  have hB (B : Finset (Fin n)) :
+      (∫ σ : ArrivalOrder n,
+        f (univ.filter fun e : Fin n => (σ.symm e).val < B.card)
+        ∂(PMF.uniformOfFintype (ArrivalOrder n)).toMeasure) =
+      (∑ S ∈ (univ : Finset (Fin n)).powersetCard B.card, f S) /
+        Nat.choose n B.card :=
+    integral_uniform_prefix (by simpa using Finset.card_le_univ B) f
+  simp_rw [hB]
+  simpa only [Finset.card_univ, Fintype.card_fin, div_eq_mul_inv, mul_comm] using
+    SecretaryBinomialMixture.predrawn_card_uniform_subset p (univ : Finset (Fin n)) f
+
+/-- Exact test-function identity for the manuscript's concrete full source seed.
+The branch, prefix length and every unused source coin are sampled before the
+independent uniform permutation. -/
+theorem integral_source_random_prefix {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (f : Bool → Finset (Fin n) → ℝ) :
+    (∫ r, ∫ σ : ArrivalOrder n,
+      f (mainBranch r)
+        (univ.filter fun e : Fin n =>
+          (σ.symm e).val < ((completeHiddenRule M hE).mask r).card)
+      ∂(PMF.uniformOfFintype (ArrivalOrder n)).toMeasure ∂sourceSeedLaw n) =
+      ∫ r, f (mainBranch r) ((completeHiddenRule M hE).mask r) ∂sourceSeedLaw n := by
+  rw [integral_source_branch_mask M hE (fun j B =>
+    ∫ σ : ArrivalOrder n,
+      f j (univ.filter fun e : Fin n => (σ.symm e).val < B.card)
+      ∂(PMF.uniformOfFintype (ArrivalOrder n)).toMeasure)]
+  rw [integral_source_branch_mask M hE f]
+  simp_rw [predrawn_mask_prefix_integral]
+
+/-- The full branch/prefix pushforward equals the branch/sacrificed-mask law of
+our concrete source algorithm. This is the exact input used by the finite
+conditional-table reconstruction, including empty and full prefixes. -/
+theorem source_random_prefix_joint_law {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) :
+    ((sourceSeedLaw n).prod
+      (PMF.uniformOfFintype (ArrivalOrder n)).toMeasure).map
+      (fun z : Seed (mainSeedBits n) × ArrivalOrder n =>
+        (mainBranch z.1, orderPrefix z.2 ((completeHiddenRule M hE).mask z.1).card)) =
+      (sourceSeedLaw n).map
+        (fun r => (mainBranch r, (completeHiddenRule M hE).mask r)) := by
+  classical
+  let index : Seed (mainSeedBits n) × ArrivalOrder n → Bool × Finset (Fin n) :=
+    fun z => (mainBranch z.1, orderPrefix z.2 ((completeHiddenRule M hE).mask z.1).card)
+  let obs : Seed (mainSeedBits n) → Bool × Finset (Fin n) :=
+    fun r => (mainBranch r, (completeHiddenRule M hE).mask r)
+  let μ := (sourceSeedLaw n).prod (PMF.uniformOfFintype (ArrivalOrder n)).toMeasure
+  have htest (f : Bool × Finset (Fin n) → ℝ) :
+      (∫ z, f (index z) ∂μ) = ∫ r, f (obs r) ∂sourceSeedLaw n := by
+    rw [integral_prod _ Integrable.of_finite]
+    simpa only [index, obs, orderPrefix] using
+      integral_source_random_prefix M hE (fun j P => f (j, P))
+  change μ.map index = (sourceSeedLaw n).map obs
+  apply Measure.ext_of_singleton
+  intro b
+  have hreal : (μ.map index).real {b} = ((sourceSeedLaw n).map obs).real {b} := by
+    rw [← integral_indicator_one (measurableSet_singleton b),
+      ← integral_indicator_one (measurableSet_singleton b)]
+    rw [integral_map_of_stronglyMeasurable (measurable_of_countable index)
+      (measurable_of_countable _).stronglyMeasurable,
+      integral_map_of_stronglyMeasurable (measurable_of_countable obs)
+      (measurable_of_countable _).stronglyMeasurable]
+    exact htest _
+  calc
+    μ.map index {b} = ENNReal.ofReal ((μ.map index).real {b}) :=
+      (ofReal_measureReal).symm
+    _ = ENNReal.ofReal (((sourceSeedLaw n).map obs).real {b}) :=
+      congrArg ENNReal.ofReal hreal
+    _ = (sourceSeedLaw n).map obs {b} := ofReal_measureReal
+
+end MatroidProphet.Secretary
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Secretary/Specification.lean

@@ -0,0 +1,18 @@
+import OAI.Probability.MatroidSecretary.Secretary.ProbabilityModel
+import Mathlib.Probability.Independence.Basic
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+/-!
+# Independent specification of the full-seed secretary endpoint
+
+The rule and its finite initial seed law are chosen before the fixed vector
+of weights and before the probability space or adversary.  The initial
+uniform order is independent of the complete seed.  Only its ordered prefix
+is preserved in the actual execution; the suffix may depend on all available
+information, and even on additional randomization carried by the ambient
+space.  No independence assumption is made on the executed order.
+
+Finite seed types suffice for the manuscript construction: all conditional
+reconstruction tables can be sampled in advance.  `Fin q` is just an
+enumeration of this finite seed space, with its arbitrary probability law.
+-/

lean/OAI/Probability/MatroidSecretary/Secretary/TableLaw.lean

@@ -0,0 +1,60 @@
+import Mathlib.MeasureTheory.Integral.Pi
+import Mathlib.MeasureTheory.Integral.Prod
+import Mathlib.MeasureTheory.Integral.Bochner.SumMeasure
+
+namespace OAI
+
+/-!
+# Precommitted finite conditional-randomness tables
+
+The secretary construction draws all conditional random choices before the
+random arrival permutation.  A table indexed by every possible branch/prefix
+pair does this without concealing later randomness.  Its law is the ordinary
+finite product measure `Measure.pi κ`.  Evaluating the table after an independent
+prefix experiment has exactly the corresponding conditional law.
+
+These lemmas concern only this sampling construction, not the source theorem's
+competitive guarantee.  In particular an application must separately prove the
+prefix law and the concrete source conditional-kernel laws.
+-/
+
+namespace MatroidProphet.Secretary
+
+open MeasureTheory
+open scoped BigOperators
+
+variable {ι α Ω : Type*} [Fintype ι] [Fintype α] [Fintype Ω]
+  [MeasurableSpace α] [MeasurableSingletonClass α]
+  [MeasurableSpace Ω] [MeasurableSingletonClass Ω]
+
+/-- All conditional samples can be drawn initially and independently. Evaluating
+one coordinate after an independent finite experiment has the prescribed law. -/
+theorem integral_precommittedTable
+    (κ : ι → Measure α) [∀ i, IsProbabilityMeasure (κ i)]
+    (μ : Measure Ω) [IsFiniteMeasure μ] (index : Ω → ι) (f : ι → α → ℝ) :
+    (∫ z : Ω × (ι → α), f (index z.1) (z.2 (index z.1))
+      ∂μ.prod (Measure.pi κ)) =
+      ∫ ω, ∫ r, f (index ω) r ∂κ (index ω) ∂μ := by
+  rw [integral_prod _ Integrable.of_finite]
+  apply integral_congr_ae
+  exact ae_of_all _ fun ω => by
+    exact integral_comp_eval (μ := κ) (i := index ω)
+      (f := f (index ω))
+      (measurable_of_countable (f (index ω))).aestronglyMeasurable
+
+/-- The same identity with the independent experiment explicitly summed. It
+retains the complete table, including all coordinates unused in this run. -/
+theorem integral_precommittedTable_eq_sum
+    (κ : ι → Measure α) [∀ i, IsProbabilityMeasure (κ i)]
+    (μ : Measure Ω) [IsFiniteMeasure μ] (index : Ω → ι) (f : ι → α → ℝ) :
+    (∫ z : Ω × (ι → α), f (index z.1) (z.2 (index z.1))
+      ∂μ.prod (Measure.pi κ)) =
+      ∑ ω, μ.real {ω} * (∫ r, f (index ω) r ∂κ (index ω)) := by
+  rw [integral_precommittedTable]
+  simpa only [smul_eq_mul, measureReal_def] using
+    (integral_fintype (μ := μ)
+      (f := fun ω => ∫ r, f (index ω) r ∂κ (index ω)) Integrable.of_finite)
+
+end MatroidProphet.Secretary
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Secretary/TripleKernel.lean

@@ -0,0 +1,127 @@
+import OAI.Probability.MatroidProphet.Main
+import OAI.Probability.MatroidSecretary.Secretary.TripleKernelModel
+import Mathlib.Algebra.BigOperators.Finprod
+import Mathlib.Probability.ProbabilityMassFunction.Constructions
+import Mathlib.Tactic
+
+namespace OAI
+
+/-! Explicit normalized one-label reconstruction kernel from secretary.tex,
+lines 64--81. These are finite identities, including the zero-mask case. -/
+
+namespace MatroidProphet.Secretary
+
+open Finset
+
+lemma tripleWeight_sum (t : ℝ) : (∑ x : MaskTriple, tripleWeight t x) = 1 := by
+  simp [MaskTriple, Fintype.sum_prod_type, tripleWeight]
+  ring
+
+lemma tripleWeight_nonneg {t : ℝ} (ht0 : 0 ≤ t) (ht1 : t ≤ 1)
+    (x : MaskTriple) : 0 ≤ tripleWeight t x := by
+  rcases x with ⟨h,d,c⟩
+  cases d <;> cases c <;> norm_num [tripleWeight] <;> linarith
+
+lemma tripleWeight_zero (t : ℝ) :
+    tripleWeight t (false, false, false) = 3 / 8 * (1-t) := by
+  norm_num [tripleWeight]
+
+lemma mainRevealRate_eq_source :
+    mainRevealRate = (5 : ℝ) / 8 + 3 * ((2 : ℝ)^143)⁻¹ := by
+  norm_num [mainRevealRate, thinningRate]
+
+lemma mainRevealRate_pos : 0 < mainRevealRate := by
+  norm_num [mainRevealRate, thinningRate]
+
+lemma mainRevealRate_lt_one : mainRevealRate < 1 := by
+  norm_num [mainRevealRate, thinningRate]
+
+lemma mainRevealRate_complement :
+    1 - mainRevealRate = tripleWeight thinningRate (false, false, false) := by
+  simp [mainRevealRate, tripleWeight]
+  ring
+
+lemma tripleRevealed_eq_false (x : MaskTriple) :
+    tripleRevealed x = false ↔ x = (false, false, false) := by
+  rcases x with ⟨h,d,c⟩
+  cases h <;> cases d <;> cases c <;> decide
+
+lemma conditionalTripleWeight_nonneg (b : Bool) (x : MaskTriple) :
+    0 ≤ conditionalTripleWeight b x := by
+  have ht0 : 0 ≤ thinningRate := constants_positive.2.2.1.le
+  have ht1 : thinningRate ≤ 1 := by norm_num [thinningRate]
+  unfold conditionalTripleWeight
+  split_ifs
+  · exact div_nonneg (tripleWeight_nonneg ht0 ht1 x) mainRevealRate_pos.le
+  · norm_num
+  · norm_num
+  · norm_num
+
+lemma conditionalTripleWeight_sum (b : Bool) :
+    (∑ x : MaskTriple, conditionalTripleWeight b x) = 1 := by
+  cases b
+  · simp [conditionalTripleWeight]
+  · simp [MaskTriple, Fintype.sum_prod_type,
+      conditionalTripleWeight, tripleRevealed, tripleWeight]
+    field_simp [ne_of_gt mainRevealRate_pos]
+    simp [mainRevealRate]
+    ring
+
+lemma conditionalTripleWeight_support (b : Bool) (x : MaskTriple)
+    (h : tripleRevealed x ≠ b) : conditionalTripleWeight b x = 0 := by
+  rcases x with ⟨x,y,z⟩
+  cases b <;> cases x <;> cases y <;> cases z <;>
+    simp_all [conditionalTripleWeight, tripleRevealed]
+
+/-- Multiplying the explicit conditional kernel by the observed-bit law
+recovers the original joint law, not just a marginal event probability. -/
+lemma conditionalTripleWeight_joint (b : Bool) (x : MaskTriple) :
+    revealBitWeight b * conditionalTripleWeight b x =
+      if tripleRevealed x = b then tripleWeight thinningRate x else 0 := by
+  rcases x with ⟨x,y,z⟩
+  cases b <;> cases x <;> cases y <;> cases z <;>
+    simp [revealBitWeight, conditionalTripleWeight, tripleRevealed,
+      mainRevealRate_complement] <;>
+    field_simp [ne_of_gt mainRevealRate_pos]
+
+lemma conditionalTripleWeight_reconstruct (x : MaskTriple) :
+    (∑ b : Bool, revealBitWeight b * conditionalTripleWeight b x) =
+      tripleWeight thinningRate x := by
+  simp only [conditionalTripleWeight_joint, Fintype.sum_bool]
+  cases h : tripleRevealed x <;> simp
+
+lemma revealBitWeight_pos (b : Bool) : 0 < revealBitWeight b := by
+  cases b
+  · exact sub_pos.mpr mainRevealRate_lt_one
+  · exact mainRevealRate_pos
+
+lemma revealBitWeight_sum : (∑ b : Bool, revealBitWeight b) = 1 := by
+  simp [revealBitWeight]
+
+lemma tripleWeight_source_pos (x : MaskTriple) :
+    0 < tripleWeight thinningRate x := by
+  rcases x with ⟨h,d,c⟩
+  cases d <;> cases c <;> norm_num [tripleWeight, thinningRate]
+
+/-- Exactly seven triples are compatible with an observed label. -/
+lemma card_revealed_triples :
+    Fintype.card {x : MaskTriple // tripleRevealed x = true} = 7 := by decide
+
+lemma conditionalTripleWeight_pos_iff (b : Bool) (x : MaskTriple) :
+    0 < conditionalTripleWeight b x ↔ tripleRevealed x = b := by
+  constructor
+  · intro hx
+    by_contra h
+    rw [conditionalTripleWeight_support b x h] at hx
+    exact (lt_irrefl (0 : ℝ)) hx
+  · intro hx
+    have h := conditionalTripleWeight_joint b x
+    rw [ite_eq_left hx] at h
+    have hp : 0 < revealBitWeight b * conditionalTripleWeight b x := by
+      rw [h]
+      exact tripleWeight_source_pos x
+    exact (mul_pos_iff_of_pos_left (revealBitWeight_pos b)).mp hp
+
+end MatroidProphet.Secretary
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Secretary/TripleKernelModel.lean

@@ -0,0 +1,39 @@
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.Data.Fintype.Prod
+
+namespace OAI
+
+/-! Concrete one-label conditional kernel for the secretary reconstruction.
+The boolean records membership in the sacrificed observation mask, not branch choice.
+The three coordinates are the original H, D, C coins; the T coin is not sacrificed.
+-/
+
+namespace MatroidProphet.Secretary
+
+abbrev MaskTriple := Bool × Bool × Bool
+
+/-- Whether at least one of the three observation coins is set. -/
+def tripleRevealed (x : MaskTriple) : Bool := x.1 || x.2.1 || x.2.2
+
+/-- The independent H,D,C law at one label, retaining the thinning parameter. -/
+noncomputable def tripleWeight (t : ℝ) (x : MaskTriple) : ℝ :=
+  (1 / 2) * (if x.2.1 then 1 / 4 else 3 / 4) *
+    (if x.2.2 then t else 1 - t)
+
+/-- Probability that a label is sacrificed in the main branch. -/
+noncomputable def mainRevealRate : ℝ := 5 / 8 + 3 * thinningRate / 8
+
+/-- The source specifies all seven nonzero triple masses divided by the reveal rate.
+Outside the observation set the triple is deterministically zero. -/
+noncomputable def conditionalTripleWeight (revealed : Bool) (x : MaskTriple) : ℝ :=
+  if revealed then
+    if tripleRevealed x then tripleWeight thinningRate x / mainRevealRate else 0
+  else if x = (false, false, false) then 1 else 0
+
+/-- Probability of a prescribed observation-mask membership bit. -/
+noncomputable def revealBitWeight (revealed : Bool) : ℝ :=
+  if revealed then mainRevealRate else 1 - mainRevealRate
+
+end MatroidProphet.Secretary
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/AssignedSafe.lean

@@ -0,0 +1,137 @@
+import OAI.Probability.MatroidProphet.Main
+import OAI.Probability.MatroidSecretary.Selection.SafeSpecification
+
+namespace OAI
+
+namespace MatroidProphet
+
+open Finset
+variable {α : Type*} [Fintype α] [DecidableEq α]
+
+/-- The stronger half-loss estimate explicitly obtained in the source proof.
+The named lemma then enlarges the loss from `|D_h|/(2κ)` to `|D_h|/κ`. -/
+theorem safeSampleCount_half_loss
+    (M : Matroid α) (hE : M.E = Set.univ)
+    (κ : ℕ) (hκ : 0 < κ) (D : ℕ → Set α) (G : ℕ → Finset α)
+    (hG : Pairwise (fun i j => Disjoint (G i) (G j)))
+    (q : α → ℝ) (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1)
+    (h : ℕ) (I : Finset α) (hI : M.Indep (I : Set α)) :
+    (((2 : ℝ) ^ 12)⁻¹) / 4 * I.card - (D h).ncard / (2 * (κ : ℝ)) ≤
+      bitsExpectation q univ (fun C => bitsExpectation q univ (fun T =>
+        fairParityExpectation (safeSampleCount M hE κ D G h I C T))) := by
+  have hpre := safeCountBeforeParity_lower M hE κ hκ D G hG q hq0 hq1 h I hI
+  have heq : bitsExpectation q univ (fun C => bitsExpectation q univ (fun T =>
+      fairParityExpectation (safeSampleCount M hE κ D G h I C T))) =
+      bitsExpectation q univ (fun C =>
+        bitsExpectation q univ (safeCountBeforeParity M hE κ D G h I C)) / 2 := by
+    simp only [safeSampleCount_fair_parity, div_eq_mul_inv]
+    simp_rw [bitsExpectation_mul_right]
+  rw [heq]
+  have hloss : ((D h).ncard : ℝ) / (2 * (κ : ℝ)) =
+      ((D h).ncard : ℝ) / (κ : ℝ) / 2 := by ring
+  rw [hloss]
+  linarith
+
+end MatroidProphet
+
+namespace MatroidProphet.MainAlgorithm
+
+open Finset
+variable {n : ℕ}
+attribute [local instance] Classical.propDecidable
+
+/-- The fixed-density safety estimate with the exact density-sample loss. -/
+theorem listedSafeStatistic_exact_density
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (κ : ℕ) (hκ : 0 < κ) (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)) (hY : Y ⊆ (trueGroup M d s i : Set (Fin n)))
+    (hI : M.Indep Y) (q : Fin n → ℝ)
+    (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) :
+    exitThreshold / 4 * ((d.D : Set (Fin n)) ∩ Y).ncard -
+        (d.D ∩ trueGroup M d s i).card / (κ : ℝ) ≤
+      bitsExpectation q univ (fun C => bitsExpectation q univ (fun T =>
+        fairParityExpectation (fun p =>
+          (listedSafeStatistic M hE κ (withMasks d d.D C T) s i Y
+            (boolParity p) : ℝ)))) := by
+  by_cases hi : i ∈ groups M d s
+  · have hsafe := safeLayerStatistic_lower M hE κ hκ (groupMask M d s d.D)
+      (groupGround M d s) (groupGround_disjoint M d s) q hq0 hq1
+      ((groups M d s).idxOf i) (trueGroup M d s i : Set (Fin n))
+      ((d.D : Set (Fin n)) ∩ Y) (Set.inter_subset_right.trans hY)
+      (hI.subset Set.inter_subset_right)
+    rw [groupMask_at_key M d s d.D _ i (groups_get?_idxOf M d s i hi),
+      Set.ncard_coe_finset] at hsafe
+    simpa only [listedSafeStatistic_guards M hE κ d s i Y,
+      hi, exitThreshold] using hsafe
+  · have hempty := unlisted_density_inter_empty M d s i hi Y hY
+    have hzero (C T : Finset (Fin n)) (p : Bool) :
+        listedSafeStatistic M hE κ (withMasks d d.D C T) s i Y
+          (boolParity p) = 0 := by
+      change (if i ∈ groups M d s then _ else 0) = 0
+      rw [ite_eq_right hi]
+    simp only [hempty, Set.ncard_empty, Nat.cast_zero, mul_zero, zero_sub,
+      hzero, fairParityExpectation, zero_add, zero_div, bitsExpectation_const]
+    exact neg_nonpos.mpr (div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _))
+
+/-- Restricting the comparison set to this true group does not change its
+safe-label statistic. This permits the source's global independent set `Y`. -/
+theorem listedSafeStatistic_inter_trueGroup
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ) (κ : ℕ)
+    (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)) (ε : Fin 2) :
+    listedSafeStatistic M hE κ d s i
+      (Y ∩ (trueGroup M d s i : Set (Fin n))) ε =
+      listedSafeStatistic M hE κ d s i Y ε := by
+  unfold listedSafeStatistic
+  split_ifs
+  · unfold safeLayerStatistic
+    apply sum_congr rfl
+    intro b _
+    congr 1
+    ext e
+    simp only [safeLayerSet, Set.mem_sdiff, Set.mem_inter_iff]
+    constructor
+    · rintro ⟨⟨⟨heD, heY, _⟩, heL⟩, heN⟩
+      exact ⟨⟨⟨heD, heY⟩, heL⟩, heN⟩
+    · rintro ⟨⟨⟨heD, heY⟩, heL⟩, heN⟩
+      exact ⟨⟨⟨heD, heY, heL.1⟩, heL⟩, heN⟩
+  · rfl
+
+/-- Source `lem:safe`, specialized to the manuscript's literal density
+threshold and thinning rate, for the global independent comparison set.
+It also covers an unlisted group, whose safe count is defined to be zero. -/
+theorem safe_sampled_labels
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)) (hI : M.Indep Y) :
+    exitThreshold / 4 *
+        ((d.D : Set (Fin n)) ∩ (Y ∩ (trueGroup M d s i : Set (Fin n)))).ncard -
+        (d.D ∩ trueGroup M d s i).card / densityThreshold ≤
+      bitsExpectation (fun _ => thinningRate) univ (fun C =>
+        bitsExpectation (fun _ => thinningRate) univ (fun T =>
+          fairParityExpectation (fun p =>
+            (listedSafeStatistic M hE (2 ^ 100) (withMasks d d.D C T) s i Y
+              (boolParity p) : ℝ)))) := by
+  have hs := listedSafeStatistic_exact_density M hE (2 ^ 100) (by positivity)
+    d s i (Y ∩ (trueGroup M d s i : Set (Fin n))) Set.inter_subset_right
+    (hI.subset Set.inter_subset_left) (fun _ => thinningRate)
+    (fun _ => constants_positive.2.2.1.le)
+    (fun _ => by norm_num [thinningRate])
+  have heq (C T : Finset (Fin n)) (p : Bool) :
+      listedSafeStatistic M hE (2 ^ 100) (withMasks d d.D C T) s i
+        (Y ∩ (trueGroup M d s i : Set (Fin n))) (boolParity p) =
+      listedSafeStatistic M hE (2 ^ 100) (withMasks d d.D C T) s i Y
+        (boolParity p) := by
+    simpa only [trueGroup_withMasks] using
+      listedSafeStatistic_inter_trueGroup M hE (2 ^ 100)
+        (withMasks d d.D C T) s i Y (boolParity p)
+  simpa only [Nat.cast_pow, Nat.cast_ofNat, densityThreshold, heq] using hs
+
+/-- Proof of the independently stated complete safe-label claim. -/
+theorem safe_sampled_labels_claim : SafeSampleClaim := by
+  intro n M hE d s i Y hI
+  exact safe_sampled_labels M hE d s i Y hI
+
+end MatroidProphet.MainAlgorithm
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/AveragedSafeExact.lean

@@ -0,0 +1,119 @@
+import OAI.Probability.MatroidSecretary.Selection.AssignedSafe
+
+namespace OAI
+
+/-!
+# The exact density-averaged safety loss
+
+This retains the first, sharper inequality in `eq:averaged-safe-count`
+(`sections/transfer.tex`, line 330). The density mask is averaged only after
+the exact conditional loss has been bounded by `|D ∩ U_i| / κ`. The previous
+endpoint route weakened this to `|U_i| / κ` before averaging, which suffices
+there but does not state the displayed `|U_i| / (4κ)` estimate.
+
+The statistic remains zero on unlisted outcomes. No conditioning on listing,
+focal density bits, or an arrival order is introduced.
+-/
+
+namespace MatroidProphet.MainAlgorithm
+
+open Finset
+
+variable {n : ℕ}
+
+/-- Literal first inequality of `eq:averaged-safe-count`, for a fixed true
+group and any independent comparison subset of that group. -/
+theorem listedSafeStatistic_averaged_exact
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (κ : ℕ) (hκ : 0 < κ) (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)) (hY : Y ⊆ (trueGroup M d s i : Set (Fin n)))
+    (hI : M.Indep Y) (q : Fin n → ℝ)
+    (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1) :
+    retainedFraction * Y.ncard - (trueGroup M d s i).card / (4 * (κ : ℝ)) ≤
+      tripleMaskExpectation (fun _ => (1 : ℝ) / 4) q q univ (fun D C T =>
+        fairParityExpectation (fun p =>
+          (listedSafeStatistic M hE κ (withMasks d D C T) s i Y
+            (boolParity p) : ℝ))) := by
+  classical
+  have hfixed (D : Finset (Fin n)) :
+      exitThreshold / 4 * ((D : Set (Fin n)) ∩ Y).ncard -
+          (D ∩ trueGroup M d s i).card / (κ : ℝ) ≤
+        bitsExpectation q univ (fun C => bitsExpectation q univ (fun T =>
+          fairParityExpectation (fun p =>
+            (listedSafeStatistic M hE κ (withMasks d D C T) s i Y
+              (boolParity p) : ℝ)))) :=
+    listedSafeStatistic_exact_density M hE κ hκ (withMasks d D ∅ ∅)
+      s i Y hY hI q hq0 hq1
+  have hmean := bitsExpectation_mono (fun _ : Fin n => (1 : ℝ) / 4)
+    (by intro e; norm_num) (by intro e; norm_num) univ (fun D _ => hfixed D)
+  have hcardY : bitsExpectation (fun _ : Fin n => (1 : ℝ) / 4) univ
+      (fun D => (((D : Set (Fin n)) ∩ Y).ncard : ℝ)) = Y.ncard / 4 := by
+    have hset (D : Finset (Fin n)) : (D : Set (Fin n)) ∩ Y =
+        ((Y.toFinset ∩ D : Finset (Fin n)) : Set (Fin n)) := by
+      ext e
+      simp only [Set.mem_inter_iff, Finset.mem_coe, mem_inter, Set.mem_toFinset]
+      exact and_comm
+    simp only [hset, Set.ncard_coe_finset]
+    rw [bitsExpectation_card_inter (fun _ : Fin n => (1 : ℝ) / 4)
+      univ Y.toFinset (subset_univ _)]
+    simp only [sum_const, nsmul_eq_mul, ← Set.ncard_eq_toFinset_card']
+    ring
+  have hcardU : bitsExpectation (fun _ : Fin n => (1 : ℝ) / 4) univ
+      (fun D => ((D ∩ trueGroup M d s i).card : ℝ)) =
+        (trueGroup M d s i).card / 4 := by
+    simpa [Finset.inter_comm, div_eq_mul_inv] using
+      bitsExpectation_card_inter (fun _ : Fin n => (1 : ℝ) / 4)
+        univ (trueGroup M d s i) (subset_univ _)
+  have heq : bitsExpectation (fun _ : Fin n => (1 : ℝ) / 4) univ
+      (fun D => exitThreshold / 4 * ((D : Set (Fin n)) ∩ Y).ncard -
+        (D ∩ trueGroup M d s i).card / (κ : ℝ)) =
+      retainedFraction * Y.ncard - (trueGroup M d s i).card / (4 * (κ : ℝ)) := by
+    calc
+      _ = bitsExpectation (fun _ : Fin n => (1 : ℝ) / 4) univ
+          (fun D => exitThreshold / 4 * ((D : Set (Fin n)) ∩ Y).ncard +
+            (-(κ : ℝ)⁻¹) * (D ∩ trueGroup M d s i).card) := by
+        apply bitsExpectation_congr
+        intro D _
+        ring
+      _ = exitThreshold / 4 * (Y.ncard / 4) +
+          (-(κ : ℝ)⁻¹) * ((trueGroup M d s i).card / 4) := by
+        rw [bitsExpectation_add, bitsExpectation_mul_const,
+          bitsExpectation_mul_const, hcardY, hcardU]
+      _ = _ := by
+        norm_num [exitThreshold, retainedFraction]
+        ring
+  rw [heq] at hmean
+  exact hmean
+
+/-- Source specialization for its global independent comparison set `Y`.
+The intersection appearing here is exactly the source's `Y_i`; all statistics
+are those of the actual density-dependent listed groups. -/
+theorem averaged_safe_sampled_labels
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)) (hI : M.Indep Y) :
+    retainedFraction * (Y ∩ (trueGroup M d s i : Set (Fin n))).ncard -
+        (trueGroup M d s i).card / (4 * densityThreshold) ≤
+      tripleMaskExpectation (fun _ => (1 : ℝ) / 4)
+        (fun _ => thinningRate) (fun _ => thinningRate) univ (fun D C T =>
+          fairParityExpectation (fun p =>
+            (listedSafeStatistic M hE (2 ^ 100) (withMasks d D C T) s i Y
+              (boolParity p) : ℝ))) := by
+  have hs := listedSafeStatistic_averaged_exact M hE (2 ^ 100) (by positivity)
+    d s i (Y ∩ (trueGroup M d s i : Set (Fin n))) Set.inter_subset_right
+    (hI.subset Set.inter_subset_left) (fun _ => thinningRate)
+    (fun _ => constants_positive.2.2.1.le)
+    (fun _ => by norm_num [thinningRate])
+  have heq (D C T : Finset (Fin n)) (p : Bool) :
+      listedSafeStatistic M hE (2 ^ 100) (withMasks d D C T) s i
+        (Y ∩ (trueGroup M d s i : Set (Fin n))) (boolParity p) =
+      listedSafeStatistic M hE (2 ^ 100) (withMasks d D C T) s i Y
+        (boolParity p) := by
+    simpa only [trueGroup_withMasks] using
+      listedSafeStatistic_inter_trueGroup M hE (2 ^ 100)
+        (withMasks d D C T) s i Y (boolParity p)
+  simpa only [Nat.cast_pow, Nat.cast_ofNat, densityThreshold, heq] using hs
+
+end MatroidProphet.MainAlgorithm
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/CandidateContract.lean

@@ -0,0 +1,89 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+namespace MatroidProphet.SourceContracts
+
+open Finset Set MainAlgorithm
+
+/-- Positive rounding does not remove a positive weight or create one at zero. -/
+theorem roundedWeight_pos_iff {B x : ℝ} (hB : 0 < B) :
+    0 < roundedWeight B x ↔ 0 < x := by
+  unfold roundedWeight roundedLevel
+  by_cases hx : 0 < x
+  · rw [ite_eq_left hx, levelWeight]
+    exact iff_of_true (zpow_pos hB _) hx
+  · rw [ite_eq_right hx, levelWeight]
+    exact iff_of_false (lt_irrefl 0) hx
+
+/-- The actual candidate test is exactly `eq:candidates`, with higher rounded
+levels taking priority and the original fixed label order breaking ties. -/
+theorem mem_candidateLabels_iff {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (B : ℝ) (H : Finset (Fin n)) (e : Fin n) :
+    e ∈ candidateLabels M (fun f => roundedLevel B (w f)) H ↔
+      0 < w e ∧ e ∉ H ∧
+        e ∉ M.closure {f | f ∈ H ∧
+          higher f (roundedLevel B (w f)) e (roundedLevel B (w e))} := by
+  classical
+  have hpos : roundedLevel B (w e) ≠ none ↔ 0 < w e := by
+    simp [roundedLevel]
+  constructor
+  · intro hcandidate
+    obtain ⟨hlevel, houtside, hclosure⟩ := (Finset.mem_filter.mp hcandidate).2
+    exact ⟨hpos.mp hlevel, houtside, hclosure⟩
+  · rintro ⟨hpositive, houtside, hclosure⟩
+    exact Finset.mem_filter.mpr
+      ⟨Finset.mem_univ _, hpos.mpr hpositive, houtside, hclosure⟩
+
+/-- The same test in the source's literal `u_e > 0` notation. -/
+theorem mem_candidateLabels_iff_rounded {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) {B : ℝ} (hB : 0 < B) (H : Finset (Fin n)) (e : Fin n) :
+    e ∈ candidateLabels M (fun f => roundedLevel B (w f)) H ↔
+      0 < roundedWeight B (w e) ∧ e ∉ H ∧
+        e ∉ M.closure {f | f ∈ H ∧
+          higher f (roundedLevel B (w f)) e (roundedLevel B (w e))} := by
+  rw [roundedWeight_pos_iff hB]
+  exact mem_candidateLabels_iff M w B H e
+
+/-- Candidates cannot be loops, including when loops have positive weights. -/
+theorem candidateLabels_nonloop {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) (H : Finset (Fin n)) (e : Fin n)
+    (he : e ∈ candidateLabels M a H) : e ∉ M.closure ∅ := by
+  classical
+  exact candidate_not_mem_closure_empty M ⟨H, ∅, ∅, ∅, false⟩ a e (a e)
+    (Finset.mem_filter.mp he).2
+
+/-- Both deterministic assertions and both expectation assertions in `lem:filter`.
+The assumptions include no positive-rank, nonempty-ground, or no-ties condition. -/
+theorem candidate_mass {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (w : Weights n) (_hw : ∀ e, 0 ≤ w e) {B : ℝ} (hB : 1 < B) :
+    (∀ H : Finset (Fin n),
+      M.Indep ((positiveGreedy M (fun e => roundedLevel B (w e)) \ H :
+        Finset (Fin n)) : Set (Fin n)) ∧
+      positiveGreedy M (fun e => roundedLevel B (w e)) \ H ⊆
+        candidateLabels M (fun e => roundedLevel B (w e)) H) ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ positiveGreedy M (fun e => roundedLevel B (w e)) \ H,
+        roundedWeight B (w e)) = optimum M (fun e => roundedWeight B (w e)) / 2 ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ candidateLabels M (fun e => roundedLevel B (w e)) H,
+        roundedWeight B (w e)) ≤ optimum M (fun e => roundedWeight B (w e)) := by
+  refine ⟨?_, expectation_positiveGreedy_survivors M hE w hB,
+    expectation_candidateLabels_le_optimum M hE w B⟩
+  intro H
+  exact ⟨positiveGreedy_survivors_indep M hE _ H,
+    positiveGreedy_survivors_subset M _ H⟩
+
+/-- The two-sided optimum rounding estimate `eq:rounding`, including zero weights. -/
+theorem optimum_rounding {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (hw : ∀ e, 0 ≤ w e) {B : ℝ} (hB : 1 < B) :
+    optimum M w / B ≤ optimum M (fun e => roundedWeight B (w e)) ∧
+      optimum M (fun e => roundedWeight B (w e)) ≤ optimum M w := by
+  constructor
+  · apply (div_le_iff₀ (zero_lt_one.trans hB)).2
+    simpa only [mul_comm] using optimum_rounding_bound M B hB w hw
+  · exact optimum_mono M _ w (fun e => roundedWeight_le hB (hw e))
+
+end MatroidProphet.SourceContracts
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/CandidateContracts.lean

@@ -0,0 +1,77 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-!
+Source-facing contracts for the candidate filter (setup.tex, Lemma `lem:filter`).
+The sets below are the actual rounded-priority greedy survivors and candidate
+labels, not arbitrary sets satisfying a desired inequality. The fair-mask law
+is the concrete product law `bitsExpectation` on the entire labeled ground set.
+-/
+
+namespace MatroidProphet.CandidateContracts
+
+open Finset MainAlgorithm
+
+/-- The full candidate-mass contract, including pointwise independence and
+containment for every mask. No positivity premise is needed here because the
+rounding map itself discards nonpositive coordinates. -/
+theorem candidate_mass {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (w : Weights n) :
+    let a := fun e => roundedLevel weightBase (w e)
+    let Y := fun H => positiveGreedy M a \ H
+    let U := candidateLabels M a
+    (∀ H, M.Indep (Y H : Set (Fin n)) ∧ Y H ⊆ U H) ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ Y H, roundedWeight weightBase (w e)) =
+        optimum M (fun e => roundedWeight weightBase (w e)) / 2 ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ U H, roundedWeight weightBase (w e)) ≤
+        optimum M (fun e => roundedWeight weightBase (w e)) := by
+  dsimp only
+  refine ⟨?_, ?_, ?_⟩
+  · intro H
+    exact ⟨positiveGreedy_survivors_indep M hE _ H,
+      positiveGreedy_survivors_subset M _ H⟩
+  · exact expectation_positiveGreedy_survivors M hE w (by norm_num [weightBase])
+  · exact expectation_candidateLabels_le_optimum M hE w weightBase
+
+/-- Both inequalities of the source's rounding bound, together with an actual
+independent positive-priority greedy maximizer. This includes zero weights,
+loops, ties, the empty ground set, and rank zero. -/
+theorem rounding_and_greedy {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (w : Weights n) (hw : ∀ e, 0 ≤ w e) :
+    let u := fun e => roundedWeight weightBase (w e)
+    let I := positiveGreedy M (fun e => roundedLevel weightBase (w e))
+    optimum M w / weightBase ≤ optimum M u ∧
+    optimum M u ≤ optimum M w ∧
+    M.Indep (I : Set (Fin n)) ∧
+    (∑ e ∈ I, u e) = optimum M u := by
+  dsimp only
+  have hB : (1 : ℝ) < weightBase := by norm_num [weightBase]
+  refine ⟨?_, ?_, positiveGreedy_indep M hE _, ?_⟩
+  · apply (div_le_iff₀ (zero_lt_one.trans hB)).2
+    simpa only [mul_comm] using optimum_rounding_bound M weightBase hB w hw
+  · exact optimum_mono M _ w (fun e => roundedWeight_le hB (hw e))
+  · change (∑ e ∈ positiveGreedy M (fun e => roundedLevel weightBase (w e)),
+      levelWeight weightBase (roundedLevel weightBase (w e))) = _
+    rw [sum_positiveGreedy]
+    exact Priority.rounded_greedy_optimal M hE w hB
+
+/-- The actual candidate predicate never includes a loop or a nonpositive label.
+This is a pointwise statement for every mask, not only almost surely. -/
+theorem candidate_positive_nonloop {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (H : Finset (Fin n)) (e : Fin n)
+    (he : e ∈ candidateLabels M (fun f => roundedLevel weightBase (w f)) H) :
+    0 < w e ∧ e ∉ H ∧ e ∉ M.closure ∅ := by
+  classical
+  have hc : candidate M ⟨H, ∅, ∅, ∅, false⟩
+      (fun f => roundedLevel weightBase (w f)) e (roundedLevel weightBase (w e)) :=
+    (Finset.mem_filter.mp he).2
+  refine ⟨?_, hc.2.1, candidate_not_mem_closure_empty M _ _ _ _ hc⟩
+  by_contra hn
+  exact hc.1 (by simp [roundedLevel, hn])
+
+end MatroidProphet.CandidateContracts
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/CandidateSpecification.lean

@@ -0,0 +1,53 @@
+import Mathlib.Combinatorics.Matroid.Closure
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+namespace MatroidProphet.CandidateSpecification
+
+open Finset
+
+/-- Strict rounded-weight priority, including the fixed label tie-breaking rule. -/
+def higher {n : ℕ} (f : Fin n) (a : Option ℤ) (e : Fin n) (b : Option ℤ) : Prop :=
+  match a, b with
+  | some i, some j => j < i ∨ j = i ∧ f < e
+  | some _, none => True
+  | _, _ => False
+
+/-- Source candidate set: positive, unobserved, and not spanned by higher-priority
+observed labels. The full candidate set is analytical, not given to the algorithm. -/
+noncomputable def candidates {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) (H : Finset (Fin n)) : Finset (Fin n) := by
+  classical
+  exact Finset.univ.filter fun e => a e ≠ none ∧ e ∉ H ∧
+    e ∉ M.closure {f | f ∈ H ∧ higher f (a f) e (a e)}
+
+/-- Positive priority-greedy on the entire ground set, characterized by failure
+of the strictly higher-priority labels to span the current label. -/
+noncomputable def greedy {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) : Finset (Fin n) := by
+  classical
+  exact Finset.univ.filter fun e => a e ≠ none ∧
+    e ∉ M.closure {f | higher f (a f) e (a e)}
+
+/-- The source comparison independent set after sacrificing the fair mask. -/
+noncomputable def survivors {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) (H : Finset (Fin n)) : Finset (Fin n) :=
+  greedy M a \ H
+
+/-- The complete mathematical assertion of Lemma `lem:filter`, stated solely
+using the concrete source definitions and the finite independent fair-mask law. -/
+def CandidateMass : Prop :=
+  ∀ (n : ℕ) (M : Matroid (Fin n)), M.E = Set.univ → ∀ w : Weights n,
+    let a := fun e => roundedLevel weightBase (w e)
+    let u := fun e => roundedWeight weightBase (w e)
+    (∀ H, M.Indep (survivors M a H : Set (Fin n)) ∧
+      survivors M a H ⊆ candidates M a H) ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ survivors M a H, u e) = optimum M u / 2 ∧
+    bitsExpectation (fun _ => (1 / 2 : ℝ)) Finset.univ
+      (fun H => ∑ e ∈ candidates M a H, u e) ≤ optimum M u
+
+end MatroidProphet.CandidateSpecification
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/CandidateSpecificationTheorems.lean

@@ -0,0 +1,88 @@
+import OAI.Probability.MatroidSecretary.Selection.CandidateSpecification
+import OAI.Probability.MatroidSecretary.Selection.CandidateContracts
+
+namespace OAI
+
+/-! Correspondence of the independent source definitions with the implemented
+candidate filter and positive priority-greedy, followed by the source contract. -/
+
+namespace MatroidProphet.CandidateSpecification
+
+open Finset
+
+lemma higher_eq_main {n : ℕ} (f : Fin n) (a : Option ℤ)
+    (e : Fin n) (b : Option ℤ) :
+    higher f a e b ↔ MainAlgorithm.higher f a e b := Iff.rfl
+
+lemma candidates_eq_main {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) (H : Finset (Fin n)) :
+    candidates M a H = MainAlgorithm.candidateLabels M a H := by
+  classical
+  rw [MainAlgorithm.candidateLabels, MainAlgorithm.candidateSet_eq_filter]
+  ext element
+  by_cases hpositive : a element = none
+  · simp [candidates, hpositive]
+  · have hprior : {label | label ∈ H ∧ higher label (a label) element (a element)} =
+        Candidates.prior (Priority.time a) H element := by
+      ext label
+      simp only [Candidates.prior, Set.mem_ofPred_eq, higher_eq_main,
+        Priority.main_higher_iff_time a label element hpositive]
+    simp [candidates, Candidates.candidates, hpositive, hprior]
+
+lemma greedy_eq_main {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) : greedy M a = MainAlgorithm.positiveGreedy M a := by
+  classical
+  ext e
+  by_cases ha : a e = none
+  · simp [greedy, MainAlgorithm.positiveGreedy, ha]
+  · have hp : {f | higher f (a f) e (a e)} =
+        Candidates.prior (Priority.time a) Finset.univ e := by
+      ext f
+      simp only [Candidates.prior, Finset.mem_univ, true_and,
+        Set.mem_ofPred_eq, higher_eq_main, Priority.main_higher_iff_time a f e ha]
+    simp [greedy, MainAlgorithm.positiveGreedy, Candidates.greedy, ha, hp]
+
+lemma survivors_eq_main {n : ℕ} (M : Matroid (Fin n))
+    (a : Fin n → Option ℤ) (H : Finset (Fin n)) :
+    survivors M a H = MainAlgorithm.positiveGreedy M a \ H := by
+  rw [survivors, greedy_eq_main]
+
+ 
+
+theorem candidateMass : CandidateMass := by
+  intro n M hE w
+  simpa only [survivors_eq_main, candidates_eq_main] using
+    CandidateContracts.candidate_mass M hE w
+
+/-- Candidate membership uses only the focal key and keys on the revealed mask,
+never another unobserved label's key. -/
+lemma candidate_membership_congr {n : ℕ} (M : Matroid (Fin n))
+    (a a' : Fin n → Option ℤ) (H : Finset (Fin n)) (e : Fin n)
+    (he : a e = a' e) (hH : ∀ f ∈ H, a f = a' f) :
+    e ∈ candidates M a H ↔ e ∈ candidates M a' H := by
+  classical
+  have hp : {f | f ∈ H ∧ higher f (a f) e (a e)} =
+      {f | f ∈ H ∧ higher f (a' f) e (a' e)} := by
+    ext f
+    by_cases hf : f ∈ H
+    · simp [hf, he, hH f hf]
+    · simp [hf]
+  simp only [candidates, Finset.mem_filter, Finset.mem_univ, true_and]
+  rw [hp, he]
+
+/-- The source greedy definition really attains rounded OPT, with the source's
+rounding comparison on both sides. This verifies the ancillary input `I*` rather
+than assuming its optimality. -/
+theorem source_rounding_and_greedy {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (w : Weights n) (hw : ∀ e, 0 ≤ w e) :
+    let u := fun e => roundedWeight weightBase (w e)
+    let I := greedy M (fun e => roundedLevel weightBase (w e))
+    optimum M w / weightBase ≤ optimum M u ∧
+    optimum M u ≤ optimum M w ∧
+    M.Indep (I : Set (Fin n)) ∧
+    (∑ e ∈ I, u e) = optimum M u := by
+  simpa only [greedy_eq_main] using CandidateContracts.rounding_and_greedy M hE w hw
+
+end MatroidProphet.CandidateSpecification
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/FeasibilityContract.lean

@@ -0,0 +1,123 @@
+import OAI.Probability.MatroidProphet.Main
+import OAI.Probability.MatroidSecretary.Accounting.MainFeasibilityContract
+import OAI.Probability.MatroidSecretary.Selection.FeasibilitySpec
+import OAI.Probability.MatroidSecretary.Selection.GreedyExecution
+
+namespace OAI
+
+/-! Complete source contract for `algorithm.tex`, `lem:feasibility` (lines
+179--183; source SHA256 b702fa1da832d3cbebcf5a70f0b0e9505b3423e2ed9884c22fe4194ba4974fbe).
+The actual main rule is used, not an abstract feasible-rule hypothesis. -/
+
+namespace MatroidProphet
+namespace FeasibilityContract
+open Set Finset MeasureTheory
+
+/-- Hidden observations depend only on the initially sacrificed coordinates. -/
+theorem observed_eq_of_eq_on_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w w' : Weights n)
+    (h : ∀ e ∈ A.mask r, w e = w' e) :
+    observed A r w = observed A r w' := by
+  classical
+  funext e
+  by_cases he : e ∈ A.mask r
+  · simp only [observed, ite_eq_left he, h e he]
+  · simp only [observed, ite_eq_right he]
+
+/-- Hidden execution is nonanticipating: equal initial observations and equal
+revealed histories force equal current decisions, irrespective of future data. -/
+theorem hidden_decision_congr {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w w' : Weights n) (π π' : ArrivalOrder n) (k : Fin n)
+    (hmask : ∀ e ∈ A.mask r, w e = w' e)
+    (hhist : history w π k = history w' π' k) :
+    decisionAt A.core r (observed A r w) w π k =
+      decisionAt A.core r (observed A r w') w' π' k := by
+  rw [observed_eq_of_eq_on_mask A r w w' hmask]
+  exact decisionAt_congr A.core r (observed A r w') w w' π π' k hhist
+
+/-- Sacrificing the fixed mask preserves irrevocability. -/
+theorem hiddenAcceptedThrough_mono {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) (π : ArrivalOrder n)
+    {t t' : ℕ} (h : t ≤ t') :
+    hiddenAcceptedThrough A r w π t ⊆ hiddenAcceptedThrough A r w π t' := by
+  intro e he
+  obtain ⟨he, hm⟩ := Finset.mem_sdiff.mp he
+  exact Finset.mem_sdiff.mpr
+    ⟨acceptedThrough_mono A.core r (observed A r w) w π h he, hm⟩
+
+/-- No sacrificed observation label is ever accepted. -/
+theorem hiddenAcceptedThrough_disjoint_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) (π : ArrivalOrder n) (t : ℕ) :
+    Disjoint (hiddenAcceptedThrough A r w π t) (A.mask r) := by
+  apply Finset.disjoint_left.mpr
+  intro e he hm
+  exact (Finset.mem_sdiff.mp he).2 hm
+
+/-- All parts of the manuscript's feasibility and information contract for the
+actual layered main algorithm. Empty ground sets, loops, zero weights, ties,
+and empty group lists remain within the quantified input domain. -/
+theorem main_rule {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ) :
+    (∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      ∀ (r : Seed (mainSeedBits n)) (π : ArrivalOrder n) (t : ℕ),
+        M.Indep (hiddenAcceptedThrough (MainAlgorithm.hidden M hE) r w π t : Set (Fin n))) ∧
+    (∀ k, Measurable
+      (fun x : Seed (mainSeedBits n) × (Weights n × History n k) =>
+        (MainAlgorithm.core M hE).decide k x.1 x.2.1 x.2.2)) ∧
+    (∀ (r : Seed (mainSeedBits n)) (w w' : Weights n)
+      (π π' : ArrivalOrder n) (k : Fin n),
+      (∀ e ∈ (MainAlgorithm.hidden M hE).mask r, w e = w' e) →
+      history w π k = history w' π' k →
+      decisionAt (MainAlgorithm.core M hE) r
+          (observed (MainAlgorithm.hidden M hE) r w) w π k =
+        decisionAt (MainAlgorithm.core M hE) r
+          (observed (MainAlgorithm.hidden M hE) r w') w' π' k) ∧
+    (∀ (r : Seed (mainSeedBits n)) (w : Weights n) (π : ArrivalOrder n)
+      (t t' : ℕ), t ≤ t' →
+      hiddenAcceptedThrough (MainAlgorithm.hidden M hE) r w π t ⊆
+        hiddenAcceptedThrough (MainAlgorithm.hidden M hE) r w π t') ∧
+    (∀ (r : Seed (mainSeedBits n)) (w : Weights n) (π : ArrivalOrder n) (t : ℕ),
+      Disjoint (hiddenAcceptedThrough (MainAlgorithm.hidden M hE) r w π t)
+        ((mainMasks r).H ∪ (mainMasks r).D ∪ (mainMasks r).C)) := by
+  refine ⟨MainAlgorithm.hidden_feasible M hE, ?_, ?_, ?_, ?_⟩
+  · exact (MainAlgorithm.core M hE).measurable_decide
+  · exact hidden_decision_congr (MainAlgorithm.hidden M hE)
+  · intro r w π t t' ht
+    exact hiddenAcceptedThrough_mono (MainAlgorithm.hidden M hE) r w π ht
+  · exact hiddenAcceptedThrough_disjoint_mask (MainAlgorithm.hidden M hE)
+
+/-- The empty listed-group case cannot assign any arriving label to a layer. -/
+theorem assign_none_of_groups_nil {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (d : MainMasks n) (seen : Fin n → Option ℤ)
+    (hg : MainAlgorithm.groups M d seen = []) (e : Fin n) (w : Option ℤ) :
+    MainAlgorithm.assign M hE d seen e w = none := by
+  classical
+  cases w with
+  | none => rfl
+  | some i =>
+    have hn : ¬ MainAlgorithm.eligible M hE d seen e i := by
+      intro he
+      simpa [hg] using he.2.2.1
+    simp [MainAlgorithm.assign, hn]
+
+/-- Zero weights do not enter a logarithm and are assigned no layer. -/
+theorem assign_zero {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (seen : Fin n → Option ℤ) (e : Fin n) :
+    MainAlgorithm.assign M hE d seen e (roundedLevel weightBase 0) = none := by
+  simp [roundedLevel, MainAlgorithm.assign]
+
+/-- A loop can never pass the actual candidate test, regardless of priorities. -/
+theorem not_candidate_of_loop {n : ℕ} (M : Matroid (Fin n)) (d : MainMasks n)
+    (seen : Fin n → Option ℤ) (e : Fin n) (w : Option ℤ)
+    (he : e ∈ M.closure ∅) : ¬ MainAlgorithm.candidate M d seen e w := by
+  intro hc
+  exact hc.2.2 (M.closure_subset_closure (Set.empty_subset _) he)
+
+/-- The complete required `lem:feasibility` contract, for the concrete source rule. -/
+theorem source_main_feasibility {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) : MainRuleFeasibility M (MainAlgorithm.hidden M hE) :=
+  MainAlgorithm.source_feasibility_contract M hE
+
+end FeasibilityContract
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/FeasibilitySpec.lean

@@ -0,0 +1,31 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+namespace MatroidProphet
+open Set Finset MeasureTheory
+
+/-- Core and hidden prefix feasibility, measurability after masking the initial
+observations, complete accepted-set nonanticipation, irrevocability, and literal
+rejection of sacrificed labels. The mask depends only on the initial seed by
+the type of `HiddenRule`; no weight-dependent mask is allowed. -/
+def MainRuleFeasibility {n bits : ℕ} (M : Matroid (Fin n))
+    (A : HiddenRule n bits) : Prop :=
+  Feasible M A.core ∧
+  (∀ k, Measurable (fun x : Seed bits × (Weights n × History n k) =>
+    A.core.decide k x.1 (observed A x.1 x.2.1) x.2.2)) ∧
+  (∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+    ∀ (r : Seed bits) (π : ArrivalOrder n) (t : ℕ),
+      M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n))) ∧
+  (∀ (r : Seed bits) (w w' : Weights n) (π π' : ArrivalOrder n) (t : ℕ),
+    (∀ e ∈ A.mask r, w e = w' e) →
+    (∀ j : Fin n, j.val < t → (π j, w (π j)) = (π' j, w' (π' j))) →
+    hiddenAcceptedThrough A r w π t = hiddenAcceptedThrough A r w' π' t) ∧
+  (∀ (r : Seed bits) (w : Weights n) (π : ArrivalOrder n),
+    Monotone (hiddenAcceptedThrough A r w π)) ∧
+  (∀ (r : Seed bits) (w : Weights n) (π : ArrivalOrder n) (t : ℕ),
+    Disjoint (hiddenAcceptedThrough A r w π t) (A.mask r))
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/GreedyExecution.lean

@@ -0,0 +1,90 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-! Exact agreement between the source's previous-accepted-label test and the
+concrete implementation's previous-eligible-label test. No arrival-order
+assumption beyond the explicit arrival times is used in span preservation. -/
+
+namespace MatroidProphet
+open Set Finset
+
+variable {α : Type*} [DecidableEq α]
+
+/-- Rejected earlier eligible labels do not change the span of a layer prefix. -/
+theorem layerGreedy_closure_prior (M : Matroid α) (E : Finset α)
+    (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ)
+    (hE : M.E = Set.univ) (b : ℤ) (k : ℕ) :
+    M.closure (base b ∪ layerPrior E layer time b k) =
+      M.closure (base b ∪
+        layerPrior (layerGreedy M E base layer time) layer time b k) := by
+  apply Set.Subset.antisymm
+  · apply M.closure_subset_closure_of_subset_closure
+    rintro e (he | ⟨he, hb, ht⟩)
+    · exact M.mem_closure_of_mem' (Or.inl he) (by simp [hE])
+    · have hs := layerGreedy_spans_prefix M E base layer time hE e he
+      apply M.closure_subset_closure ?_ hs
+      rintro f (hf | ⟨hf, hfb, hft⟩)
+      · exact Or.inl (by simpa [hb] using hf)
+      · exact Or.inr ⟨hf, hfb.trans hb, hft.trans_lt ht⟩
+  · apply M.closure_subset_closure
+    rintro e (he | ⟨he, hb, ht⟩)
+    · exact Or.inl he
+    · exact Or.inr ⟨layerGreedy_subset M E base layer time he, hb, ht⟩
+
+/-- The online decision can be implemented using only earlier accepted labels
+of the same layer, exactly as in step 3 of the manuscript algorithm. -/
+theorem layerGreedy_mem_iff_previous_accepted (M : Matroid α) (E : Finset α)
+    (base : ℤ → Set α) (layer : α → ℤ) (time : α → ℕ)
+    (hE : M.E = Set.univ) (e : α) :
+    e ∈ layerGreedy M E base layer time ↔
+      e ∈ E ∧ e ∉ M.closure (base (layer e) ∪
+        layerPrior (layerGreedy M E base layer time) layer time (layer e) (time e)) := by
+  classical
+  conv_lhs => unfold layerGreedy
+  rw [Finset.mem_filter]
+  rw [layerGreedy_closure_prior M E base layer time hE]
+
+omit [DecidableEq α] in
+/-- On a finite ground set the source's rank-one test is precisely nonmembership
+in the closure, including rank-zero and loop cases. -/
+theorem conditionalRank_singleton_eq_one_iff [Fintype α] (M : Matroid α)
+    (hE : M.E = Set.univ) (P : Set α) (e : α) :
+    conditionalRank M {e} P = 1 ↔ e ∉ M.closure P := by
+  by_cases he : e ∈ M.closure P
+  · rw [Pivots.conditionalRank_singleton_of_mem_closure M P he]
+    simp [he]
+  · rw [Pivots.conditionalRank_singleton_of_notMem_closure M P (by simp [hE]) he]
+    simp [he]
+
+/-- Exact rank form of the source's accept/reject condition. -/
+theorem layerGreedy_mem_iff_rank_previous_accepted [Fintype α]
+    (M : Matroid α) (E : Finset α) (base : ℤ → Set α)
+    (layer : α → ℤ) (time : α → ℕ) (hE : M.E = Set.univ) (e : α) :
+    e ∈ layerGreedy M E base layer time ↔
+      e ∈ E ∧ conditionalRank M {e} (base (layer e) ∪
+        layerPrior (layerGreedy M E base layer time) layer time (layer e) (time e)) = 1 := by
+  rw [layerGreedy_mem_iff_previous_accepted M E base layer time hE,
+    conditionalRank_singleton_eq_one_iff M hE]
+
+/-- The concrete history-based online decision agrees with the rank test on
+previously accepted labels in the current layer. -/
+theorem layerKeyDecision_eq_rank_previous_accepted {n : ℕ} {K : Type*}
+    (M : Matroid (Fin n)) (hE : M.E = Set.univ) (base : ℤ → Set (Fin n))
+    (assign : Fin n → K → Option ℤ) (v : Fin n → K)
+    (π : ArrivalOrder n) (k : Fin n) :
+    layerKeyDecision M base assign k (keyHistory v π k) = true ↔
+      π k ∈ assignedEligible assign v ∧
+      conditionalRank M {π k} (base (assignedLayer assign v (π k)) ∪
+        layerPrior
+          (layerGreedy M (assignedEligible assign v) base (assignedLayer assign v)
+            (fun e => (π.symm e).val))
+          (assignedLayer assign v) (fun e => (π.symm e).val)
+          (assignedLayer assign v (π k)) k.val) = 1 := by
+  rw [layerKeyDecision_eq_greedy,
+    layerGreedy_mem_iff_rank_previous_accepted M _ _ _ _ hE]
+  simp only [Equiv.symm_apply_apply]
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/LayerImplementation.lean

@@ -0,0 +1,71 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-!
+# The layer rule is the source's accepted-prefix greedy rule
+
+The implementation tests the span of all previous eligible labels. The source
+algorithm tests the span of the previous accepted labels. Prefix span preservation
+makes these tests exactly equal, not merely comparable in final reward.
+-/
+
+namespace MatroidProphet
+open Set Finset
+
+lemma layerGreedy_closure_prefix {α : Type*} [DecidableEq α]
+    (M : Matroid α) (E : Finset α) (base : ℤ → Set α)
+    (layer : α → ℤ) (time : α → ℕ) (hE : M.E = Set.univ) (b : ℤ) (k : ℕ) :
+    M.closure (base b ∪ layerPrior E layer time b k) =
+      M.closure (base b ∪
+        {e | e ∈ layerGreedy M E base layer time ∧ layer e = b ∧ time e < k}) := by
+  apply Set.Subset.antisymm
+  · apply M.closure_subset_closure_of_subset_closure
+    rintro e (he | ⟨he, hb, ht⟩)
+    · exact M.mem_closure_of_mem' (Or.inl he) (by simp [hE])
+    · have hs := layerGreedy_spans_prefix M E base layer time hE e he
+      apply M.closure_subset_closure _ hs
+      rintro f (hf | ⟨hf, hfb, hft⟩)
+      · exact Or.inl (by simpa only [hb] using hf)
+      · exact Or.inr ⟨hf, hfb.trans hb, hft.trans_lt ht⟩
+  · apply M.closure_subset_closure
+    rintro e (he | ⟨he, hb, ht⟩)
+    · exact Or.inl he
+    · exact Or.inr ⟨layerGreedy_subset M E base layer time he, hb, ht⟩
+
+/-- The actual layer acceptance test may use only its earlier accepted labels. -/
+theorem layerGreedy_mem_iff_accepted_prefix {α : Type*} [DecidableEq α]
+    (M : Matroid α) (E : Finset α) (base : ℤ → Set α)
+    (layer : α → ℤ) (time : α → ℕ) (hE : M.E = Set.univ) (e : α) :
+    e ∈ layerGreedy M E base layer time ↔
+      e ∈ E ∧ e ∉ M.closure (base (layer e) ∪
+        {f | f ∈ layerGreedy M E base layer time ∧
+          layer f = layer e ∧ time f < time e}) := by
+  classical
+  rw [show e ∈ layerGreedy M E base layer time ↔ e ∈ E ∧
+    e ∉ M.closure (base (layer e) ∪ layerPrior E layer time (layer e) (time e)) from
+      Finset.mem_filter]
+  rw [layerGreedy_closure_prefix M E base layer time hE]
+
+/-- Exact conditional-rank form of the source test at an arrival. -/
+theorem layerGreedy_mem_iff_rank_one {α : Type*} [Fintype α] [DecidableEq α]
+    (M : Matroid α) (E : Finset α) (base : ℤ → Set α)
+    (layer : α → ℤ) (time : α → ℕ) (hE : M.E = Set.univ) (e : α) :
+    e ∈ layerGreedy M E base layer time ↔
+      e ∈ E ∧ conditionalRank M {e} (base (layer e) ∪
+        {f | f ∈ layerGreedy M E base layer time ∧
+          layer f = layer e ∧ time f < time e}) = 1 := by
+  rw [layerGreedy_mem_iff_accepted_prefix M E base layer time hE]
+  constructor
+  · rintro ⟨he, hne⟩
+    exact ⟨he, Pivots.conditionalRank_singleton_of_notMem_closure M _
+      (by simp [hE]) hne⟩
+  · rintro ⟨he, hr⟩
+    refine ⟨he, ?_⟩
+    intro hmem
+    have hz := Pivots.conditionalRank_singleton_of_mem_closure M _ hmem
+    omega
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Selection/SafeSpecification.lean

@@ -0,0 +1,26 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+namespace MatroidProphet
+
+open MainAlgorithm
+
+/-- The source safety guarantee, including the literal constants, all listed
+groups, global independent comparison set, and the harmless unlisted zero case. -/
+def SafeSampleClaim : Prop :=
+  ∀ (n : ℕ) (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (Y : Set (Fin n)), M.Indep Y →
+    exitThreshold / 4 *
+        ((d.D : Set (Fin n)) ∩ (Y ∩ (trueGroup M d s i : Set (Fin n)))).ncard -
+        (d.D ∩ trueGroup M d s i).card / densityThreshold ≤
+      bitsExpectation (fun _ => thinningRate) Finset.univ (fun C =>
+        bitsExpectation (fun _ => thinningRate) Finset.univ (fun T =>
+          fairParityExpectation (fun p =>
+            (listedSafeStatistic M hE (2 ^ 100) (withMasks d d.D C T) s i Y
+              (boolParity p) : ℝ))))
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/AdversarialMinimum.lean

@@ -0,0 +1,94 @@
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+namespace OAI
+
+open MeasureTheory
+
+namespace MatroidProphet
+
+/-- For a fixed vector, arbitrary measurable seed-dependent orders give an
+integrable reward under every finite measure. No feasibility or sign assumption
+is needed, since the seed and order spaces are finite. -/
+lemma integrable_hiddenReward_randomOrder {n bits : ℕ} (A : HiddenRule n bits)
+    (w : Weights n) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsFiniteMeasure μ]
+    (R : Ω → Seed bits) (π : Ω → ArrivalOrder n)
+    (hR : Measurable R) (hπ : Measurable π) :
+    Integrable (fun ω => hiddenReward A (R ω) w (π ω)) μ := by
+  let f : Seed bits × ArrivalOrder n → ℝ := fun x => hiddenReward A x.1 w x.2
+  have hf : Measurable f := measurable_of_finite f
+  have hpair : Measurable (fun ω => (R ω, π ω)) := hR.prodMk hπ
+  exact (integrable_map_measure hf.aestronglyMeasurable hpair.aemeasurable).1
+    (Integrable.of_finite (f := f))
+
+/-- The seedwise minimum is integrable after any measurable finite-seed map. -/
+lemma integrable_hiddenWorstReward_comp {n bits : ℕ} (A : HiddenRule n bits)
+    (w : Weights n) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsFiniteMeasure μ]
+    (R : Ω → Seed bits) (hR : Measurable R) :
+    Integrable (fun ω => hiddenWorstReward A w (R ω)) μ := by
+  have hf : Measurable (hiddenWorstReward A w) := measurable_of_finite _
+  exact (integrable_map_measure hf.aestronglyMeasurable hR.aemeasurable).1
+    (Integrable.of_finite (f := hiddenWorstReward A w))
+
+/-- A reconstructed seed's correct marginal transports the expected minimum to
+any measurable full-information order. The order need not be independent of the
+seed, and the ambient space may carry arbitrarily much additional information. -/
+theorem hiddenWorstReward_integral_le_randomOrder {n bits : ℕ}
+    (A : HiddenRule n bits) (w : Weights n)
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
+    (ν : Measure (Seed bits)) (R : Ω → Seed bits) (π : Ω → ArrivalOrder n)
+    (hR : Measurable R) (hπ : Measurable π) (hRlaw : μ.map R = ν) :
+    (∫ r, hiddenWorstReward A w r ∂ν) ≤
+      ∫ ω, hiddenReward A (R ω) w (π ω) ∂μ := by
+  have hf : Measurable (hiddenWorstReward A w) := measurable_of_finite _
+  rw [← hRlaw, integral_map_of_stronglyMeasurable hR hf.stronglyMeasurable]
+  apply integral_mono
+    (integrable_hiddenWorstReward_comp A w μ R hR)
+    (integrable_hiddenReward_randomOrder A w μ R π hR hπ)
+  intro ω
+  exact hiddenWorstReward_le A w (R ω) (π ω)
+
+/-- A pointwise accepted-reward identity may be replaced by an almost-everywhere
+identity. This is useful when a reconstruction kernel has zero-mass seed outcomes. -/
+theorem hiddenWorstReward_integral_le_replayed {n bits : ℕ}
+    (A : HiddenRule n bits) (w : Weights n)
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
+    (ν : Measure (Seed bits)) (R : Ω → Seed bits) (π : Ω → ArrivalOrder n)
+    (hR : Measurable R) (hπ : Measurable π) (hRlaw : μ.map R = ν)
+    (payoff : Ω → ℝ)
+    (hreplay : payoff =ᵐ[μ] fun ω => hiddenReward A (R ω) w (π ω)) :
+    Integrable payoff μ ∧ (∫ r, hiddenWorstReward A w r ∂ν) ≤ ∫ ω, payoff ω ∂μ := by
+  refine ⟨(integrable_hiddenReward_randomOrder A w μ R π hR hπ).congr hreplay.symm, ?_⟩
+  rw [integral_congr_ae hreplay]
+  exact hiddenWorstReward_integral_le_randomOrder A w μ ν R π hR hπ hRlaw
+
+/-- There is a measurable adversary attaining the minimum separately at every
+seed. Thus the minimum used above is genuinely inside expectation, not the
+minimum of fixed-order expected rewards. -/
+lemma exists_measurable_worstOrder {n bits : ℕ} (A : HiddenRule n bits)
+    (w : Weights n) :
+    ∃ π : Seed bits → ArrivalOrder n, Measurable π ∧
+      ∀ r, hiddenReward A r w (π r) = hiddenWorstReward A w r := by
+  classical
+  have hex (r : Seed bits) :
+      ∃ π : ArrivalOrder n, hiddenReward A r w π = hiddenWorstReward A w r := by
+    obtain ⟨π, _, hπ⟩ := Finset.exists_mem_eq_inf'
+      (s := (Finset.univ : Finset (ArrivalOrder n))) Finset.univ_nonempty
+      (hiddenReward A r w)
+    exact ⟨π, hπ.symm⟩
+  choose π hπ using hex
+  exact ⟨π, measurable_of_finite π, hπ⟩
+
+/-- The lower bound is sharp among measurable full-seed order policies. -/
+lemma exists_order_integral_eq_hiddenWorstReward {n bits : ℕ}
+    (A : HiddenRule n bits) (w : Weights n) (ν : Measure (Seed bits)) :
+    ∃ π : Seed bits → ArrivalOrder n, Measurable π ∧
+      (∫ r, hiddenReward A r w (π r) ∂ν) = ∫ r, hiddenWorstReward A w r ∂ν := by
+  obtain ⟨π, hπ, heq⟩ := exists_measurable_worstOrder A w
+  exact ⟨π, hπ, integral_congr_ae (ae_of_all _ heq)⟩
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/GeneralSimulation.lean

@@ -0,0 +1,391 @@
+import OAI.Probability.MatroidSecretary.Transport.GeneralSimulationModel
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.MeasureTheory.Integral.Prod
+
+namespace OAI
+
+/-! One-sample simulation for an arbitrary measurable complete seed. -/
+
+namespace MatroidProphet.General
+
+open MeasureTheory ProbabilityTheory
+
+variable {n : ℕ} {R : Type*} [MeasurableSpace R]
+
+lemma measurable_mask_membership :
+    MeasurableSet {x : Finset (Fin n) × Fin n | x.2 ∈ x.1} :=
+  (Set.toFinite _).measurableSet
+
+lemma measurable_observed (A : HiddenRule n R) :
+    Measurable (fun x : R × Weights n => observed A x.1 x.2) := by
+  classical
+  apply Measurable.of_eval
+  intro e
+  have hm : MeasurableSet {x : R × Weights n | e ∈ A.mask x.1} :=
+    (measurableSet_mem_finset e).preimage (A.measurable_mask.comp measurable_fst)
+  exact Measurable.ite hm ((measurable_pi_apply e).comp measurable_snd) measurable_const
+
+lemma measurable_simulationHistory (A : HiddenRule n R) (k : Fin n) :
+    Measurable (fun x : R × (Weights n × History n k) =>
+      simulationHistory A x.1 x.2.1 x.2.2) := by
+  classical
+  apply Measurable.of_eval
+  intro j
+  have hh : Measurable (fun x : R × (Weights n × History n k) => x.2.2 j) :=
+    (measurable_pi_apply j).comp (measurable_snd.comp measurable_snd)
+  have hm : MeasurableSet {x : R × (Weights n × History n k) |
+      (x.2.2 j).1 ∈ A.mask x.1} :=
+    measurable_mask_membership.preimage
+      ((A.measurable_mask.comp measurable_fst).prodMk (measurable_fst.comp hh))
+  exact (measurable_fst.comp hh).prodMk (Measurable.ite hm
+    (MatroidProphet.measurable_weight_eval.comp
+      ((measurable_fst.comp measurable_snd).prodMk (measurable_fst.comp hh)))
+    (measurable_snd.comp hh))
+
+lemma measurable_simulationDecision (A : HiddenRule n R) (k : Fin n) :
+    Measurable (fun x : R × (Weights n × History n k) =>
+      simulationDecision A k x.1 x.2.1 x.2.2) := by
+  classical
+  have hc : Measurable (fun x : R × (Weights n × History n k) =>
+      (x.2.2 ⟨k.val, Nat.lt_succ_self _⟩).1) :=
+    measurable_fst.comp ((measurable_pi_apply
+      (⟨k.val, Nat.lt_succ_self _⟩ : Fin (k.val + 1))).comp
+        (measurable_snd.comp measurable_snd))
+  have hm : MeasurableSet {x : R × (Weights n × History n k) |
+      (x.2.2 ⟨k.val, Nat.lt_succ_self _⟩).1 ∈ A.mask x.1} :=
+    measurable_mask_membership.preimage
+      ((A.measurable_mask.comp measurable_fst).prodMk hc)
+  exact Measurable.ite hm measurable_const
+    ((A.core.measurable_decide k).comp (measurable_fst.prodMk
+      (((measurable_observed A).comp
+        (measurable_fst.prodMk (measurable_fst.comp measurable_snd))).prodMk
+          (measurable_simulationHistory A k))))
+
+noncomputable def sampleSimulation (A : HiddenRule n R) : OnlineRule n R where
+  decide := simulationDecision A
+  measurable_decide := measurable_simulationDecision A
+
+lemma observed_glue (A : HiddenRule n R) (r : R) (s v : Weights n) :
+    observed A r (glue (A.mask r) s v) = observed A r s := by
+  classical
+  funext e
+  by_cases he : e ∈ A.mask r <;> simp [observed, glue, he]
+
+lemma simulationHistory_eq (A : HiddenRule n R) (r : R)
+    (s v : Weights n) (π : ArrivalOrder n) (k : Fin n) :
+    simulationHistory A r s (history v π k) = history (glue (A.mask r) s v) π k := rfl
+
+theorem sampleSimulation_acceptedThrough (A : HiddenRule n R) (r : R)
+    (s v : Weights n) (π : ArrivalOrder n) (t : ℕ) :
+    acceptedThrough (sampleSimulation A) r s v π t =
+      hiddenAcceptedThrough A r (glue (A.mask r) s v) π t := by
+  classical
+  ext e
+  by_cases he : e ∈ A.mask r <;>
+    simp [acceptedThrough, hiddenAcceptedThrough, decisionAt, sampleSimulation,
+      simulationDecision, history, prefixIndex, simulationHistory_eq, observed_glue, he]
+
+theorem sampleSimulation_reward (A : HiddenRule n R) (r : R)
+    (s v : Weights n) (π : ArrivalOrder n) :
+    reward (sampleSimulation A) r s v π = hiddenReward A r (glue (A.mask r) s v) π := by
+  classical
+  unfold reward hiddenReward
+  rw [sampleSimulation_acceptedThrough]
+  apply Finset.sum_congr rfl
+  intro e he
+  have he' : e ∉ A.mask r := (Finset.mem_sdiff.mp he).2
+  simp [glue, he']
+
+theorem sampleSimulation_feasible (M : Matroid (Fin n)) (A : HiddenRule n R)
+    (hA : HiddenFeasible M A) : Feasible M (sampleSimulation A) := by
+  intro r s v π t hs hv
+  rw [sampleSimulation_acceptedThrough]
+  apply hA
+  intro e
+  classical
+  by_cases he : e ∈ A.mask r
+  · simpa [glue, he] using hs e
+  · simpa [glue, he] using hv e
+
+lemma reward_nonneg (A : OnlineRule n R) (r : R) (s v : Weights n)
+    (π : ArrivalOrder n) (hv : ∀ e, 0 ≤ v e) : 0 ≤ reward A r s v π :=
+  Finset.sum_nonneg fun e _ => hv e
+
+lemma reward_le_optimum (M : Matroid (Fin n)) (A : OnlineRule n R)
+    (hA : Feasible M A) (r : R) (s v : Weights n) (π : ArrivalOrder n)
+    (hs : ∀ e, 0 ≤ s e) (hv : ∀ e, 0 ≤ v e) :
+    reward A r s v π ≤ optimum M v :=
+  sum_le_optimum M v _ (hA r s v π n hs hv)
+
+lemma hiddenWorstReward_le (A : HiddenRule n R) (w : Weights n)
+    (r : R) (π : ArrivalOrder n) :
+    hiddenWorstReward A w r ≤ hiddenReward A r w π := by
+  classical
+  exact Finset.inf'_le (hiddenReward A r w) (Finset.mem_univ π)
+
+lemma hiddenWorstReward_nonneg (A : HiddenRule n R) (w : Weights n)
+    (hw : ∀ e, 0 ≤ w e) (r : R) : 0 ≤ hiddenWorstReward A w r := by
+  classical
+  apply Finset.le_inf'
+  intro π _
+  exact Finset.sum_nonneg fun e _ => hw e
+
+lemma hiddenWorstReward_le_optimum (M : Matroid (Fin n)) (A : HiddenRule n R)
+    (hA : HiddenFeasible M A) (w : Weights n) (hw : ∀ e, 0 ≤ w e) (r : R) :
+    hiddenWorstReward A w r ≤ optimum M w := by
+  apply (hiddenWorstReward_le A w r (Equiv.refl _)).trans
+  exact sum_le_optimum M w _ (hA w hw r (Equiv.refl _) n)
+
+lemma measurable_decisionAt {n : ℕ} {R : Type*} [MeasurableSpace R] (A : OnlineRule n R)
+    (π : ArrivalOrder n) (k : Fin n) :
+    Measurable (fun x : R × (Weights n × Weights n) =>
+      decisionAt A x.1 x.2.1 x.2.2 π k) :=
+  (A.measurable_decide k).comp
+    (measurable_fst.prodMk ((measurable_fst.comp measurable_snd).prodMk
+      ((measurable_history π k).comp (measurable_snd.comp measurable_snd))))
+
+lemma reward_eq_sum {n : ℕ} {R : Type*} [MeasurableSpace R] (A : OnlineRule n R) (r : R)
+    (s v : Weights n) (π : ArrivalOrder n) :
+    reward A r s v π =
+      ∑ e : Fin n, if decisionAt A r s v π (π.symm e) = true then v e else 0 := by
+  classical
+  unfold reward acceptedThrough
+  rw [Finset.sum_filter]
+  apply Finset.sum_congr rfl
+  intro e _
+  simp only [(π.symm e).isLt, true_and]
+
+lemma measurable_reward_fixed_order {n : ℕ} {R : Type*} [MeasurableSpace R] (A : OnlineRule n R)
+    (π : ArrivalOrder n) :
+    Measurable (fun x : R × (Weights n × Weights n) =>
+      reward A x.1 x.2.1 x.2.2 π) := by
+  classical
+  simp_rw [reward_eq_sum]
+  apply Finset.measurable_sum
+  intro e _
+  have hd := measurable_decisionAt A π (π.symm e)
+  have ht : MeasurableSet {x : R × (Weights n × Weights n) |
+      decisionAt A x.1 x.2.1 x.2.2 π (π.symm e) = true} :=
+    hd (measurableSet_singleton true)
+  exact Measurable.ite ht
+    ((measurable_pi_apply e).comp (measurable_snd.comp measurable_snd)) measurable_const
+
+/-- The realized reward remains measurable for arbitrary measurable adversarial permutations. -/
+theorem measurable_reward {n : ℕ} {R : Type*} [MeasurableSpace R] (A : OnlineRule n R) :
+    Measurable (fun x : ArrivalOrder n × (R × (Weights n × Weights n)) =>
+      reward A x.2.1 x.2.2.1 x.2.2.2 x.1) :=
+  measurable_from_prod_countable_right (measurable_reward_fixed_order A)
+
+@[simp] lemma glue_self (mask : Finset (Fin n)) (w : Weights n) :
+    glue mask w w = w := by
+  classical
+  funext e
+  simp [glue]
+
+lemma measurable_hiddenReward {n : ℕ} {R : Type*} [MeasurableSpace R] (A : HiddenRule n R) (π : ArrivalOrder n) :
+    Measurable (fun x : R × Weights n => hiddenReward A x.1 x.2 π) := by
+  have hm := (measurable_reward_fixed_order (sampleSimulation A) π).comp
+    (measurable_fst.prodMk (measurable_snd.prodMk measurable_snd))
+  simpa only [Function.comp_def, sampleSimulation_reward, glue_self] using hm
+
+lemma measurable_hiddenWorstReward {n : ℕ} {R : Type*} [MeasurableSpace R] (A : HiddenRule n R) :
+    Measurable (fun x : R × Weights n => hiddenWorstReward A x.2 x.1) := by
+  classical
+  have hm : Measurable ((Finset.univ : Finset (ArrivalOrder n)).inf'
+      Finset.univ_nonempty (fun π (x : R × Weights n) => hiddenReward A x.1 x.2 π)) :=
+    Finset.inf'_induction Finset.univ_nonempty _
+      (fun _ hf _ hg => hf.inf hg) (fun π _ => measurable_hiddenReward A π)
+  convert hm using 1
+  ext x
+  simp only [hiddenWorstReward, Finset.inf'_apply]
+
+lemma measurable_glue (mask : Finset (Fin n)) :
+    Measurable (fun x : Weights n × Weights n => glue mask x.1 x.2) :=
+  MatroidProphet.measurable_glue mask
+
+lemma measurable_glue_seed (mask : R → Finset (Fin n)) (hmask : Measurable mask) :
+    Measurable (fun x : R × (Weights n × Weights n) => glue (mask x.1) x.2.1 x.2.2) := by
+  have h : Measurable (fun x : Finset (Fin n) × (Weights n × Weights n) =>
+      glue x.1 x.2.1 x.2.2) :=
+    measurable_from_prod_countable_right measurable_glue
+  exact h.comp ((hmask.comp measurable_fst).prodMk measurable_snd)
+
+theorem glue_fixed_law {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (S V : Ω → Weights n) (hS : Measurable S) (hV : Measurable V)
+    (hi : iIndepFun (pairedCoordinates S V) μ)
+    (hlaw : ∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e))
+    (mask : Finset (Fin n)) :
+    μ.map (fun ω => glue mask (S ω) (V ω)) = μ.map V :=
+  MatroidProphet.glue_fixed_law μ S V hS hV hi hlaw mask
+
+/-- Joint gluing law with an arbitrary measurable complete seed; in particular,
+the observation mask may depend on all of that seed. -/
+theorem glue_seed_joint_law {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (ν : Measure R) [IsProbabilityMeasure ν]
+    (S V : Ω → Weights n) (seed : Ω → R)
+    (hS : Measurable S) (hV : Measurable V) (hseedM : Measurable seed)
+    (hi : iIndepFun (pairedCoordinates S V) μ)
+    (hlaw : ∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e))
+    (hseed : IndepFun (fun ω => (S ω, V ω)) seed μ)
+    (hseedLaw : μ.map seed = ν) (mask : R → Finset (Fin n)) (hmask : Measurable mask) :
+    MeasurePreserving (fun ω => (seed ω, glue (mask (seed ω)) (S ω) (V ω)))
+      μ (ν.prod (μ.map V)) := by
+  have hfiber (r : R) :
+      (μ.map (fun ω => (S ω, V ω))).map (fun d => glue (mask r) d.1 d.2) = μ.map V := by
+    rw [Measure.map_map (measurable_glue (mask r)) (hS.prodMk hV)]
+    exact glue_fixed_law μ S V hS hV hi hlaw (mask r)
+  have hstart : MeasurePreserving (fun ω => (seed ω, (S ω, V ω))) μ
+      (ν.prod (μ.map (fun ω => (S ω, V ω)))) := by
+    refine ⟨hseedM.prodMk (hS.prodMk hV), ?_⟩
+    rw [hseed.symm.map_prod_eq_prod_map_map hseedM.aemeasurable
+      (hS.prodMk hV).aemeasurable, hseedLaw]
+  have hend := (MeasurePreserving.id ν).skew_product
+    (g := fun (r : R) (d : Weights n × Weights n) => glue (mask r) d.1 d.2)
+    (measurable_glue_seed mask hmask) (ae_of_all _ hfiber)
+  exact hend.comp hstart
+
+/-- Nonnegativity of a finite vector is a Borel condition. -/
+lemma measurableSet_nonnegative (n : ℕ) :
+    MeasurableSet {w : Weights n | ∀ e, 0 ≤ w e} := by
+  simp only [Set.ofPred_forall]
+  exact MeasurableSet.iInter fun e => measurableSet_le measurable_const (measurable_pi_apply e)
+
+lemma integrable_hidden_product {n : ℕ} {Ξ : Type*} [MeasurableSpace Ξ] (M : Matroid (Fin n)) (A : HiddenRule n Ξ)
+    (ν : Measure (Ξ)) [IsProbabilityMeasure ν] (ρ : Measure (Weights n)) [SFinite ρ]
+    (hA : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      ∀ (r : Ξ) (π : ArrivalOrder n) (t : ℕ),
+        M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n)))
+    (hNN : ∀ᵐ w ∂ρ, ∀ e, 0 ≤ w e) (hopt : Integrable (optimum M) ρ) :
+    Integrable (fun x : Ξ × Weights n => hiddenWorstReward A x.2 x.1)
+      (ν.prod ρ) := by
+  apply (hopt.comp_snd ν).mono' (measurable_hiddenWorstReward A).aestronglyMeasurable
+  filter_upwards [(Measure.quasiMeasurePreserving_snd (μ := ν) (ν := ρ)).ae hNN] with x hx
+  rw [Real.norm_eq_abs, abs_of_nonneg (hiddenWorstReward_nonneg A x.2 hx x.1)]
+  exact hiddenWorstReward_le_optimum M A hA x.2 hx x.1
+
+lemma hidden_product_integral_bound {n : ℕ} {Ξ : Type*} [MeasurableSpace Ξ] (M : Matroid (Fin n))
+    (A : HiddenRule n Ξ) (ν : Measure (Ξ)) [IsProbabilityMeasure ν]
+    (ρ : Measure (Weights n)) [IsProbabilityMeasure ρ] (c : ℝ)
+    (hA : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      ∀ (r : Ξ) (π : ArrivalOrder n) (t : ℕ),
+        M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n)))
+    (hNN : ∀ᵐ w ∂ρ, ∀ e, 0 ≤ w e) (hopt : Integrable (optimum M) ρ)
+    (hbound : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      c * optimum M w ≤ ∫ r, hiddenWorstReward A w r ∂ν) :
+    c * (∫ w, optimum M w ∂ρ) ≤
+      ∫ x : Ξ × Weights n, hiddenWorstReward A x.2 x.1 ∂ν.prod ρ := by
+  have hip := integrable_hidden_product M A ν ρ hA hNN hopt
+  rw [← integral_const_mul]
+  calc
+    _ ≤ ∫ w, ∫ r, hiddenWorstReward A w r ∂ν ∂ρ := by
+      apply integral_mono_ae (hopt.const_mul c) hip.integral_prod_right
+      filter_upwards [hNN] with w hw
+      exact hbound w hw
+    _ = _ := (integral_prod_symm _ hip).symm
+
+lemma integrable_feasible_reward {n : ℕ} {Ξ : Type*} [MeasurableSpace Ξ] (M : Matroid (Fin n))
+    (A : OnlineRule n Ξ) (hA : Feasible M A)
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (S V : Ω → Weights n) (R : Ω → Ξ) (π : Ω → ArrivalOrder n)
+    (hS : Measurable S) (hV : Measurable V) (hR : Measurable R) (hπ : Measurable π)
+    (hSN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ S ω e) (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e)
+    (hopt : Integrable (fun ω => optimum M (V ω)) μ) :
+    Integrable (fun ω => reward A (R ω) (S ω) (V ω) (π ω)) μ := by
+  have hrm := (measurable_reward A).comp (hπ.prodMk (hR.prodMk (hS.prodMk hV)))
+  apply hopt.mono' hrm.aestronglyMeasurable
+  filter_upwards [hSN, hVN] with ω hs hv
+  change ‖reward A (R ω) (S ω) (V ω) (π ω)‖ ≤ optimum M (V ω)
+  rw [Real.norm_eq_abs, abs_of_nonneg (reward_nonneg A (R ω) (S ω) (V ω) (π ω) hv)]
+  exact reward_le_optimum M A hA (R ω) (S ω) (V ω) (π ω) hs hv
+
+/-- The full one-sample integration step preserves the expected minimum over all orders. -/
+theorem oneSample_of_hidden {n : ℕ} {Ξ : Type*} [MeasurableSpace Ξ] (M : Matroid (Fin n)) (A : HiddenRule n Ξ)
+    (ν : Measure (Ξ)) [IsProbabilityMeasure ν] (c : ℝ)
+    (hA : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      ∀ (r : Ξ) (π : ArrivalOrder n) (t : ℕ),
+        M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n)))
+    (hbound : ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      c * optimum M w ≤ ∫ r, hiddenWorstReward A w r ∂ν)
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (S V : Ω → Weights n) (R : Ω → Ξ)
+    (hS : Measurable S) (hV : Measurable V) (hR : Measurable R)
+    (hSN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ S ω e) (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e)
+    (hi : iIndepFun (pairedCoordinates S V) μ)
+    (hlaw : ∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e))
+    (hseed : IndepFun (fun ω => (S ω, V ω)) R μ)
+    (hRlaw : μ.map R = ν)
+    (hopt : Integrable (fun ω => optimum M (V ω)) μ)
+    (π : Ω → ArrivalOrder n) (hπ : Measurable π) :
+    Integrable (fun ω => reward (sampleSimulation A) (R ω) (S ω) (V ω) (π ω)) μ ∧
+      c * (∫ ω, optimum M (V ω) ∂μ) ≤
+        ∫ ω, reward (sampleSimulation A) (R ω) (S ω) (V ω) (π ω) ∂μ := by
+  have hj := glue_seed_joint_law μ ν S V R hS hV hR hi hlaw hseed hRlaw A.mask A.measurable_mask
+  have hoptLaw : Integrable (optimum M) (μ.map V) :=
+    (integrable_map_measure (measurable_optimum M).aestronglyMeasurable hV.aemeasurable).2 hopt
+  have hNNLaw : ∀ᵐ w ∂μ.map V, ∀ e, 0 ≤ w e :=
+    (ae_map_iff hV.aemeasurable (measurableSet_nonnegative n)).2 hVN
+  have hip := integrable_hidden_product M A ν (μ.map V) hA hNNLaw hoptLaw
+  have him := hj.integrable_comp_of_integrable hip
+  have hri := integrable_feasible_reward M (sampleSimulation A)
+    (sampleSimulation_feasible M A hA) μ S V R π hS hV hR hπ hSN hVN hopt
+  have hb := hidden_product_integral_bound M A ν (μ.map V) c hA hNNLaw hoptLaw hbound
+  have hoptEq := integral_map_of_stronglyMeasurable (μ := μ) hV
+    (measurable_optimum M).stronglyMeasurable
+  have hminEq := integral_map_of_stronglyMeasurable (μ := μ) hj.measurable
+    (measurable_hiddenWorstReward A).stronglyMeasurable
+  rw [hj.map_eq] at hminEq
+  rw [hoptEq, hminEq] at hb
+  refine ⟨hri, hb.trans (integral_mono_ae him hri (ae_of_all _ ?_))⟩
+  intro ω
+  change hiddenWorstReward A (glue (A.mask (R ω)) (S ω) (V ω)) (R ω) ≤
+    reward (sampleSimulation A) (R ω) (S ω) (V ω) (π ω)
+  rw [sampleSimulation_reward]
+  exact hiddenWorstReward_le A _ (R ω) (π ω)
+
+/-- The manuscript's simulation lemma without any finite-seed restriction. -/
+theorem simulation_contract.{u, v} : SimulationContract.{u, v} := by
+  intro n R mR M A ν hν c hA hbound
+  let := hν
+  refine ⟨sampleSimulation A, ?_, sampleSimulation_feasible M A hA,
+    sampleSimulation_acceptedThrough A, sampleSimulation_reward A, ?_⟩
+  · intro k r s h
+    rfl
+  · intro Ω mΩ μ hμ S V seed hS hV hseedM hSN hVN hi hlaw hseed hseedLaw hopt π hπ
+    exact ⟨glue_seed_joint_law μ ν S V seed hS hV hseedM hi hlaw hseed hseedLaw
+      A.mask A.measurable_mask,
+      oneSample_of_hidden M A ν c hA hbound μ S V seed hS hV hseedM hSN hVN
+        hi hlaw hseed hseedLaw hopt π hπ⟩
+
+/-- The concrete finite-seed information model is a special case, with exactly
+the same decisions rather than an unrelated replacement rule. -/
+def OnlineRule.ofFinite {bits : ℕ} (A : MatroidProphet.OnlineRule n bits) :
+    OnlineRule n (Seed bits) where
+  decide := A.decide
+  measurable_decide := A.measurable_decide
+
+def HiddenRule.ofFinite {bits : ℕ} (A : MatroidProphet.HiddenRule n bits) :
+    HiddenRule n (Seed bits) where
+  mask := A.mask
+  measurable_mask := measurable_of_countable A.mask
+  core := OnlineRule.ofFinite A.core
+
+@[simp] lemma acceptedThrough_ofFinite {bits : ℕ}
+    (A : MatroidProphet.OnlineRule n bits) (r : Seed bits) (s v : Weights n)
+    (π : ArrivalOrder n) (t : ℕ) :
+    acceptedThrough (OnlineRule.ofFinite A) r s v π t =
+      MatroidProphet.acceptedThrough A r s v π t := rfl
+
+@[simp] lemma hiddenAcceptedThrough_ofFinite {bits : ℕ}
+    (A : MatroidProphet.HiddenRule n bits) (r : Seed bits) (w : Weights n)
+    (π : ArrivalOrder n) (t : ℕ) :
+    hiddenAcceptedThrough (HiddenRule.ofFinite A) r w π t =
+      MatroidProphet.hiddenAcceptedThrough A r w π t := rfl
+
+@[simp] lemma hiddenWorstReward_ofFinite {bits : ℕ}
+    (A : MatroidProphet.HiddenRule n bits) (w : Weights n) (r : Seed bits) :
+    hiddenWorstReward (HiddenRule.ofFinite A) w r = MatroidProphet.hiddenWorstReward A w r := rfl
+
+end MatroidProphet.General
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/GeneralSimulationModel.lean

@@ -0,0 +1,130 @@
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.Probability.Independence.Basic
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+namespace OAI
+
+namespace MatroidProphet.General
+
+open MeasureTheory ProbabilityTheory
+
+/-- A decision uses only the entire initial seed, the initially observed vector,
+and the label/value history through the current arrival. -/
+structure OnlineRule (n : ℕ) (R : Type*) [MeasurableSpace R] where
+  decide : (k : Fin n) → R → Weights n → History n k → Bool
+  measurable_decide : ∀ k, Measurable
+    (fun x : R × (Weights n × History n k) => decide k x.1 x.2.1 x.2.2)
+
+def decisionAt {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : OnlineRule n R) (r : R) (s v : Weights n)
+    (π : ArrivalOrder n) (k : Fin n) : Bool :=
+  A.decide k r s (history v π k)
+
+noncomputable def acceptedThrough {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : OnlineRule n R) (r : R) (s v : Weights n)
+    (π : ArrivalOrder n) (t : ℕ) : Finset (Fin n) := by
+  classical
+  exact Finset.univ.filter fun e =>
+    (π.symm e).val < t ∧ decisionAt A r s v π (π.symm e) = true
+
+noncomputable def reward {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : OnlineRule n R) (r : R) (s v : Weights n) (π : ArrivalOrder n) : ℝ :=
+  ∑ e ∈ acceptedThrough A r s v π n, v e
+
+def Feasible {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (M : Matroid (Fin n)) (A : OnlineRule n R) : Prop :=
+  ∀ (r : R) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ),
+    (∀ e, 0 ≤ s e) → (∀ e, 0 ≤ v e) →
+    M.Indep (acceptedThrough A r s v π t : Set (Fin n))
+
+/-- The observation mask is a measurable function of the seed alone. -/
+structure HiddenRule (n : ℕ) (R : Type*) [MeasurableSpace R] where
+  mask : R → Finset (Fin n)
+  measurable_mask : Measurable mask
+  core : OnlineRule n R
+
+noncomputable def observed {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (r : R) (w : Weights n) : Weights n := by
+  classical
+  exact fun e => if e ∈ A.mask r then w e else 0
+
+noncomputable def hiddenAcceptedThrough {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (r : R) (w : Weights n)
+    (π : ArrivalOrder n) (t : ℕ) : Finset (Fin n) :=
+  acceptedThrough A.core r (observed A r w) w π t \ A.mask r
+
+noncomputable def hiddenReward {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (r : R) (w : Weights n) (π : ArrivalOrder n) : ℝ :=
+  ∑ e ∈ hiddenAcceptedThrough A r w π n, w e
+
+noncomputable def hiddenWorstReward {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (w : Weights n) (r : R) : ℝ := by
+  classical
+  exact Finset.univ.inf' Finset.univ_nonempty (hiddenReward A r w)
+
+def HiddenFeasible {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (M : Matroid (Fin n)) (A : HiddenRule n R) : Prop :=
+  ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+    ∀ (r : R) (π : ArrivalOrder n) (t : ℕ),
+      M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n))
+
+/-- Sample values on the sacrificed mask, and realized values elsewhere. -/
+noncomputable def glue {n : ℕ} (mask : Finset (Fin n)) (s v : Weights n) : Weights n := by
+  classical
+  exact fun e => if e ∈ mask then s e else v e
+
+noncomputable def simulationHistory {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (r : R) (s : Weights n)
+    {k : Fin n} (h : History n k) : History n k := by
+  classical
+  exact fun j => ((h j).1, if (h j).1 ∈ A.mask r then s (h j).1 else (h j).2)
+
+ 
+
+noncomputable def simulationDecision {n : ℕ} {R : Type*} [MeasurableSpace R]
+    (A : HiddenRule n R) (k : Fin n) (r : R) (s : Weights n)
+    (h : History n k) : Bool := by
+  classical
+  exact if (h ⟨k.val, Nat.lt_succ_self _⟩).1 ∈ A.mask r then false
+    else A.core.decide k r (observed A r s) (simulationHistory A r s h)
+
+/-- Full source contract for `lem:simulation`, with arbitrary measurable seed
+and probability spaces.  The simulator is constructed before the distributions
+and adversary are supplied.  Its decision function is specified concretely;
+the conjunction includes exact execution, feasibility, the seed/glued-vector
+joint law, integrability, and preservation of the same competitive ratio. -/
+def SimulationContract.{u, v} : Prop :=
+  ∀ (n : ℕ) (R : Type v) [MeasurableSpace R]
+    (M : Matroid (Fin n)) (A : HiddenRule n R)
+    (ν : Measure R), IsProbabilityMeasure ν →
+    ∀ (c : ℝ), HiddenFeasible M A →
+    (∀ (w : Weights n), (∀ e, 0 ≤ w e) →
+      c * optimum M w ≤ ∫ r, hiddenWorstReward A w r ∂ν) →
+    ∃ B : OnlineRule n R,
+      (∀ (k : Fin n) (r : R) (s : Weights n) (h : History n k),
+        B.decide k r s h = simulationDecision A k r s h) ∧
+      Feasible M B ∧
+      (∀ (r : R) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ),
+        acceptedThrough B r s v π t =
+          hiddenAcceptedThrough A r (glue (A.mask r) s v) π t) ∧
+      (∀ (r : R) (s v : Weights n) (π : ArrivalOrder n),
+        reward B r s v π = hiddenReward A r (glue (A.mask r) s v) π) ∧
+      ∀ {Ω : Type u} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+        (S V : Ω → Weights n) (seed : Ω → R),
+        Measurable S → Measurable V → Measurable seed →
+        (∀ᵐ ω ∂μ, ∀ e, 0 ≤ S ω e) →
+        (∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e) →
+        iIndepFun (pairedCoordinates S V) μ →
+        (∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e)) →
+        IndepFun (fun ω => (S ω, V ω)) seed μ → μ.map seed = ν →
+        Integrable (fun ω => optimum M (V ω)) μ →
+        ∀ (π : Ω → ArrivalOrder n), Measurable π →
+          MeasurePreserving (fun ω => (seed ω, glue (A.mask (seed ω)) (S ω) (V ω)))
+            μ (ν.prod (μ.map V)) ∧
+          Integrable (fun ω => reward B (seed ω) (S ω) (V ω) (π ω)) μ ∧
+          c * (∫ ω, optimum M (V ω) ∂μ) ≤
+            ∫ ω, reward B (seed ω) (S ω) (V ω) (π ω) ∂μ
+
+end MatroidProphet.General
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/InformationRestriction.lean

@@ -0,0 +1,128 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-!
+# Explicit information restrictions for hidden-vector rules
+
+These lemmas formalize the no-future-information and irrevocability clauses of
+`sections/algorithm.tex`, Lemma `lem:feasibility`. They use only the concrete
+history and acceptance definitions; no correctness hypothesis for an algorithm
+is introduced.
+-/
+
+namespace MatroidProphet
+
+open Finset
+
+lemma observed_eq_of_eq_on_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w w' : Weights n)
+    (h : ∀ e ∈ A.mask r, w e = w' e) :
+    observed A r w = observed A r w' := by
+  classical
+  funext e
+  by_cases he : e ∈ A.mask r
+  · simp only [observed, ite_eq_left he, h e he]
+  · simp only [observed, ite_eq_right he]
+
+lemma history_eq_of_agree_before {n : ℕ} (v v' : Weights n)
+    (π π' : ArrivalOrder n) (t : ℕ)
+    (h : ∀ j : Fin n, j.val < t → (π j, v (π j)) = (π' j, v' (π' j)))
+    (k : Fin n) (hk : k.val < t) :
+    history v π k = history v' π' k := by
+  funext j
+  exact h (prefixIndex k j) (by dsimp [prefixIndex]; omega)
+
+/-- Equal available label/value pairs give the same accepted set through a prefix.
+The two complete arrival orders and all later values may be different. -/
+theorem acceptedThrough_eq_of_agree_before {n bits : ℕ} (A : OnlineRule n bits)
+    (r : Seed bits) (s v v' : Weights n) (π π' : ArrivalOrder n) (t : ℕ)
+    (h : ∀ j : Fin n, j.val < t → (π j, v (π j)) = (π' j, v' (π' j))) :
+    acceptedThrough A r s v π t = acceptedThrough A r s v' π' t := by
+  classical
+  have subset (v₁ v₂ : Weights n) (ρ₁ ρ₂ : ArrivalOrder n)
+      (hρ : ∀ j : Fin n, j.val < t →
+        (ρ₁ j, v₁ (ρ₁ j)) = (ρ₂ j, v₂ (ρ₂ j))) :
+      acceptedThrough A r s v₁ ρ₁ t ⊆ acceptedThrough A r s v₂ ρ₂ t := by
+    intro e he
+    have hmem := (Finset.mem_filter.mp he).2
+    have hl := congrArg Prod.fst (hρ (ρ₁.symm e) hmem.1)
+    have hidx : ρ₂.symm e = ρ₁.symm e := by
+      apply ρ₂.injective
+      simpa only [Equiv.apply_symm_apply] using hl
+    apply Finset.mem_filter.mpr
+    refine ⟨Finset.mem_univ e, ?_, ?_⟩
+    · simpa only [hidx] using hmem.1
+    · rw [hidx]
+      rw [← decisionAt_congr A r s v₁ v₂ ρ₁ ρ₂ (ρ₁.symm e)
+        (history_eq_of_agree_before v₁ v₂ ρ₁ ρ₂ t hρ _ hmem.1)]
+      exact hmem.2
+  exact Finset.Subset.antisymm (subset v v' π π' h)
+    (subset v' v π' π (fun j hj => (h j hj).symm))
+
+/-- A hidden-vector execution depends only on its revealed coordinates and the
+actual arrival history, never on the unobserved future values or future order. -/
+theorem hiddenAcceptedThrough_eq_of_same_information {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (w w' : Weights n)
+    (π π' : ArrivalOrder n) (t : ℕ)
+    (hmask : ∀ e ∈ A.mask r, w e = w' e)
+    (hhist : ∀ j : Fin n, j.val < t →
+      (π j, w (π j)) = (π' j, w' (π' j))) :
+    hiddenAcceptedThrough A r w π t = hiddenAcceptedThrough A r w' π' t := by
+  unfold hiddenAcceptedThrough
+  rw [observed_eq_of_eq_on_mask A r w w' hmask]
+  rw [acceptedThrough_eq_of_agree_before A.core r (observed A r w') w w' π π' t hhist]
+
+/-- Hidden-vector acceptances cannot be revoked. -/
+theorem hiddenAcceptedThrough_monotone {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) (π : ArrivalOrder n) :
+    Monotone (hiddenAcceptedThrough A r w π) := by
+  intro t t' htt' e he
+  have hm := Finset.mem_sdiff.mp he
+  exact Finset.mem_sdiff.mpr
+    ⟨acceptedThrough_mono A.core r (observed A r w) w π htt' hm.1, hm.2⟩
+
+/-- Sacrifice is literal rejection, not merely exclusion from the reward sum. -/
+theorem hiddenAcceptedThrough_disjoint_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) (π : ArrivalOrder n) (t : ℕ) :
+    Disjoint (hiddenAcceptedThrough A r w π t) (A.mask r) := by
+  exact Finset.sdiff_disjoint
+
+/-- Every accepted hidden-vector label has actually arrived. -/
+theorem hiddenAcceptedThrough_arrived {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) (π : ArrivalOrder n) (t : ℕ)
+    (e : Fin n) (he : e ∈ hiddenAcceptedThrough A r w π t) :
+    (π.symm e).val < t :=
+  acceptedThrough_arrived A.core r (observed A r w) w π t e
+    (Finset.mem_sdiff.mp he).1
+
+/-- The observation operation is jointly measurable in the complete initial seed
+and the hidden vector, despite an arbitrary seed-dependent mask. -/
+lemma measurable_observed_seed {n bits : ℕ} (A : HiddenRule n bits) :
+    Measurable (fun x : Seed bits × Weights n => observed A x.1 x.2) := by
+  classical
+  apply measurable_from_prod_countable_right
+  intro r
+  apply Measurable.of_eval
+  intro e
+  by_cases he : e ∈ A.mask r
+  · simpa only [observed, ite_eq_left he] using
+      (measurable_pi_apply e : Measurable (fun w : Weights n => w e))
+  · simpa only [observed, ite_eq_right he] using
+      (measurable_const : Measurable (fun _ : Weights n => (0 : ℝ)))
+
+/-- With observations substituted, the actual core decision remains measurable. -/
+lemma measurable_hidden_core_decide {n bits : ℕ} (A : HiddenRule n bits)
+    (k : Fin n) :
+    Measurable (fun x : Seed bits × (Weights n × History n k) =>
+      A.core.decide k x.1 (observed A x.1 x.2.1) x.2.2) := by
+  apply measurable_from_prod_countable_right
+  intro r
+  exact (A.core.measurable_decide k).comp
+    (measurable_const.prodMk
+      (((measurable_observed_seed A).comp
+        (measurable_const.prodMk measurable_fst)).prodMk measurable_snd))
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/SimulationInformation.lean

@@ -0,0 +1,116 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-!
+# Information restrictions of the one-sample simulation
+
+These pointwise statements make explicit the information restrictions used in
+`sections/setup.tex`, Lemma `lem:simulation`: unused samples and online values
+of sacrificed labels cannot affect the execution.  The final two replay
+identities also support the prefix/suffix construction in `sections/secretary.tex`.
+No independence, positivity, or feasibility assumptions are needed for these
+deterministic identities.
+-/
+
+namespace MatroidProphet
+
+lemma simulationObserved_eq_of_eq_on_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (s s' : Weights n)
+    (hs : ∀ e ∈ A.mask r, s e = s' e) :
+    observed A r s = observed A r s' := by
+  classical
+  funext e
+  by_cases he : e ∈ A.mask r
+  · simp [observed, he, hs e he]
+  · simp [observed, he]
+
+lemma simulationHistory_eq_of_eq_on_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (s s' : Weights n) {k : Fin n} (h : History n k)
+    (hs : ∀ e ∈ A.mask r, s e = s' e) :
+    simulationHistory A r s h = simulationHistory A r s' h := by
+  classical
+  funext j
+  by_cases he : (h j).1 ∈ A.mask r
+  · simp [simulationHistory, he, hs _ he]
+  · simp [simulationHistory, he]
+
+/-- The simulator's current decision ignores every sample outside its mask. -/
+theorem sampleSimulation_decide_eq_of_eq_on_mask {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (s s' : Weights n)
+    (k : Fin n) (h : History n k)
+    (hs : ∀ e ∈ A.mask r, s e = s' e) :
+    (sampleSimulation A).decide k r s h =
+      (sampleSimulation A).decide k r s' h := by
+  classical
+  simp only [sampleSimulation]
+  rw [simulationObserved_eq_of_eq_on_mask A r s s' hs,
+    simulationHistory_eq_of_eq_on_mask A r s s' h hs]
+
+lemma glue_eq_of_eq_on_regions {n : ℕ} (mask : Finset (Fin n))
+    (s s' v v' : Weights n)
+    (hs : ∀ e ∈ mask, s e = s' e)
+    (hv : ∀ e ∉ mask, v e = v' e) :
+    glue mask s v = glue mask s' v' := by
+  classical
+  funext e
+  by_cases he : e ∈ mask
+  · simp [glue, he, hs e he]
+  · simp [glue, he, hv e he]
+
+/-- Neither unused samples nor sacrificed online values change any accepted prefix. -/
+theorem sampleSimulation_acceptedThrough_noninterference {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (s s' v v' : Weights n)
+    (π : ArrivalOrder n) (t : ℕ)
+    (hs : ∀ e ∈ A.mask r, s e = s' e)
+    (hv : ∀ e ∉ A.mask r, v e = v' e) :
+    acceptedThrough (sampleSimulation A) r s v π t =
+      acceptedThrough (sampleSimulation A) r s' v' π t := by
+  rw [sampleSimulation_acceptedThrough, sampleSimulation_acceptedThrough,
+    glue_eq_of_eq_on_regions (A.mask r) s s' v v' hs hv]
+
+/-- The same information invariance holds for the reward in actual online values. -/
+theorem sampleSimulation_reward_noninterference {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (s s' v v' : Weights n)
+    (π : ArrivalOrder n)
+    (hs : ∀ e ∈ A.mask r, s e = s' e)
+    (hv : ∀ e ∉ A.mask r, v e = v' e) :
+    reward (sampleSimulation A) r s v π =
+      reward (sampleSimulation A) r s' v' π := by
+  rw [sampleSimulation_reward, sampleSimulation_reward,
+    glue_eq_of_eq_on_regions (A.mask r) s s' v v' hs hv]
+
+/-- A sacrificed label is rejected at every prefix, irrespective of its value. -/
+theorem sampleSimulation_rejects_mask {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ)
+    (e : Fin n) (he : e ∈ A.mask r) :
+    e ∉ acceptedThrough (sampleSimulation A) r s v π t := by
+  rw [sampleSimulation_acceptedThrough]
+  exact fun h => (Finset.mem_sdiff.mp h).2 he
+
+lemma glue_observed_left {n bits : ℕ} (A : HiddenRule n bits)
+    (r : Seed bits) (w : Weights n) :
+    glue (A.mask r) (observed A r w) w = w := by
+  classical
+  funext e
+  by_cases he : e ∈ A.mask r <;> simp [glue, observed, he]
+
+/-- Replaying the full arrived history after supplying only the observed mask
+agrees exactly with the hidden rule, at every prefix including zero. -/
+theorem sampleSimulation_replay_acceptedThrough {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (w : Weights n)
+    (π : ArrivalOrder n) (t : ℕ) :
+    acceptedThrough (sampleSimulation A) r (observed A r w) w π t =
+      hiddenAcceptedThrough A r w π t := by
+  rw [sampleSimulation_acceptedThrough, glue_observed_left]
+
+/-- The replay identity preserves the actual reward without a numerical loss. -/
+theorem sampleSimulation_replay_reward {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (w : Weights n)
+    (π : ArrivalOrder n) :
+    reward (sampleSimulation A) r (observed A r w) w π = hiddenReward A r w π := by
+  rw [sampleSimulation_reward, glue_observed_left]
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/StrongOneSample.lean

@@ -0,0 +1,59 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-!
+# The stronger constant for the concrete one-sample rule
+
+The introduction explicitly records the stronger `2⁻²⁹³` constant proved in
+accounting.tex.  The root endpoint uses its announced `2⁻³¹⁰` constant.  This
+supporting theorem exposes the stronger claim for the actual constructed rule,
+without changing the endpoint or imposing moments on individual loop values.
+
+The rule and initial seed law below depend only on the known labeled matroid.
+The probability space, matching input laws, and full-seed-aware adversary are
+supplied afterwards.  Feasibility is pointwise at every prefix and the reward
+estimate uses only integrability of the actual offline optimum.
+-/
+
+namespace MatroidProphet
+
+open MeasureTheory ProbabilityTheory
+
+/-- The actual simulated source rule is feasible before any laws are chosen. -/
+theorem source_one_sample_feasible {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) :
+    Feasible M (sampleSimulation (completeHiddenRule M hE)) :=
+  sampleSimulation_feasible M (completeHiddenRule M hE)
+    (completeHiddenRule_feasible M hE)
+
+/-- The source construction attains the stronger constant advertised after
+`thm:main`, even when the order sees the complete initial seed.  This is a
+consequence for the concrete rule, not a premise asserting its performance. -/
+theorem source_one_sample_strong {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ)
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (S V : Ω → Weights n) (R : Ω → Seed (mainSeedBits n))
+    (hS : Measurable S) (hV : Measurable V) (hR : Measurable R)
+    (hSN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ S ω e)
+    (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e)
+    (hi : iIndepFun (pairedCoordinates S V) μ)
+    (hlaw : ∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e))
+    (hseed : IndepFun (fun ω => (S ω, V ω)) R μ)
+    (hRlaw : μ.map R = sourceSeedLaw n)
+    (hopt : Integrable (fun ω => optimum M (V ω)) μ)
+    (π : Ω → ArrivalOrder n) (hπ : Measurable π) :
+    Integrable (fun ω =>
+      reward (sampleSimulation (completeHiddenRule M hE))
+        (R ω) (S ω) (V ω) (π ω)) μ ∧
+      ((2 : ℝ) ^ 293)⁻¹ * (∫ ω, optimum M (V ω) ∂μ) ≤
+        ∫ ω, reward (sampleSimulation (completeHiddenRule M hE))
+          (R ω) (S ω) (V ω) (π ω) ∂μ :=
+  oneSample_of_hidden M (completeHiddenRule M hE) (sourceSeedLaw n)
+    (((2 : ℝ) ^ 293)⁻¹) (completeHiddenRule_feasible M hE)
+    (complete_hidden_guarantee M hE) μ S V R hS hV hR hSN hVN
+    hi hlaw hseed hRlaw hopt π hπ
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/TransferContract.lean

@@ -0,0 +1,95 @@
+import OAI.Probability.MatroidProphet.Main
+import OAI.Probability.MatroidSecretary.Transport.TransferSpecification
+
+namespace OAI
+
+/-!
+# Source-facing sample-to-rank transfer
+
+Source: `sections/transfer.tex`, `lem:transfer` / `eq:rank-transfer`.
+The comparison set is the actual priority-greedy survivor group; its independence
+and containment are proved, not supplied as extra assumptions.  `mainMean` fixes
+only H and averages the density, guard, test, and parity coins.  `trueZ` uses zero
+on unlisted outcomes, so the expectation is not conditioned on listing.
+-/
+
+namespace MatroidProphet.SourceProof
+
+open Finset MainAlgorithm
+
+/-- Conditional averaging depends on the fixed filter mask only.  All other
+fields of the initial record are overwritten by independent product samples. -/
+lemma mainMean_filter_congr {n : ℕ} (d d' : MainMasks n)
+    (hH : d.H = d'.H) (f : MainMasks n → ℝ) : mainMean d f = mainMean d' f := by
+  rcases d with ⟨H, D, C, T, p⟩
+  rcases d' with ⟨H', D', C', T', p'⟩
+  change H = H' at hH
+  subst H'
+  rfl
+
+/-- The unlisted branch is included in the product average with zero statistic. -/
+lemma trueZ_unlisted {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (hi : i ∉ groups M d s) : trueZ M hE d s i = 0 := by
+  classical
+  simp only [trueZ, ite_eq_right hi]
+
+/-- In particular, a true group missed by the discovery sample contributes zero;
+no positivity or listing assumption is imposed on the individual outcomes. -/
+lemma trueZ_zero_of_no_discovery {n : ℕ} (M : Matroid (Fin n))
+    (hE : M.E = Set.univ) (d : MainMasks n) (s : Fin n → Option ℤ) (i : ℤ)
+    (hmiss : d.D ∩ trueGroup M d s i = ∅) : trueZ M hE d s i = 0 := by
+  apply trueZ_unlisted
+  intro hi
+  obtain ⟨e, heD, heU⟩ := (mem_listed_iff M d s i).mp ((mem_groups M d s i).mp hi)
+  have he : e ∈ d.D ∩ trueGroup M d s i := mem_inter.mpr ⟨heD, heU⟩
+  rw [hmiss] at he
+  exact notMem_empty e he
+
+/-- The source transfer at arbitrary rounded-level keys.  This stronger helper
+also covers the `none` keys representing zero/nonpositive weights. -/
+theorem transfer_keys {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (s : Fin n → Option ℤ) (H : Finset (Fin n)) (i : ℤ) :
+    let d : MainMasks n := ⟨H, ∅, ∅, ∅, false⟩
+    let U := trueGroup M d s i
+    let Y := (positiveGreedy M s \ H).filter (fun e => s e = some i)
+    densityThreshold ≤ (U.card : ℝ) →
+      ((((2 : ℝ)^16)⁻¹ * Y.card - ((2 : ℝ)^23)⁻¹ * U.card) / (2 : ℝ)^100) ≤
+        mainMean d (fun d' => (trueZ M hE d' s i : ℝ)) := by
+  classical
+  dsimp only
+  intro hn
+  let d : MainMasks n := ⟨H, ∅, ∅, ∅, false⟩
+  let Y := (positiveGreedy M s \ H).filter (fun e => s e = some i)
+  have hY : (Y : Set (Fin n)) ⊆ (trueGroup M d s i : Set (Fin n)) := by
+    intro e he
+    rw [trueGroup_eq_candidate_filter]
+    rcases mem_filter.mp he with ⟨heG, hei⟩
+    exact mem_filter.mpr ⟨positiveGreedy_survivors_subset M s H heG, hei⟩
+  have hI : M.Indep (Y : Set (Fin n)) :=
+    (positiveGreedy_survivors_indep M hE s H).subset
+      (fun _ he => (mem_filter.mp he).1)
+  have h := mainMean_trueZ_lower M hE d s i (Y : Set (Fin n)) hY hI hn
+  simpa only [Set.ncard_coe_finset, retainedFraction, densityThreshold, d, Y] using h
+
+/-- `lem:transfer` for the manuscript's actual rounded nonnegative weights,
+with literal constants gamma = 2^-16 and kappa = 2^100. -/
+theorem transfer {n : ℕ} (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (w : Weights n) (_hw : ∀ e, 0 ≤ w e) (H : Finset (Fin n)) (i : ℤ) :
+    let s : Fin n → Option ℤ := fun e => roundedLevel weightBase (w e)
+    let d : MainMasks n := ⟨H, ∅, ∅, ∅, false⟩
+    let U := trueGroup M d s i
+    let Y := (positiveGreedy M s \ H).filter (fun e => s e = some i)
+    densityThreshold ≤ (U.card : ℝ) →
+      ((((2 : ℝ)^16)⁻¹ * Y.card - ((2 : ℝ)^23)⁻¹ * U.card) / (2 : ℝ)^100) ≤
+        mainMean d (fun d' => (trueZ M hE d' s i : ℝ)) :=
+  transfer_keys M hE (fun e => roundedLevel weightBase (w e)) H i
+
+/-- Thin proof alias for the independent root-target specification. -/
+theorem transfer_claim : TransferClaim := by
+  intro n M hE w hw H i
+  exact transfer M hE w hw H i
+
+end MatroidProphet.SourceProof
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/TransferContracts.lean

@@ -0,0 +1,106 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+namespace MatroidProphet
+namespace TransferContracts
+
+open Finset Set Pivots MainAlgorithm
+
+section Pivots
+
+variable {α : Type*} {r q n : ℕ}
+
+/-- An injectively timed sequence determines one recorded pivot-mark vector. -/
+lemma recordsPivots_unique (M : Matroid α) (label : Occurrence r q → α)
+    (test : Fin n → α) (time : Occurrence r q → ℕ)
+    (htime : Function.Injective time) (oldMark : Fin r → Bool)
+    (movableMark : Fin q → Bool) {t u : Finset (Fin n)}
+    (ht : RecordsPivots M label test time oldMark movableMark t)
+    (hu : RecordsPivots M label test time oldMark movableMark u) : t = u := by
+  ext f
+  obtain ⟨o, ho, hto⟩ := ht f
+  obtain ⟨p, hp, hup⟩ := hu f
+  have hop := pivot_unique M label time htime ho hp
+  subst p
+  exact hto.symm.trans hup
+
+variable [Fintype α]
+
+/-- Complete marked-pivot contract: arbitrary repeated/redundant old labels,
+all placements/orders/marks of at most `s` movable occurrences, and the exact
+binomial bound. Source old-spanning/nonloop assumptions ensure every permitted
+interleaving actually contributes exactly one vector. No positivity assumption
+on `s`, `q`, `r`, or `n` is imposed. -/
+theorem marked_pivot_contract (M : Matroid α) (b : ℕ → α) (a : Fin q → α)
+    (test : Fin n → α) (oldMark : Fin r → Bool) (s : ℕ) (hqs : q ≤ s)
+    (hground : ∀ o : Occurrence r q, occurrenceLabel b a o ∈ M.E)
+    (holdspan : M.closure (oldPrefix b r) = M.E)
+    (htest : ∀ f, test f ∈ M.E ∧ test f ∉ M.closure ∅) :
+    (markedPivotPatterns M b a test oldMark).card ≤
+        4 ^ s * ∑ k ∈ Finset.Iic s, n.choose k ∧
+      ∀ (time : Occurrence r q → ℕ), OldOrdered time → Function.Injective time →
+        ∀ movableMark : Fin q → Bool,
+          ∃! t, t ∈ markedPivotPatterns M b a test oldMark ∧
+            RecordsPivots M (occurrenceLabel b a) test time oldMark movableMark t := by
+  refine ⟨card_markedPivotPatterns_le M b a test oldMark s hqs hground, ?_⟩
+  intro time horder htime movableMark
+  obtain ⟨t, htmem, ht⟩ := recorded_pattern_exists_of_old_spanning M b a test oldMark
+    holdspan htest time horder htime movableMark
+  refine ⟨t, ⟨htmem, ht⟩, ?_⟩
+  intro u hu
+  exact recordsPivots_unique M (occurrenceLabel b a) test time htime oldMark movableMark hu.2 ht
+
+end Pivots
+
+section Transfer
+
+variable {n : ℕ}
+
+/-- The independent comparison group is constructed by priority greedy and
+fair-mask deletion, exactly as in the manuscript (`Y_i = (I* \ H) ∩ U_i`). -/
+lemma comparison_group_indep_subset (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (d : MainMasks n) (a : Fin n → Option ℤ) (i : ℤ) :
+    let Y := (positiveGreedy M a \ d.H).filter (fun e => a e = some i)
+    M.Indep (Y : Set (Fin n)) ∧ (Y : Set (Fin n)) ⊆ (trueGroup M d a i : Set (Fin n)) := by
+  classical
+  dsimp only
+  constructor
+  · exact (positiveGreedy_survivors_indep M hE a d.H).subset (Finset.filter_subset _ _)
+  · intro e he
+    obtain ⟨heY, hei⟩ := Finset.mem_filter.mp he
+    apply (mem_trueGroup M d a i e).mpr
+    refine ⟨?_, hei⟩
+    exact (Finset.mem_filter.mp (positiveGreedy_survivors_subset M a d.H heY)).2
+
+/-- Full sample-to-rank inequality for the actual rounded weight vector.
+`withMasks` averages all density, guard and test bits while fixing `H`;
+`fairParityExpectation` averages parity. `listedRankStatistic` is explicitly
+zero on the unlisted branch. Thus there is no conditioning on listing and no
+independence assumption about the selected residual. -/
+theorem sample_to_rank_contract (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (w : Weights n) (d : MainMasks n) (i : ℤ)
+    (hn : densityThreshold ≤
+      ((trueGroup M d (fun e => roundedLevel weightBase (w e)) i).card : ℝ)) :
+    let a := fun e => roundedLevel weightBase (w e)
+    let Y := (positiveGreedy M a \ d.H).filter (fun e => a e = some i)
+    (retainedFraction * (Y.card : ℝ) - ((2 : ℝ) ^ 23)⁻¹ *
+      (trueGroup M d a i).card) / densityThreshold ≤
+      tripleMaskExpectation (fun _ => (1 : ℝ) / 4)
+        (fun _ => thinningRate) (fun _ => thinningRate) Finset.univ
+        (fun D C T => fairParityExpectation (fun p =>
+          (listedRankStatistic M hE (2 ^ 100) (withMasks d D C T) a i
+            (boolParity p) : ℝ))) := by
+  classical
+  let a := fun e => roundedLevel weightBase (w e)
+  let Y := (positiveGreedy M a \ d.H).filter (fun e => a e = some i)
+  have hY := comparison_group_indep_subset M hE d a i
+  have h := listedRankStatistic_lower M hE d a i (Y : Set (Fin n)) hY.2 hY.1 hn
+  simpa only [Set.ncard_coe_finset] using h
+
+end Transfer
+
+end TransferContracts
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Transport/TransferSpecification.lean

@@ -0,0 +1,28 @@
+import OAI.Probability.MatroidProphet.Main
+
+namespace OAI
+
+/-! Independent specification of source `lem:transfer` / `eq:rank-transfer`.
+The fixed filter mask is arbitrary. Every remaining product coordinate and parity
+is averaged, and the actual nominal rank statistic is zero when unlisted. -/
+
+namespace MatroidProphet
+
+open Finset MainAlgorithm
+
+/-- Full sample-to-rank contract for the actual rounded greedy survivor groups. -/
+def TransferClaim : Prop :=
+  ∀ (n : ℕ) (M : Matroid (Fin n)) (hE : M.E = Set.univ)
+    (w : Weights n), (∀ e, 0 ≤ w e) →
+    ∀ (H : Finset (Fin n)) (i : ℤ),
+    let s : Fin n → Option ℤ := fun e => roundedLevel weightBase (w e)
+    let d : MainMasks n := ⟨H, ∅, ∅, ∅, false⟩
+    let U := trueGroup M d s i
+    let Y := (positiveGreedy M s \ H).filter (fun e => s e = some i)
+    densityThreshold ≤ (U.card : ℝ) →
+      ((((2 : ℝ)^16)⁻¹ * Y.card - ((2 : ℝ)^23)⁻¹ * U.card) / (2 : ℝ)^100) ≤
+        mainMean d (fun d' => (trueZ M hE d' s i : ℝ))
+
+end MatroidProphet
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Weights/DegenerateCases.lean

@@ -0,0 +1,124 @@
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.Combinatorics.Matroid.Loop
+
+namespace OAI
+
+/-!
+# Degenerate inputs and loop coordinates
+
+These lemmas concern the actual optimum and online execution, not a surrogate
+benchmark. They make explicit the empty-ground, all-loop, zero-optimum and
+fully-sacrificed cases admitted by setup.tex and secretary.tex. In particular,
+no moment or boundedness hypothesis on a loop coordinate is needed for OPT.
+-/
+
+namespace MatroidProphet.DegenerateCases
+
+open Finset
+
+/-- Offline optimization is unaffected by any change in loop coordinates. -/
+theorem optimum_congr_on_nonloops {n : ℕ} (M : Matroid (Fin n))
+    (v w : Weights n) (h : ∀ e, M.IsNonloop e → v e = w e) :
+    optimum M v = optimum M w := by
+  classical
+  unfold optimum
+  congr 1
+  funext I
+  split_ifs with hI
+  · apply Finset.sum_congr rfl
+    intro e he
+    exact h e (hI.isNonloop_of_mem he)
+  · rfl
+
+/-- Zero weights have zero optimum, without a full-ground assumption. -/
+theorem optimum_zero {n : ℕ} (M : Matroid (Fin n)) :
+    optimum M (fun _ => 0) = 0 := by
+  classical
+  unfold optimum
+  simp
+
+/-- If every nonloop has zero weight, arbitrary loop weights do not affect OPT. -/
+theorem optimum_eq_zero_of_nonloops_zero {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (hw : ∀ e, M.IsNonloop e → w e = 0) :
+    optimum M w = 0 := by
+  rw [optimum_congr_on_nonloops M w (fun _ => 0) hw, optimum_zero]
+
+/-- The all-loop case includes arbitrarily large and arbitrary-sign loop weights. -/
+theorem optimum_eq_zero_of_all_loops {n : ℕ} (M : Matroid (Fin n))
+    (hM : ∀ e, M.IsLoop e) (w : Weights n) : optimum M w = 0 := by
+  apply optimum_eq_zero_of_nonloops_zero
+  intro e he
+  exact False.elim (he.not_isLoop (hM e))
+
+/-- No labels is a valid input, and its actual offline optimum is zero. -/
+theorem optimum_empty (M : Matroid (Fin 0)) (w : Weights 0) :
+    optimum M w = 0 := by
+  apply optimum_eq_zero_of_nonloops_zero
+  intro e
+  exact Fin.elim0 e
+
+/-- A nonloop singleton is one of the sets in the optimization benchmark. -/
+theorem nonloop_weight_le_optimum {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (e : Fin n) (he : M.IsNonloop e) :
+    w e ≤ optimum M w := by
+  simpa using sum_le_optimum M w {e} (by simpa using he.indep)
+
+/-- On nonnegative vectors, OPT vanishes exactly when every nonloop weight does. -/
+theorem optimum_eq_zero_iff {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (hw : ∀ e, 0 ≤ w e) :
+    optimum M w = 0 ↔ ∀ e, M.IsNonloop e → w e = 0 := by
+  constructor
+  · intro h e he
+    exact le_antisymm (h ▸ nonloop_weight_le_optimum M w e he) (hw e)
+  · exact optimum_eq_zero_of_nonloops_zero M w
+
+/-- Every feasible rule has exactly zero reward on a zero-OPT input. -/
+theorem reward_eq_zero_of_optimum_eq_zero {n bits : ℕ}
+    (M : Matroid (Fin n)) (A : OnlineRule n bits) (hA : Feasible M A)
+    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n)
+    (hs : ∀ e, 0 ≤ s e) (hv : ∀ e, 0 ≤ v e) (hopt : optimum M v = 0) :
+    reward A r s v π = 0 := by
+  apply le_antisymm
+  · simpa only [hopt] using reward_le_optimum M A hA r s v π hs hv
+  · exact reward_nonneg A r s v π hv
+
+/-- Running past the finite final arrival does not create any further decisions. -/
+theorem acceptedThrough_stabilizes {n bits : ℕ} (A : OnlineRule n bits)
+    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n)
+    (t : ℕ) (ht : n ≤ t) :
+    acceptedThrough A r s v π t = accepted A r s v π := by
+  classical
+  ext e
+  have he : (π.symm e).val < t := lt_of_lt_of_le (π.symm e).isLt ht
+  simp [accepted, acceptedThrough, he]
+
+/-- The empty prefix never accepts anything, regardless of the rule. -/
+theorem acceptedThrough_zero {n bits : ℕ} (A : OnlineRule n bits)
+    (r : Seed bits) (s v : Weights n) (π : ArrivalOrder n) :
+    acceptedThrough A r s v π 0 = ∅ := by
+  classical
+  simp [acceptedThrough]
+
+/-- Fully revealed hidden-vector inputs are fully sacrificed, at every prefix. -/
+theorem hiddenAcceptedThrough_eq_empty_of_full_mask {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (hmask : A.mask r = Finset.univ)
+    (w : Weights n) (π : ArrivalOrder n) (t : ℕ) :
+    hiddenAcceptedThrough A r w π t = ∅ := by
+  simp [hiddenAcceptedThrough, hmask]
+
+/-- Full sacrifice gives zero reward for every order, including the empty order. -/
+theorem hiddenReward_eq_zero_of_full_mask {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (hmask : A.mask r = Finset.univ)
+    (w : Weights n) (π : ArrivalOrder n) : hiddenReward A r w π = 0 := by
+  simp [hiddenReward, hiddenAcceptedThrough_eq_empty_of_full_mask A r hmask]
+
+/-- The seed-wise adversarial minimum also vanishes under full sacrifice. -/
+theorem hiddenWorstReward_eq_zero_of_full_mask {n bits : ℕ}
+    (A : HiddenRule n bits) (r : Seed bits) (hmask : A.mask r = Finset.univ)
+    (w : Weights n) : hiddenWorstReward A w r = 0 := by
+  classical
+  simp [hiddenWorstReward, hiddenReward_eq_zero_of_full_mask A r hmask]
+
+end MatroidProphet.DegenerateCases
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Weights/FiniteWeightLawModel.lean

@@ -0,0 +1,39 @@
+import Mathlib.Probability.ProbabilityMassFunction.Integrals
+
+namespace OAI
+
+namespace MatroidProphet.FiniteLaw
+
+open MeasureTheory
+open scoped BigOperators
+
+noncomputable def weightPMF {α : Type*} [Fintype α] (p : α → ℝ)
+    (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1) : PMF α :=
+  PMF.ofFintype (fun a => ENNReal.ofReal (p a)) (by
+    rw [← ENNReal.ofReal_sum_of_nonneg (fun a _ => hp a), hp1]
+    exact ENNReal.ofReal_one)
+
+noncomputable def weightMeasure {α : Type*} [Fintype α] [MeasurableSpace α]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1) : Measure α :=
+  (weightPMF p hp hp1).toMeasure
+
+noncomputable def kernelJointPMF {α β : Type*} [Fintype α] [Fintype β]
+    (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1) : PMF (β × α) :=
+  weightPMF (fun ba => m ba.1 * k ba.1 ba.2)
+    (fun ba => mul_nonneg (hm ba.1) (hk ba.1 ba.2)) (by
+      rw [Fintype.sum_prod_type]
+      simp_rw [← Finset.mul_sum, hk1, mul_one]
+      exact hm1)
+
+noncomputable def kernelJointMeasure {α β : Type*} [Fintype α] [Fintype β]
+    [MeasurableSpace α] [MeasurableSpace β]
+    (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1) : Measure (β × α) :=
+  (kernelJointPMF m k hm hm1 hk hk1).toMeasure
+
+end MatroidProphet.FiniteLaw
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Weights/FiniteWeightLawTheorems.lean

@@ -0,0 +1,170 @@
+import OAI.Probability.MatroidSecretary.Weights.FiniteWeightLawModel
+
+namespace OAI
+
+/-!
+Finite conditional-kernel bridge for the secretary transport.  The algebraic
+fiber identity is a hypothesis of these reusable lemmas, not a substitute for
+proving that identity for the manuscript's actual source-seed law.
+-/
+
+namespace MatroidProphet.FiniteLaw
+
+open MeasureTheory
+open scoped BigOperators Classical
+
+variable {α β : Type*} [Fintype α] [Fintype β]
+
+@[simp] theorem weightPMF_apply (p : α → ℝ) (hp : ∀ a, 0 ≤ p a)
+    (hp1 : ∑ a, p a = 1) (a : α) :
+    weightPMF p hp hp1 a = ENNReal.ofReal (p a) := rfl
+
+instance weightMeasure_probability [MeasurableSpace α]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1) :
+    IsProbabilityMeasure (weightMeasure p hp hp1) := by
+  unfold weightMeasure
+  infer_instance
+
+theorem weightMeasure_singleton [MeasurableSpace α] [MeasurableSingletonClass α]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1) (a : α) :
+    weightMeasure p hp hp1 {a} = ENNReal.ofReal (p a) := by
+  exact PMF.toMeasure_apply_singleton _ a (MeasurableSet.singleton a)
+
+theorem integral_weightMeasure [MeasurableSpace α] [MeasurableSingletonClass α]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1) (f : α → ℝ) :
+    (∫ a, f a ∂weightMeasure p hp hp1) = ∑ a, p a * f a := by
+  rw [weightMeasure, PMF.integral_eq_sum]
+  simp only [weightPMF_apply, ENNReal.toReal_ofReal (hp _), smul_eq_mul]
+
+theorem sum_real_singleton [MeasurableSpace α] [MeasurableSingletonClass α]
+    (μ : Measure α) [IsProbabilityMeasure μ] :
+    (∑ a, μ.real {a}) = 1 := by
+  simp
+
+/-- No finite-law assumption is added: every probability measure on a finite
+discrete space is exactly the measure of its real singleton weights. -/
+theorem weightMeasure_real_singleton [MeasurableSpace α] [MeasurableSingletonClass α]
+    (μ : Measure α) [IsProbabilityMeasure μ] :
+    weightMeasure (fun a => μ.real {a}) (fun _ => measureReal_nonneg)
+      (sum_real_singleton μ) = μ := by
+  apply Measure.ext_of_singleton
+  intro a
+  rw [weightMeasure_singleton, measureReal_def]
+  exact ENNReal.ofReal_toReal (measure_ne_top μ {a})
+
+omit [Fintype β] in
+theorem map_real_singleton
+    [MeasurableSpace α] [MeasurableSingletonClass α]
+    [MeasurableSpace β] [MeasurableSingletonClass β]
+    (μ : Measure α) [IsProbabilityMeasure μ] (obs : α → β) (b : β) :
+    (μ.map obs).real {b} = ∑ a, if obs a = b then μ.real {a} else 0 := by
+  classical
+  have hs : ((Finset.univ.filter fun a => obs a = b : Finset α) : Set α) =
+      obs ⁻¹' {b} := by
+    ext a
+    simp
+  rw [← Finset.sum_filter, sum_measureReal_singleton, hs]
+  simp only [measureReal_def,
+    Measure.map_apply (measurable_of_countable obs) (MeasurableSet.singleton b)]
+
+@[simp] theorem kernelJointPMF_apply
+    (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (b : β) (a : α) :
+    kernelJointPMF m k hm hm1 hk hk1 (b, a) = ENNReal.ofReal (m b * k b a) := rfl
+
+instance kernelJointMeasure_probability [MeasurableSpace α] [MeasurableSpace β]
+    (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1) :
+    IsProbabilityMeasure (kernelJointMeasure m k hm hm1 hk hk1) := by
+  unfold kernelJointMeasure
+  infer_instance
+
+theorem integral_kernelJointMeasure
+    [MeasurableSpace α] [MeasurableSingletonClass α]
+    [MeasurableSpace β] [MeasurableSingletonClass β]
+    (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (f : β × α → ℝ) :
+    (∫ ba, f ba ∂kernelJointMeasure m k hm hm1 hk hk1) =
+      ∫ b, ∫ a, f (b, a) ∂weightMeasure (k b) (hk b) (hk1 b)
+        ∂weightMeasure m hm hm1 := by
+  rw [kernelJointMeasure, kernelJointPMF]
+  change (∫ ba, f ba ∂weightMeasure _ _ _) = _
+  rw [integral_weightMeasure, Fintype.sum_prod_type, integral_weightMeasure]
+  simp_rw [integral_weightMeasure, Finset.mul_sum, mul_assoc]
+
+theorem kernelJointPMF_eq_map
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1)
+    (obs : α → β) (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (hjoint : ∀ b a, m b * k b a = if obs a = b then p a else 0) :
+    kernelJointPMF m k hm hm1 hk hk1 =
+      (weightPMF p hp hp1).map (fun a => (obs a, a)) := by
+  classical
+  ext ba : 1
+  obtain ⟨b, a⟩ := ba
+  rw [kernelJointPMF_apply, hjoint]
+  simp only [PMF.map_apply, tsum_fintype, Prod.mk.injEq, weightPMF_apply]
+  rw [Finset.sum_eq_single a]
+  · by_cases h : obs a = b
+    · simp [h]
+    · have h' : b ≠ obs a := Ne.symm h
+      simp [h, h']
+  · intro a' _ hne
+    simp [Ne.symm hne]
+  · simp
+
+theorem kernelJointMeasure_eq_map
+    [MeasurableSpace α] [MeasurableSingletonClass α]
+    [MeasurableSpace β] [MeasurableSingletonClass β]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1)
+    (obs : α → β) (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (hjoint : ∀ b a, m b * k b a = if obs a = b then p a else 0) :
+    kernelJointMeasure m k hm hm1 hk hk1 =
+      (weightMeasure p hp hp1).map (fun a => (obs a, a)) := by
+  rw [kernelJointMeasure, kernelJointPMF_eq_map p hp hp1 obs m k hm hm1 hk hk1 hjoint]
+  exact (PMF.toMeasure_map (fun a => (obs a, a)) (weightPMF p hp hp1)
+    (measurable_of_countable _)).symm
+
+/-- The joint law transports every statistic of the observation and full seed,
+not merely statistics of the sacrificed mask. -/
+theorem integral_reconstruction
+    [MeasurableSpace α] [MeasurableSingletonClass α]
+    [MeasurableSpace β] [MeasurableSingletonClass β]
+    (p : α → ℝ) (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1)
+    (obs : α → β) (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (hjoint : ∀ b a, m b * k b a = if obs a = b then p a else 0)
+    (f : β × α → ℝ) :
+    (∫ b, ∫ a, f (b, a) ∂weightMeasure (k b) (hk b) (hk1 b)
+        ∂weightMeasure m hm hm1) =
+      ∫ a, f (obs a, a) ∂weightMeasure p hp hp1 := by
+  rw [← integral_kernelJointMeasure m k hm hm1 hk hk1 f,
+    kernelJointMeasure_eq_map p hp hp1 obs m k hm hm1 hk hk1 hjoint]
+  exact integral_map_of_stronglyMeasurable (measurable_of_countable _)
+    (measurable_of_countable f).stronglyMeasurable
+
+/-- Every positive-mass reconstructed joint outcome has exactly its advertised
+observation. Zero-mass fibers are not silently ruled out. -/
+theorem observation_eq_of_joint_support
+    (p : α → ℝ) (obs : α → β) (m : β → ℝ) (k : β → α → ℝ)
+    (hm : ∀ b, 0 ≤ m b) (hm1 : ∑ b, m b = 1)
+    (hk : ∀ b a, 0 ≤ k b a) (hk1 : ∀ b, ∑ a, k b a = 1)
+    (hjoint : ∀ b a, m b * k b a = if obs a = b then p a else 0)
+    (b : β) (a : α)
+    (ha : (b, a) ∈ (kernelJointPMF m k hm hm1 hk hk1).support) : obs a = b := by
+  rw [PMF.mem_support_iff, kernelJointPMF_apply, hjoint] at ha
+  by_contra h
+  exact ha (by simp [h])
+
+end MatroidProphet.FiniteLaw
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Weights/OptimumIntegrability.lean

@@ -0,0 +1,90 @@
+import OAI.Probability.MatroidSecretary.Weights.DegenerateCases
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+namespace OAI
+
+/-!
+# The exact finite-moment requirement
+
+For a finite matroid and nonnegative measurable weights, integrability of the
+actual offline optimum is equivalent to integrability of the nonloop
+coordinates. No loop-coordinate moments are imposed. This is a supporting
+scope check for introduction.tex, Theorem `thm:main`, and setup.tex's
+one-sample simulation argument; it does not replace its competitive claim.
+-/
+
+namespace MatroidProphet.DegenerateCases
+
+open MeasureTheory Classical
+open scoped BigOperators
+
+/-- Only nonloops can contribute to a feasible sum. -/
+theorem optimum_le_sum_nonloops {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (hw : ∀ e, 0 ≤ w e) :
+    optimum M w ≤ ∑ e : Fin n, if M.IsNonloop e then w e else 0 := by
+  classical
+  have hn (e : Fin n) : 0 ≤ if M.IsNonloop e then w e else 0 := by
+    split_ifs
+    · exact hw e
+    · exact le_rfl
+  apply optimum_le_of_independent_bound M w _ (Finset.sum_nonneg fun e _ => hn e)
+  intro I hI
+  calc
+    (∑ e ∈ I, w e) = ∑ e ∈ I, if M.IsNonloop e then w e else 0 := by
+      apply Finset.sum_congr rfl
+      intro e he
+      simp [hI.isNonloop_of_mem he]
+    _ ≤ ∑ e : Fin n, if M.IsNonloop e then w e else 0 := by
+      exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ I)
+        (fun e _ _ => hn e)
+
+/-- Nonloop moments follow from the assumed finite offline optimum moment. -/
+theorem integrable_nonloop_of_integrable_optimum {n : ℕ}
+    (M : Matroid (Fin n)) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (V : Ω → Weights n) (hV : Measurable V)
+    (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e)
+    (hopt : Integrable (fun ω => optimum M (V ω)) μ)
+    (e : Fin n) (he : M.IsNonloop e) : Integrable (fun ω => V ω e) μ := by
+  apply hopt.mono' ((measurable_pi_apply e).comp hV).aestronglyMeasurable
+  filter_upwards [hVN] with ω hω
+  change ‖V ω e‖ ≤ optimum M (V ω)
+  rw [Real.norm_eq_abs, abs_of_nonneg (hω e)]
+  exact nonloop_weight_le_optimum M (V ω) e he
+
+/-- Conversely, finite moments only on the nonloops suffice for finite E[OPT]. -/
+theorem integrable_optimum_of_integrable_nonloops {n : ℕ}
+    (M : Matroid (Fin n)) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (V : Ω → Weights n) (hV : Measurable V)
+    (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e)
+    (hmom : ∀ e, M.IsNonloop e → Integrable (fun ω => V ω e) μ) :
+    Integrable (fun ω => optimum M (V ω)) μ := by
+  classical
+  have hsum : Integrable (fun ω =>
+      ∑ e : Fin n, if M.IsNonloop e then V ω e else 0) μ := by
+    apply integrable_finsetSum
+    intro e _
+    by_cases he : M.IsNonloop e
+    · simpa only [ite_eq_left he] using hmom e he
+    · simp only [ite_eq_right he]
+      exact integrable_zero _ _ _
+  apply hsum.mono' ((measurable_optimum M).comp hV).aestronglyMeasurable
+  filter_upwards [hVN] with ω hω
+  change ‖optimum M (V ω)‖ ≤ ∑ e : Fin n, if M.IsNonloop e then V ω e else 0
+  rw [Real.norm_eq_abs, abs_of_nonneg (optimum_nonneg M (V ω))]
+  exact optimum_le_sum_nonloops M (V ω) hω
+
+/-- An exact criterion: loop moments are deliberately absent on the right. -/
+theorem integrable_optimum_iff {n : ℕ} (M : Matroid (Fin n))
+    {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (V : Ω → Weights n) (hV : Measurable V)
+    (hVN : ∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e) :
+    Integrable (fun ω => optimum M (V ω)) μ ↔
+      ∀ e, M.IsNonloop e → Integrable (fun ω => V ω e) μ := by
+  constructor
+  · exact integrable_nonloop_of_integrable_optimum M μ V hV hVN
+  · exact integrable_optimum_of_integrable_nonloops M μ V hV hVN
+
+end MatroidProphet.DegenerateCases
+
+end OAI

lean/OAI/Probability/MatroidSecretary/Weights/ZeroBenchmark.lean

@@ -0,0 +1,134 @@
+import OAI.Probability.MatroidProphet.Main
+import Mathlib.MeasureTheory.Integral.Bochner.Basic
+
+namespace OAI
+
+namespace MatroidProphet.ZeroBenchmark
+
+open MeasureTheory Finset
+open scoped Classical
+
+/-- Only singleton-independent labels can affect the offline optimum.
+No sign or integrability assumption is necessary for this identity. -/
+theorem optimum_congr_on_singletons {n : ℕ} (M : Matroid (Fin n))
+    (w v : Weights n)
+    (h : ∀ e, M.Indep ({e} : Set (Fin n)) → w e = v e) :
+    optimum M w = optimum M v := by
+  classical
+  unfold optimum
+  apply Finset.sup'_congr Finset.univ_nonempty rfl
+  intro I _
+  by_cases hI : M.Indep (I : Set (Fin n))
+  · simp only [ite_eq_left hI]
+    apply Finset.sum_congr rfl
+    intro e he
+    exact h e (hI.subset (Set.singleton_subset_iff.mpr he))
+  · simp only [ite_eq_right hI]
+
+/-- The zero-weight benchmark is zero, also for empty or rank-zero matroids. -/
+@[simp] theorem optimum_zero {n : ℕ} (M : Matroid (Fin n)) :
+    optimum M (fun _ => 0) = 0 := by
+  classical
+  simp [optimum]
+
+/-- On nonnegative inputs, a zero benchmark is exactly the condition that
+every label that could be accepted on its own has zero weight. -/
+theorem optimum_eq_zero_iff {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) (hw : ∀ e, 0 ≤ w e) :
+    optimum M w = 0 ↔ ∀ e, M.Indep ({e} : Set (Fin n)) → w e = 0 := by
+  constructor
+  · intro h e he
+    have hb := sum_le_optimum M w {e} (by simpa using he)
+    simp only [Finset.sum_singleton, h] at hb
+    exact le_antisymm hb (hw e)
+  · intro h
+    rw [optimum_congr_on_singletons M w (fun _ => 0) h]
+    exact optimum_zero M
+
+/-- Replacing all loop coordinates by zero never changes the objective.
+Here ground-set outsiders, if any, are also harmless. -/
+theorem optimum_ignore_infeasible_coordinates {n : ℕ} (M : Matroid (Fin n))
+    (w : Weights n) :
+    optimum M (fun e => if M.Indep ({e} : Set (Fin n)) then w e else 0) =
+      optimum M w := by
+  classical
+  apply optimum_congr_on_singletons
+  intro e he
+  simp only [ite_eq_left he]
+
+/-- Rank-zero behavior needs no bound at all on the values of its labels. -/
+theorem optimum_eq_zero_of_no_independent_singleton {n : ℕ}
+    (M : Matroid (Fin n))
+    (hM : ∀ e, ¬ M.Indep ({e} : Set (Fin n))) (w : Weights n) :
+    optimum M w = 0 := by
+  rw [optimum_congr_on_singletons M w (fun _ => 0) (fun e he => (hM e he).elim)]
+  exact optimum_zero M
+
+/-- The empty instance has the zero benchmark without a positive-size premise. -/
+@[simp] theorem optimum_empty (M : Matroid (Fin 0)) (w : Weights 0) :
+    optimum M w = 0 := by
+  apply optimum_eq_zero_of_no_independent_singleton
+  intro e
+  exact Fin.elim0 e
+
+/-- Every feasible realized hidden reward vanishes when the benchmark does. -/
+theorem hiddenReward_eq_zero {n bits : ℕ} (M : Matroid (Fin n))
+    (A : HiddenRule n bits) (r : Seed bits) (w : Weights n)
+    (π : ArrivalOrder n) (hw : ∀ e, 0 ≤ w e)
+    (hA : M.Indep (hiddenAcceptedThrough A r w π n : Set (Fin n)))
+    (hopt : optimum M w = 0) : hiddenReward A r w π = 0 := by
+  apply le_antisymm
+  · exact (sum_le_optimum M w _ hA).trans_eq hopt
+  · exact Finset.sum_nonneg fun e _ => hw e
+
+/-- The zero-benchmark conclusion also holds for the minimum taken separately
+at each complete seed, before any expectation. -/
+theorem hiddenWorstReward_eq_zero {n bits : ℕ} (M : Matroid (Fin n))
+    (A : HiddenRule n bits) (w : Weights n) (hw : ∀ e, 0 ≤ w e)
+    (hA : ∀ r π, M.Indep (hiddenAcceptedThrough A r w π n : Set (Fin n)))
+    (hopt : optimum M w = 0) (r : Seed bits) :
+    hiddenWorstReward A w r = 0 := by
+  apply le_antisymm
+  · exact (hiddenWorstReward_le A w r (Equiv.refl _)).trans_eq
+      (hiddenReward_eq_zero M A r w (Equiv.refl _) hw (hA r _) hopt)
+  · exact hiddenWorstReward_nonneg A w hw r
+
+/-- No probability-law or moment premise is needed in the zero case. -/
+theorem integral_hiddenWorstReward_eq_zero {n bits : ℕ} (M : Matroid (Fin n))
+    (A : HiddenRule n bits) (w : Weights n) (hw : ∀ e, 0 ≤ w e)
+    (hA : ∀ r π, M.Indep (hiddenAcceptedThrough A r w π n : Set (Fin n)))
+    (hopt : optimum M w = 0) (ν : Measure (Seed bits)) :
+    (∫ r, hiddenWorstReward A w r ∂ν) = 0 := by
+  simp only [hiddenWorstReward_eq_zero M A w hw hA hopt]
+  exact integral_zero _ _
+
+/-- Even completely unrestricted loop coordinates cannot create a moment
+requirement when the usable coordinates vanish almost everywhere. -/
+theorem integrable_optimum_of_usable_coordinates_zero {n : ℕ}
+    (M : Matroid (Fin n)) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (V : Ω → Weights n)
+    (hV : ∀ᵐ ω ∂μ, ∀ e, M.Indep ({e} : Set (Fin n)) → V ω e = 0) :
+    Integrable (fun ω => optimum M (V ω)) μ := by
+  apply (integrable_zero Ω ℝ μ).congr
+  filter_upwards [hV] with ω hω
+  symm
+  rw [optimum_congr_on_singletons M (V ω) (fun _ => 0) hω]
+  exact optimum_zero M
+
+ 
+theorem integral_optimum_of_usable_coordinates_zero {n : ℕ}
+    (M : Matroid (Fin n)) {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (V : Ω → Weights n)
+    (hV : ∀ᵐ ω ∂μ, ∀ e, M.Indep ({e} : Set (Fin n)) → V ω e = 0) :
+    (∫ ω, optimum M (V ω) ∂μ) = 0 := by
+  calc
+    (∫ ω, optimum M (V ω) ∂μ) = ∫ _ : Ω, (0 : ℝ) ∂μ := by
+      apply integral_congr_ae
+      filter_upwards [hV] with ω hω
+      rw [optimum_congr_on_singletons M (V ω) (fun _ => 0) hω]
+      exact optimum_zero M
+    _ = 0 := integral_zero _ _
+
+end MatroidProphet.ZeroBenchmark
+
+end OAI

lean/OAI/Probability/MemoryPrecision/AmbientGram.lean

@@ -0,0 +1,664 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+
+open MeasureTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+
+abbrev Space (d : ℕ) := EuclideanSpace ℝ (Fin d)
+
+def J (β : ℝ) (m j : ℕ) : ℝ :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let three : ℝ := @OfNat.ofNat ℝ 3 (@instOfNatAtLeastTwo ℝ 3 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 1)))
+  1 + three^j * two^β * (m : ℝ) / (β - (j : ℝ) - (m : ℝ))
+
+def AmbientBallBound {d : ℕ} (μ : Measure (Space d)) (H β : ℝ) : Prop :=
+  ∀ x : Space d, ∀ r : ℝ, 0 < r →
+    μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H * r^β)
+
+def InverseGram {d p : ℕ} (m : ℕ) (v : Space d × (Fin (p-1) → Space d)) : ℝ≥0∞ :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  letI : AddCommGroup (Space d) := WithLp.instAddCommGroup exponent (Fin d → ℝ)
+  letI : Inner ℝ (Space d) := @InnerProductSpace.toInner ℝ (Space d) _
+    (PiLp.seminormedAddCommGroup exponent (fun _ : Fin d => ℝ))
+    (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ))
+  ENNReal.ofReal ((Real.sqrt (Matrix.gram ℝ (fun i => v.2 i - v.1)).det)⁻¹ ^ m)
+
+lemma sharp_inverse_unit {X : Type*} [MeasurableSpace X]
+    (μ : Measure X) (f : X → ℝ) (hf : Measurable f) (hf0 : ∀ x, 0 ≤ f x)
+    {m a C : ℝ} (hm : 0 < m) (ha : m < a) (hC : 0 ≤ C)
+    (htube : ∀ t : ℝ, 0 < t → t ≤ 1 →
+      μ {x | f x ≤ t} ≤ ENNReal.ofReal (C * t^a)) :
+    (∫⁻ x, ENNReal.ofReal (f x ^ (-m)) ∂μ) ≤
+      μ univ + ENNReal.ofReal (C * m / (a-m)) := by
+  have htail (t : ℝ) (ht : 1 < t) :
+      μ {x | t < f x ^ (-m)} ≤ ENNReal.ofReal (C * t ^ (-a/m)) := by
+    have ht0 : 0 < t := by linarith
+    have hr0 : 0 < t ^ ((-m)⁻¹) := Real.rpow_pos_of_pos ht0 _
+    have hr1 : t ^ ((-m)⁻¹) ≤ 1 := by
+      calc
+        _ ≤ t ^ (0 : ℝ) := Real.rpow_le_rpow_of_exponent_le ht.le (inv_nonpos.mpr (by linarith))
+        _ = 1 := Real.rpow_zero _
+    have hsub : {x | t < f x ^ (-m)} ⊆ {x | f x ≤ t ^ ((-m)⁻¹)} := by
+      intro x hx
+      have hfx : 0 < f x := by
+        by_contra h
+        have heq : f x = 0 := le_antisymm (le_of_not_gt h) (hf0 x)
+        simp only [mem_ofPred_eq, heq, Real.zero_rpow (neg_ne_zero.mpr hm.ne')] at hx
+        linarith
+      exact ((Real.lt_rpow_inv_iff_of_neg hfx ht0 (by linarith)).2 hx).le
+    calc
+      _ ≤ μ {x | f x ≤ t ^ ((-m)⁻¹)} := measure_mono hsub
+      _ ≤ ENNReal.ofReal (C * (t ^ ((-m)⁻¹)) ^ a) := htube _ hr0 hr1
+      _ = _ := by
+        rw [← Real.rpow_mul ht0.le]
+        congr 2
+        ring_nf
+  have hb : -a/m < -1 := by
+    rw [div_lt_iff₀ hm]
+    linarith
+  have hint : IntegrableOn (fun t : ℝ => C * t ^ (-a/m)) (Ioi 1) :=
+    (integrableOn_Ioi_rpow_of_lt hb (by norm_num)).const_mul C
+  have hnn : 0 ≤ᵐ[volume.restrict (Ioi (1:ℝ))] (fun t : ℝ => C * t ^ (-a/m)) := by
+    filter_upwards [ae_restrict_mem (μ := (volume : Measure ℝ)) measurableSet_Ioi] with t ht
+    exact mul_nonneg hC (Real.rpow_nonneg (by have ht' : (1:ℝ) < t := ht; linarith : 0 ≤ t) _)
+  have htailint : (∫⁻ t in Ioi (1:ℝ), ENNReal.ofReal (C * t ^ (-a/m))) =
+      ENNReal.ofReal (C * m / (a-m)) := by
+    rw [← ofReal_integral_eq_lintegral_ofReal hint hnn, integral_const_mul,
+      integral_Ioi_rpow_of_lt hb (by norm_num), Real.one_rpow]
+    congr 1
+    field_simp [hm.ne', show a - m ≠ 0 by linarith, show -a + m ≠ 0 by linarith]
+    ring
+  have hsplit : Ioi (0:ℝ) = Ioc 0 1 ∪ Ioi 1 := by
+    ext t
+    simp only [mem_Ioi, mem_union, mem_Ioc]
+    constructor
+    · intro ht
+      by_cases h : t ≤ 1
+      · exact Or.inl ⟨ht,h⟩
+      · exact Or.inr (lt_of_not_ge h)
+    · rintro (⟨ht,_⟩ | ht) <;> linarith
+  rw [lintegral_eq_lintegral_meas_lt μ
+    (Filter.Eventually.of_forall fun x => Real.rpow_nonneg (hf0 x) _) (hf.pow_const _).aemeasurable,
+    hsplit]
+  apply (lintegral_union_le _ _ _).trans
+  apply add_le_add
+  · calc
+      _ ≤ ∫⁻ _t in Ioc (0:ℝ) 1, μ univ := lintegral_mono fun t => measure_mono (subset_univ _)
+      _ = μ univ := by simp [Real.volume_Ioc]
+  · calc
+      _ ≤ ∫⁻ t in Ioi (1:ℝ), ENNReal.ofReal (C * t ^ (-a/m)) := by
+        apply lintegral_mono_ae
+        filter_upwards [ae_restrict_mem (μ := (volume : Measure ℝ)) measurableSet_Ioi] with t ht
+        exact htail t ht
+      _ = _ := htailint
+
+lemma ae_pos_of_power_tube {X : Type*} [MeasurableSpace X]
+    (μ : Measure X) (f : X → ℝ) {a C : ℝ} (ha : 0 < a)
+    (htube : ∀ t : ℝ, 0 < t → t ≤ 1 →
+      μ {x | f x ≤ t} ≤ ENNReal.ofReal (C * t^a)) : ∀ᵐ x ∂μ, 0 < f x := by
+  have hb (n : ℕ) : μ {x | f x ≤ 0} ≤ ENNReal.ofReal (C * ((1/2 : ℝ)^n)^a) := by
+    calc
+      μ {x | f x ≤ 0} ≤ μ {x | f x ≤ (1/2 : ℝ)^n} :=
+        measure_mono fun x hx => (show f x ≤ 0 from hx).trans (by positivity)
+      _ ≤ _ := htube _ (by positivity) (pow_le_one₀ (by norm_num) (by norm_num))
+  have hlim : Tendsto (fun n : ℕ => ENNReal.ofReal (C * ((1/2 : ℝ)^n)^a)) atTop (𝓝 (0:ℝ≥0∞)) := by
+    have h := (tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0:ℝ) ≤ 1/2)
+      (by norm_num : (1/2:ℝ) < 1)).rpow_const_nhds_zero ha
+    simpa using ENNReal.tendsto_ofReal (tendsto_const_nhds.mul h)
+  have hz := le_antisymm (ge_of_tendsto' hlim hb) (bot_le : (0:ℝ≥0∞) ≤ μ {x | f x ≤ 0})
+  simpa only [ae_iff, not_lt] using hz
+
+lemma sharp_inverse_scaled {X : Type*} [MeasurableSpace X]
+    (μ : Measure X) (f : X → ℝ) (hf : Measurable f) (hf0 : ∀ x, 0 ≤ f x)
+    {m a B C R : ℝ} (hm : 0 < m) (ha : m < a)
+    (hB : 0 ≤ B) (hC : 0 ≤ C) (hR : 0 < R)
+    (hmass : μ univ ≤ ENNReal.ofReal B)
+    (htube : ∀ t : ℝ, 0 < t → t ≤ 1 →
+      μ {x | f x ≤ R*t} ≤ ENNReal.ofReal (C * t^a)) :
+    (∀ᵐ x ∂μ, 0 < f x) ∧
+    (∫⁻ x, (ENNReal.ofReal (f x)) ^ (-m) ∂μ) ≤
+      ENNReal.ofReal ((B + C*m/(a-m)) * R^(-m)) := by
+  have hg0 (x : X) : 0 ≤ f x / R := div_nonneg (hf0 x) hR.le
+  have hg : Measurable (fun x => f x / R) := hf.div_const R
+  have hgtube (t : ℝ) (ht : 0 < t) (ht1 : t ≤ 1) :
+      μ {x | f x / R ≤ t} ≤ ENNReal.ofReal (C*t^a) := by
+    have heq : {x | f x / R ≤ t} = {x | f x ≤ R*t} := by
+      ext x
+      simp only [mem_ofPred_eq, div_le_iff₀ hR, mul_comm]
+    rw [heq]
+    exact htube t ht ht1
+  have hgp := ae_pos_of_power_tube μ (fun x => f x / R) (hm.trans ha) hgtube
+  have hfp : ∀ᵐ x ∂μ, 0 < f x := by
+    filter_upwards [hgp] with x hx
+    exact (div_pos_iff_of_pos_right hR).mp hx
+  refine ⟨hfp, ?_⟩
+  have hi := sharp_inverse_unit μ (fun x => f x/R) hg hg0 hm ha hC hgtube
+  have hcpos : 0 < R^(-m) := Real.rpow_pos_of_pos hR _
+  calc
+    _ = ∫⁻ x, ENNReal.ofReal (R^(-m)) * ENNReal.ofReal ((f x/R)^(-m)) ∂μ := by
+      apply lintegral_congr_ae
+      filter_upwards [hfp] with x hx
+      rw [ENNReal.ofReal_rpow_of_pos hx, ← ENNReal.ofReal_mul hcpos.le,
+        Real.div_rpow hx.le hR.le]
+      congr 1
+      exact (mul_div_cancel₀ _ hcpos.ne').symm
+    _ = ENNReal.ofReal (R^(-m)) * (∫⁻ x, ENNReal.ofReal ((f x/R)^(-m)) ∂μ) :=
+      lintegral_const_mul _ (hg.pow_const _).ennreal_ofReal
+    _ ≤ ENNReal.ofReal (R^(-m)) *
+        (ENNReal.ofReal B + ENNReal.ofReal (C*m/(a-m))) :=
+      mul_le_mul' le_rfl (hi.trans (add_le_add hmass le_rfl))
+    _ = _ := by
+      rw [← ENNReal.ofReal_add hB (by positivity), ← ENNReal.ofReal_mul hcpos.le]
+      congr 1
+      ring
+
+section Geometry
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+
+lemma affine_tube_cover_radius (L : AffineSubspace ℝ E) [Nonempty L]
+    (z : E) {R t : ℝ} (hR : 0 < R) (ht : 0 < t) (htR : t ≤ R) :
+    ∃ s : Finset L.direction,
+      (s.card : ℝ) ≤ (3*R/t)^Module.finrank ℝ L.direction ∧
+      ∀ x : E, dist x z ≤ R → Metric.infDist x L ≤ t →
+        ∃ y ∈ s, dist x (R • (y:E) + (orthogonalProjection L z : E)) ≤ 2*t := by
+  classical
+  have hr : 0 < t/R := div_pos ht hR
+  have hr1 : t/R ≤ 1 := (div_le_one hR).2 htR
+  obtain ⟨s, _, hcard, hnet⟩ := NoiselessRegression.exists_unit_ball_net
+    (E := L.direction) hr hr1
+  refine ⟨s, ?_, ?_⟩
+  · convert hcard using 1
+    congr 1
+    field_simp
+  · intro x hx hdist
+    let v : L.direction := L.direction.orthogonalProjectionOnto (x-z)
+    have hv : ‖v‖ ≤ R := by
+      apply (L.direction.norm_orthogonalProjectionOnto_apply_le (x-z)).trans
+      simpa only [dist_eq_norm] using hx
+    have hvnorm : ‖R⁻¹ • v‖ ≤ 1 := by
+      rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hR)]
+      calc
+        _ ≤ R⁻¹ * R := mul_le_mul_of_nonneg_left hv (inv_nonneg.mpr hR.le)
+        _ = 1 := inv_mul_cancel₀ hR.ne'
+    obtain ⟨y, hy, hclose⟩ := hnet (R⁻¹ • v) hvnorm
+    refine ⟨y, hy, ?_⟩
+    have hscaled : dist (v:E) (R • (y:E)) ≤ t := by
+      have heq : (v:E) = R • (R⁻¹ • (v:E)) := by simp [smul_smul, hR.ne']
+      rw [heq, dist_smul₀, Real.norm_eq_abs, abs_of_pos hR]
+      calc
+        _ ≤ R * (t/R) := mul_le_mul_of_nonneg_left hclose hR.le
+        _ = t := mul_div_cancel₀ _ hR.ne'
+    have hproj : (orthogonalProjection L x : E) =
+        (v:E) + (orthogonalProjection L z : E) := by
+      have h := (orthogonalProjection L).map_vadd z (x-z)
+      simpa only [vadd_eq_add, sub_add_cancel, orthogonalProjection_contLinear,
+        AffineSubspace.coe_vadd] using congrArg (fun q : L => (q:E)) h
+    have hpd : dist (orthogonalProjection L x : E)
+        (R • (y:E) + (orthogonalProjection L z : E)) ≤ t := by
+      rw [hproj, dist_add_right]
+      exact hscaled
+    have hxp : dist x (orthogonalProjection L x : E) ≤ t := by
+      rwa [dist_orthogonalProjection_eq_infDist]
+    calc
+      _ ≤ dist x (orthogonalProjection L x : E) +
+          dist (orthogonalProjection L x : E) (R • (y:E) + (orthogonalProjection L z : E)) :=
+        dist_triangle _ _ _
+      _ ≤ t+t := add_le_add hxp hpd
+      _ = 2*t := by ring
+
+end Geometry
+
+section AmbientMoments
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+
+lemma ambient_tube_radius_factors (j : ℕ) (β : ℝ) {R t : ℝ} (ht : 0 < t) :
+    (3*R/t)^j * (2*t)^β = (3:ℝ)^j * (2:ℝ)^β * R^j * t^(β-(j:ℝ)) := by
+  rw [div_pow, mul_pow, Real.mul_rpow (by norm_num) ht.le,
+    Real.rpow_sub_natCast ht.ne']
+  ring
+
+lemma ambient_tube {μ : Measure E} {H β R : ℝ} {z : E}
+    (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    (L : AffineSubspace ℝ E) [Nonempty L] {t : ℝ} (ht : 0 < t) (htR : t ≤ R) :
+    μ {x | Metric.infDist x L ≤ t} ≤ ENNReal.ofReal
+      ((3:ℝ)^Module.finrank ℝ L.direction * (2:ℝ)^β * H *
+        R^Module.finrank ℝ L.direction * t^(β-(Module.finrank ℝ L.direction:ℝ))) := by
+  classical
+  obtain ⟨s, hcard, hcover⟩ := affine_tube_cover_radius L z hR ht htR
+  let c : L.direction → E := fun y => R • (y:E) + (orthogonalProjection L z : E)
+  have hsub : {x | Metric.infDist x L ≤ t} ≤ᵐ[μ]
+      ⋃ y ∈ s, Metric.closedBall (c y) (2*t) := by
+    filter_upwards [μ.support_mem_ae] with x hx
+    intro hxL
+    have hxR : dist x z ≤ R := hsupport hx
+    obtain ⟨y, hy, hxy⟩ := hcover x hxR hxL
+    exact mem_iUnion₂.mpr ⟨y, hy, hxy⟩
+  calc
+    _ ≤ μ (⋃ y ∈ s, Metric.closedBall (c y) (2*t)) := measure_mono_ae hsub
+    _ ≤ ∑ y ∈ s, μ (Metric.closedBall (c y) (2*t)) := measure_biUnion_finset_le _ _
+    _ ≤ ∑ _y ∈ s, ENNReal.ofReal (H*(2*t)^β) :=
+      Finset.sum_le_sum fun y _ => hball (c y) _ (by positivity)
+    _ = (s.card : ℝ≥0∞) * ENNReal.ofReal (H*(2*t)^β) := by simp
+    _ ≤ ENNReal.ofReal ((3*R/t)^Module.finrank ℝ L.direction) *
+        ENNReal.ofReal (H*(2*t)^β) := by
+      gcongr
+      exact_mod_cast ENNReal.ofReal_le_ofReal hcard
+    _ = _ := by
+      rw [← ENNReal.ofReal_mul (by positivity)]
+      congr 1
+      calc
+        _ = H * ((3*R/t)^Module.finrank ℝ L.direction * (2*t)^β) := by ring
+        _ = _ := by rw [ambient_tube_radius_factors _ _ ht]; ring
+
+omit [BorelSpace E] in
+lemma ambient_mass_bound {μ : Measure E} {H β R : ℝ} {z : E}
+    (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β)) :
+    μ univ ≤ ENNReal.ofReal (H * R^β) := by
+  calc
+    _ ≤ μ (Metric.closedBall z R) := by
+      apply measure_mono_ae
+      filter_upwards [μ.support_mem_ae] with x hx
+      intro _
+      exact hsupport hx
+    _ ≤ _ := hball z R hR
+
+lemma ambient_tube_scaled {μ : Measure E} {H β R : ℝ} {z : E}
+    (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    (L : AffineSubspace ℝ E) [Nonempty L] {t : ℝ} (ht : 0 < t) (ht1 : t ≤ 1) :
+    μ {x | Metric.infDist x L ≤ R*t} ≤ ENNReal.ofReal
+      (((3:ℝ)^Module.finrank ℝ L.direction * (2:ℝ)^β * H * R^β) *
+        t^(β-(Module.finrank ℝ L.direction:ℝ))) := by
+  refine (ambient_tube hR hsupport hball L (mul_pos hR ht)
+    (by nlinarith)).trans_eq ?_
+  congr 1
+  rw [Real.mul_rpow hR.le ht.le]
+  have heq : R^Module.finrank ℝ L.direction * R^(β-(Module.finrank ℝ L.direction:ℝ)) = R^β := by
+    rw [← Real.rpow_natCast, ← Real.rpow_add hR]
+    congr 1
+    ring
+  calc
+    _ = ((3:ℝ)^Module.finrank ℝ L.direction * (2:ℝ)^β * H) *
+      (R^Module.finrank ℝ L.direction * R^(β-(Module.finrank ℝ L.direction:ℝ))) *
+      t^(β-(Module.finrank ℝ L.direction:ℝ)) := by ring
+    _ = _ := by rw [heq]
+
+lemma ambient_inverse_moment {μ : Measure E} {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    (L : AffineSubspace ℝ E) [Nonempty L] {m : ℕ} (hm : 0 < m)
+    (hgap : (Module.finrank ℝ L.direction:ℝ) + (m:ℝ) < β) :
+    (∀ᵐ x ∂μ, 0 < Metric.infDist x L) ∧
+    (∫⁻ x, (ENNReal.ofReal (Metric.infDist x L)) ^ (-(m:ℝ)) ∂μ) ≤
+      ENNReal.ofReal (J β m (Module.finrank ℝ L.direction) * H * R^(β-(m:ℝ))) := by
+  have hm' : (0:ℝ) < m := by exact_mod_cast hm
+  have hi := sharp_inverse_scaled μ (fun x => Metric.infDist x L)
+    (Metric.continuous_infDist_pt _).measurable (fun _ => Metric.infDist_nonneg)
+    hm' (show (m:ℝ) < β-(Module.finrank ℝ L.direction:ℝ) by linarith)
+    (show 0 ≤ H*R^β by positivity)
+    (show 0 ≤ (3:ℝ)^Module.finrank ℝ L.direction * (2:ℝ)^β * H * R^β by positivity)
+    hR (ambient_mass_bound hR hsupport hball)
+    (fun t ht ht1 => ambient_tube_scaled hR hsupport hball L ht ht1)
+  refine ⟨hi.1, hi.2.trans_eq ?_⟩
+  congr 1
+  have heq : H*R^β + ((3:ℝ)^Module.finrank ℝ L.direction * (2:ℝ)^β * H * R^β) *
+      (m:ℝ)/(β-(Module.finrank ℝ L.direction:ℝ)-(m:ℝ)) =
+      J β m (Module.finrank ℝ L.direction) * H * R^β := by
+    unfold J
+    ring
+  rw [heq, mul_assoc, ← Real.rpow_add hR]
+  congr 2
+
+end AmbientMoments
+
+lemma J_pos {β : ℝ} {m j : ℕ} (hgap : (j:ℝ)+(m:ℝ)<β) : 0 < J β m j := by
+  unfold J
+  have hd : 0 < β-(j:ℝ)-(m:ℝ) := by linarith
+  positivity
+
+lemma J_mono {β : ℝ} {m j k : ℕ} (hjk : j ≤ k)
+    (hgap : (k:ℝ)+(m:ℝ)<β) : J β m j ≤ J β m k := by
+  have hjk' : (j:ℝ) ≤ k := by exact_mod_cast hjk
+  unfold J
+  apply add_le_add le_rfl
+  apply div_le_div₀
+  · positivity
+  · gcongr
+    norm_num
+  · linarith
+  · linarith
+
+section ReplicaExact
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+open NoiselessRegression InnerProductSpace
+
+lemma ambient_inverse_moment_le {μ : Measure E} {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    (L : AffineSubspace ℝ E) [Nonempty L] {m k : ℕ} (hm : 0 < m)
+    (hdim : Module.finrank ℝ L.direction ≤ k) (hgap : (k:ℝ)+(m:ℝ)<β) :
+    (∫⁻ x, ENNReal.ofReal ((Metric.infDist x L)⁻¹ ^ m) ∂μ) ≤
+      ENNReal.ofReal (J β m k * H * R^(β-(m:ℝ))) := by
+  have hdim' : (Module.finrank ℝ L.direction:ℝ) ≤ k := by exact_mod_cast hdim
+  obtain ⟨ha, hi⟩ := ambient_inverse_moment hH hR hsupport hball L hm (by linarith)
+  calc
+    _ = ∫⁻ x, (ENNReal.ofReal (Metric.infDist x L)) ^ (-(m:ℝ)) ∂μ := by
+      apply lintegral_congr_ae
+      filter_upwards [ha] with x hx
+      rw [ENNReal.ofReal_rpow_of_pos hx, Real.rpow_neg hx.le, Real.rpow_natCast, inv_pow]
+    _ ≤ ENNReal.ofReal (J β m (Module.finrank ℝ L.direction) * H * R^(β-(m:ℝ))) := hi
+    _ ≤ _ := by
+      apply ENNReal.ofReal_le_ofReal
+      gcongr
+      exact J_mono hdim hgap
+
+lemma replica_integral_exact {μ : Measure E} [IsFiniteMeasure μ] {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    {m : ℕ} (hm : 0 < m) (p : E) (n : ℕ)
+    (hgap : (n:ℝ)+(m:ℝ)-1<β) :
+    (∫⁻ v : Fin n → E, replicaWeight m p v ∂Measure.pi (fun _ => μ)) ≤
+      ∏ j : Fin n, ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ))) := by
+  induction n with
+  | zero => simp [replicaWeight]
+  | succ n ih =>
+    have hngap : (n:ℝ)+(m:ℝ)<β := by push_cast at hgap; linarith
+    have hinner (v : Fin n → E) :
+        (∫⁻ x, replicaWeight m p (Fin.snoc v x) ∂μ) ≤
+          replicaWeight m p v * ENNReal.ofReal (J β m n * H * R^(β-(m:ℝ))) := by
+      simp_rw [replicaWeight_snoc]
+      rw [lintegral_const_mul _ (by fun_prop)]
+      apply mul_le_mul' le_rfl
+      apply ambient_inverse_moment_le hH hR hsupport hball _ hm _ hngap
+      rw [AffineSubspace.direction_mk']
+      simpa only [Fintype.card_fin, Set.finrank] using
+        finrank_range_le_card (R := ℝ) (fun i : Fin n => v i - p)
+    calc
+      _ = ∫⁻ v : Fin n → E, ∫⁻ x, replicaWeight m p (Fin.snoc v x) ∂μ
+          ∂Measure.pi (fun _ => μ) := lintegral_pi_snoc μ _ (measurable_replicaWeight m p (n+1))
+      _ ≤ ∫⁻ v : Fin n → E, replicaWeight m p v *
+          ENNReal.ofReal (J β m n * H * R^(β-(m:ℝ))) ∂Measure.pi (fun _ => μ) :=
+        lintegral_mono hinner
+      _ = (∫⁻ v : Fin n → E, replicaWeight m p v ∂Measure.pi (fun _ => μ)) *
+          ENNReal.ofReal (J β m n * H * R^(β-(m:ℝ))) :=
+        lintegral_mul_const _ (measurable_replicaWeight m p n)
+      _ ≤ (∏ j : Fin n, ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ)))) *
+          ENNReal.ofReal (J β m n * H * R^(β-(m:ℝ))) :=
+        mul_le_mul' (ih (by linarith)) le_rfl
+      _ = _ := by rw [Fin.prod_univ_castSucc]; rfl
+
+lemma ae_replica_nondegenerate_exact {μ : Measure E} [IsFiniteMeasure μ] {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    {m : ℕ} (hm : 0 < m) (p : E) (n : ℕ)
+    (hgap : (n:ℝ)+(m:ℝ)-1<β) :
+    ∀ᵐ v : Fin n → E ∂Measure.pi (fun _ => μ),
+      ∀ i, gramSchmidt ℝ (fun j => v j-p) i ≠ 0 := by
+  induction n with
+  | zero => exact Filter.Eventually.of_forall fun _ i => Fin.elim0 i
+  | succ n ih =>
+    rw [ae_pi_snoc μ (measurableSet_gramSchmidt_ne_zero p (n+1))]
+    have hngap : (n:ℝ)+(m:ℝ)<β := by push_cast at hgap; linarith
+    filter_upwards [ih (by linarith)] with v hv
+    let L := AffineSubspace.mk' p (Submodule.span ℝ (Set.range (fun i : Fin n => v i-p)))
+    have hdim : (Module.finrank ℝ L.direction:ℝ) ≤ n := by
+      dsimp [L]
+      rw [AffineSubspace.direction_mk']
+      have hh := finrank_range_le_card (R := ℝ) (fun i : Fin n => v i-p)
+      simp only [Fintype.card_fin, Set.finrank] at hh
+      exact_mod_cast hh
+    have ha := (ambient_inverse_moment hH hR hsupport hball L hm (by linarith)).1
+    filter_upwards [ha] with x hx
+    intro i
+    induction i using Fin.lastCases with
+    | last =>
+      apply norm_ne_zero_iff.mp
+      rw [norm_gramSchmidt_sub_eq_affine_infDist, image_Iio_last]
+      simp only [Fin.snoc_castSucc, Fin.snoc_last]
+      exact hx.ne'
+    | cast j => simpa only [gramSchmidt_castSucc, Fin.snoc_castSucc] using hv j
+
+lemma measurable_joint_replicaWeight (m n : ℕ) :
+    Measurable (fun v : E × (Fin n → E) => replicaWeight m v.1 v.2) := by
+  have hs : Measurable (fun v : E × (Fin n → E) => fun j => v.2 j-v.1) := by fun_prop
+  exact Finset.measurable_prod _ fun i _ =>
+    (((measurable_gramSchmidt i).comp hs).norm.inv.pow_const m).ennreal_ofReal
+
+lemma ae_joint_replica_independent {μ : Measure E} [IsFiniteMeasure μ] {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    {m : ℕ} (hm : 0 < m) (n : ℕ)
+    (hgap : (n:ℝ)+(m:ℝ)-1<β) :
+    ∀ᵐ v : E × (Fin n → E) ∂μ.prod (Measure.pi (fun _ => μ)),
+      LinearIndependent ℝ (fun j => v.2 j-v.1) := by
+  have hmeas : MeasurableSet {v : E × (Fin n → E) |
+      ∀ i, gramSchmidt ℝ (fun j => v.2 j-v.1) i ≠ 0} := by
+    rw [Set.ofPred_forall]
+    apply MeasurableSet.iInter
+    intro i
+    have h := (measurable_gramSchmidt i).comp
+      (show Measurable (fun v : E × (Fin n → E) => fun j => v.2 j-v.1) by fun_prop)
+    exact (measurableSet_eq_fun h measurable_const).compl
+  have ha : ∀ᵐ v : E × (Fin n → E) ∂μ.prod (Measure.pi (fun _ => μ)),
+      ∀ i, gramSchmidt ℝ (fun j => v.2 j-v.1) i ≠ 0 := by
+    rw [Measure.ae_prod_iff_ae_ae hmeas]
+    exact Filter.Eventually.of_forall fun p =>
+      ae_replica_nondegenerate_exact hH hR hsupport hball hm p n hgap
+  filter_upwards [ha] with v hv
+  apply Matrix.linearIndependent_of_det_gram_ne_zero
+  rw [det_gram_eq_prod_gramSchmidt]
+  exact Finset.prod_ne_zero_iff.mpr fun i _ => pow_ne_zero _ (norm_ne_zero_iff.mpr (hv i))
+
+lemma joint_replica_integral_exact {μ : Measure E} [IsFiniteMeasure μ] {H β R : ℝ} {z : E}
+    (hH : 0 < H) (hR : 0 < R) (hsupport : μ.support ⊆ Metric.closedBall z R)
+    (hball : ∀ x : E, ∀ r : ℝ, 0 < r →
+      μ (Metric.closedBall x r) ≤ ENNReal.ofReal (H*r^β))
+    {m : ℕ} (hm : 0 < m) (n : ℕ)
+    (hgap : (n:ℝ)+(m:ℝ)-1<β) :
+    (∫⁻ v : E × (Fin n → E), replicaWeight m v.1 v.2
+      ∂μ.prod (Measure.pi (fun _ => μ))) ≤
+      ENNReal.ofReal (H^(n+1) * R^(β*(n+1:ℕ)-(m:ℝ)*(n:ℝ)) *
+        ∏ j : Fin n, J β m j) := by
+  have hJ (j : Fin n) : 0 < J β m j := by
+    apply J_pos
+    have hj : (j:ℝ)+1 ≤ n := by exact_mod_cast Nat.succ_le_of_lt j.isLt
+    linarith
+  have hfac (j : Fin n) : 0 ≤ J β m j * H * R^(β-(m:ℝ)) := by
+    exact le_of_lt (mul_pos (mul_pos (hJ j) hH) (Real.rpow_pos_of_pos hR _))
+  calc
+    _ = ∫⁻ p, ∫⁻ v : Fin n → E, replicaWeight m p v
+        ∂Measure.pi (fun _ => μ) ∂μ :=
+      lintegral_prod _ (measurable_joint_replicaWeight m n).aemeasurable
+    _ ≤ ∫⁻ _p, ∏ j : Fin n, ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ))) ∂μ :=
+      lintegral_mono fun p => replica_integral_exact hH hR hsupport hball hm p n hgap
+    _ = (∏ j : Fin n, ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ)))) * μ univ :=
+      lintegral_const _
+    _ ≤ (∏ j : Fin n, ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ)))) *
+        ENNReal.ofReal (H*R^β) := mul_le_mul' le_rfl (ambient_mass_bound hR hsupport hball)
+    _ = _ := by
+      rw [← ENNReal.ofReal_prod_of_nonneg (fun j _ => hfac j),
+        ← ENNReal.ofReal_mul (Finset.prod_nonneg fun j _ => hfac j)]
+      congr 1
+      simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin]
+      rw [← Real.rpow_mul_natCast hR.le]
+      have heq : R^((β-(m:ℝ))*(n:ℝ)) * R^β =
+          R^(β*(n+1:ℕ)-(m:ℝ)*(n:ℝ)) := by
+        rw [← Real.rpow_add hR]
+        congr 1
+        push_cast
+        ring
+      calc
+        _ = (H^n*H) * (R^((β-(m:ℝ))*(n:ℝ)) * R^β) * ∏ j : Fin n, J β m j := by ring
+        _ = _ := by rw [← pow_succ, heq]
+
+end ReplicaExact
+
+lemma specialized_J_bound (d m p : ℕ) (hd : 16 ≤ d) (hp : p=d/8)
+    (_ : 1 ≤ m) (hmp : m ≤ p) (β : ℝ)
+    (hβlo : ((d:ℝ)-1)/2 ≤ β) (hβhi : β ≤ (d:ℝ)/2) :
+    ∀ j : ℕ, j ≤ p-2 →
+      ((d:ℝ)-1)/2 - 2*(p:ℝ) + 2 ≤ β-(j:ℝ)-(m:ℝ) ∧
+      (d:ℝ)/4 + 3/2 ≤ ((d:ℝ)-1)/2 - 2*(p:ℝ) + 2 ∧
+      J β m j ≤ (7:ℝ)^d := by
+  have hp2 : 2 ≤ p := by omega
+  have hp8 : p*8 ≤ d := by rw [hp]; exact Nat.div_mul_le_self d 8
+  have hp8' : (p:ℝ)*8 ≤ d := by exact_mod_cast hp8
+  have hd' : (16:ℝ) ≤ d := by exact_mod_cast hd
+  have hm' : (m:ℝ) ≤ p := by exact_mod_cast hmp
+  intro j hj
+  have hj' : (j:ℝ)+2 ≤ p := by exact_mod_cast (show j+2 ≤ p by omega)
+  have hmargin : ((d:ℝ)-1)/2-2*(p:ℝ)+2 ≤ β-(j:ℝ)-(m:ℝ) := by linarith
+  have hdim : (d:ℝ)/4+3/2 ≤ ((d:ℝ)-1)/2-2*(p:ℝ)+2 := by linarith
+  refine ⟨hmargin, hdim, ?_⟩
+  have hgap : 0 < β-(j:ℝ)-(m:ℝ) := by linarith
+  have hquot : (m:ℝ)/(β-(j:ℝ)-(m:ℝ)) ≤ 1 := by
+    rw [div_le_one hgap]
+    linarith
+  have h3 : (3:ℝ)^j ≤ (3:ℝ)^d := by
+    apply pow_le_pow_right₀ (by norm_num)
+    omega
+  have h2 : (2:ℝ)^β ≤ (2:ℝ)^d := by
+    rw [← Real.rpow_natCast]
+    apply Real.rpow_le_rpow_of_exponent_le (by norm_num)
+    linarith
+  calc
+    J β m j = 1 + (3:ℝ)^j * (2:ℝ)^β * ((m:ℝ)/(β-(j:ℝ)-(m:ℝ))) := by unfold J; ring
+    _ ≤ 1 + (3:ℝ)^j * (2:ℝ)^β * 1 := by gcongr
+    _ ≤ 1 + (3:ℝ)^d * (2:ℝ)^d := by rw [mul_one]; gcongr
+    _ = 1 + (6:ℝ)^d := by rw [← mul_pow]; norm_num
+    _ ≤ (7:ℝ)^d := by
+      simpa only [one_pow, show (1:ℝ)+6=7 by norm_num] using pow_add_pow_le (show (0:ℝ) ≤ 1 by norm_num)
+        (show (0:ℝ) ≤ 6 by norm_num) (show d ≠ 0 by omega)
+
+lemma specialized_gram_product_bound (d m p : ℕ) (hd : 16 ≤ d) (hp : p=d/8)
+    (hm : 1 ≤ m) (hmp : m ≤ p) (β : ℝ)
+    (hβlo : ((d:ℝ)-1)/2 ≤ β) (hβhi : β ≤ (d:ℝ)/2)
+    (H R : ℝ) (hH : 0 < H) (hR : 0 < R) :
+    H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ)) * (∏ j : Fin (p-1), J β m j) ≤
+      (7:ℝ)^(d*(p-1)) * H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ)) := by
+  have hp2 : 2 ≤ p := by omega
+  have hs := specialized_J_bound d m p hd hp hm hmp β hβlo hβhi
+  have hprod : (∏ j : Fin (p-1), J β m j) ≤ (7:ℝ)^(d*(p-1)) := by
+    calc
+      _ ≤ ∏ _j : Fin (p-1), (7:ℝ)^d := by
+        apply Finset.prod_le_prod₀
+        · intro j _
+          apply (J_pos ?_).le
+          have hh := hs j (by have := j.isLt; omega)
+          have hd' : (16:ℝ) ≤ d := by exact_mod_cast hd
+          linarith [hh.1, hh.2.1]
+        · intro j _
+          exact (hs j (by have := j.isLt; omega)).2.2
+      _ = _ := by simp [← pow_mul]
+  calc
+    _ ≤ H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ)) * (7:ℝ)^(d*(p-1)) := by gcongr
+    _ = _ := by ring
+
+def AmbientGramStatement : Prop :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let three : ℝ := @OfNat.ofNat ℝ 3 (@instOfNatAtLeastTwo ℝ 3 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 1)))
+  let four : ℝ := @OfNat.ofNat ℝ 4 (@instOfNatAtLeastTwo ℝ 4 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 2)))
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  (∀ (d m p : ℕ),
+    letI : MeasurableSpace (Space d) := WithLp.measurableSpace exponent (Fin d → ℝ)
+    letI : PseudoMetricSpace (Space d) :=
+      PiLp.instPseudoMetricSpace (p := exponent) (β := fun _ : Fin d => ℝ)
+    letI : AddCommGroup (Space d) := WithLp.instAddCommGroup exponent (Fin d → ℝ)
+    letI : Module ℝ (Space d) := WithLp.instModule (p := exponent) (K := ℝ) (V := Fin d → ℝ)
+    1 ≤ d → 1 ≤ m → 2 ≤ p →
+    ∀ β R H : ℝ, (m : ℝ) + (p : ℝ) - two < β → 0 < R → 0 < H →
+    ∀ (μ : Measure (Space d)), IsFiniteMeasure μ →
+    ∀ z : Space d, μ.support ⊆ Metric.closedBall z R →
+    AmbientBallBound μ H β →
+    (∀ (j : ℕ), j ≤ p-2 → ∀ L : AffineSubspace ℝ (Space d),
+      Nonempty L → Module.finrank ℝ L.direction = j →
+      (∀ t : ℝ, 0 < t → t ≤ R →
+        μ {s | Metric.infDist s L ≤ t} ≤
+          ENNReal.ofReal (three^j * two^β * H * R^j * t^(β-(j:ℝ)))) ∧
+      (∫⁻ s, (ENNReal.ofReal (Metric.infDist s L)) ^ (-(m:ℝ)) ∂μ) ≤
+        ENNReal.ofReal (J β m j * H * R^(β-(m:ℝ)))) ∧
+    (∀ᵐ v : Space d × (Fin (p-1) → Space d)
+      ∂μ.prod (Measure.pi (fun _ : Fin (p-1) => μ)),
+      LinearIndependent ℝ (fun i => v.2 i - v.1)) ∧
+    (∫⁻ v : Space d × (Fin (p-1) → Space d), InverseGram m v
+      ∂μ.prod (Measure.pi (fun _ : Fin (p-1) => μ))) ≤
+      ENNReal.ofReal (H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ)) *
+        ∏ j : Fin (p-1), J β m j)) ∧
+  (∃ C : ℝ, 1 ≤ C ∧ ∀ (d m p : ℕ), 16 ≤ d → p = d/8 →
+    1 ≤ m → m ≤ p → ∀ β : ℝ, ((d:ℝ)-1)/two ≤ β → β ≤ (d:ℝ)/two →
+    (∀ j : ℕ, j ≤ p-2 →
+      ((d:ℝ)-1)/two - two*(p:ℝ) + two ≤ β-(j:ℝ)-(m:ℝ) ∧
+      (d:ℝ)/four + three/two ≤ ((d:ℝ)-1)/two - two*(p:ℝ) + two ∧
+      J β m j ≤ C^d) ∧
+    (∀ H R : ℝ, 0 < H → 0 < R →
+      H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ)) * (∏ j : Fin (p-1), J β m j) ≤
+        C^(d*(p-1)) * H^p * R^(β*(p:ℝ)-(m:ℝ)*(p-1:ℕ))))
+
+theorem ambient_gram : AmbientGramStatement := by
+  constructor
+  · intro d m p _hd hm hp β R H hβ hR hH μ hfin z hsupport hball
+    let : IsFiniteMeasure μ := hfin
+    have hm0 : 0 < m := by omega
+    have hp1 : 1 ≤ p := by omega
+    have hgap : ((p-1:ℕ):ℝ)+(m:ℝ)-1<β := by
+      rw [Nat.cast_sub hp1]
+      push_cast
+      linarith
+    refine ⟨?_, ?_, ?_⟩
+    · intro j hj L hnonempty hdim
+      let : Nonempty L := hnonempty
+      have hj' : (j:ℝ)+2 ≤ p := by exact_mod_cast (show j+2 ≤ p by omega)
+      constructor
+      · intro t ht htR
+        simpa only [hdim] using ambient_tube hR hsupport hball L ht htR
+      · have hi := (ambient_inverse_moment hH hR hsupport hball L hm0
+          (by rw [hdim]; linarith)).2
+        simpa only [hdim] using hi
+    · exact ae_joint_replica_independent hH hR hsupport hball hm0 (p-1) hgap
+    · have hi := joint_replica_integral_exact hH hR hsupport hball hm0 (p-1) hgap
+      simpa only [NoiselessRegression.replicaWeight_eq_det, InverseGram,
+        Nat.sub_add_cancel hp1] using hi
+  · refine ⟨7, by norm_num, ?_⟩
+    intro d m p hd hp hm hmp β hβlo hβhi
+    exact ⟨specialized_J_bound d m p hd hp hm hmp β hβlo hβhi,
+      specialized_gram_product_bound d m p hd hp hm hmp β hβlo hβhi⟩
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/BallAverages.lean

@@ -0,0 +1,142 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.RadialMixture
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma gaussianKernel_scale (m : ℕ) {δ : ℝ} (hδ : 0 < δ) (y : Space m) :
+    GaussianKernel m δ (δ • y) = δ⁻¹ ^ m * GaussianKernel m 1 y := by
+  have he (a : ℝ) : gaussianPDFReal 0 ⟨δ^2,sq_nonneg δ⟩ (δ*a) =
+      δ⁻¹ * gaussianPDFReal 0 1 a := by
+    have h := gaussianPDFReal_inv_mul (μ := 0) (v := 1) hδ.ne' (δ*a)
+    simp only [inv_mul_cancel_left₀ hδ.ne', mul_zero, mul_one, abs_of_pos hδ] at h
+    rw [h]
+    field_simp
+    rfl
+  unfold GaussianKernel
+  simp only [PiLp.smul_apply, smul_eq_mul, one_pow]
+  simp_rw [he]
+  simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin]
+  rfl
+
+lemma radialMixture_scale (m : ℕ) {δ : ℝ} (hδ : 0 < δ) (r : ℝ) :
+    RadialMixture m δ (δ*r) = δ⁻¹ * RadialMixture m 1 r := by
+  unfold RadialMixture
+  rw [mul_smul, gaussianKernel_scale m hδ]
+  simp only [one_pow, div_one, mul_pow, inv_pow]
+  field_simp
+
+def BallAverage {m : ℕ} (ν : Measure (Space m)) (y : Space m) (r : ℝ) : ℝ :=
+  (ν (Metric.ball y r)).toReal / (UnitBallVolume m * r^m)
+
+lemma ballAverage_measurable {m : ℕ} (ν : Measure (Space m)) (y : Space m) :
+    Measurable (BallAverage ν y) := by
+  have h : Monotone (fun r : ℝ => ν (Metric.ball y r)) := fun r t h =>
+    measure_mono (Metric.ball_subset_ball h)
+  exact h.measurable.ennreal_toReal.div (by fun_prop)
+
+lemma ballAverage_nonneg {m : ℕ} (ν : Measure (Space m)) (y : Space m) {r : ℝ}
+    (hr : 0 < r) : 0 ≤ BallAverage ν y r := by
+  exact div_nonneg ENNReal.toReal_nonneg (mul_nonneg (unitBallVolume_pos m).le
+    (pow_nonneg hr.le _))
+
+lemma ac_ball_eq_closedBall {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    (hν : ν ≪ volume) (y : Space m) (r : ℝ) :
+    ν (Metric.ball y r) = ν (Metric.closedBall y r) := by
+  have : NeZero m := ⟨by omega⟩
+  apply measure_eq_measure_of_null_sdiff Metric.ball_subset_closedBall
+  rw [Metric.closedBall_sdiff_ball]
+  exact hν (Measure.addHaar_sphere volume y r)
+
+lemma ae_tendsto_ballAverage {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    [IsFiniteMeasure ν] (hν : ν ≪ volume) :
+    ∀ᵐ y ∂(volume : Measure (Space m)), Tendsto (BallAverage ν y)
+      (𝓝[>] (0:ℝ)) (𝓝 ((ν.rnDeriv volume y).toReal)) := by
+  have : NeZero m := ⟨by omega⟩
+  filter_upwards [Besicovitch.ae_tendsto_rnDeriv ν volume, ν.rnDeriv_lt_top volume] with y hy hyfin
+  have ht := (ENNReal.continuousAt_toReal hyfin.ne).tendsto.comp hy
+  apply ht.congr'
+  filter_upwards [self_mem_nhdsWithin] with r hr
+  unfold BallAverage
+  simp only [Function.comp_apply]
+  rw [ENNReal.toReal_div, Measure.addHaar_closedBall_eq_addHaar_ball volume y r,
+    ← ac_ball_eq_closedBall hm ν hν y r, volume_ball_eq m hm y hr,
+    ENNReal.toReal_ofReal (mul_nonneg (unitBallVolume_pos m).le (pow_nonneg hr.le _))]
+
+lemma ballAverage_bounded {m : ℕ} (ν : Measure (Space m)) [IsFiniteMeasure ν]
+    (y : Space m) {f : ℝ} (hf : 0 ≤ f)
+    (ht : Tendsto (BallAverage ν y) (𝓝[>] (0:ℝ)) (𝓝 f)) :
+    ∃ B : ℝ, 0 ≤ B ∧ ∀ r : ℝ, 0 < r → ‖BallAverage ν y r‖ ≤ B := by
+  rcases Metric.tendsto_nhdsWithin_nhds.mp ht 1 zero_lt_one with ⟨b,hb,hnear⟩
+  let C : ℝ := max (f+1) ((ν Set.univ).toReal / (UnitBallVolume m * b^m))
+  refine ⟨C, le_trans (by linarith : 0 ≤ f+1) (le_max_left _ _), ?_⟩
+  intro r hr
+  rw [Real.norm_eq_abs, abs_of_nonneg (ballAverage_nonneg ν y hr)]
+  by_cases h : r < b
+  · have he := hnear hr (by simpa [Real.dist_eq, abs_of_pos hr] using h)
+    have he' : BallAverage ν y r < f+1 := by
+      rw [Real.dist_eq] at he
+      have := (abs_lt.mp he).2
+      linarith
+    exact he'.le.trans (le_max_left _ _)
+  · apply le_trans ?_ (le_max_right _ _)
+    unfold BallAverage
+    have hvol : 0 < UnitBallVolume m := unitBallVolume_pos m
+    apply div_le_div₀ (by positivity) ?_ (by positivity) ?_
+    · exact (ENNReal.toReal_le_toReal (measure_ne_top _ _) (measure_ne_top _ _)).mpr
+        (measure_mono (Set.subset_univ _))
+    · exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ hb.le (le_of_not_gt h) _)
+        (unitBallVolume_pos m).le
+
+lemma tendsto_radial_average {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m)) [IsFiniteMeasure ν]
+    (y : Space m) {f : ℝ} (hf : 0 ≤ f)
+    (ht : Tendsto (BallAverage ν y) (𝓝[>] (0:ℝ)) (𝓝 f)) :
+    Tendsto (fun δ : ℝ => ∫ r in Ioi 0, RadialMixture m 1 r * BallAverage ν y (δ*r))
+      (𝓝[>] (0:ℝ)) (𝓝 f) := by
+  obtain ⟨B,hB,hbound⟩ := ballAverage_bounded ν y hf ht
+  have hw : IntegrableOn (RadialMixture m 1) (Ioi 0) :=
+    integrable_of_integral_eq_one (radialMixture_integral m hm zero_lt_one)
+  have hl := tendsto_integral_filter_of_dominated_convergence
+    (μ := volume.restrict (Ioi 0)) (l := 𝓝[>] (0:ℝ))
+    (F := fun δ r => RadialMixture m 1 r * BallAverage ν y (δ*r))
+    (f := fun r => RadialMixture m 1 r * f)
+    (fun r => RadialMixture m 1 r * B)
+    (Eventually.of_forall (fun δ =>
+      ((radialMixture_measurable m 1).mul ((ballAverage_measurable ν y).comp
+        (by fun_prop))).aestronglyMeasurable))
+    (show ∀ᶠ δ in 𝓝[>] (0:ℝ), ∀ᵐ r ∂volume.restrict (Ioi 0),
+      ‖RadialMixture m 1 r * BallAverage ν y (δ*r)‖ ≤ RadialMixture m 1 r * B from by
+      filter_upwards [self_mem_nhdsWithin] with δ hδ
+      filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+      rw [norm_mul, Real.norm_eq_abs, abs_of_nonneg (radialMixture_nonneg m 1 hr)]
+      exact mul_le_mul_of_nonneg_left (hbound _ (mul_pos hδ hr)) (radialMixture_nonneg m 1 hr))
+    (hw.mul_const B) (show ∀ᵐ r ∂volume.restrict (Ioi 0),
+      Tendsto (fun δ => RadialMixture m 1 r * BallAverage ν y (δ*r))
+        (𝓝[>] (0:ℝ)) (𝓝 (RadialMixture m 1 r * f)) from by
+      filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+      apply Tendsto.const_mul
+      apply ht.comp
+      apply tendsto_nhdsWithin_iff.mpr
+      refine ⟨?_, ?_⟩
+      · simpa using ((continuous_id.mul_const r).tendsto (0:ℝ)).mono_left nhdsWithin_le_nhds
+      · filter_upwards [self_mem_nhdsWithin] with δ hδ
+        change 0 < δ*r
+        exact mul_pos hδ hr)
+  simpa only [integral_mul_const, radialMixture_integral m hm zero_lt_one, one_mul] using hl
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CoefficientStep.lean

@@ -0,0 +1,81 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.KernelModel
+import OAI.Probability.MemoryPrecision.WeightedImage
+import OAI.Probability.MemoryPrecision.WeightedSelection
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+abbrev Sphere (d : ℕ) := Metric.sphere (0 : Space d) 1
+def SpherePrior (d : ℕ) : Measure (Sphere d) :=
+  MemoryPrecision.Kernel.UniformSphere d
+
+def SphereBallBound {d : ℕ} (h : Sphere d → ℝ≥0∞) (H α : ℝ) : Prop :=
+  ∀ z : Space d, ∀ r : ℝ, 0 < r →
+    (∫⁻ s in {s : Sphere d | dist s.val z ≤ r}, h s ∂SpherePrior d) ≤
+      ENNReal.ofReal (H * r^α)
+def SphereBlock {d m N : ℕ} (h : Fin N → Sphere d → ℝ≥0∞)
+    (g : Fin N → ((Fin m → Space d) × (Fin m → ℝ)) → ℝ≥0∞)
+    (s : Sphere d) : ℝ≥0∞ :=
+  WeightedBlock Subtype.val h g s
+def CoefficientStepStatement : Prop :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  ∃ C : ℝ, 1 ≤ C ∧ ∀ d m N : ℕ, 16 ≤ d →
+    1 ≤ m → m ≤ d/8 → 1 ≤ N →
+    ∀ α H : ℝ, ((d:ℝ)-1)/two ≤ α → α ≤ (d:ℝ)/two → 0 < H →
+    ∀ h : Fin N → Sphere d → ℝ≥0∞,
+      (∀ w, Measurable (h w)) → (∀ w s, h w s ≤ 1) →
+      (∀ w, SphereBallBound (h w) H α) →
+    ∀ g : Fin N → ((Fin m → Space d) × (Fin m → ℝ)) → ℝ≥0∞,
+      (∀ w, Measurable (g w)) → (∀ x, ∑ w, g w x ≤ 1) →
+      SphereBallBound (SphereBlock h g) (C^d * (N:ℝ)^(1/((d/8:ℕ):ℝ)) * H) α
+
+theorem coefficient_step : CoefficientStepStatement := by
+  refine ⟨1344, by norm_num, ?_⟩
+  intro d m N hd hm hmp hN α H hαlo hαhi hH h hh hh1 hb g hg hgsum z r hr
+  have : NeZero d := ⟨by omega⟩
+  have : IsProbabilityMeasure (SpherePrior d) :=
+    (show IsProbabilityMeasure (NoiselessRegression.sphereLaw (E := Space d)) from inferInstance)
+  let ν (w : Fin N) := ((SpherePrior d).withDensity (h w)).map Subtype.val
+  let (w : Fin N) : IsFiniteMeasure (ν w) :=
+    weighted_image_finite (SpherePrior d) Subtype.val (h w) (hh1 w)
+  have hν (w) : AmbientBallBound (ν w) H α := by
+    intro x ρ hρ
+    rw [show ν w = ((SpherePrior d).withDensity (h w)).map Subtype.val from rfl,
+      weighted_image_ball _ measurable_subtype_coe]
+    exact hb w x ρ hρ
+  have hp : 2 ≤ d/8 := by omega
+  have hmd : m ≤ d := hmp.trans (Nat.div_le_self _ _)
+  have hgap : (m:ℝ)+((d/8:ℕ):ℝ)-2 < α := by
+    have hm' : (m:ℝ) ≤ (d/8:ℕ) := by exact_mod_cast hmp
+    have hp' : ((d/8:ℕ):ℝ)*8 ≤ d := by exact_mod_cast Nat.div_mul_le_self d 8
+    have hd' : (16:ℝ) ≤ d := by exact_mod_cast hd
+    linarith
+  have hJ := fun j hj => (specialized_J_bound d m (d/8) hd rfl hm hmp α hαlo hαhi j hj).2.2
+  have hsel := localized_weighted_selection ν hp hm hmd (by norm_num : (1:ℝ) ≤ 7)
+    hH hgap hJ hν g hg hgsum z hr
+  have he := weightedBlock_mass_identity (SpherePrior d) measurable_subtype_coe hh hh1 hg
+    (show MeasurableSet (Metric.closedBall z r) from Metric.isClosed_closedBall.measurableSet)
+  change (∫⁻ s in Subtype.val ⁻¹' Metric.closedBall z r,
+    WeightedBlock Subtype.val h g s ∂SpherePrior d) ≤ _
+  rw [he]
+  convert hsel using 1
+  norm_num [ν, mul_assoc]
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeArithmetic.lean

@@ -0,0 +1,93 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeContinuation
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+
+lemma cube_memory_ratio {d M : ℕ} (hd : 16 ≤ d) (hM : M ≤ d^2) :
+    (M:ℝ) / (((d/2)/4:ℕ):ℝ) ≤ 72 * (d/2:ℕ) := by
+  have hd3 : d ≤ 3*(d/2) := by omega
+  have hn8 : d/2 ≤ 8*((d/2)/4) := by omega
+  have hm : M ≤ (72*(d/2))*((d/2)/4) := by
+    calc
+      M ≤ d^2 := hM
+      _ ≤ (3*(d/2))^2 := Nat.pow_le_pow_left hd3 2
+      _ = 9*(d/2)*(d/2) := by ring
+      _ ≤ 9*(d/2)*(8*((d/2)/4)) := Nat.mul_le_mul_left _ hn8
+      _ = _ := by ring
+  apply (div_le_iff₀ (by exact_mod_cast (show 0 < (d/2)/4 by omega))).2
+  exact_mod_cast hm
+
+lemma cube_memory_factor {d M : ℕ} (hd : 16 ≤ d) (hM : M ≤ d^2) :
+    ((2^M:ℕ):ℝ)^(1/(((d/2)/4:ℕ):ℝ)) ≤ ((2:ℝ)^72)^(d/2) := by
+  have he : ((2^M:ℕ):ℝ)^(1/(((d/2)/4:ℕ):ℝ)) =
+      (2:ℝ)^((M:ℝ)/(((d/2)/4:ℕ):ℝ)) := by
+    rw [Nat.cast_pow, Nat.cast_ofNat, ← Real.rpow_natCast,
+      ← Real.rpow_mul (by norm_num : (0:ℝ) ≤ 2)]
+    congr 1
+    ring
+  rw [he, ← pow_mul, ← Real.rpow_natCast]
+  apply Real.rpow_le_rpow_of_exponent_le (by norm_num : (1:ℝ) ≤ 2)
+  simpa using cube_memory_ratio hd hM
+
+lemma cube_stopping_factor {d : ℕ} (hd : 16 ≤ d) (T : ℕ) :
+    (T+1:ℝ) ≤ ((2:ℝ)^(d/2))^BlockCount T ((d/2)/4) := by
+  have hT := blockCount_mul_ge T (by omega : 0 < (d/2)/4)
+  have hp : (d/2)/4 ≤ d/2 := Nat.div_le_self _ _
+  have hTn : T ≤ (d/2) * BlockCount T ((d/2)/4) := by nlinarith
+  have htwo : (T+1:ℕ) ≤ 2^T := Nat.lt_two_pow_self
+  have hpow : (2:ℝ)^T ≤ 2^((d/2) * BlockCount T ((d/2)/4)) :=
+    pow_le_pow_right₀ (by norm_num) hTn
+  rw [pow_mul] at hpow
+  exact (by exact_mod_cast htwo : (T+1:ℝ) ≤ (2:ℝ)^T).trans hpow
+
+def CubeSuccessConstant : ℝ := max 12 (2*CubeStepConstant*2^72)
+lemma cubeSuccessConstant_twelve : 12 ≤ CubeSuccessConstant := le_max_left _ _
+lemma cubeSuccessConstant_one : 1 ≤ CubeSuccessConstant :=
+  (by norm_num : (1:ℝ) ≤ 12).trans cubeSuccessConstant_twelve
+lemma cubeSuccessConstant_exp : Real.exp 1 ≤ CubeSuccessConstant :=
+  Real.exp_one_lt_three.le.trans ((by norm_num : (3:ℝ) ≤ 12).trans cubeSuccessConstant_twelve)
+lemma cubeSuccessConstant_pos : 0 < CubeSuccessConstant :=
+  lt_of_lt_of_le zero_lt_one cubeSuccessConstant_one
+
+lemma cube_whole_factor {d M : ℕ} (hd : 16 ≤ d) (hM : M ≤ d^2) (T : ℕ) :
+    (T+1:ℝ) * ((12:ℝ)^(d/2) * CubeStep d (2^M) ^ BlockCount T ((d/2)/4)) ≤
+      CubeSuccessConstant^((d/2)*(BlockCount T ((d/2)/4)+1)) := by
+  have hC := cubeStepConstant_pos
+  have hD := cubeSuccessConstant_pos
+  have hS := cubeStep_pos d (show 1 ≤ 2^M by exact one_le_pow₀ (by norm_num))
+  have hmem := cube_memory_factor hd hM
+  have hstep : (2:ℝ)^(d/2) * CubeStep d (2^M) ≤ CubeSuccessConstant^(d/2) := by
+    calc
+      _ ≤ 2^(d/2) * (CubeStepConstant^(d/2) * ((2:ℝ)^72)^(d/2)) :=
+        mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hmem (by positivity)) (by positivity)
+      _ = (2*CubeStepConstant*2^72)^(d/2) := by simp only [mul_pow]; ring
+      _ ≤ _ := pow_le_pow_left₀ (by positivity) (le_max_right _ _) _
+  calc
+    _ = 12^(d/2) * ((T+1:ℝ) * CubeStep d (2^M) ^ BlockCount T ((d/2)/4)) := by ring
+    _ ≤ 12^(d/2) * (((2:ℝ)^(d/2))^BlockCount T ((d/2)/4) *
+        CubeStep d (2^M) ^ BlockCount T ((d/2)/4)) :=
+      mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right (cube_stopping_factor hd T) (by positivity))
+        (by positivity)
+    _ = 12^(d/2) * ((2:ℝ)^(d/2) * CubeStep d (2^M))^BlockCount T ((d/2)/4) := by rw [mul_pow]
+    _ ≤ CubeSuccessConstant^(d/2) * (CubeSuccessConstant^(d/2))^BlockCount T ((d/2)/4) :=
+      mul_le_mul (pow_le_pow_left₀ (by norm_num) cubeSuccessConstant_twelve _)
+        (pow_le_pow_left₀ (by positivity) hstep _) (by positivity) (by positivity)
+    _ = _ := by rw [pow_mul, pow_succ]; ring
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeBlock.lean

@@ -0,0 +1,165 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeGeometry
+import OAI.Probability.MemoryPrecision.WeightedImage
+import OAI.Probability.MemoryPrecision.WeightedSelection
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma cube_J_bound {d k : ℕ} (hd : 16 ≤ d) (hk : k ≤ (d/2)/4) :
+    ∀ j : ℕ, j ≤ (d/2)/4-2 → J (3*(d/2:ℕ)/4:ℝ) k j ≤ (7:ℝ)^d := by
+  have hp2 : 2 ≤ (d/2)/4 := by omega
+  have hn4 : (((d/2)/4:ℕ):ℝ)*4 ≤ (d/2:ℕ) := by exact_mod_cast Nat.div_mul_le_self (d/2) 4
+  have hn : ((d/2:ℕ):ℝ) ≤ d := by exact_mod_cast Nat.div_le_self d 2
+  have hm : (k:ℝ) ≤ ((d/2)/4:ℕ) := by exact_mod_cast hk
+  intro j hj
+  have hj' : (j:ℝ)+2 ≤ ((d/2)/4:ℕ) := by exact_mod_cast (show j+2 ≤ (d/2)/4 by omega)
+  have hgap : 0 < (3*(d/2:ℕ)/4:ℝ)-(j:ℝ)-(k:ℝ) := by linarith
+  have hquot : (k:ℝ)/((3*(d/2:ℕ)/4:ℝ)-(j:ℝ)-(k:ℝ)) ≤ 1 := by
+    rw [div_le_one hgap]
+    linarith
+  have h3 : (3:ℝ)^j ≤ (3:ℝ)^d := pow_le_pow_right₀ (by norm_num) (by omega)
+  have h2 : (2:ℝ)^(3*(d/2:ℕ)/4:ℝ) ≤ (2:ℝ)^d := by
+    rw [← Real.rpow_natCast]
+    apply Real.rpow_le_rpow_of_exponent_le (by norm_num)
+    linarith
+  calc
+    J (3*(d/2:ℕ)/4:ℝ) k j = 1+(3:ℝ)^j*(2:ℝ)^(3*(d/2:ℕ)/4:ℝ)*
+      ((k:ℝ)/((3*(d/2:ℕ)/4:ℝ)-(j:ℝ)-(k:ℝ))) := by unfold J; ring
+    _ ≤ 1+(3:ℝ)^j*(2:ℝ)^(3*(d/2:ℕ)/4:ℝ)*1 := by gcongr
+    _ ≤ 1+(3:ℝ)^d*(2:ℝ)^d := by rw [mul_one]; gcongr
+    _ = 1+(6:ℝ)^d := by rw [← mul_pow]; norm_num
+    _ ≤ (7:ℝ)^d := by
+      simpa only [one_pow, show (1:ℝ)+6=7 by norm_num] using
+        pow_add_pow_le (show (0:ℝ) ≤ 1 by norm_num) (show (0:ℝ) ≤ 6 by norm_num) (show d ≠ 0 by omega)
+
+lemma cube_weighted_ambient {d : ℕ} (hd : 2 ≤ d) {f : Cube d → ℝ≥0∞}
+    {L : ℝ} (hf : CubeLocal f L) :
+    AmbientBallBound (((CubeLaw d).withDensity f).map (CubeEmbedding d)) L (3*(d/2:ℕ)/4:ℝ) := by
+  intro x r hr
+  rw [weighted_image_ball _ (cubeEmbedding_measurable d)]
+  apply (lintegral_mono_set (show {u | dist (CubeEmbedding d u) x ≤ r} ⊆
+    CubeBall d (Real.sqrt (d/2:ℕ) • cubeProject d x) r from ?_)).trans
+    (hf _ _ hr)
+  intro u hu
+  exact (cubeProject_parameter_dist hd u x).trans
+    (mul_le_mul_of_nonneg_left hu (Real.sqrt_nonneg _))
+
+lemma cubeBall_embedding_subset {d : ℕ} (hd : 2 ≤ d) (z : Space (d/2)) {r : ℝ}
+    (u₀ : Cube d) (hu₀ : u₀ ∈ CubeBall d z r) :
+    CubeBall d z r ⊆ CubeEmbedding d ⁻¹' Metric.closedBall (CubeEmbedding d u₀) (4*r) := by
+  have hs : 0 < Real.sqrt (d/2:ℕ) := Real.sqrt_pos.2 (by exact_mod_cast (show 0 < d/2 by omega))
+  intro u hu
+  have hu' : dist u.val z ≤ Real.sqrt (d/2:ℕ)*r := hu
+  have hu₀' : dist u₀.val z ≤ Real.sqrt (d/2:ℕ)*r := hu₀
+  have hab : dist u.val u₀.val ≤ 2*Real.sqrt (d/2:ℕ)*r := by
+    have := dist_triangle u.val z u₀.val
+    rw [dist_comm z u₀.val] at this
+    linarith
+  apply (cubeEmbedding_dist hd u u₀).trans
+  calc
+    _ ≤ 2/Real.sqrt (d/2:ℕ)*(2*Real.sqrt (d/2:ℕ)*r) :=
+      mul_le_mul_of_nonneg_left hab (by positivity)
+    _ = 4*r := by field_simp [ne_of_gt hs]; ring
+
+lemma weightedBlock_le_sum {X : Type*} {d m N : ℕ}
+    (ι : X → Space d) (f : Fin N → X → ℝ≥0∞)
+    {g : Fin N → ((Fin m → Space d) × (Fin m → ℝ)) → ℝ≥0∞}
+    (hg : ∀ x, ∑ w, g w x ≤ 1) (x : X) : WeightedBlock ι f g x ≤ ∑ w, f w x := by
+  unfold WeightedBlock
+  calc
+    _ ≤ ∫⁻ _A : Fin m → Space d, (∑ w, f w x) ∂Measure.pi (fun _ => stdGaussian (Space d)) := by
+      apply lintegral_mono
+      intro A
+      apply Finset.sum_le_sum
+      intro w _
+      exact mul_le_of_le_one_left' ((Finset.single_le_sum (fun _ _ => zero_le) (Finset.mem_univ w)).trans (hg _))
+    _ = _ := by simp
+
+def CubeBlockConstant : ℝ := 4*1344^3
+lemma cubeBlockConstant_one : 1 ≤ CubeBlockConstant := by norm_num [CubeBlockConstant]
+
+lemma cube_constant_scale {d : ℕ} (hd : 2 ≤ d) {r : ℝ} (hr : 0 < r) :
+    (1344:ℝ)^d * (4*r)^(3*(d/2:ℕ)/4:ℝ) ≤ CubeBlockConstant^(d/2) * r^(3*(d/2:ℕ)/4:ℝ) := by
+  rw [Real.mul_rpow (by norm_num) hr.le]
+  have hp : (1344:ℝ)^d ≤ (1344^3:ℝ)^(d/2) := by
+    rw [← pow_mul]
+    apply pow_le_pow_right₀ (by norm_num)
+    omega
+  have h4 : (4:ℝ)^(3*(d/2:ℕ)/4:ℝ) ≤ (4:ℝ)^(d/2) := by
+    rw [← Real.rpow_natCast]
+    apply Real.rpow_le_rpow_of_exponent_le (by norm_num)
+    have := Nat.cast_nonneg (α := ℝ) (d/2)
+    linarith
+  calc
+    _ = ((1344:ℝ)^d*(4:ℝ)^(3*(d/2:ℕ)/4:ℝ))*r^(3*(d/2:ℕ)/4:ℝ) := by ring
+    _ ≤ ((1344^3:ℝ)^(d/2)*(4:ℝ)^(d/2))*r^(3*(d/2:ℕ)/4:��) := by gcongr
+    _ = _ := by rw [← mul_pow]; congr 2; norm_num [CubeBlockConstant]
+
+def CubeBlockStatement : Prop :=
+  ∃ C : ℝ, 1 ≤ C ∧ ∀ d k N : ℕ, 16 ≤ d → 1 ≤ k → k ≤ (d/2)/4 → 1 ≤ N →
+    ∀ L : ℝ, 0 ≤ L → ∀ f : Fin N → Cube d → ℝ≥0∞,
+      (∀ v, Measurable (f v)) → (∀ v u, f v u ≤ 1) → (∀ v, CubeLocal (f v) L) →
+    ∀ g : Fin N → ((Fin k → Space d) × (Fin k → ℝ)) → ℝ≥0∞,
+      (∀ v, Measurable (g v)) → (∀ x, ∑ v, g v x ≤ 1) →
+      CubeLocal (WeightedBlock (CubeEmbedding d) f g)
+        (C^(d/2) * (N:ℝ)^(1/(((d/2)/4:ℕ):ℝ)) * L)
+theorem cube_block : CubeBlockStatement := by
+  refine ⟨CubeBlockConstant, cubeBlockConstant_one, ?_⟩
+  intro d k N hd hk hkp hN L hL f hf hf1 hloc g hg hgs z r hr
+  by_cases hL0 : L = 0
+  · simp only [hL0, mul_zero, zero_mul, ENNReal.ofReal_zero]
+    calc
+      _ ≤ ∫⁻ u in CubeBall d z r, ∑ w, f w u ∂CubeLaw d :=
+        lintegral_mono (weightedBlock_le_sum _ _ hgs)
+      _ = ∑ w, ∫⁻ u in CubeBall d z r, f w u ∂CubeLaw d :=
+        lintegral_finsetSum _ (fun w _ => hf w)
+      _ ≤ ∑ _w : Fin N, ENNReal.ofReal (L*r^(3*(d/2:ℕ)/4:ℝ)) :=
+        Finset.sum_le_sum (fun w _ => hloc w z r hr)
+      _ = 0 := by simp [hL0]
+  have hLpos : 0 < L := lt_of_le_of_ne hL (Ne.symm hL0)
+  by_cases hempty : CubeBall d z r = ∅
+  · simp [hempty]
+  obtain ⟨u₀,hu₀⟩ := Set.nonempty_iff_ne_empty.mpr hempty
+  let ν (w : Fin N) := ((CubeLaw d).withDensity (f w)).map (CubeEmbedding d)
+  let (w : Fin N) : IsFiniteMeasure (ν w) := weighted_image_finite (CubeLaw d) (CubeEmbedding d) (f w) (hf1 w)
+  have hν w : AmbientBallBound (ν w) L (3*(d/2:ℕ)/4:ℝ) := cube_weighted_ambient (by omega) (hloc w)
+  have hp : 2 ≤ (d/2)/4 := by omega
+  have hkd : k ≤ d := by omega
+  have hgap : (k:ℝ)+(((d/2)/4:ℕ):ℝ)-2 < (3*(d/2:ℕ)/4:ℝ) := by
+    have hp' : (((d/2)/4:ℕ):ℝ)*4 ≤ (d/2:ℕ) := by exact_mod_cast Nat.div_mul_le_self (d/2) 4
+    have hk' : (k:ℝ) ≤ ((d/2)/4:ℕ) := by exact_mod_cast hkp
+    have hn' : (8:ℝ) ≤ (d/2:ℕ) := by exact_mod_cast (show 8 ≤ d/2 by omega)
+    linarith
+  have hsel := localized_weighted_selection ν hp hk hkd (by norm_num : (1:ℝ) ≤ 7)
+    hLpos hgap (cube_J_bound hd hkp) hν g hg hgs (CubeEmbedding d u₀) (by positivity : 0 < 4*r)
+  have he := weightedBlock_mass_identity (CubeLaw d) (cubeEmbedding_measurable d) hf hf1 hg
+    (show MeasurableSet (Metric.closedBall (CubeEmbedding d u₀) (4*r)) from Metric.isClosed_closedBall.measurableSet)
+  apply (lintegral_mono_set (cubeBall_embedding_subset (by omega) z u₀ hu₀)).trans
+  rw [he]
+  apply hsel.trans (ENNReal.ofReal_le_ofReal ?_)
+  have hscale := cube_constant_scale (d := d) (by omega) hr
+  norm_num only [show (7:ℝ)*192=1344 by norm_num]
+  calc
+    _ = ((1344:ℝ)^d*(4*r)^(3*(d/2:ℕ)/4:ℝ))*((N:ℝ)^(1/(((d/2)/4:ℕ):ℝ))*L) := by ring
+    _ ≤ (CubeBlockConstant^(d/2)*r^(3*(d/2:ℕ)/4:ℝ))*((N:ℝ)^(1/(((d/2)/4:ℕ):ℝ))*L) :=
+      mul_le_mul_of_nonneg_right hscale (by positivity)
+    _ = _ := by ring
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeCaps.lean

@@ -0,0 +1,142 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeGeometry
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma coordinate_ball_root_volume (n : ℕ) :
+    volume (coordinateBall n (Real.sqrt n)) ≤ ENNReal.ofReal ((12:ℝ)^n) := by
+  have hpoint (x : Fin n → ℝ) :
+      (coordinateBall n (Real.sqrt n)).indicator (fun _ => (1:ℝ≥0∞)) x ≤
+        ENNReal.ofReal (Real.exp n) * ∏ i, ENNReal.ofReal (Real.exp (-(x i)^2/4)) := by
+    by_cases hx : x ∈ coordinateBall n (Real.sqrt n)
+    · rw [Set.indicator_of_mem hx, ← ENNReal.ofReal_prod_of_nonneg (fun i _ => Real.exp_nonneg _),
+        ← ENNReal.ofReal_mul (Real.exp_nonneg _), ← Real.exp_sum, ← Real.exp_add]
+      have hs : (∑ i, (x i)^2) ≤ n := by
+        have hp := pow_le_pow_left₀ (norm_nonneg _) hx 2
+        change coordinateNorm x ^ 2 ≤ (Real.sqrt (n:ℝ)) ^ 2 at hp
+        rw [coordinateNorm_sq, Real.sq_sqrt (by positivity)] at hp
+        exact hp
+      have he : 1 ≤ Real.exp ((n:ℝ) + ∑ i, -(x i)^2/4) := by
+        apply Real.one_le_exp_iff.mpr
+        rw [← Finset.sum_div, Finset.sum_neg_distrib]
+        have hn : (0:ℝ) ≤ n := Nat.cast_nonneg n
+        linarith
+      exact_mod_cast (ENNReal.ofReal_le_ofReal he)
+    · rw [Set.indicator_of_notMem hx]
+      exact zero_le
+  calc
+    volume (coordinateBall n (Real.sqrt n)) =
+        ∫⁻ x : Fin n → ℝ, (coordinateBall n (Real.sqrt n)).indicator (fun _ => (1:ℝ≥0∞)) x := by
+      rw [lintegral_indicator_const (measurableSet_coordinateBall _ _), one_mul]
+    _ ≤ ∫⁻ x : Fin n → ℝ, ENNReal.ofReal (Real.exp n) *
+        ∏ i, ENNReal.ofReal (Real.exp (-(x i)^2/4)) := lintegral_mono hpoint
+    _ = ENNReal.ofReal (Real.exp n) *
+        (∫⁻ z : ℝ, ENNReal.ofReal (Real.exp (-(z^2)/4)))^n := by
+      rw [lintegral_const_mul _ (by fun_prop), volume_pi,
+        lintegral_fin_prod volume n (fun _ => fun z : ℝ => ENNReal.ofReal (Real.exp (-(z^2)/4))) (fun _ => by fun_prop)]
+      simp
+    _ ≤ ENNReal.ofReal (Real.exp n) * (4:ℝ≥0∞)^n := by
+      gcongr
+      exact lintegral_quarterGaussian_le
+    _ ≤ ENNReal.ofReal ((12:ℝ)^n) := by
+      have he : Real.exp (n:ℝ) ≤ (3:ℝ)^n := by
+        rw [← mul_one (n:ℝ), Real.exp_nat_mul]
+        exact pow_le_pow_left₀ (Real.exp_nonneg _) Real.exp_one_lt_three.le n
+      calc
+        _ ≤ ENNReal.ofReal ((3:ℝ)^n) * (4:ℝ≥0∞)^n := mul_le_mul' (ENNReal.ofReal_le_ofReal he) le_rfl
+        _ = _ := by rw [ENNReal.ofReal_pow (by norm_num), ← mul_pow]; norm_num
+
+lemma cube_scaled_ball_volume (n : ℕ) (z : Space n) {r : ℝ} (hr : 0 < r) :
+    volume (Metric.closedBall z (Real.sqrt n*r)) ≤ ENNReal.ofReal ((12:ℝ)^n*r^n) := by
+  rw [Measure.addHaar_closedBall_center]
+  have he : (WithLp.toLp 2 : (Fin n → ℝ) → Space n) ⁻¹' Metric.closedBall 0 (Real.sqrt n*r) =
+      coordinateBall n (r*Real.sqrt n) := by
+    ext x
+    simp [Metric.mem_closedBall, dist_zero_right, coordinateBall, coordinateNorm, mul_comm]
+  rw [← (PiLp.volume_preserving_toLp (Fin n)).measure_preimage (show NullMeasurableSet (Metric.closedBall (0:Space n) (Real.sqrt n*r)) volume from Metric.isClosed_closedBall.measurableSet.nullMeasurableSet), he,
+    volume_coordinateBall_smul n r (Real.sqrt n) hr]
+  calc
+    _ ≤ ENNReal.ofReal (r^n) * ENNReal.ofReal ((12:ℝ)^n) :=
+      mul_le_mul' le_rfl (coordinate_ball_root_volume n)
+    _ = _ := by rw [← ENNReal.ofReal_mul (by positivity)]; congr 1; ring
+
+lemma cubeBall_volume (d : ℕ) (z : Space (d/2)) {r : ℝ} (hr : 0 < r) :
+    CubeLaw d (CubeBall d z r) ≤ ENNReal.ofReal ((12:ℝ)^(d/2)*r^(d/2)) := by
+  rw [CubeLaw, comap_subtype_coe_apply (cubeSet_measurable _)]
+  apply (measure_mono (show Subtype.val '' CubeBall d z r ⊆ Metric.closedBall z (Real.sqrt (d/2:ℕ)*r) from ?_)).trans
+    (cube_scaled_ball_volume (d/2) z hr)
+  rintro _ ⟨u,hu,rfl⟩
+  exact hu
+
+lemma cube_cap_local {d : ℕ} (hd : 2 ≤ d) (y : Space d) {ε : ℝ} (hε : 0 < ε) :
+    CubeLocal (fun u => capWeight y ε (CubeEmbedding d u))
+      ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ)) := by
+  intro z r hr
+  let A : Set (Cube d) := CubeEmbedding d ⁻¹' Metric.closedBall y ε
+  have hA : MeasurableSet A := Metric.isClosed_closedBall.measurableSet.preimage (cubeEmbedding_measurable d)
+  have hint : (∫⁻ u in CubeBall d z r, capWeight y ε (CubeEmbedding d u) ∂CubeLaw d) =
+      CubeLaw d (A ∩ CubeBall d z r) := by
+    change (∫⁻ u in CubeBall d z r, A.indicator (fun _ => (1:ℝ≥0∞)) u ∂CubeLaw d) = _
+    rw [lintegral_indicator_const hA, one_mul, Measure.restrict_apply hA]
+  rw [hint]
+  have hεball : A ⊆ CubeBall d (Real.sqrt (d/2:ℕ) • cubeProject d y) ε := by
+    intro u hu
+    exact (cubeProject_parameter_dist hd u y).trans
+      (mul_le_mul_of_nonneg_left hu (Real.sqrt_nonneg _))
+  have hs : (0:ℝ) ≤ (d/2:ℕ)/4 := by positivity
+  have ht : (0:ℝ) ≤ 3*(d/2:ℕ)/4 := by positivity
+  have he (t : ℝ) (ht : 0 < t) : t^(d/2) = t^((d/2:ℕ)/4:ℝ)*t^(3*(d/2:ℕ)/4:ℝ) := by
+    rw [← Real.rpow_add ht, show ((d/2:ℕ)/4:ℝ)+(3*(d/2:ℕ)/4:ℝ) = (d/2:ℕ) by ring, Real.rpow_natCast]
+  by_cases hh : r ≤ ε
+  · apply ((measure_mono Set.inter_subset_right).trans (cubeBall_volume d z hr)).trans
+    apply ENNReal.ofReal_le_ofReal
+    rw [he r hr, ← mul_assoc]
+    gcongr
+  · apply ((measure_mono (Set.inter_subset_left.trans hεball)).trans
+      (cubeBall_volume d (Real.sqrt (d/2:ℕ) • cubeProject d y) hε)).trans
+    apply ENNReal.ofReal_le_ofReal
+    rw [he ε hε, ← mul_assoc]
+    gcongr
+    exact le_of_not_ge hh
+
+lemma cubeBall_univ (d : ℕ) : CubeBall d 0 1 = Set.univ := by
+  ext u
+  simp only [Set.mem_univ, iff_true]
+  change dist u.val 0 ≤ Real.sqrt (d/2:ℕ)*1
+  rw [dist_zero_right, mul_one]
+  apply nonneg_le_nonneg_of_sq_le_sq (Real.sqrt_nonneg _)
+  simp only [← pow_two]
+  rw [Real.sq_sqrt (by positivity), EuclideanSpace.norm_sq_eq]
+  calc
+    _ ≤ ∑ _i : Fin (d/2), (1:ℝ) := by
+      apply Finset.sum_le_sum
+      intro i _
+      have h := u.property i
+      have hab := abs_le.mp h
+      simp only [Real.norm_eq_abs, sq_abs]
+      nlinarith
+    _ = _ := by simp
+
+lemma cube_mass_bound {d : ℕ} {f : Cube d → ℝ≥0∞} {L : ℝ} (h : CubeLocal f L) :
+    (∫⁻ u, f u ∂CubeLaw d) ≤ ENNReal.ofReal L := by
+  simpa [cubeBall_univ] using h 0 1 zero_lt_one
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeContinuation.lean

@@ -0,0 +1,123 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeBlock
+import OAI.Probability.MemoryPrecision.CubeCaps
+import OAI.Probability.MemoryPrecision.RealContinuation
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+def CubeStepConstant : ℝ := Classical.choose cube_block
+lemma cubeStepConstant_one : 1 ≤ CubeStepConstant := (Classical.choose_spec cube_block).1
+lemma cubeStepConstant_pos : 0 < CubeStepConstant := lt_of_lt_of_le zero_lt_one cubeStepConstant_one
+
+def CubeStep (d N : ℕ) : ℝ := CubeStepConstant^(d/2) * (N:ℝ)^(1/(((d/2)/4:ℕ):ℝ))
+lemma cubeStep_one (d : ℕ) {N : ℕ} (hN : 1 ≤ N) : 1 ≤ CubeStep d N := by
+  apply one_le_mul_of_one_le_of_one_le
+  · exact one_le_pow₀ cubeStepConstant_one
+  · exact Real.one_le_rpow (by exact_mod_cast hN) (by positivity)
+lemma cubeStep_pos (d : ℕ) {N : ℕ} (hN : 1 ≤ N) : 0 < CubeStep d N :=
+  lt_of_lt_of_le zero_lt_one (cubeStep_one d hN)
+
+lemma cube_deterministic_step {d m N : ℕ} (hd : 16 ≤ d) (hm : 1 ≤ m)
+    (hmp : m ≤ (d/2)/4) (hN : 1 ≤ N) {H : ℝ} (hH : 0 < H)
+    (h : Fin N → Space d → ℝ≥0∞) (hh : ∀ w, Measurable (h w))
+    (hh1 : ∀ w s, h w s ≤ 1)
+    (hb : ∀ w, CubeLocal (fun u => h w (CubeEmbedding d u)) H)
+    (φ : ((Fin m → Space d) × (Fin m → ℝ)) → Fin N) (hφ : Measurable φ) :
+    CubeLocal (fun u => blockValue h φ (CubeEmbedding d u)) (CubeStep d N * H) := by
+  classical
+  let g (w : Fin N) (x : (Fin m → Space d) × (Fin m → ℝ)) : ℝ≥0∞ :=
+    if φ x = w then 1 else 0
+  have hg (w) : Measurable (g w) := by
+    exact Measurable.ite (measurableSet_eq_fun hφ measurable_const) measurable_const measurable_const
+  have hg1 (x) : ∑ w, g w x ≤ 1 := by simp [g]
+  have hb' := (Classical.choose_spec cube_block).2 d m N hd hm hmp hN H hH.le
+    (fun w u => h w (CubeEmbedding d u)) (fun w => (hh w).comp (cubeEmbedding_measurable d))
+    (fun w u => hh1 w (CubeEmbedding d u)) hb g hg hg1
+  convert hb' using 1
+  · funext u
+    unfold blockValue WeightedBlock
+    congr 1
+    funext A
+    simp [g]
+  · rfl
+
+lemma CubeLocal.mono {d : ℕ} {h : Cube d → ℝ≥0∞} {H K : ℝ}
+    (hh : CubeLocal h H) (hHK : H ≤ K) : CubeLocal h K := by
+  intro z r hr
+  exact (hh z r hr).trans (ENNReal.ofReal_le_ofReal (mul_le_mul_of_nonneg_right hHK (by positivity)))
+
+lemma cube_continuation_mass {d N : ℕ} (hd : 16 ≤ d) (hN : 1 ≤ N)
+    {δ : ℕ → Fin N → (Space d × ℝ) → Fin N}
+    {w : ℕ → Fin N → Space d → ℝ≥0∞}
+    (hδ : ∀ n j, Measurable (δ n j)) (hw : ∀ n j, Measurable (w n j))
+    (hw1 : ∀ n j s, w n j s ≤ 1) {H : ℝ} (hH : 0 < H)
+    (hlocal : ∀ n j, CubeLocal (fun s => w n j (CubeEmbedding d s)) H)
+    (b k : ℕ) (hk : k ≤ b*((d/2)/4)) (n : ℕ) (j : Fin N) :
+    CubeLocal (fun s => continuation δ w n k j (CubeEmbedding d s))
+      (H * CubeStep d N ^ b) := by
+  have hp : 0 < (d/2)/4 := by omega
+  have hK := cubeStep_one d hN
+  have hK0 := cubeStep_pos d hN
+  induction b generalizing k n j with
+  | zero =>
+    have : k = 0 := by omega
+    subst k
+    simpa [continuation] using hlocal n j
+  | succ b ih =>
+    by_cases hk0 : k = 0
+    · subst k
+      apply (hlocal n j).mono
+      simpa [continuation] using le_mul_of_one_le_right hH.le (one_le_pow₀ hK)
+    · let m := min k ((d/2)/4)
+      have hm : 1 ≤ m := by dsimp [m]; omega
+      have hmp : m ≤ (d/2)/4 := min_le_right _ _
+      have hmk : m ≤ k := min_le_left _ _
+      have hk' : k-m ≤ b*((d/2)/4) := by
+        dsimp [m]
+        rw [Nat.succ_mul] at hk
+        omega
+      have hb := cube_deterministic_step hd hm hmp hN
+        (mul_pos hH (pow_pos hK0 b))
+        (fun a => continuation δ w (n+m) (k-m) a)
+        (fun a => measurable_continuation hδ hw _ _ a)
+        (fun a s => continuation_le_one hw1 _ _ a s)
+        (fun a => ih (k-m) hk' (n+m) a) (streamRoute δ n m j)
+        (measurable_streamRoute hδ n m j)
+      have he : (fun s : Cube d => continuation δ w n k j (CubeEmbedding d s)) =
+          (fun s : Cube d => blockValue (fun a => continuation δ w (n+m) (k-m) a)
+            (streamRoute δ n m j) (CubeEmbedding d s)) := by
+        funext s
+        simpa [Nat.add_sub_of_le hmk] using continuation_unroll hδ n m (k-m) j (CubeEmbedding d s)
+      rw [he]
+      convert hb using 1
+      rw [pow_succ]; ring
+
+lemma cube_continuation_cap_integral {d N : ℕ} (hd : 16 ≤ d) (hN : 1 ≤ N)
+    {δ : ℕ → Fin N → (Space d × ℝ) → Fin N} (hδ : ∀ n j, Measurable (δ n j))
+    (y : ℕ → Fin N → Space d) {ε : ℝ} (hε : 0 < ε) (n k : ℕ) (j : Fin N) :
+    (∫⁻ u, continuation δ (fun n j => capWeight (y n j) ε) n k j (CubeEmbedding d u) ∂CubeLaw d) ≤
+      ENNReal.ofReal ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) * CubeStep d N ^ BlockCount k ((d/2)/4)) := by
+  apply cube_mass_bound
+  apply cube_continuation_mass hd hN hδ (fun n j => measurable_capWeight _ _)
+    (fun n j s => capWeight_le_one _ _ _) (by positivity)
+    (fun n j => cube_cap_local (by omega) (y n j) hε)
+  simpa [mul_comm] using blockCount_mul_ge k (by omega : 0 < (d/2)/4)
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeExperiment.lean

@@ -0,0 +1,103 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeCaps
+import OAI.Probability.MemoryPrecision.PriorMeasurability
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+def CubeSphere {d : ℕ} (hd : 2 ≤ d) (u : Cube d) : UnitSphere d :=
+  ⟨CubeEmbedding d u, by simpa [Metric.mem_sphere, dist_zero_right] using cubeEmbedding_norm hd u⟩
+lemma cubeSphere_measurable {d : ℕ} (hd : 2 ≤ d) : Measurable (CubeSphere hd) :=
+  (cubeEmbedding_measurable d).subtype_mk
+
+def CubeSuccess {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Learner d M T Ω) (ρ : Measure Ω) (hd : 2 ≤ d) (ε : ℝ) : ℝ≥0∞ :=
+  ((CubeLaw d).prod (ρ.prod (sampleLaw d T)))
+    {z | Learner.angularError (CubeSphere hd z.1)
+      (L.estimate (CubeSphere hd z.1) z.2.1 z.2.2) ≤ ε}
+def CubeAmbient (d : ℕ) : Measure (Space d) := (CubeLaw d).map (CubeEmbedding d)
+instance (d : ℕ) : IsProbabilityMeasure (CubeAmbient d) :=
+  inferInstanceAs (IsProbabilityMeasure ((CubeLaw d).map (CubeEmbedding d)))
+
+lemma cubeAmbient_support {d : ℕ} (hd : 2 ≤ d) : (CubeAmbient d).support ⊆ Metric.closedBall 0 1 := by
+  apply Measure.support_subset_of_isClosed Metric.isClosed_closedBall
+  rw [mem_ae_iff, CubeAmbient, Measure.map_apply (cubeEmbedding_measurable d)
+    Metric.isClosed_closedBall.measurableSet.compl]
+  have he : CubeEmbedding d ⁻¹' (Metric.closedBall (0:Space d) 1)ᶜ = ∅ := by
+    ext u
+    simp [cubeEmbedding_norm hd, Metric.mem_closedBall, dist_zero_right]
+  rw [he, measure_empty]
+
+lemma cubeAmbient_polynomial {d : ℕ} (hd : 2 ≤ d) :
+    PolynomialMass (CubeAmbient d) (d/2) (ENNReal.ofReal ((12:ℝ)^(d/2))) := by
+  intro x r hr
+  rw [CubeAmbient, Measure.map_apply (cubeEmbedding_measurable d) Metric.isClosed_closedBall.measurableSet]
+  have hsub : CubeEmbedding d ⁻¹' Metric.closedBall x r ⊆
+      CubeBall d (Real.sqrt (d/2:ℕ) • cubeProject d x) r := by
+    intro u hu
+    exact (cubeProject_parameter_dist hd u x).trans
+      (mul_le_mul_of_nonneg_left hu (Real.sqrt_nonneg _))
+  exact ((measure_mono hsub).trans (cubeBall_volume d _ hr)).trans_eq (ENNReal.ofReal_mul (by positivity))
+
+lemma cube_observation_quasi {d : ℕ} (hd : 16 ≤ d) :
+    Measure.QuasiMeasurePreserving
+      (fun z : Cube d × Space d => (z.2,⟪CubeEmbedding d z.1,z.2⟫))
+      ((CubeLaw d).prod (stdGaussian (Space d))) (observationReference d) := by
+  have hac : projectionLaw (CubeAmbient d) 1 ≪ matrixLabelReference (E := Space d) 1 := by
+    apply projectionLaw_absolutelyContinuous (cubeAmbient_polynomial (by omega : 2 ≤ d))
+      (C := ENNReal.ofReal ((12:ℝ)^(d/2))) (n := 1)
+    · positivity
+    · exact ENNReal.ofReal_ne_top
+    · exact cubeAmbient_support (by omega)
+    · omega
+    · omega
+  have hp : Measure.QuasiMeasurePreserving
+      (fun z : (Fin 1 → Space d) × Space d => (z.1,fun j => ⟪z.2,z.1 j⟫))
+      ((Measure.pi (fun _ : Fin 1 => stdGaussian (Space d))).prod (CubeAmbient d))
+      (matrixLabelReference (E := Space d) 1) := ⟨by fun_prop,hac⟩
+  have h1 := ((measurePreserving_funUnique (stdGaussian (Space d)) (Fin 1)).symm
+      (MeasurableEquiv.funUnique (Fin 1) (Space d))).prod
+    ((cubeEmbedding_measurable d).measurePreserving (CubeLaw d))
+  have h2 := (measurePreserving_funUnique (stdGaussian (Space d)) (Fin 1)).prod
+    (volume_preserving_funUnique (Fin 1) ℝ)
+  have h3 := h2.quasiMeasurePreserving.comp (hp.comp (h1.quasiMeasurePreserving.comp
+    Measure.measurePreserving_swap.quasiMeasurePreserving))
+  convert h3 using 1
+  · ext z <;> simp [MeasurableEquiv.funUnique]
+  · rfl
+
+lemma cube_sample_observation_quasi {d T : ℕ} (hd : 16 ≤ d) (i : Fin T) :
+    Measure.QuasiMeasurePreserving
+      (fun z : Cube d × Samples d T => (z.2 i,⟪CubeEmbedding d z.1,z.2 i⟫))
+      ((CubeLaw d).prod (sampleLaw d T)) (observationReference d) := by
+  exact (cube_observation_quasi hd).comp
+    ((MeasurePreserving.id (CubeLaw d)).prod
+      (measurePreserving_eval (fun _ : Fin T => stdGaussian (Space d)) i)).quasiMeasurePreserving
+
+lemma cube_estimate_aemeasurable {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ]
+    (hL : L.Admissible ρ) (hd : 16 ≤ d) :
+    AEMeasurable (fun z : Cube d × (Ω × Samples d T) =>
+      L.estimate (CubeSphere (by omega) z.1) z.2.1 z.2.2)
+      ((CubeLaw d).prod (ρ.prod (sampleLaw d T))) :=
+  prior_estimate_aemeasurable (CubeLaw d) ρ (CubeSphere (by omega)) L hL
+    (cube_sample_observation_quasi hd)
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeGeometry.lean

@@ -0,0 +1,279 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.AmbientGram
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+abbrev CubeSet (n : ℕ) : Set (EuclideanSpace ℝ (Fin n)) :=
+  fun (point : EuclideanSpace ℝ (Fin n)) => ∀ index : Fin n,
+    @LE.le ℝ Real.instLE
+      (@abs ℝ Real.lattice Real.instAddGroup
+        (@WithLp.ofLp
+          (@OfNat.ofNat ℝ≥0∞ 2
+            (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+              (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0))))
+          (Fin n → ℝ) point index))
+      (@HDiv.hDiv ℝ ℝ ℝ (@instHDiv ℝ Real.instDivInvMonoid.toDiv)
+        (@OfNat.ofNat ℝ 1 (@One.toOfNat1 ℝ Real.instOne))
+        (@OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+          (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))))
+abbrev Cube (d : ℕ) := CubeSet (d/2)
+def CubeLaw (d : ℕ) : Measure (Cube d) :=
+  (volume : Measure (Space (d/2))).comap Subtype.val
+lemma cube_second_coordinate_lt (d : ℕ) (index : Fin d)
+    (lower : ¬index.val < d/2) (upper : index.val < 2*(d/2)) :
+    index.val - d/2 < d/2 := by omega
+
+def cubeRaw (d : ℕ) (u : Space (d/2)) : Space d :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  @HSMul.hSMul ℝ (Space d) (Space d)
+    (@instHSMul ℝ (Space d) (WithLp.instSMul exponent ℝ (Fin d → ℝ)))
+    (Real.sqrt (d/2:ℕ))⁻¹ (WithLp.toLp exponent (fun index : Fin d =>
+      if lower : index.val < d/2 then
+        @WithLp.ofLp exponent (Fin (d/2) → ℝ) u ⟨index.val, lower⟩
+      else if upper : index.val < 2*(d/2) then
+        Real.sqrt (1-(@WithLp.ofLp exponent (Fin (d/2) → ℝ) u
+          ⟨index.val-d/2, cube_second_coordinate_lt d index lower upper⟩)^2)
+      else 0))
+def CubeEmbedding (d : ℕ) (u : Cube d) : Space d := cubeRaw d u.val
+def CubeBall (d : ℕ) (z : Space (d/2)) (r : ℝ) : Set (Cube d) :=
+  {u | dist u.val z ≤ Real.sqrt (d/2:ℕ) * r}
+def CubeLocal {d : ℕ} (f : Cube d → ℝ≥0∞) (L : ℝ) : Prop :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let cubeMeasurable := @Subtype.instMeasurableSpace (Space (d/2)) (CubeSet (d/2))
+    (@WithLp.measurableSpace exponent (Fin (d/2) → ℝ) inferInstance)
+  ∀ z : Space (d/2), ∀ r : ℝ, 0 < r →
+    @MeasureTheory.lintegral (Cube d) cubeMeasurable
+      (@Measure.restrict (Cube d) cubeMeasurable (CubeLaw d) (CubeBall d z r)) f ≤
+      ENNReal.ofReal (L * r^(
+        (@OfNat.ofNat ℝ 3 (@instOfNatAtLeastTwo ℝ 3 Real.commRing.toNatCast
+          (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 1)))) * (d/2:ℕ) /
+        (@OfNat.ofNat ℝ 4 (@instOfNatAtLeastTwo ℝ 4 Real.commRing.toNatCast
+          (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 2)))) : ℝ))
+
+lemma cubeSet_closed (n : ℕ) : IsClosed (CubeSet n) := by
+  change IsClosed {u : Space n | ∀ i, |u i| ≤ 1/2}
+  simp only [Set.ofPred_forall]
+  exact isClosed_iInter (fun i => isClosed_le (by fun_prop) continuous_const)
+
+lemma cubeSet_measurable (n : ℕ) : MeasurableSet (CubeSet n) :=
+  (cubeSet_closed n).measurableSet
+
+lemma cubeLaw_probability (d : ℕ) : IsProbabilityMeasure (CubeLaw d) := by
+  constructor
+  rw [CubeLaw, comap_subtype_coe_apply (cubeSet_measurable _), Set.image_univ,
+    Subtype.range_coe]
+  have he : CubeSet (d/2) = WithLp.ofLp ⁻¹' (Set.univ.pi (fun _ : Fin (d/2) => Icc (-1/2:ℝ) (1/2))) := by
+    ext u
+    change (∀ i, |u i| ≤ (1/2 : ℝ)) ↔ _
+    simp only [Set.mem_preimage, Set.mem_univ_pi, Set.mem_Icc, abs_le]
+    norm_num
+  rw [he, (PiLp.volume_preserving_ofLp (Fin (d/2))).measure_preimage (by measurability)]
+  rw [volume_pi, Measure.pi_pi]
+  norm_num [Real.volume_Icc]
+
+instance (d : ℕ) : IsProbabilityMeasure (CubeLaw d) := cubeLaw_probability d
+
+lemma cubeBall_measurable (d : ℕ) (z : Space (d/2)) (r : ℝ) : MeasurableSet (CubeBall d z r) := by
+  exact measurableSet_le (by fun_prop) measurable_const
+
+lemma cubeRaw_continuous (d : ℕ) : Continuous (cubeRaw d) := by
+  unfold cubeRaw
+  refine Continuous.const_smul (c := (Real.sqrt (d/2:ℕ))⁻¹) ?_
+  apply (PiLp.continuous_toLp 2 (fun _ : Fin d => ℝ)).comp
+  apply continuous_pi
+  intro i
+  dsimp
+  split_ifs <;> fun_prop
+
+lemma cubeEmbedding_continuous (d : ℕ) : Continuous (CubeEmbedding d) :=
+  (cubeRaw_continuous d).comp continuous_subtype_val
+
+lemma cubeEmbedding_measurable (d : ℕ) : Measurable (CubeEmbedding d) :=
+  (cubeEmbedding_continuous d).measurable
+
+lemma sum_fin_split {n d : ℕ} (hn : n ≤ d) (f : Fin d → ℝ) :
+    (∑ i, f i) = (∑ i : Fin n, f ⟨i.val,by omega⟩) +
+      ∑ i : Fin (d-n), f ⟨n+i.val,by omega⟩ := by
+  let e : Fin (n+(d-n)) ≃ Fin d := finCongr (Nat.add_sub_of_le hn)
+  calc
+    _ = ∑ i : Fin (n+(d-n)), f (e i) := (Equiv.sum_comp e f).symm
+    _ = _ := by rw [Fin.sum_univ_add]; rfl
+
+def cubeCoords (d : ℕ) (u : Space (d/2)) : Space d :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  WithLp.toLp exponent (fun index : Fin d =>
+    if lower : index.val < d/2 then
+      @WithLp.ofLp exponent (Fin (d/2) → ℝ) u ⟨index.val, lower⟩
+    else if upper : index.val < 2*(d/2) then
+      Real.sqrt (1-(@WithLp.ofLp exponent (Fin (d/2) → ℝ) u
+        ⟨index.val-d/2, cube_second_coordinate_lt d index lower upper⟩)^2)
+    else 0)
+
+lemma cubeCoords_first (d : ℕ) (u : Space (d/2)) (i : Fin (d/2)) :
+    cubeCoords d u ⟨i.val,by omega⟩ = u i := by
+  simp [cubeCoords, i.isLt]
+
+lemma cubeCoords_second (d : ℕ) (u : Space (d/2)) (i : Fin (d/2)) :
+    cubeCoords d u ⟨d/2+i.val,by omega⟩ = Real.sqrt (1-u i^2) := by
+  simp [cubeCoords, show ¬d/2+i.val < d/2 by omega, show d/2+i.val < 2*(d/2) by omega]
+
+lemma cubeCoords_tail (d : ℕ) (u : Space (d/2)) (i : Fin d) (hi : 2*(d/2) ≤ i.val) :
+    cubeCoords d u i = 0 := by
+  simp [cubeCoords, show ¬i.val < d/2 by omega, show ¬i.val < 2*(d/2) by omega]
+
+lemma cubeCoords_sum (d : ℕ) (u : Space (d/2)) (f : ℝ → ℝ) (hf : f 0 = 0) :
+    (∑ i : Fin d, f (cubeCoords d u i)) =
+      (∑ i : Fin (d/2), f (u i)) + ∑ i : Fin (d/2), f (Real.sqrt (1-u i^2)) := by
+  rw [sum_fin_split (show d/2 ≤ d by omega)]
+  simp_rw [cubeCoords_first]
+  rw [sum_fin_split (show d/2 ≤ d-d/2 by omega)]
+  congr 1
+  have h1 : (∑ i : Fin (d/2), f (cubeCoords d u ⟨d/2+i.val,by omega⟩)) =
+      ∑ i : Fin (d/2), f (Real.sqrt (1-u i^2)) := by simp_rw [cubeCoords_second]
+  rw [h1]
+  have h0 : (∑ i : Fin (d-d/2-d/2), f (cubeCoords d u ⟨d/2+(d/2+i.val),by omega⟩)) = 0 := by
+    apply Finset.sum_eq_zero
+    intro i _
+    rw [cubeCoords_tail d u _ (show 2*(d/2) ≤ d/2+(d/2+i.val) by omega), hf]
+  rw [h0, add_zero]
+
+lemma cube_coordinate_square_le {d : ℕ} (u : Cube d) (i : Fin (d/2)) : u.val i^2 ≤ 1/4 := by
+  have hu : -(1/2 : ℝ) ≤ u.val i ∧ u.val i ≤ 1/2 := abs_le.mp (u.property i)
+  nlinarith [sq_nonneg (u.val i-1/2), sq_nonneg (u.val i+1/2)]
+
+lemma cubeEmbedding_norm {d : ℕ} (hd : 2 ≤ d) (u : Cube d) :
+    @Norm.norm (Space d) (PiLp.instNorm
+      (p := @OfNat.ofNat ℝ≥0∞ 2
+        (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+          (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (β := fun _ : Fin d => ℝ))
+      (CubeEmbedding d u) = (1 : ℝ) := by
+  have hs : ‖cubeCoords d u.val‖^2 = (d/2:ℕ) := by
+    rw [EuclideanSpace.real_norm_sq_eq, cubeCoords_sum d u.val (fun x => x^2) (by norm_num)]
+    have he (i : Fin (d/2)) : Real.sqrt (1-u.val i^2)^2 = 1-u.val i^2 :=
+      Real.sq_sqrt (by have := cube_coordinate_square_le u i; linarith)
+    simp_rw [he]
+    rw [← Finset.sum_add_distrib]
+    simp
+  have hn : 0 < (d/2:ℕ) := by omega
+  have hr : 0 < Real.sqrt (d/2:ℕ) := Real.sqrt_pos.2 (by exact_mod_cast hn)
+  have hnorm : ‖cubeCoords d u.val‖ = Real.sqrt (d/2:ℕ) := by
+    rw [← Real.sqrt_sq (norm_nonneg _), hs]
+  change ‖(Real.sqrt (d/2:ℕ))⁻¹ • cubeCoords d u.val‖ = 1
+  rw [norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos hr, hnorm, inv_mul_cancel₀ hr.ne']
+
+lemma sqrt_pair_lipschitz {a b : ℝ} (ha : |a| ≤ 1/2) (hb : |b| ≤ 1/2) :
+    |Real.sqrt (1-a^2) - Real.sqrt (1-b^2)| ≤ |a-b| := by
+  have ha2 : a^2 ≤ 1/4 := by rcases abs_le.mp ha with ⟨ha₁,ha₂⟩; nlinarith
+  have hb2 : b^2 ≤ 1/4 := by rcases abs_le.mp hb with ⟨hb₁,hb₂⟩; nlinarith
+  have hsa := Real.sq_sqrt (show 0 ≤ 1-a^2 by linarith)
+  have hsb := Real.sq_sqrt (show 0 ≤ 1-b^2 by linarith)
+  have has : 1/2 ≤ Real.sqrt (1-a^2) := by nlinarith [Real.sqrt_nonneg (1-a^2)]
+  have hbs : 1/2 ≤ Real.sqrt (1-b^2) := by nlinarith [Real.sqrt_nonneg (1-b^2)]
+  have hab : |a+b| ≤ 1 := (abs_add_le a b).trans (by linarith)
+  have he : (Real.sqrt (1-a^2)-Real.sqrt (1-b^2)) *
+      (Real.sqrt (1-a^2)+Real.sqrt (1-b^2)) = -(a-b)*(a+b) := by nlinarith
+  calc
+    _ ≤ |Real.sqrt (1-a^2)-Real.sqrt (1-b^2)| *
+        |Real.sqrt (1-a^2)+Real.sqrt (1-b^2)| := by
+      apply le_mul_of_one_le_right (abs_nonneg _)
+      rw [abs_of_nonneg (by positivity)]
+      linarith
+    _ = |a-b| * |a+b| := by rw [← abs_mul, he, abs_mul, abs_neg]
+    _ ≤ |a-b| := mul_le_of_le_one_right (abs_nonneg _) hab
+
+private lemma cubeCoords_sub_norm (d : ℕ) (u v : Cube d) :
+    ‖cubeCoords d u.val - cubeCoords d v.val‖ ≤ 2 * ‖u.val-v.val‖ := by
+  have hs : ‖cubeCoords d u.val - cubeCoords d v.val‖^2 =
+      (∑ i : Fin (d/2), (u.val i-v.val i)^2) +
+      ∑ i : Fin (d/2), (Real.sqrt (1-u.val i^2)-Real.sqrt (1-v.val i^2))^2 := by
+    rw [EuclideanSpace.real_norm_sq_eq, sum_fin_split (show d/2 ≤ d by omega)]
+    simp only [PiLp.sub_apply, cubeCoords_first]
+    rw [sum_fin_split (show d/2 ≤ d-d/2 by omega)]
+    simp only [cubeCoords_second]
+    have hz : (∑ i : Fin (d-d/2-d/2),
+      (cubeCoords d u.val ⟨d/2+(d/2+i.val),by omega⟩ -
+        cubeCoords d v.val ⟨d/2+(d/2+i.val),by omega⟩)^2) = 0 := by
+      apply Finset.sum_eq_zero
+      intro i _
+      rw [cubeCoords_tail d u.val _ (show 2*(d/2) ≤ d/2+(d/2+i.val) by omega),
+        cubeCoords_tail d v.val _ (show 2*(d/2) ≤ d/2+(d/2+i.val) by omega)]
+      norm_num
+    rw [hz, add_zero]
+  have hsq : (∑ i : Fin (d/2), (Real.sqrt (1-u.val i^2)-Real.sqrt (1-v.val i^2))^2) ≤
+      ∑ i : Fin (d/2), (u.val i-v.val i)^2 := by
+    apply Finset.sum_le_sum
+    intro i _
+    exact (sq_le_sq).2 (sqrt_pair_lipschitz (u.property i) (v.property i))
+  have hv : ‖u.val-v.val‖^2 = ∑ i : Fin (d/2), (u.val i-v.val i)^2 := by
+    simp [EuclideanSpace.real_norm_sq_eq]
+  nlinarith [norm_nonneg (cubeCoords d u.val-cubeCoords d v.val), norm_nonneg (u.val-v.val)]
+
+lemma cubeEmbedding_dist {d : ℕ} (hd : 2 ≤ d) (u v : Cube d) :
+    dist (CubeEmbedding d u) (CubeEmbedding d v) ≤
+      2 / Real.sqrt (d/2:ℕ) * dist u.val v.val := by
+  have hr : 0 < Real.sqrt (d/2:ℕ) := Real.sqrt_pos.2 (by exact_mod_cast (show 0 < d/2 by omega))
+  change dist ((Real.sqrt (d/2:ℕ))⁻¹ • cubeCoords d u.val)
+    ((Real.sqrt (d/2:ℕ))⁻¹ • cubeCoords d v.val) ≤ _
+  rw [dist_eq_norm, ← smul_sub, norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos hr, dist_eq_norm]
+  calc
+    _ ≤ (Real.sqrt (d/2:ℕ))⁻¹ * (2*‖u.val-v.val‖) :=
+      mul_le_mul_of_nonneg_left (cubeCoords_sub_norm d u v) (inv_nonneg.mpr hr.le)
+    _ = _ := by ring
+
+def cubeProject (d : ℕ) (x : Space d) : Space (d/2) :=
+  WithLp.toLp 2 (fun i : Fin (d/2) => x ⟨i.val,by omega⟩)
+
+lemma cubeProject_continuous (d : ℕ) : Continuous (cubeProject d) := by
+  unfold cubeProject
+  fun_prop
+
+lemma cubeProject_norm (d : ℕ) (x : Space d) : ‖cubeProject d x‖ ≤ ‖x‖ := by
+  have h : ‖cubeProject d x‖^2 ≤ ‖x‖^2 := by
+    rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq,
+      sum_fin_split (show d/2 ≤ d by omega)]
+    change (∑ i : Fin (d/2), x ⟨i.val,by omega⟩^2) ≤ _
+    exact le_add_of_nonneg_right (Finset.sum_nonneg (fun _ _ => sq_nonneg _))
+  nlinarith [norm_nonneg (cubeProject d x), norm_nonneg x]
+
+lemma cubeProject_sub (d : ℕ) (x y : Space d) : cubeProject d (x-y) = cubeProject d x-cubeProject d y := by
+  ext i
+  rfl
+
+lemma cubeProject_embedding (d : ℕ) (u : Cube d) :
+    cubeProject d (CubeEmbedding d u) = (Real.sqrt (d/2:ℕ))⁻¹ • u.val := by
+  ext i
+  simp [cubeProject, CubeEmbedding, cubeRaw]
+
+lemma cubeProject_parameter_dist {d : ℕ} (hd : 2 ≤ d) (u : Cube d) (x : Space d) :
+    dist u.val (Real.sqrt (d/2:ℕ) • cubeProject d x) ≤
+      Real.sqrt (d/2:ℕ) * dist (CubeEmbedding d u) x := by
+  have hr : 0 < Real.sqrt (d/2:ℕ) := Real.sqrt_pos.2 (by exact_mod_cast (show 0 < d/2 by omega))
+  have he : u.val - Real.sqrt (d/2:ℕ) • cubeProject d x =
+      Real.sqrt (d/2:ℕ) • cubeProject d (CubeEmbedding d u-x) := by
+    rw [cubeProject_sub, cubeProject_embedding, smul_sub, smul_smul, mul_inv_cancel₀ hr.ne', one_smul]
+  rw [dist_eq_norm, he, norm_smul, Real.norm_eq_abs, abs_of_pos hr, dist_eq_norm]
+  exact mul_le_mul_of_nonneg_left (cubeProject_norm d _) hr.le
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/CubeSuccess.lean

@@ -0,0 +1,85 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeArithmetic
+import OAI.Probability.MemoryPrecision.KernelCube
+import OAI.Probability.MemoryPrecision.Precision
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision.Kernel
+open MemoryPrecision NoiselessRegression Policy
+
+lemma source_cube_bound {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Ω → Policy d M T) (ρ : Measure Ω) [IsProbabilityMeasure ρ]
+    (hd : 16 ≤ d) (hL : Admissible L ρ (CubePrior (by omega)))
+    (hM : M ≤ d^2) {ε : ℝ} (hε : 0 < ε) :
+    Success L ρ (CubePrior (by omega)) ε ≤ min 1 (ENNReal.ofReal
+      (CubeSuccessConstant^((d/2)*(BlockCount T ((d/2)/4)+1)) * ε^((d/2:ℕ)/4:ℝ))) := by
+  refine le_min (Policy.success_le_one L ρ (CubePrior (by omega)) ε) ?_
+  have hb := (Policy.success_le_chord L ρ (CubePrior (by omega)) ε).trans
+    (Policy.source_cube_chord_bound L ρ hd hL hε)
+  have he : (T+1:ℝ≥0∞) * ENNReal.ofReal
+      ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) * CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4)) =
+      ENNReal.ofReal ((T+1:ℝ) *
+        ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) * CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4))) := by
+    rw [ENNReal.ofReal_mul (by positivity : (0:ℝ) ≤ T+1)]
+    congr 1
+    simp [ENNReal.ofReal_add]
+  rw [he] at hb
+  apply hb.trans (ENNReal.ofReal_le_ofReal ?_)
+  calc
+    _ = ((T+1:ℝ) * ((12:ℝ)^(d/2) * CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4))) *
+        ε^((d/2:ℕ)/4:ℝ) := by ring
+    _ ≤ _ := mul_le_mul_of_nonneg_right (cube_whole_factor hd hM T) (by positivity)
+
+lemma cubePrior_dimension {d₀ d : ℕ} (hd₀ : 16 ≤ d₀) (hd : d₀ ≤ d) : 2 ≤ d :=
+  Nat.le_trans (by decide : 2 ≤ 16) (Nat.le_trans hd₀ hd)
+
+def CubeSuccessEstimate {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (D : ℝ) (hd : 2 ≤ d) (ε : ℝ) (K : Ω → Policy d M T) (ρ : Measure Ω) : Prop :=
+  Policy.Success K ρ (CubePrior hd) ε ≤ min 1 (ENNReal.ofReal
+    (D^((d/2)*(MemoryPrecision.Kernel.BlockCount T ((d/2)/4)+1)) * ε^((d/2:ℕ)/4:ℝ)))
+
+def PointwisePrecisionEstimate {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (c ε : ℝ) (K : Ω → Policy d M T) (ρ : Measure Ω) : Prop :=
+  (∀ signal : MemoryPrecision.Kernel.Sphere d,
+      (@OfNat.ofNat ℝ≥0∞ 2
+        (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast inferInstance)) /
+      (@OfNat.ofNat ℝ≥0∞ 3
+        (@instOfNatAtLeastTwo ℝ≥0∞ 3 ENNReal.instAddCommMonoidWithOne.toNatCast inferInstance)) ≤
+        Policy.FixedSuccess K ρ ε signal) → c*(d:ℝ)*Real.log (1/ε) ≤ (T:ℝ)
+
+abbrev SourceCubeStatement : Prop :=
+  ∃ D : ℝ, Real.exp 1 ≤ D ∧ ∃ d₀ : ℕ, ∃ hd₀ : 16 ≤ d₀, ∃ c : ℝ, 0 < c ∧
+  ∀ d M T : ℕ, ∀ hd : d₀ ≤ d, M ≤ d^2 → ∀ ε : ℝ, 0 < ε → ε ≤ 1/10 →
+  ∀ (Ω : Type u) [MeasurableSpace Ω] (ρ : Measure Ω), IsProbabilityMeasure ρ →
+  ∀ K : Ω → MemoryPrecision.Kernel.Policy d M T, Policy.ModelAdmissible.{u} K ρ →
+    CubeSuccessEstimate.{u} D (cubePrior_dimension hd₀ hd) ε K ρ ∧
+    PointwisePrecisionEstimate.{u} c ε K ρ
+
+theorem source_cube_success : SourceCubeStatement := by
+  refine ⟨CubeSuccessConstant,cubeSuccessConstant_exp,32,by norm_num,
+    1/(8+20*StreamConstant*(1+1)),by have := streamConstant_pos; positivity,?_⟩
+  intro d M T hd hM ε hε hε1 Ω _ ρ hρ L hL
+  have : IsProbabilityMeasure ρ := hρ
+  let : NeZero d := ⟨by omega⟩
+  refine ⟨source_cube_bound L ρ (by omega) (hL _ inferInstance) hM hε, ?_⟩
+  intro hs
+  apply Policy.source_precision L ρ hd (hL _ inferInstance) (by norm_num : (0:ℝ) < 1)
+    (by exact_mod_cast (by simpa using hM : M ≤ 1*d^2)) hε hε1
+  exact Policy.source_uniform_of_pointwise L ρ (by omega) (hL _ inferInstance) ε hs
+end MemoryPrecision.Kernel
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/DensityPassage.lean

@@ -0,0 +1,313 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+section FiberSmoothing
+variable {Ω Y : Type*} [MeasurableSpace Ω] [NormedAddCommGroup Y]
+  [MeasurableSpace Y] [BorelSpace Y] [SecondCountableTopology Y]
+  (γ : Measure Ω) (τ : Measure Y) [SigmaFinite τ]
+
+def fiberSmoothing (F : Ω × Y → ℝ≥0∞) (ρ : Y → ℝ≥0∞) (z : Ω × Y) : ℝ≥0∞ :=
+  ∫⁻ b, ρ (z.2 - b) * F (z.1, b) ∂τ
+
+@[fun_prop] lemma measurable_fiberSmoothing {F : Ω × Y → ℝ≥0∞} {ρ : Y → ℝ≥0∞}
+    (hF : Measurable F) (hρ : Measurable ρ) :
+    Measurable (fiberSmoothing τ F ρ) := by
+  unfold fiberSmoothing
+  exact Measurable.lintegral_prod_right (by fun_prop)
+
+lemma lintegral_fiberSmoothing_test {F : Ω × Y → ℝ≥0∞} {ρ : Y → ℝ≥0∞}
+    (hF : Measurable F) (hρ : Measurable ρ) (f : Ω × Y → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ z, fiberSmoothing τ F ρ z * f z ∂γ.prod τ) =
+      ∫⁻ z, (∫⁻ y, ρ (y - z.2) * f (z.1, y) ∂τ) ∂(γ.prod τ).withDensity F := by
+  have hK : Measurable (fun z : Ω × Y => ∫⁻ y, ρ (y-z.2) * f (z.1,y) ∂τ) :=
+    Measurable.lintegral_prod_right (by fun_prop)
+  rw [lintegral_withDensity_eq_lintegral_mul _ hF hK]
+  simp only [Pi.mul_apply]
+  rw [lintegral_prod (fun z => fiberSmoothing τ F ρ z * f z)
+      ((measurable_fiberSmoothing τ hF hρ).mul hf).aemeasurable,
+    lintegral_prod (fun z => F z * ∫⁻ y, ρ (y-z.2) * f (z.1,y) ∂τ)
+      (hF.mul hK).aemeasurable]
+  apply lintegral_congr
+  intro A
+  dsimp only [fiberSmoothing]
+  have hmul (y : Y) : (∫⁻ b, ρ (y-b) * F (A,b) ∂τ) * f (A,y) =
+      ∫⁻ b, (ρ (y-b) * F (A,b)) * f (A,y) ∂τ :=
+    (lintegral_mul_const _ (by fun_prop)).symm
+  simp_rw [hmul]
+  rw [lintegral_lintegral_swap (by fun_prop)]
+  apply lintegral_congr
+  intro b
+  rw [← lintegral_const_mul _ (by fun_prop : Measurable (fun y => ρ (y-b) * f (A,y)))]
+  apply lintegral_congr
+  intro y
+  ring
+end FiberSmoothing
+
+section ProjectionSmoothing
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+
+local instance density_reference_sigmaFinite (m : ℕ) :
+    SigmaFinite (matrixLabelReference (E := E) m) := by
+  unfold matrixLabelReference
+  infer_instance
+
+lemma lintegral_projectionSmoothing_test (ν : Measure E) [SigmaFinite ν]
+    (φ : ℝ → ℝ≥0∞) (hφ : Measurable φ) (m : ℕ)
+    (f : (Fin m → E) × (Fin m → ℝ) → ℝ≥0∞) (hf : Measurable f) :
+    (∫⁻ z, projectionSmoothing ν φ m z * f z ∂matrixLabelReference m) =
+      ∫⁻ z, (∫⁻ y : Fin m → ℝ, (∏ j, φ (y j - z.2 j)) * f (z.1, y))
+        ∂projectionLaw ν m := by
+  have hK : Measurable (fun z : (Fin m → E) × (Fin m → ℝ) =>
+      ∫⁻ y : Fin m → ℝ, (∏ j, φ (y j-z.2 j)) * f (z.1,y)) :=
+    Measurable.lintegral_prod_right (by fun_prop)
+  rw [projectionLaw, lintegral_map hK (by fun_prop), matrixLabelReference,
+    lintegral_prod (fun z => projectionSmoothing ν φ m z * f z)
+      ((measurable_projectionSmoothing ν φ hφ m).mul hf).aemeasurable,
+    lintegral_prod _ (by fun_prop)]
+  apply lintegral_congr
+  intro A
+  dsimp only [projectionSmoothing]
+  have hmul (y : Fin m → ℝ) : (∫⁻ t : E, ∏ j, φ (y j-⟪t,A j⟫) ∂ν) * f (A,y) =
+      ∫⁻ t : E, (∏ j, φ (y j-⟪t,A j⟫)) * f (A,y) ∂ν :=
+    (lintegral_mul_const _ (by fun_prop)).symm
+  simp_rw [hmul]
+  rw [lintegral_lintegral_swap (by fun_prop)]
+
+lemma projectionSmoothing_ae_eq_fiberSmoothing (ν : Measure E) [SigmaFinite ν]
+    (m : ℕ) (F : (Fin m → E) × (Fin m → ℝ) → ℝ≥0∞) (hF : Measurable F)
+    (hden : (matrixLabelReference m).withDensity F = projectionLaw ν m)
+    (φ : ℝ → ℝ≥0∞) (hφ : Measurable φ) :
+    projectionSmoothing ν φ m =ᵐ[matrixLabelReference m]
+      fiberSmoothing volume F (fun y : Fin m → ℝ => ∏ j, φ (y j)) := by
+  apply (withDensity_eq_iff_of_sigmaFinite
+    (measurable_projectionSmoothing ν φ hφ m).aemeasurable
+    (measurable_fiberSmoothing volume hF (by fun_prop)).aemeasurable).mp
+  apply Measure.ext_of_lintegral
+  intro f hf
+  rw [lintegral_withDensity_eq_lintegral_mul _
+    (measurable_projectionSmoothing ν φ hφ m) hf,
+    lintegral_withDensity_eq_lintegral_mul _
+      (measurable_fiberSmoothing volume hF (by fun_prop)) hf]
+  simp only [Pi.mul_apply]
+  rw [lintegral_projectionSmoothing_test ν φ hφ m f hf]
+  change _ = ∫⁻ z, fiberSmoothing volume F (fun y : Fin m → ℝ => ∏ j, φ (y j)) z * f z
+    ∂(Measure.pi (fun _ : Fin m => stdGaussian E)).prod volume
+  rw [lintegral_fiberSmoothing_test _ volume hF (by fun_prop) f hf]
+
+  unfold matrixLabelReference at hden
+  rw [hden]
+  rfl
+end ProjectionSmoothing
+
+def boxScalar (δ : ℝ) (t : ℝ) : ℝ≥0∞ :=
+  (ENNReal.ofReal (2*δ))⁻¹ * (Icc (-δ) δ).indicator 1 t
+
+@[fun_prop] lemma measurable_boxScalar (δ : ℝ) : Measurable (boxScalar δ) := by
+  exact measurable_const.mul (measurable_const.indicator measurableSet_Icc)
+
+lemma lintegral_boxScalar {δ : ℝ} (hδ : 0 < δ) : ∫⁻ t, boxScalar δ t = 1 := by
+  unfold boxScalar
+  rw [lintegral_const_mul _ (show Measurable ((Icc (-δ) δ).indicator (1 : ℝ → ℝ≥0∞)) from
+    measurable_one.indicator measurableSet_Icc), lintegral_indicator measurableSet_Icc]
+  simp only [Pi.one_apply, lintegral_const, one_mul, Measure.restrict_apply_univ,
+    Real.volume_Icc, sub_neg_eq_add]
+  rw [← two_mul]
+  exact ENNReal.inv_mul_cancel (ENNReal.ofReal_ne_zero_iff.mpr (by positivity)) ENNReal.ofReal_ne_top
+
+lemma box_product_eq (m : ℕ) {δ : ℝ} (hδ : 0 < δ) (y : Fin m → ℝ) :
+    (∏ j, boxScalar δ (y j)) =
+      ((volume : Measure (Fin m → ℝ)) (Metric.closedBall 0 δ))⁻¹ *
+        (Metric.closedBall 0 δ).indicator 1 y := by
+  have hv : (volume : Measure (Fin m → ℝ)) (Metric.closedBall 0 δ) =
+      (ENNReal.ofReal (2*δ))^m := by
+    rw [volume_pi, closedBall_pi _ hδ.le, Measure.pi_pi]
+    simp [Real.closedBall_eq_Icc, ← two_mul]
+  rw [hv]
+  simp only [boxScalar, Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin,
+    ENNReal.inv_pow]
+  congr 1
+  by_cases hy : y ∈ Metric.closedBall (0 : Fin m → ℝ) δ
+  · rw [Set.indicator_of_mem hy]
+    have hy' : ∀ j, y j ∈ Icc (-δ) δ := by
+      intro j
+      rw [closedBall_pi _ hδ.le] at hy
+      simpa [Real.closedBall_eq_Icc] using hy j (mem_univ j)
+    simp [hy']
+  · rw [Set.indicator_of_notMem hy]
+    have hy' : ∃ j, y j ∉ Icc (-δ) δ := by
+      by_contra h
+      apply hy
+      rw [closedBall_pi _ hδ.le]
+      intro j _
+      have hh := not_not.mp (not_exists.mp h j)
+      simpa [Real.closedBall_eq_Icc] using hh
+    obtain ⟨j,hj⟩ := hy'
+    exact Finset.prod_eq_zero (Finset.mem_univ j) (Set.indicator_of_notMem hj _)
+
+section Differentiation
+variable {Ω : Type*} [MeasurableSpace Ω]
+
+lemma fiberSmoothing_box_eq_average (m : ℕ)
+    (F : Ω × (Fin m → ℝ) → ℝ≥0∞) (hF : Measurable F)
+    {δ : ℝ} (hδ : 0 < δ) (A : Ω) (y : Fin m → ℝ) :
+    fiberSmoothing volume F (fun x : Fin m → ℝ => ∏ j, boxScalar δ (x j)) (A,y) =
+      (∫⁻ b in Metric.closedBall y δ, F (A,b)) /
+        (volume : Measure (Fin m → ℝ)) (Metric.closedBall y δ) := by
+  unfold fiberSmoothing
+  simp_rw [box_product_eq m hδ]
+  have he (b : Fin m → ℝ) :
+      (Metric.closedBall (0 : Fin m → ℝ) δ).indicator (1 : (Fin m → ℝ) → ℝ≥0∞) (y-b) * F (A,b) =
+      (Metric.closedBall y δ).indicator (fun b => F (A,b)) b := by
+    have hb : y-b ∈ Metric.closedBall (0 : Fin m → ℝ) δ ↔ b ∈ Metric.closedBall y δ := by
+      simp [Metric.mem_closedBall, dist_eq_norm, norm_sub_rev]
+    by_cases h : b ∈ Metric.closedBall y δ
+    · rw [Set.indicator_of_mem (hb.mpr h), Set.indicator_of_mem h]; simp
+    · rw [Set.indicator_of_notMem (mt hb.mp h), Set.indicator_of_notMem h]; simp
+  simp_rw [mul_assoc, he]
+  rw [lintegral_const_mul _ (show Measurable ((Metric.closedBall y δ).indicator
+    (fun b => F (A,b))) from (hF.comp (measurable_const.prodMk measurable_id)).indicator
+      Metric.isClosed_closedBall.measurableSet), lintegral_indicator Metric.isClosed_closedBall.measurableSet,
+    div_eq_mul_inv, Measure.addHaar_closedBall_center volume y δ, mul_comm]
+
+lemma ae_tendsto_fiberSmoothing_box (γ : Measure Ω) [SigmaFinite γ] (m : ℕ)
+    (F : Ω × (Fin m → ℝ) → ℝ≥0∞) (hF : Measurable F)
+    (hfin : (∫⁻ z, F z ∂γ.prod volume) ≠ ∞) :
+    ∀ᵐ z ∂γ.prod volume,
+      Tendsto (fun k : ℕ => fiberSmoothing volume F
+        (fun x : Fin m → ℝ => ∏ j, boxScalar (1 / ((k:ℝ)+1)) (x j)) z)
+        atTop (𝓝 (F z)) := by
+  have hmeas (k : ℕ) : Measurable (fiberSmoothing volume F
+      (fun x : Fin m → ℝ => ∏ j, boxScalar (1 / ((k:ℝ)+1)) (x j))) :=
+    measurable_fiberSmoothing volume hF (by fun_prop)
+  rw [Measure.ae_prod_iff_ae_ae (measurableSet_tendsto_fun hmeas hF)]
+  have hinner : (∫⁻ A, ∫⁻ y : Fin m → ℝ, F (A,y) ∂volume ∂γ) ≠ ∞ := by
+    rwa [← lintegral_prod _ hF.aemeasurable]
+  filter_upwards [ae_lt_top (Measurable.lintegral_prod_right
+    (show Measurable (fun z : Ω × (Fin m → ℝ) => F (z.1,z.2)) from hF)) hinner] with A hA
+  have hFA : Measurable (fun y : Fin m → ℝ => F (A,y)) :=
+    hF.comp (measurable_const.prodMk measurable_id)
+  filter_upwards [(Besicovitch.vitaliFamily (volume : Measure (Fin m → ℝ))).ae_tendsto_lintegral_div
+    hFA.aemeasurable hA.ne] with y hy
+  have hδ : Tendsto (fun k : ℕ => 1 / ((k:ℝ)+1)) atTop (𝓝[>] (0:ℝ)) :=
+    tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_add_atTop_nhds_zero_nat,
+      Filter.Eventually.of_forall (fun k => by change 0 < 1 / ((k:ℝ)+1); positivity)⟩
+  convert (hy.comp (Besicovitch.tendsto_filterAt volume y)).comp hδ using 1
+  ext k
+  exact fiberSmoothing_box_eq_average m F hF (by positivity) A y
+end Differentiation
+
+section MomentPassage
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
+local instance passage_reference_sigmaFinite (m : ℕ) :
+    SigmaFinite (matrixLabelReference (E := E) m) := by
+  unfold matrixLabelReference
+  infer_instance
+local instance passage_projection_finite (ν : Measure E) [IsFiniteMeasure ν] (m : ℕ) :
+    IsFiniteMeasure (projectionLaw ν m) := by
+  unfold projectionLaw
+  infer_instance
+
+lemma projectionLaw_set_bound_of_moment (ν : Measure E) [IsFiniteMeasure ν]
+    (m n : ℕ) (hn : 1 ≤ n) (C : ℝ≥0∞) (hC : C ≠ ∞)
+    (hbound : ∀ φ : ℝ → ℝ≥0∞, Measurable φ → (∫⁻ x, φ x = 1) →
+      (∫⁻ Ay, projectionSmoothing ν φ m Ay ^ (n+1) ∂matrixLabelReference m) ≤ C)
+    (S : Set ((Fin m → E) × (Fin m → ℝ))) :
+    projectionLaw ν m S ≤ C^(1 / ((n : ℝ) + 1)) *
+      (matrixLabelReference (E := E) m S)^(1 - 1 / ((n : ℝ) + 1)) := by
+  have hp : 1 < (n : ℝ) + 1 := by exact_mod_cast (by omega : 1 < n + 1)
+  have hα : 0 < 1 - 1 / ((n : ℝ) + 1) := by
+    exact sub_pos.mpr ((div_lt_one (by positivity)).mpr hp)
+  have := matrixLabelReference_outerRegular (E := E) m
+  apply measure_apply_le_of_isOpen _ _ (ENNReal.rpow_ne_top_of_nonneg (by positivity) hC) hα
+  intro U hU
+  rw [← gaussianCoupling_map_noisyObservation_zero ν m]
+  apply map_apply_open_le_of_tendsto (gaussianCoupling ν m)
+    (matrixLabelReference (E := E) m) (noisyObservation m 0)
+    (fun k => noisyObservation m (1 / ((k : ℝ) + 1)))
+    (measurable_noisyObservation m 0) (fun k => measurable_noisyObservation m _)
+    (tendsto_noisyObservation m) _ _ (U := U) (hU := hU)
+  intro k V hV
+  have hδ : (1 / ((k : ℝ) + 1)) ≠ 0 := by positivity
+  rw [gaussianCoupling_map_noisyObservation ν m _ hδ]
+  apply withDensity_apply_le_moment _ _
+    (measurable_projectionSmoothing _ _ (measurable_gaussianPDF _ _) _) hp _ _ hV.measurableSet
+  have hv : (NNReal.mk ((1 / ((k : ℝ) + 1)) ^ 2)
+      (sq_nonneg (1 / ((k : ℝ) + 1)))) ≠ 0 := by
+    rw [← NNReal.coe_ne_zero]
+    exact pow_ne_zero 2 hδ
+  simpa only [← ENNReal.rpow_natCast, Nat.cast_add, Nat.cast_one] using
+    hbound (gaussianPDF 0 (NNReal.mk ((1 / ((k : ℝ) + 1)) ^ 2)
+      (sq_nonneg (1 / ((k : ℝ) + 1))))) (measurable_gaussianPDF _ _)
+      (lintegral_gaussianPDF_eq_one _ hv)
+
+lemma projectionLaw_ac_of_moment (ν : Measure E) [IsFiniteMeasure ν]
+    (m n : ℕ) (hn : 1 ≤ n) (C : ℝ≥0∞) (hC : C ≠ ∞)
+    (hbound : ∀ φ : ℝ → ℝ≥0∞, Measurable φ → (∫⁻ x, φ x = 1) →
+      (∫⁻ Ay, projectionSmoothing ν φ m Ay ^ (n+1) ∂matrixLabelReference m) ≤ C) :
+    projectionLaw ν m ≪ matrixLabelReference m := by
+  intro S hS
+  have hh := projectionLaw_set_bound_of_moment ν m n hn C hC hbound S
+  have hα : 0 < 1 - 1 / ((n : ℝ) + 1) := by
+    have hn' : (1:ℝ) ≤ n := by exact_mod_cast hn
+    exact sub_pos.mpr ((div_lt_one (by positivity)).mpr (by linarith))
+  rw [hS, ENNReal.zero_rpow_of_pos hα, mul_zero] at hh
+  exact le_zero_iff.mp hh
+
+lemma projectionLaw_rnDeriv_moment (ν : Measure E) [IsFiniteMeasure ν]
+    (m n : ℕ) (hn : 1 ≤ n) (C : ℝ≥0∞) (hC : C ≠ ∞)
+    (hbound : ∀ φ : ℝ → ℝ≥0∞, Measurable φ → (∫⁻ x, φ x = 1) →
+      (∫⁻ Ay, projectionSmoothing ν φ m Ay ^ (n+1) ∂matrixLabelReference m) ≤ C) :
+    (∫⁻ Ay, ((projectionLaw ν m).rnDeriv (matrixLabelReference m) Ay)^(n+1)
+      ∂matrixLabelReference m) ≤ C := by
+  let F := (projectionLaw ν m).rnDeriv (matrixLabelReference m)
+  have hF : Measurable F := Measure.measurable_rnDeriv _ _
+  have hden : (matrixLabelReference m).withDensity F = projectionLaw ν m :=
+    Measure.withDensity_rnDeriv_eq _ _ (projectionLaw_ac_of_moment ν m n hn C hC hbound)
+  let f : ℕ → ((Fin m → E) × (Fin m → ℝ)) → ℝ≥0∞ := fun k =>
+    projectionSmoothing ν (boxScalar (1/((k:ℝ)+1))) m
+  have hf (k : ℕ) : Measurable (f k) :=
+    measurable_projectionSmoothing ν _ (measurable_boxScalar _) m
+  have heq (k : ℕ) : f k =ᵐ[matrixLabelReference m]
+      fiberSmoothing volume F (fun y : Fin m → ℝ => ∏ j, boxScalar (1/((k:ℝ)+1)) (y j)) :=
+    projectionSmoothing_ae_eq_fiberSmoothing ν m F hF hden _ (measurable_boxScalar _)
+  have ht : ∀ᵐ Ay ∂matrixLabelReference m, Tendsto (fun k => f k Ay) atTop (𝓝 (F Ay)) := by
+    filter_upwards [ae_all_iff.mpr heq,
+      ae_tendsto_fiberSmoothing_box (Measure.pi (fun _ : Fin m => stdGaussian E)) m F hF
+        (Measure.lintegral_rnDeriv_lt_top (projectionLaw ν m) (matrixLabelReference m)).ne]
+      with Ay he ht
+    exact ht.congr (fun k => (he k).symm)
+  calc
+    _ = ∫⁻ Ay, atTop.liminf (fun k => (f k Ay)^(n+1)) ∂matrixLabelReference m := by
+      apply lintegral_congr_ae
+      filter_upwards [ht] with Ay hAy
+      exact (((ENNReal.continuous_pow (n+1)).tendsto _ |>.comp hAy).liminf_eq).symm
+    _ ≤ atTop.liminf (fun k => ∫⁻ Ay, (f k Ay)^(n+1) ∂matrixLabelReference m) :=
+      lintegral_liminf_le (fun k => (hf k).pow_const _)
+    _ ≤ C := by
+      apply liminf_le_of_frequently_le (hu_le := by isBoundedDefault)
+      exact (Filter.Eventually.of_forall (fun k =>
+        hbound _ (measurable_boxScalar _) (lintegral_boxScalar (by positivity)))).frequently
+end MomentPassage
+
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/DensityUniqueness.lean

@@ -0,0 +1,95 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.FiberDensity
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma piGaussianConvolution_withDensity {m : ℕ} (F : (Fin m → ℝ) → ℝ≥0∞)
+    (hF : Measurable F) (δ : ℝ) (y : Fin m → ℝ) :
+    PiGaussianConvolution (volume.withDensity F) δ y =
+      (∫⁻ x, (∏ j, gaussianPDF 0 ⟨δ^2,sq_nonneg δ⟩ (y j-x j)) * F x).toReal := by
+  unfold PiGaussianConvolution
+  rw [integral_eq_lintegral_of_nonneg_ae
+    (Eventually.of_forall (fun x => Finset.prod_nonneg (fun j _ => gaussianPDFReal_nonneg _ _ _)))
+    ((show Continuous (fun x : Fin m → ℝ => ∏ j,
+      gaussianPDFReal 0 ⟨δ^2,sq_nonneg δ⟩ (y j-x j)) from
+      by unfold gaussianPDFReal; fun_prop).aestronglyMeasurable),
+    lintegral_withDensity_eq_lintegral_mul _ hF (by fun_prop)]
+  congr 1
+  apply lintegral_congr
+  intro x
+  simp only [Pi.mul_apply, gaussianPDF]
+  rw [ENNReal.ofReal_prod_of_nonneg (fun j _ =>
+    gaussianPDFReal_nonneg 0 ⟨δ^2,sq_nonneg δ⟩ (y j-x j)), mul_comm]
+
+lemma ae_tendsto_fiberGaussian {Ω : Type*} [MeasurableSpace Ω] (γ : Measure Ω)
+    [SigmaFinite γ] {m : ℕ} (hm : 1 ≤ m)
+    (F : Ω × (Fin m → ℝ) → ℝ≥0∞) (hF : Measurable F)
+    (hfin : (∫⁻ z, F z ∂γ.prod volume) ≠ ∞) :
+    ∀ᵐ z ∂γ.prod volume, Tendsto
+      (fun i : ℕ => (fiberSmoothing volume F
+        (fun y : Fin m → ℝ => ∏ j, gaussianPDF 0
+          ⟨(1/(i:ℝ))^2,sq_nonneg _⟩ (y j)) z).toReal)
+      atTop (𝓝 (F z).toReal) := by
+  have hmeas (i : ℕ) : Measurable (fun z => (fiberSmoothing volume F
+      (fun y : Fin m → ℝ => ∏ j, gaussianPDF 0
+        ⟨(1/(i:ℝ))^2,sq_nonneg _⟩ (y j)) z).toReal) :=
+    (measurable_fiberSmoothing volume hF (by fun_prop)).ennreal_toReal
+  rw [Measure.ae_prod_iff_ae_ae (measurableSet_tendsto_fun hmeas hF.ennreal_toReal)]
+  have hinner : (∫⁻ A, ∫⁻ y : Fin m → ℝ, F (A,y) ∂volume ∂γ) ≠ ∞ := by
+    rwa [← lintegral_prod _ hF.aemeasurable]
+  filter_upwards [ae_lt_top (Measurable.lintegral_prod_right
+    (show Measurable (fun z : Ω × (Fin m → ℝ) => F (z.1,z.2)) from hF)) hinner] with A hA
+  let ν : Measure (Fin m → ℝ) := volume.withDensity (fun y => F (A,y))
+  have hFA : Measurable (fun y : Fin m → ℝ => F (A,y)) :=
+    hF.comp (measurable_const.prodMk measurable_id)
+  let : IsFiniteMeasure ν := isFiniteMeasure_withDensity hA.ne
+  have hac : ν ≪ volume := withDensity_absolutelyContinuous _ _
+  have hRN := Measure.rnDeriv_withDensity volume hFA
+  filter_upwards [ae_tendsto_piGaussianConvolution hm ν hac, hRN] with y hy hyRN
+  rw [hyRN] at hy
+  convert hy.comp reciprocal_nat_tendsto using 1
+  ext i
+  exact (piGaussianConvolution_withDensity (fun y => F (A,y)) hFA _ y).symm
+
+lemma pointwiseDensity_ae_eq {d m : ℕ} (hm : 1 ≤ m) (μ : Measure (Space d))
+    [IsFiniteMeasure μ] (F : ((Fin m → Space d) × (Fin m → ℝ)) → ℝ)
+    (hFm : Measurable F) (hF0 : ∀ x, 0 ≤ F x)
+    (hden : (MatrixLabelReference d m).withDensity (fun x => ENNReal.ofReal (F x)) =
+      ProjectionLaw μ m) :
+    PointwiseDensity μ m =ᵐ[MatrixLabelReference d m] F := by
+  have hfin : (∫⁻ z, ENNReal.ofReal (F z) ∂MatrixLabelReference d m) ≠ ∞ := by
+    have he := congrArg (fun ν => ν Set.univ) hden
+    rw [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ] at he
+    rw [he]
+    let : IsFiniteMeasure (ProjectionLaw μ m) := by unfold ProjectionLaw; infer_instance
+    exact measure_ne_top _ _
+  have ht := ae_tendsto_fiberGaussian
+    (Measure.pi (fun _ : Fin m => stdGaussian (Space d))) hm
+    (fun x => ENNReal.ofReal (F x)) hFm.ennreal_ofReal hfin
+  have he (i : ℕ) := projectionSmoothing_ae_eq_fiberSmoothing μ m
+    (fun x => ENNReal.ofReal (F x)) hFm.ennreal_ofReal hden
+    (gaussianPDF 0 ⟨(1/(i:ℝ))^2,sq_nonneg _⟩) (measurable_gaussianPDF _ _)
+  filter_upwards [ht, ae_all_iff.mpr he] with x hx hxe
+  apply PointwiseDensity_eq_of_tendsto
+  rw [ENNReal.toReal_ofReal (hF0 x)] at hx
+  convert hx using 1
+  ext i
+  rw [GaussianRegularization_eq_toReal μ m _, hxe i]
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/EllipsoidSuccess.lean

@@ -0,0 +1,111 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.SuccessArithmetic
+import OAI.Probability.MemoryPrecision.ZeroHorizon
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma chord_real_coefficient {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ]
+    (hL : L.Admissible ρ) (hd : 16 ≤ d) {ε : ℝ} (hε : 0 < ε)
+    {α : ℝ} (hαlo : ((d:ℝ)-1)/2 ≤ α) (hαhi : α ≤ (d:ℝ)/2) :
+    uniformChordSuccess L ρ ε ≤ ENNReal.ofReal
+      ((T+1:ℝ) * ((3*4^d:ℝ)*ε^((d:ℝ)-1-α) * RealStep d (2^M)^BlockCount T (d/8))) := by
+  apply (chord_real_bound L ρ hL hd hε hαlo hαhi).trans_eq
+  rw [ENNReal.ofReal_mul (by positivity : (0:ℝ) ≤ T+1)]
+  congr 1
+  simp [ENNReal.ofReal_add]
+
+lemma chord_half_sphere_bound {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ]
+    (hL : L.Admissible ρ) (hd : 16 ≤ d) {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1/10) :
+    uniformChordSuccess L ρ ε ≤ ENNReal.ofReal
+      (4^d * ε^(((d:ℝ)-1)/2) *
+        (SuccessConstant^d * (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)))^BlockCount T (d/8)) := by
+  by_cases hT : T = 0
+  · subst T
+    simp only [blockCount_zero, pow_zero, mul_one]
+    exact (chord_zero_bound L ρ hL (by omega) hε).trans
+      (ENNReal.ofReal_le_ofReal (terminal_angular_zero_bound hd hε hε1))
+  · have hb := chord_real_coefficient L ρ hL hd hε (le_refl (((d:ℝ)-1)/2)) (by linarith)
+    have he : (d:ℝ)-1-((d:ℝ)-1)/2 = ((d:ℝ)-1)/2 := by ring
+    rw [he] at hb
+    apply hb.trans (ENNReal.ofReal_le_ofReal ?_)
+    have hN : 1 ≤ 2^M := one_le_pow₀ (by norm_num)
+    have hNK : 2^M ≤ (d/8+2)*2^M := by
+      simp
+    have hs := stopping_step_bound_three hd hN hNK (by omega : 0 < T)
+    calc
+      _ = (4^d * ε^(((d:ℝ)-1)/2)) * (3*((T+1:ℝ)*RealStep d (2^M)^BlockCount T (d/8))) := by ring
+      _ ≤ _ := mul_le_mul_of_nonneg_left hs (by positivity)
+
+lemma chord_half_ambient_bound {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ]
+    (hL : L.Admissible ρ) (hd : 16 ≤ d) {ε : ℝ} (hε : 0 < ε) :
+    uniformChordSuccess L ρ ε ≤ ENNReal.ofReal
+      (12^d * ε^((d:ℝ)/2-1) *
+        (SuccessConstant^d * (((2*(d/8)+4)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)))^BlockCount T (d/8)) := by
+  have hb := chord_real_coefficient L ρ hL hd hε (by linarith : ((d:ℝ)-1)/2 ≤ (d:ℝ)/2) le_rfl
+  have he : (d:ℝ)-1-(d:ℝ)/2 = (d:ℝ)/2-1 := by ring
+  rw [he] at hb
+  apply hb.trans (ENNReal.ofReal_le_ofReal ?_)
+  have hN : 1 ≤ 2^M := one_le_pow₀ (by norm_num)
+  have hNK : 2^M ≤ (2*(d/8)+4)*2^M := by
+    simp
+  have hR := realStep_pos d hN
+  have hs := stopping_step_bound hd hN hNK T
+  have hSp := stepConstant_pos
+  have hK : 2*StepConstant ≤ SuccessConstant := by dsimp [SuccessConstant]; linarith
+  have hroot : 0 ≤ (((2*(d/8)+4)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)) := by positivity
+  have hbase := mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (by positivity : 0 ≤ 2*StepConstant) hK d) hroot
+  have hpow := pow_le_pow_left₀ (by positivity : 0 ≤ (2*StepConstant)^d *
+    (((2*(d/8)+4)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ))) hbase (BlockCount T (d/8))
+  calc
+    _ = ((3*4^d:ℝ)*ε^((d:ℝ)/2-1))*((T+1:ℝ)*RealStep d (2^M)^BlockCount T (d/8)) := by ring
+    _ ≤ _ := mul_le_mul
+      (mul_le_mul_of_nonneg_right (cap_constant_le (by omega : 1 ≤ d)) (by positivity))
+      (hs.trans hpow) (by positivity) (by positivity)
+
+def EllipsoidSuccessStatement : Prop :=
+  ∃ C C₀ : ℝ, 1 ≤ C ∧ 1 ≤ C₀ ∧
+  ∀ d M T : ℕ, 16 ≤ d → ∀ ε : ℝ, 0 < ε → ε ≤ 1/10 →
+  ∀ (Ω : Type u) [MeasurableSpace Ω] (ρ : Measure Ω), IsProbabilityMeasure ρ →
+  ∀ L : Learner d M T Ω, L.Admissible ρ →
+    L.uniformSuccess ρ ε ≤ min 1 (ENNReal.ofReal
+      (4^d * ε^(((d:ℝ)-1)/2) *
+        (C^d * (((d/8+2)*2^M : ℕ):ℝ)^(1/((d/8:ℕ):ℝ)))^(BlockCount T (d/8)))) ∧
+    uniformChordSuccess L ρ ε ≤ min 1 (ENNReal.ofReal
+      (C₀^d * ε^((d:ℝ)/2-1) *
+        (C^d * (((2*(d/8)+4)*2^M : ℕ):ℝ)^(1/((d/8:ℕ):ℝ)))^(BlockCount T (d/8)))) ∧
+    {z : UnitSphere d × (Ω × Samples d T) |
+      Learner.angularError z.1 (L.estimate z.1 z.2.1 z.2.2) ≤ ε} ⊆
+    {z | dist (L.estimate z.1 z.2.1 z.2.2).val z.1.val ≤ ε}
+
+theorem ellipsoid_success : EllipsoidSuccessStatement := by
+  refine ⟨SuccessConstant, 12, successConstant_one, by norm_num, ?_⟩
+  intro d M T hd ε hε hε1 Ω _ ρ hρ L hL
+  have : IsProbabilityMeasure ρ := hρ
+  let : NeZero d := ⟨by omega⟩
+  refine ⟨le_min ?_ ?_, le_min ?_ ?_, angular_event_subset_chord L ε⟩
+  · exact prob_le_one
+  · exact (angular_le_chord L ρ ε).trans (chord_half_sphere_bound L ρ hL hd hε hε1)
+  · exact prob_le_one
+  · exact chord_half_ambient_bound L ρ hL hd hε
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/FiberDensity.lean

@@ -0,0 +1,111 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.GaussianConvolution
+import OAI.Probability.MemoryPrecision.PointwiseDensity
+import OAI.Probability.MemoryPrecision.SphericalProjection
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+def PiGaussianConvolution {m : ℕ} (ν : Measure (Fin m → ℝ)) (δ : ℝ) (y : Fin m → ℝ) : ℝ :=
+  ∫ x, ∏ j, gaussianPDFReal 0 ⟨δ^2,sq_nonneg δ⟩ (y j - x j) ∂ν
+
+lemma piGaussianConvolution_eq {m : ℕ} (ν : Measure (Fin m → ℝ)) (δ : ℝ) (y : Fin m → ℝ) :
+    PiGaussianConvolution ν δ y =
+      GaussianConvolution (ν.map (WithLp.toLp 2)) δ (WithLp.toLp 2 y) := by
+  unfold GaussianConvolution
+  rw [integral_map (WithLp.measurable_toLp 2 (Fin m → ℝ)).aemeasurable
+    ((show Continuous (fun x : Space m => GaussianKernel m δ (WithLp.toLp 2 y - x)) from
+      (gaussianKernel_continuous m δ).comp (continuous_const.sub continuous_id)).aestronglyMeasurable)]
+  rfl
+
+lemma ae_tendsto_piGaussianConvolution {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Fin m → ℝ))
+    [IsFiniteMeasure ν] (hν : ν ≪ volume) :
+    ∀ᵐ y ∂(volume : Measure (Fin m → ℝ)), Tendsto (fun δ : ℝ => PiGaussianConvolution ν δ y)
+      (𝓝[>] (0:ℝ)) (𝓝 ((ν.rnDeriv volume y).toReal)) := by
+  let e := MeasurableEquiv.toLp 2 (Fin m → ℝ)
+  have hp : MeasurePreserving e volume volume := PiLp.volume_preserving_toLp (Fin m)
+  have hac : ν.map e ≪ volume := by
+    rw [← hp.map_eq]
+    exact hν.map e.measurable
+  have ht := ae_tendsto_gaussianConvolution hm (ν.map e) hac
+  have ht' : ∀ᵐ y ∂(volume : Measure (Fin m → ℝ)),
+      Tendsto (fun δ : ℝ => GaussianConvolution (ν.map e) δ (e y))
+        (𝓝[>] (0:ℝ)) (𝓝 (((ν.map e).rnDeriv volume (e y)).toReal)) := by
+    have ht0 : ∀ᵐ y ∂(volume.map e),
+        Tendsto (fun δ : ℝ => GaussianConvolution (ν.map e) δ y)
+          (𝓝[>] (0:ℝ)) (𝓝 (((ν.map e).rnDeriv volume y).toReal)) := by
+      rwa [hp.map_eq]
+    exact e.measurableEmbedding.ae_map_iff.mp ht0
+  have hRN := e.measurableEmbedding.rnDeriv_map ν volume
+  rw [hp.map_eq] at hRN
+  filter_upwards [ht', hRN] with y hy hyRN
+  rw [hyRN] at hy
+  simpa only [piGaussianConvolution_eq, e, MeasurableEquiv.coe_toLp] using hy
+
+lemma GaussianRegularization_eq_convolution {d m : ℕ} (μ : Measure (Space d))
+    (A : Fin m → Space d) (δ : ℝ) (y : Fin m → ℝ) :
+    GaussianRegularization μ m δ (A,y) =
+      PiGaussianConvolution (μ.map (fun s => fun j => ⟪s,A j⟫)) δ y := by
+  unfold PiGaussianConvolution
+  rw [integral_map (by fun_prop)
+    (((show Continuous (fun x : Fin m → ℝ => ∏ j,
+      gaussianPDFReal 0 ⟨δ^2,sq_nonneg δ⟩ (y j - x j)) from
+      by unfold gaussianPDFReal; fun_prop)).aestronglyMeasurable)]
+  rfl
+
+lemma ae_tendsto_GaussianRegularization {d m : ℕ} (hm : 1 ≤ m) (μ : Measure (Space d))
+    [IsFiniteMeasure μ] (A : Fin m → Space d)
+    (hA : μ.map (fun s => fun j => ⟪s,A j⟫) ≪ (volume : Measure (Fin m → ℝ))) :
+    ∀ᵐ y ∂(volume : Measure (Fin m → ℝ)), Tendsto
+      (fun δ : ℝ => GaussianRegularization μ m δ (A,y)) (𝓝[>] (0:ℝ))
+      (𝓝 (((μ.map (fun s => fun j => ⟪s,A j⟫)).rnDeriv volume y).toReal)) := by
+  simpa only [GaussianRegularization_eq_convolution] using
+    ae_tendsto_piGaussianConvolution hm (μ.map (fun s => fun j => ⟪s,A j⟫)) hA
+
+lemma reciprocal_nat_tendsto :
+    Tendsto (fun i : ℕ => 1/(i:ℝ)) atTop (𝓝[>] (0:ℝ)) := by
+  refine tendsto_nhdsWithin_iff.mpr ⟨tendsto_one_div_atTop_nhds_zero_nat, ?_⟩
+  filter_upwards [eventually_gt_atTop (0:ℕ)] with i hi
+  change 0 < 1/(i:ℝ)
+  positivity
+
+lemma pointwiseDensity_fiber {d m : ℕ} (hm : 1 ≤ m) (μ : Measure (Space d))
+    [IsFiniteMeasure μ] (A : Fin m → Space d)
+    (hA : μ.map (fun s => fun j => ⟪s,A j⟫) ≪ (volume : Measure (Fin m → ℝ))) :
+    (volume : Measure (Fin m → ℝ)).withDensity
+      (fun y => ENNReal.ofReal (PointwiseDensity μ m (A,y))) =
+      μ.map (fun s => fun j => ⟪s,A j⟫) := by
+  let ν := μ.map (fun s => fun j => ⟪s,A j⟫)
+  have he : (fun y => ENNReal.ofReal (PointwiseDensity μ m (A,y))) =ᵐ[volume]
+      ν.rnDeriv volume := by
+    filter_upwards [ae_tendsto_GaussianRegularization hm μ A hA, ν.rnDeriv_lt_top volume]
+      with y hy hyfin
+    rw [PointwiseDensity_eq_of_tendsto μ (A,y) (hy.comp reciprocal_nat_tendsto)]
+    exact ENNReal.ofReal_toReal hyfin.ne
+  rw [withDensity_congr_ae he]
+  exact Measure.withDensity_rnDeriv_eq _ _ hA
+
+lemma pointwiseDensity_fullRank {d m : ℕ} (hd : 2 ≤ d) (hm : 1 ≤ m) (hmd : m < d)
+    (μ : Measure (Space d)) [IsFiniteMeasure μ] (hμ : μ ≪ UniformSphere d)
+    (A : Fin m → Space d) (hA : LinearIndependent ℝ A) :
+    (volume : Measure (Fin m → ℝ)).withDensity
+      (fun y => ENNReal.ofReal (PointwiseDensity μ m (A,y))) =
+      μ.map (fun s => fun j => ⟪s,A j⟫) :=
+  pointwiseDensity_fiber hm μ A (spherical_projection_ac hd hmd A hA μ hμ)
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/FiniteDensity.lean

@@ -0,0 +1,281 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.DensityPassage
+import OAI.Probability.MemoryPrecision.SharpGaussian
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+def MatrixLabelReference (d m : ℕ) : @Measure ((Fin m → Space d) × (Fin m → ℝ))
+    (@MeasurableSpace.prod (Fin m → Space d) (Fin m → ℝ)
+      (@MeasurableSpace.pi (Fin m) (fun _ => Space d)
+        (fun _ => WithLp.measurableSpace
+          (@OfNat.ofNat ℝ≥0∞ 2
+            (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+              (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)))
+      inferInstance) :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let euclideanMeasurable := WithLp.measurableSpace exponent (Fin d → ℝ)
+  let rowMeasurable := @MeasurableSpace.pi (Fin m) (fun _ => Space d)
+    (fun _ => euclideanMeasurable)
+  let rowLaw := @Measure.pi (Fin m) (fun _ => Space d) inferInstance
+    (fun _ => euclideanMeasurable)
+    (fun _ => @stdGaussian (Space d)
+      (PiLp.normedAddCommGroup exponent (fun _ : Fin d => ℝ))
+      (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ))
+      inferInstance euclideanMeasurable)
+  @Measure.prod _ _ rowMeasurable inferInstance rowLaw volume
+
+def ProjectionLaw {d : ℕ}
+    (μ : @Measure (Space d)
+      (WithLp.measurableSpace
+        (@OfNat.ofNat ℝ≥0∞ 2
+          (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+            (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)))
+    (m : ℕ) : @Measure ((Fin m → Space d) × (Fin m → ℝ))
+      (@MeasurableSpace.prod (Fin m → Space d) (Fin m → ℝ)
+        (@MeasurableSpace.pi (Fin m) (fun _ => Space d)
+          (fun _ => WithLp.measurableSpace
+            (@OfNat.ofNat ℝ≥0∞ 2
+              (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+                (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)))
+        inferInstance) :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let euclideanMeasurable := WithLp.measurableSpace exponent (Fin d → ℝ)
+  let rowMeasurable := @MeasurableSpace.pi (Fin m) (fun _ => Space d)
+    (fun _ => euclideanMeasurable)
+  let rowLaw := @Measure.pi (Fin m) (fun _ => Space d) inferInstance
+    (fun _ => euclideanMeasurable)
+    (fun _ => @stdGaussian (Space d)
+      (PiLp.normedAddCommGroup exponent (fun _ : Fin d => ℝ))
+      (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ))
+      inferInstance euclideanMeasurable)
+  @Measure.map ((Fin m → Space d) × Space d) ((Fin m → Space d) × (Fin m → ℝ))
+    (@MeasurableSpace.prod _ _ rowMeasurable euclideanMeasurable)
+    (@MeasurableSpace.prod _ _ rowMeasurable inferInstance)
+    (fun pair => (pair.1, fun index => @inner ℝ (Space d)
+      (@InnerProductSpace.toInner ℝ (Space d) _
+        (PiLp.seminormedAddCommGroup exponent (fun _ : Fin d => ℝ))
+        (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ)))
+      pair.2 (pair.1 index)))
+    (@Measure.prod _ _ rowMeasurable euclideanMeasurable rowLaw μ)
+def ProjectedEllipsoid {d m : ℕ} (z : Space d) (R : ℝ) :
+    Set ((Fin m → Space d) × (Fin m → ℝ)) :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let euclideanInner := @InnerProductSpace.toInner ℝ (Space d) _
+    (PiLp.seminormedAddCommGroup exponent (fun _ : Fin d => ℝ))
+    (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ))
+  {pair | ∃ displacement ∈ @Metric.closedBall (Space d)
+      (PiLp.instPseudoMetricSpace (p := exponent) (β := fun _ : Fin d => ℝ))
+      (WithLp.toLp exponent (fun _ => (0 : ℝ))) R,
+    pair.2 = fun index => @inner ℝ (Space d) euclideanInner z (pair.1 index) +
+      @inner ℝ (Space d) euclideanInner displacement (pair.1 index)}
+def ProjectionNormScale (m p : ℕ) (H β R : ℝ) : ℝ :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  (two * Real.pi) ^ (-(m : ℝ) * ((p : ℝ)-1) / (two*(p : ℝ))) * H *
+    R ^ (β - (m : ℝ)*(1-1/(p : ℝ))) *
+    (∏ j ∈ Finset.range (p-1), J β m j) ^ (1/(p : ℝ))
+
+lemma isClosed_projectedEllipsoid {d m : ℕ} (z : Space d) (R : ℝ) :
+    IsClosed (ProjectedEllipsoid (m := m) z R) := by
+  let K := Metric.closedBall (0 : Space d) R
+  have hK : IsCompact K := isCompact_closedBall _ _
+  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
+  let D : Set (((Fin m → Space d) × (Fin m → ℝ)) × K) :=
+    {w | w.1.2 = fun j => ⟪z, w.1.1 j⟫ + ⟪(w.2 : Space d), w.1.1 j⟫}
+  have hD : IsClosed D := isClosed_eq (by fun_prop) (by fun_prop)
+  have he : ProjectedEllipsoid (m := m) z R = Prod.fst '' D := by
+    ext Ay
+    constructor
+    · rintro ⟨v, hv, he⟩
+      exact ⟨(Ay, ⟨v,hv⟩), he, rfl⟩
+    · rintro ⟨⟨Ay,v⟩, hv, rfl⟩
+      exact ⟨v, v.property, hv⟩
+  rw [he]
+  exact isClosedMap_fst_of_compactSpace D hD
+
+lemma projectionLaw_ellipsoid_compl {d m : ℕ} (μ : Measure (Space d)) [IsFiniteMeasure μ]
+    {z : Space d} {R : ℝ} (hsupport : μ.support ⊆ Metric.closedBall z R) :
+    projectionLaw μ m (ProjectedEllipsoid z R)ᶜ = 0 := by
+  rw [projectionLaw, Measure.map_apply (by fun_prop)
+    (isClosed_projectedEllipsoid z R).measurableSet.compl]
+  apply measure_mono_null (t := Set.univ ×ˢ μ.supportᶜ)
+  · rintro ⟨A,s⟩ hs
+    refine ⟨mem_univ _, ?_⟩
+    intro hss
+    apply hs
+    refine ⟨s-z, ?_, ?_⟩
+    · change dist (s - z) (0 : Space d) ≤ R
+      simpa [Metric.mem_closedBall, dist_eq_norm] using hsupport hss
+    · ext j
+      simp [inner_sub_left]
+  · rw [Measure.prod_prod]
+    simp [μ.measure_compl_support]
+
+lemma projectionNormScale_pos {m p : ℕ} {H β R : ℝ} (hp : 2 ≤ p) (hH : 0 < H)
+    (hR : 0 < R) (hgap : (m:ℝ)+(p:ℝ)-2 < β) :
+    0 < ProjectionNormScale m p H β R := by
+  have hJ : 0 < ∏ j ∈ Finset.range (p-1), J β m j := by
+    apply Finset.prod_pos
+    intro j hj
+    apply J_pos
+    have hj' : j+2 ≤ p := by have := Finset.mem_range.mp hj; omega
+    have hj'' : (j:ℝ)+2 ≤ p := by exact_mod_cast hj'
+    linarith
+  unfold ProjectionNormScale
+  positivity
+
+lemma moment_root_eq_scale {m p : ℕ} {H β R : ℝ} (hp : 2 ≤ p) (hH : 0 < H)
+    (hR : 0 < R) (hgap : (m:ℝ)+(p:ℝ)-2 < β) :
+    (gaussianPeak ^ ((p-1)*m) * ENNReal.ofReal
+      (H^p * R^(β*(p:ℝ)-(m:ℝ)*((p-1:ℕ):ℝ)) * ∏ j : Fin (p-1), J β m j)) ^ (1/(p:ℝ)) =
+      ENNReal.ofReal (ProjectionNormScale m p H β R) := by
+  have hp0 : (p:ℝ) ≠ 0 := by exact_mod_cast (by omega : p ≠ 0)
+  have hp1 : 1 ≤ p := by omega
+  have hprod : 0 < ∏ j : Fin (p-1), J β m j := by
+    apply Finset.prod_pos
+    intro j _
+    apply J_pos
+    have hj : (j:ℝ)+2 ≤ p := by exact_mod_cast (show (j:ℕ)+2 ≤ p by have := j.isLt; omega)
+    linarith
+  have hpi : 0 < 2 * Real.pi := by positivity
+  rw [ENNReal.mul_rpow_of_nonneg _ _ (by positivity), gaussianPeak,
+    ← ENNReal.ofReal_pow (by positivity), ENNReal.ofReal_rpow_of_pos (by positivity),
+    ENNReal.ofReal_rpow_of_pos (by positivity), ← ENNReal.ofReal_mul (by positivity)]
+  congr 1
+  rw [Real.mul_rpow (by positivity : 0 ≤ H^p * R^(β*p-m*((p-1:ℕ):ℝ))) hprod.le,
+    Real.mul_rpow (by positivity : 0 ≤ H^p) (by positivity),
+    ← Real.rpow_natCast_mul hH.le, mul_one_div_cancel hp0, Real.rpow_one,
+    ← Real.rpow_mul hR.le,
+    ← Real.rpow_natCast_mul (by positivity : 0 ≤ (Real.sqrt (2*Real.pi))⁻¹),
+    Real.inv_rpow (by positivity), Real.sqrt_eq_rpow, ← Real.rpow_mul hpi.le,
+    ← Real.rpow_neg hpi.le]
+  have he1 : -(1/2 * (((p-1:ℕ):ℝ)*(m:ℝ) * (1/(p:ℝ)))) =
+      -(m:ℝ)*((p:ℝ)-1)/(2*(p:ℝ)) := by rw [Nat.cast_sub hp1]; push_cast; ring
+  have he2 : (β*(p:ℝ)-(m:ℝ)*((p-1:ℕ):ℝ)) * (1/(p:ℝ)) =
+      β-(m:ℝ)*(1-1/(p:ℝ)) := by rw [Nat.cast_sub hp1]; push_cast; field_simp
+  simp only [Nat.cast_mul] at *
+  rw [he1, he2, Fin.prod_univ_eq_prod_range]
+  unfold ProjectionNormScale
+  ring
+
+local instance final_reference_sigmaFinite (d m : ℕ) :
+    SigmaFinite (matrixLabelReference (E := Space d) m) := by
+  unfold matrixLabelReference
+  infer_instance
+local instance final_projection_finite {d : ℕ} (μ : Measure (Space d)) [IsFiniteMeasure μ] (m : ℕ) :
+    IsFiniteMeasure (projectionLaw μ m) := by
+  unfold projectionLaw
+  infer_instance
+
+lemma exact_finite_density (d m p : ℕ) (hp : 2 ≤ p) (hm : 1 ≤ m)
+    (β H R : ℝ) (hgap : (m:ℝ)+(p:ℝ)-2 < β) (hH : 0 < H) (hR : 0 < R)
+    (z : Space d) (μ : Measure (Space d)) [IsFiniteMeasure μ]
+    (hsupport : μ.support ⊆ Metric.closedBall z R) (hball : AmbientBallBound μ H β) :
+    ∃ F : ((Fin m → Space d) × (Fin m → ℝ)) → ℝ,
+      Measurable F ∧ (∀ x, 0 ≤ F x) ∧
+      (MatrixLabelReference d m).withDensity (fun x => ENNReal.ofReal (F x)) =
+        ProjectionLaw μ m ∧
+      (∀ᵐ x ∂MatrixLabelReference d m, x ∉ ProjectedEllipsoid z R → F x = 0) ∧
+      eLpNorm F (p : ℝ≥0∞) (MatrixLabelReference d m) ≤
+        ENNReal.ofReal (ProjectionNormScale m p H β R) := by
+  let C := gaussianPeak ^ ((p-1)*m) * ENNReal.ofReal
+    (H^p * R^(β*(p:ℝ)-(m:ℝ)*((p-1:ℕ):ℝ)) * ∏ j : Fin (p-1), J β m j)
+  have hC : C ≠ ∞ := by unfold C gaussianPeak; finiteness
+  have hp1 : p-1+1 = p := by omega
+  have hmom : ∀ φ : ℝ → ℝ≥0∞, Measurable φ → (∫⁻ x, φ x = 1) →
+      (∫⁻ Ay, projectionSmoothing μ φ m Ay ^ (p-1+1) ∂matrixLabelReference m) ≤ C := by
+    intro φ hφ hφ1
+    have hg : ((p-1:ℕ):ℝ)+(m:ℝ)-1 < β := by
+      rw [Nat.cast_sub (by omega : 1 ≤ p)]
+      push_cast
+      linarith
+    simpa only [hp1] using sharp_projectionSmoothing_moment hH hR hsupport hball φ hφ hφ1 hm (p-1) hg
+  have hac := projectionLaw_ac_of_moment μ m (p-1) (by omega) C hC hmom
+  let G := (projectionLaw μ m).rnDeriv (matrixLabelReference m)
+  have hG : Measurable G := Measure.measurable_rnDeriv _ _
+  have hden : (matrixLabelReference m).withDensity G = projectionLaw μ m :=
+    Measure.withDensity_rnDeriv_eq _ _ hac
+  have hGtop : ∀ᵐ x ∂matrixLabelReference m, G x ≠ ∞ := Measure.rnDeriv_ne_top _ _
+  have hGmom : (∫⁻ x, G x^p ∂matrixLabelReference m) ≤ C := by
+    simpa only [hp1] using projectionLaw_rnDeriv_moment μ m (p-1) (by omega) C hC hmom
+  let F := fun x => (G x).toReal
+  have hFG : (fun x => ENNReal.ofReal (F x)) =ᵐ[matrixLabelReference m] G := by
+    filter_upwards [hGtop] with x hx
+    exact ENNReal.ofReal_toReal hx
+  refine ⟨F, hG.ennreal_toReal, fun _ => ENNReal.toReal_nonneg, ?_, ?_, ?_⟩
+  · change (matrixLabelReference m).withDensity _ = projectionLaw μ m
+    rw [withDensity_congr_ae hFG, hden]
+  · have hnull := projectionLaw_ellipsoid_compl μ hsupport (m := m)
+    rw [← hden, withDensity_apply _ (isClosed_projectedEllipsoid z R).measurableSet.compl] at hnull
+    have hz := (lintegral_eq_zero_iff' hG.aemeasurable).mp hnull
+    change ∀ᵐ x ∂(matrixLabelReference m).restrict (ProjectedEllipsoid z R)ᶜ, G x = 0 at hz
+    rw [ae_restrict_iff' (isClosed_projectedEllipsoid z R).measurableSet.compl] at hz
+    filter_upwards [hz] with x hx hnot
+    dsimp [F]
+    rw [hx hnot]
+    rfl
+  · change eLpNorm F (p:ℝ≥0∞) (matrixLabelReference m) ≤ _
+    rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by exact_mod_cast (by omega : p ≠ 0))
+      (by finiteness) hG.ennreal_toReal.aestronglyMeasurable]
+    simp only [ENNReal.toReal_natCast]
+    have he : (fun x => ‖F x‖ₑ ^ (p:ℝ)) =ᵐ[matrixLabelReference m] (fun x => G x^p) := by
+      filter_upwards [hFG] with x hx
+      rw [Real.enorm_eq_ofReal ENNReal.toReal_nonneg, hx, ENNReal.rpow_natCast]
+    rw [lintegral_congr_ae he]
+    exact (ENNReal.rpow_le_rpow hGmom (by positivity)).trans_eq
+      (moment_root_eq_scale hp hH hR hgap)
+
+def FiniteDensityStatement : Prop :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  ∀ d m p : ℕ,
+  letI : MeasurableSpace (Space d) := WithLp.measurableSpace exponent (Fin d → ℝ)
+  1 ≤ d → 1 ≤ m → 2 ≤ p →
+  ∀ β H R : ℝ, (m : ℝ)+(p : ℝ)-two < β → 0 < H → 0 < R →
+  ∀ z : Space d, ∀ μ : Measure (Space d), IsFiniteMeasure μ →
+    @Measure.support (Space d)
+      (PiLp.topologicalSpace (p := exponent) (β := fun _ : Fin d => ℝ))
+      (WithLp.measurableSpace exponent (Fin d → ℝ)) μ ⊆
+      @Metric.closedBall (Space d)
+        (PiLp.instPseudoMetricSpace (p := exponent) (β := fun _ : Fin d => ℝ)) z R →
+    AmbientBallBound μ H β →
+    ∃ F : ((Fin m → Space d) × (Fin m → ℝ)) → ℝ,
+      Measurable F ∧ (∀ x, 0 ≤ F x) ∧
+      (MatrixLabelReference d m).withDensity (fun x => ENNReal.ofReal (F x)) =
+        ProjectionLaw μ m ∧
+      (∀ᵐ x ∂MatrixLabelReference d m, x ∉ ProjectedEllipsoid z R → F x = 0) ∧
+      eLpNorm F (p : ℝ≥0∞) (MatrixLabelReference d m) ≤
+        ENNReal.ofReal (ProjectionNormScale m p H β R)
+
+theorem finite_density : FiniteDensityStatement := by
+  intro d m p _ hm hp β H R hgap hH hR z μ hμ hs hb
+  let := hμ
+  exact exact_finite_density d m p hp hm β H R hgap hH hR z μ hs hb
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/GaussianConvolution.lean

@@ -0,0 +1,114 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.BallAverages
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+
+lemma gaussianKernel_translated_ball_mixture (m : ℕ) (hm : 1 ≤ m) {δ : ℝ} (hδ : 0 < δ)
+    (y x : Space m) :
+    ENNReal.ofReal (GaussianKernel m δ (y-x)) =
+      ∫⁻ r in Ioi 0, (Metric.ball y r).indicator
+        (fun _ => ENNReal.ofReal ((r/δ^2)*GaussianKernel m δ (r • CoordinateUnit m))) x := by
+  rw [gaussianKernel_ball_mixture m hm hδ]
+  apply lintegral_congr
+  intro r
+  have he : y-x ∈ Metric.ball (0 : Space m) r ↔ x ∈ Metric.ball y r := by
+    simp only [Metric.mem_ball, dist_eq_norm, sub_zero, norm_sub_rev]
+  by_cases hx : x ∈ Metric.ball y r
+  · rw [Set.indicator_of_mem (he.mpr hx), Set.indicator_of_mem hx]
+  · rw [Set.indicator_of_notMem (mt he.mp hx), Set.indicator_of_notMem hx]
+
+def GaussianConvolution {m : ℕ} (ν : Measure (Space m)) (δ : ℝ) (y : Space m) : ℝ :=
+  ∫ x, GaussianKernel m δ (y-x) ∂ν
+
+lemma gaussianConvolution_shell {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    [IsFiniteMeasure ν] {δ : ℝ} (hδ : 0 < δ) (y : Space m) :
+    GaussianConvolution ν δ y = ∫ r in Ioi 0,
+      ((r/δ^2)*GaussianKernel m δ (r • CoordinateUnit m)) * (ν (Metric.ball y r)).toReal := by
+  have hk : Measurable (GaussianKernel m δ) := (gaussianKernel_continuous m δ).measurable
+  have hmeas : Measurable (fun z : Space m × ℝ =>
+      (Metric.ball y z.2).indicator
+        (fun _ => ENNReal.ofReal ((z.2/δ^2)*GaussianKernel m δ (z.2 • CoordinateUnit m))) z.1) := by
+    have he : (fun z : Space m × ℝ => (Metric.ball y z.2).indicator
+        (fun _ => ENNReal.ofReal ((z.2/δ^2)*GaussianKernel m δ (z.2 • CoordinateUnit m))) z.1) =
+      {z : Space m × ℝ | dist z.1 y < z.2}.indicator
+        (fun z => ENNReal.ofReal ((z.2/δ^2)*GaussianKernel m δ (z.2 • CoordinateUnit m))) := by
+      ext z
+      by_cases hz : z.1 ∈ Metric.ball y z.2
+      · rw [Set.indicator_of_mem hz, Set.indicator_of_mem
+          (show z ∈ {z : Space m × ℝ | dist z.1 y < z.2} from hz)]
+      · rw [Set.indicator_of_notMem hz, Set.indicator_of_notMem
+          (show z ∉ {z : Space m × ℝ | dist z.1 y < z.2} from hz)]
+    rw [he]
+    exact (by fun_prop : Measurable (fun z : Space m × ℝ =>
+      ENNReal.ofReal ((z.2/δ^2)*GaussianKernel m δ (z.2 • CoordinateUnit m)))).indicator
+      (measurableSet_lt (by fun_prop) (by fun_prop))
+  unfold GaussianConvolution
+  rw [integral_eq_lintegral_of_nonneg_ae
+    (Eventually.of_forall (fun _ => gaussianKernel_nonneg m δ _))
+    ((hk.comp (by fun_prop)).aestronglyMeasurable)]
+  simp_rw [gaussianKernel_translated_ball_mixture m hm hδ y]
+  rw [lintegral_lintegral_swap hmeas.aemeasurable]
+  simp_rw [lintegral_indicator Metric.isOpen_ball.measurableSet, setLIntegral_const]
+  have hmass : Measurable (fun r : ℝ => (ν (Metric.ball y r)).toReal) :=
+    (show Monotone (fun r : ℝ => ν (Metric.ball y r)) from
+      fun a b h => measure_mono (Metric.ball_subset_ball h)).measurable.ennreal_toReal
+  rw [integral_eq_lintegral_of_nonneg_ae
+    ((ae_restrict_mem measurableSet_Ioi).mono (fun r hr =>
+      mul_nonneg (mul_nonneg (div_nonneg hr.le (sq_nonneg δ)) (gaussianKernel_nonneg m δ _))
+        ENNReal.toReal_nonneg)) (by fun_prop)]
+  congr 1
+  apply lintegral_congr_ae
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  rw [ENNReal.ofReal_mul (mul_nonneg (div_nonneg hr.le (sq_nonneg δ))
+    (gaussianKernel_nonneg m δ _)), ENNReal.ofReal_toReal (measure_ne_top _ _)]
+
+lemma gaussianConvolution_mixture {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    [IsFiniteMeasure ν] {δ : ℝ} (hδ : 0 < δ) (y : Space m) :
+    GaussianConvolution ν δ y = ∫ r in Ioi 0, RadialMixture m δ r * BallAverage ν y r := by
+  rw [gaussianConvolution_shell hm ν hδ y]
+  apply integral_congr_ae
+  filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
+  have hr0 : 0 < r := hr
+  unfold RadialMixture BallAverage
+  field_simp [(unitBallVolume_pos m).ne', hr0.ne']
+
+lemma gaussianConvolution_scaled_mixture {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    [IsFiniteMeasure ν] {δ : ℝ} (hδ : 0 < δ) (y : Space m) :
+    GaussianConvolution ν δ y = ∫ r in Ioi 0, RadialMixture m 1 r * BallAverage ν y (δ*r) := by
+  rw [gaussianConvolution_mixture hm ν hδ y]
+  have he := integral_comp_mul_left_Ioi'
+    (fun r => RadialMixture m δ r * BallAverage ν y r) 0 hδ
+  simp only [mul_zero, smul_eq_mul] at he
+  rw [← he, ← integral_const_mul]
+  apply integral_congr_ae
+  exact Eventually.of_forall (fun radius => by
+    dsimp only
+    rw [radialMixture_scale m hδ]
+    field_simp [hδ.ne'])
+
+lemma ae_tendsto_gaussianConvolution {m : ℕ} (hm : 1 ≤ m) (ν : Measure (Space m))
+    [IsFiniteMeasure ν] (hν : ν ≪ volume) :
+    ∀ᵐ y ∂(volume : Measure (Space m)), Tendsto (fun δ : ℝ => GaussianConvolution ν δ y)
+      (𝓝[>] (0:ℝ)) (𝓝 ((ν.rnDeriv volume y).toReal)) := by
+  filter_upwards [ae_tendsto_ballAverage hm ν hν] with y hy
+  apply (tendsto_radial_average hm ν y ENNReal.toReal_nonneg hy).congr'
+  filter_upwards [self_mem_nhdsWithin] with δ hδ
+  exact (gaussianConvolution_scaled_mixture hm ν hδ y).symm
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/JointL1.lean

@@ -0,0 +1,185 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.FiniteDensity
+import OAI.Probability.MemoryPrecision.KernelModel
+import OAI.Probability.MemoryPrecision.LabelTranslations
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision
+open NoiselessRegression
+def UniformSphere (d : ℕ) : @Measure (Space d)
+    (WithLp.measurableSpace
+      (@OfNat.ofNat ℝ≥0∞ 2
+        (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+          (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)) :=
+  let euclideanMeasurable := WithLp.measurableSpace
+    (@OfNat.ofNat ℝ≥0∞ 2
+      (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+        (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)
+  @Measure.map (Kernel.Sphere d) (Space d)
+    (MeasurableSpace.comap Subtype.val euclideanMeasurable) euclideanMeasurable
+    Subtype.val (Kernel.UniformSphere d)
+
+def GaussianRegularization {d : ℕ}
+    (μ : @Measure (Space d)
+      (WithLp.measurableSpace
+        (@OfNat.ofNat ℝ≥0∞ 2
+          (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+            (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))) (Fin d → ℝ)))
+    (m : ℕ) (δ : ℝ)
+    (Ay : (Fin m → Space d) × (Fin m → ℝ)) : ℝ :=
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  letI : MeasurableSpace (Space d) := WithLp.measurableSpace exponent (Fin d → ℝ)
+  ∫ signal, ∏ index, gaussianPDFReal 0 ⟨δ^2, sq_nonneg δ⟩
+    (Ay.2 index - @inner ℝ (Space d)
+      (@InnerProductSpace.toInner ℝ (Space d) _
+        (PiLp.seminormedAddCommGroup exponent (fun _ : Fin d => ℝ))
+        (PiLp.innerProductSpace (𝕜 := ℝ) (fun _ : Fin d => ℝ)))
+      signal (Ay.1 index)) ∂μ
+
+lemma gaussianPDF_zero_sub_comm (v : ℝ≥0) (a b : ℝ) :
+    gaussianPDF 0 v (a-b) = gaussianPDF 0 v (b-a) := by
+  simp only [gaussianPDF, gaussianPDFReal, sub_zero]
+  congr 4
+  ring
+
+lemma GaussianRegularization_eq_toReal {d : ℕ} (μ : Measure (Space d))
+    [IsFiniteMeasure μ] (m : ℕ) (δ : ℝ)
+    (x : (Fin m → Space d) × (Fin m → ℝ)) :
+    GaussianRegularization μ m δ x =
+      (projectionSmoothing μ (gaussianPDF 0 ⟨δ^2,sq_nonneg δ⟩) m x).toReal := by
+  let v : ℝ≥0 := ⟨δ^2,sq_nonneg δ⟩
+  change (∫ s, ∏ j, gaussianPDFReal 0 v (x.2 j - ⟪s,x.1 j⟫) ∂μ) = _
+  have hn : ∀ s : Space d, 0 ≤ ∏ j, gaussianPDFReal 0 v (x.2 j - ⟪s,x.1 j⟫) :=
+    fun s => Finset.prod_nonneg (fun _ _ => gaussianPDFReal_nonneg _ _ _)
+  have hm : Measurable (fun s : Space d => ∏ j, gaussianPDFReal 0 v (x.2 j - ⟪s,x.1 j⟫)) := by
+    fun_prop
+  rw [integral_eq_lintegral_of_nonneg_ae (Eventually.of_forall hn) hm.aestronglyMeasurable]
+  unfold projectionSmoothing
+  congr 1
+  apply lintegral_congr
+  intro s
+  rw [ENNReal.ofReal_prod_of_nonneg (fun _ _ => gaussianPDFReal_nonneg _ _ _)]
+  rfl
+
+lemma GaussianRegularization_ae_eq_average {d : ℕ} (μ : Measure (Space d))
+    [IsFiniteMeasure μ] (m : ℕ)
+    (F : ((Fin m → Space d) × (Fin m → ℝ)) → ℝ)
+    (hF : Measurable F) (hF0 : ∀ x, 0 ≤ F x)
+    (hden : (MatrixLabelReference d m).withDensity (fun x => ENNReal.ofReal (F x)) =
+      ProjectionLaw μ m) (δ : ℝ) (hδ : δ ≠ 0) :
+    GaussianRegularization μ m δ =ᵐ[MatrixLabelReference d m]
+      averageTranslate (Measure.pi (fun _ : Fin m => gaussianReal 0 1)) δ F := by
+  have he := projectionSmoothing_ae_eq_fiberSmoothing μ m
+    (fun x => ENNReal.ofReal (F x)) hF.ennreal_ofReal hden
+    (gaussianPDF 0 ⟨δ^2,sq_nonneg δ⟩) (measurable_gaussianPDF _ _)
+  filter_upwards [he] with x hx
+  rw [GaussianRegularization_eq_toReal, hx]
+  unfold averageTranslate
+  rw [integral_eq_lintegral_of_nonneg_ae (Eventually.of_forall (fun u => hF0 _))
+    ((hF.comp (by fun_prop)).aestronglyMeasurable)]
+  congr 1
+  change fiberSmoothing volume (fun x => ENNReal.ofReal (F x))
+    (fun y : Fin m → ℝ => ∏ j, gaussianPDF 0 _ (y j)) x =
+      ∫⁻ u : Fin m → ℝ, ENNReal.ofReal (F (x.1,fun j => x.2 j + δ * u j))
+        ∂Measure.pi (fun _ => gaussianReal 0 1)
+  rw [lintegral_gaussian_shift_scale m δ hδ x.2 (fun y => ENNReal.ofReal (F (x.1,y)))
+    (by fun_prop)]
+  apply lintegral_congr
+  intro y
+  congr 1
+  apply Finset.prod_congr rfl
+  intro j _
+  exact gaussianPDF_zero_sub_comm _ _ _
+
+lemma memLp_density_of_finite {X : Type*} [MeasurableSpace X]
+    (ν₀ η : Measure X) [IsFiniteMeasure η] {F : X → ℝ}
+    (hFm : Measurable F) (hF0 : ∀ x, 0 ≤ F x)
+    (hden : ν₀.withDensity (fun x => ENNReal.ofReal (F x)) = η) :
+    MemLp F 1 ν₀ := by
+  rw [memLp_iff, eLpNorm_one_eq_lintegral_enorm hFm.aestronglyMeasurable]
+  have he : (fun x => ‖F x‖ₑ) = (fun x => ENNReal.ofReal (F x)) := by
+    funext x
+    exact Real.enorm_eq_ofReal (hF0 x)
+  rw [he]
+  have he2 := congrArg (fun ν : Measure X => ν Set.univ) hden
+  rw [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ] at he2
+  rw [he2]
+  exact measure_lt_top _ _
+
+lemma density_ae_unique_real {X : Type*} [MeasurableSpace X]
+    (ν₀ : Measure X) [SigmaFinite ν₀] {F G : X → ℝ}
+    (hFm : Measurable F) (hF0 : ∀ x, 0 ≤ F x)
+    (hGm : Measurable G) (hG0 : ∀ x, 0 ≤ G x)
+    (hden : ν₀.withDensity (fun x => ENNReal.ofReal (F x)) =
+      ν₀.withDensity (fun x => ENNReal.ofReal (G x))) : F =ᵐ[ν₀] G := by
+  have he := (withDensity_eq_iff_of_sigmaFinite hFm.ennreal_ofReal.aemeasurable
+    hGm.ennreal_ofReal.aemeasurable).mp hden
+  filter_upwards [he] with x hx
+  exact (ENNReal.ofReal_eq_ofReal_iff (hF0 x) (hG0 x)).mp hx
+
+def JointL1Statement : Prop :=
+  let two : ℝ := @OfNat.ofNat ℝ 2 (@instOfNatAtLeastTwo ℝ 2 Real.commRing.toNatCast
+    (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  let exponent : ℝ≥0∞ := @OfNat.ofNat ℝ≥0∞ 2
+    (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast
+      (Mathlib.Meta.NormNum.instAtLeastTwo (nat_lit 0)))
+  ∀ d m p : ℕ,
+  letI : MeasurableSpace (Space d) := WithLp.measurableSpace exponent (Fin d → ℝ)
+  2 ≤ d → 1 ≤ m → m < d → 2 ≤ p →
+  ∀ β H R : ℝ, (m : ℝ)+(p : ℝ)-two < β → 0 < H → 0 < R →
+  ∀ z : Space d, ∀ μ : Measure (Space d), IsFiniteMeasure μ →
+    @Measure.support (Space d)
+      (PiLp.topologicalSpace (p := exponent) (β := fun _ : Fin d => ℝ))
+      (WithLp.measurableSpace exponent (Fin d → ℝ)) μ ⊆
+      @Metric.closedBall (Space d)
+        (PiLp.instPseudoMetricSpace (p := exponent) (β := fun _ : Fin d => ℝ)) z R →
+    AmbientBallBound μ H β →
+    μ ≪ UniformSphere d →
+  ∀ F : ((Fin m → Space d) × (Fin m → ℝ)) → ℝ,
+    Measurable F → (∀ x, 0 ≤ F x) →
+    (MatrixLabelReference d m).withDensity (fun x => ENNReal.ofReal (F x)) =
+      ProjectionLaw μ m →
+    Tendsto (fun δ => eLpNorm (fun Ay => GaussianRegularization μ m δ Ay - F Ay)
+      1 (MatrixLabelReference d m)) (𝓝[Set.Ioi 0] 0) (𝓝 0) ∧
+    eLpNorm F (p : ℝ≥0∞) (MatrixLabelReference d m) ≤
+      ENNReal.ofReal (ProjectionNormScale m p H β R)
+theorem joint_l1 : JointL1Statement := by
+  intro d m p hd hm hmd hp β H R hgap hH hR z μ hμ hs hb hac F hFm hF0 hden
+  have : IsFiniteMeasure μ := hμ
+  have : IsFiniteMeasure (ProjectionLaw μ m) := by unfold ProjectionLaw; infer_instance
+  have : SigmaFinite (MatrixLabelReference d m) := by unfold MatrixLabelReference; infer_instance
+  have hF := memLp_density_of_finite (MatrixLabelReference d m) (ProjectionLaw μ m) hFm hF0 hden
+  constructor
+  · have ht := tendsto_eLpNorm_averageTranslate_sub
+      (Measure.pi (fun _ : Fin m => stdGaussian (Space d)))
+      (volume : Measure (Fin m → ℝ))
+      (Measure.pi (fun _ : Fin m => gaussianReal 0 1)) hFm hF
+    apply (ht.mono_left nhdsWithin_le_nhds).congr'
+    filter_upwards [self_mem_nhdsWithin] with δ hδ
+    apply eLpNorm_congr_ae
+    filter_upwards [GaussianRegularization_ae_eq_average μ m F hFm hF0 hden δ
+      (ne_of_gt hδ)] with x hx
+    exact congrArg (fun t => t - F x) hx.symm
+  · obtain ⟨G,hGm,hG0,hGden,hGs,hGnorm⟩ :=
+      exact_finite_density d m p hp hm β H R hgap hH hR z μ hs hb
+    have he := density_ae_unique_real (MatrixLabelReference d m) hFm hF0 hGm hG0
+      (hden.trans hGden.symm)
+    exact (eLpNorm_congr_ae he).symm ▸ hGnorm
+end MemoryPrecision
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/KernelAdmissibility.lean

@@ -0,0 +1,48 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CoefficientStep
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision.Kernel
+namespace Policy
+
+def ModelAdmissible {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (K : Ω → Policy d M T) (ρ : Measure Ω) : Prop :=
+  ∀ π : Measure (Sphere d), IsProbabilityMeasure π → Admissible K ρ π
+
+def FixedSuccess {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (K : Ω → Policy d M T) (ρ : Measure Ω) (ε : ℝ) (s : Sphere d) : ℝ≥0∞ :=
+  let rowMeasurable := @MeasurableSpace.pi (Fin T) (fun _ => Vector d)
+    (fun _ => @WithLp.measurableSpace
+      (@OfNat.ofNat ℝ≥0∞ 2
+        (@instOfNatAtLeastTwo ℝ≥0∞ 2 ENNReal.instAddCommMonoidWithOne.toNatCast inferInstance))
+      (Fin d → ℝ) inferInstance)
+  @lintegral (Ω × Rows d T)
+    (@Prod.instMeasurableSpace Ω (Rows d T) inferInstance rowMeasurable)
+    (@Measure.prod Ω (Rows d T) inferInstance rowMeasurable ρ (RowLaw d T))
+    (fun z => experiment K (angleTest ε) (s,z))
+
+lemma modelAdmissible_of_measurable {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω]
+    (K : Ω → Policy d M T) (ρ : Measure Ω)
+    (hc : ∀ᵐ ω ∂ρ, (K ω).Completed)
+    (hm : ∀ f : Sphere d × Sphere d → ℝ≥0∞, Measurable f → (∀ x, f x ≤ 1) →
+      Measurable (experiment K f)) : ModelAdmissible K ρ := by
+  intro π hπ
+  exact ⟨hc, fun f hf h1 => (hm f hf h1).aemeasurable⟩
+end Policy
+end MemoryPrecision.Kernel
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/KernelCaps.lean

@@ -0,0 +1,119 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.CubeExperiment
+import OAI.Probability.MemoryPrecision.KernelEvaluation
+import OAI.Probability.MemoryPrecision.SphereCaps
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision.Kernel
+open MemoryPrecision NoiselessRegression
+instance {d : ℕ} [NeZero d] : IsProbabilityMeasure (UniformSphere d) :=
+  (show IsProbabilityMeasure (NoiselessRegression.sphereLaw (E := Vector d)) from inferInstance)
+instance (d T : ℕ) : IsProbabilityMeasure (RowLaw d T) := by unfold RowLaw; infer_instance
+
+namespace Policy
+variable {d M T : ℕ} (K : Policy d M T)
+
+lemma chordTest_eq_cap (ε : ℝ) (s v : MemoryPrecision.Kernel.Sphere d) :
+    chordTest ε (s,v) = capWeight v.val ε s.val := by
+  classical
+  change (if dist v.val s.val ≤ ε then 1 else 0) =
+    (if dist s.val v.val ≤ ε then 1 else 0)
+  rw [dist_comm]
+
+lemma output_chord_sphere_local (hd : 1 ≤ d) {ε α : ℝ} (hε : 0 < ε)
+    (hα : 0 ≤ α) (hαn : α ≤ (d:ℝ)-1) (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
+    SphereBallBound (K.outputTest (chordTest ε) t j)
+      ((3*4^d:ℝ)*ε^((d:ℝ)-1-α)) α := by
+  have : NeZero d := ⟨by omega⟩
+  intro z r hr
+  change (∫⁻ s in {s : MemoryPrecision.Kernel.Sphere d | dist s.val z ≤ r},
+    ∫⁻ v, chordTest ε (s,v) ∂K.output t j ∂UniformSphere d) ≤ _
+  have hm : Measurable (Function.uncurry (fun s v : MemoryPrecision.Kernel.Sphere d => chordTest ε (s,v))) :=
+    measurable_chordTest ε
+  rw [lintegral_lintegral_swap hm.aemeasurable]
+  have hb (v : MemoryPrecision.Kernel.Sphere d) := sphere_cap_real_mass hd v.val hε hα hαn z r hr
+  simp_rw [chordTest_eq_cap]
+  exact (lintegral_mono hb).trans_eq (by simp)
+
+lemma output_chord_cube_local (hd : 2 ≤ d) {ε : ℝ} (hε : 0 < ε)
+    (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
+    CubeLocal (fun u => K.outputTest (chordTest ε) t j (CubeSphere hd u))
+      ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ)) := by
+  intro z r hr
+  change (∫⁻ u in CubeBall d z r, ∫⁻ v, chordTest ε (CubeSphere hd u,v)
+    ∂K.output t j ∂CubeLaw d) ≤ _
+  have hf : Measurable (Function.uncurry (fun (u : Cube d) (v : MemoryPrecision.Kernel.Sphere d) =>
+      chordTest ε (CubeSphere hd u,v))) :=
+    (measurable_chordTest ε).comp ((cubeSphere_measurable hd).comp measurable_fst |>.prodMk measurable_snd)
+  rw [lintegral_lintegral_swap hf.aemeasurable]
+  simp_rw [chordTest_eq_cap]
+  change (∫⁻ v : MemoryPrecision.Kernel.Sphere d, ∫⁻ u in CubeBall d z r,
+      capWeight v.val ε (CubeEmbedding d u) ∂CubeLaw d ∂K.output t j) ≤ _
+  have hb (v : MemoryPrecision.Kernel.Sphere d) := cube_cap_local hd v.val hε z r hr
+  exact (lintegral_mono hb).trans_eq (by simp)
+
+lemma output_chord_sphere_total (hd : 1 ≤ d) {ε : ℝ} (hε : 0 < ε)
+    (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
+    (∫⁻ s, K.outputTest (chordTest ε) t j s ∂UniformSphere d) ≤
+      ENNReal.ofReal ((3*4^d:ℝ)*ε^(d-1)) := by
+  have h := sphere_mass_bound (K.output_chord_sphere_local hd hε (α := 0) le_rfl (by
+    have hd' : (1:ℝ) ≤ d := by exact_mod_cast hd
+    linarith) t j)
+  have hn : ((d-1:ℕ):ℝ) = (d:ℝ)-1 := by rw [Nat.cast_sub hd, Nat.cast_one]
+  simpa only [UniformSphere, SpherePrior,sub_zero, ← hn, Real.rpow_natCast] using h
+
+lemma angleTest_le_chordTest (ε : ℝ) (x : MemoryPrecision.Kernel.Sphere d × MemoryPrecision.Kernel.Sphere d) :
+    angleTest ε x ≤ chordTest ε x := by
+  classical
+  by_cases ha : Real.arccos ⟪x.2.val,x.1.val⟫ ≤ ε
+  · have hc : dist x.2.val x.1.val ≤ ε := (chord_le_arccos x.2 x.1).trans ha
+    simp [angleTest, chordTest, ha, hc]
+  · simp [angleTest, ha]
+
+lemma eval_mono {X : Type*} {w v : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞}
+    (h : ∀ n j s, w n j s ≤ v n j s) (n k : ℕ) (j : MemoryPrecision.Kernel.State M)
+    (s : X) (obs : Observations d k) : K.eval w n k j s obs ≤ K.eval v n k j s obs := by
+  induction k generalizing n j with
+  | zero => exact h n j s
+  | succ k ih =>
+    apply Finset.sum_le_sum
+    intro a _
+    apply mul_le_mul' le_rfl
+    split
+    · exact h _ _ _
+    · exact ih _ _ _
+
+lemma pathValue_mono {X : Type*} {w v : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞}
+    (h : ∀ n j s, w n j s ≤ v n j s) (s : X) (obs : Observations d T) :
+    K.pathValue w s obs ≤ K.pathValue v s obs := by
+  apply Finset.sum_le_sum
+  intro a _
+  apply mul_le_mul' le_rfl
+  split
+  · exact h _ _ _
+  · exact K.eval_mono h _ _ _ _ _
+
+lemma success_le_chord {Ω : Type*} [MeasurableSpace Ω] (L : Ω → Policy d M T)
+    (ρ : Measure Ω) (π : Measure (MemoryPrecision.Kernel.Sphere d)) (�� : ℝ) :
+    Success L ρ π ε ≤ ChordSuccess L ρ π ε := by
+  apply lintegral_mono
+  intro z
+  exact (L z.2.1).pathValue_mono (fun n j s => lintegral_mono (fun v => angleTest_le_chordTest ε (s,v))) _ _
+end Policy
+end MemoryPrecision.Kernel
+
+
+end
+
+end OAI

lean/OAI/Probability/MemoryPrecision/KernelCube.lean

@@ -0,0 +1,124 @@
+import Mathlib
+import OAI.Probability.GaussianRegression.Main
+import OAI.Probability.MemoryPrecision.KernelCaps
+import OAI.Probability.MemoryPrecision.KernelIntegral
+import OAI.Probability.MemoryPrecision.KernelVersion
+import OAI.Probability.MemoryPrecision.SeedAverage
+import OAI.Probability.MemoryPrecision.StochasticMass
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+
+noncomputable section
+universe u v
+
+
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
+namespace MemoryPrecision.Kernel
+open MemoryPrecision NoiselessRegression
+
+def CubePrior {d : ℕ} (hd : 2 ≤ d) : Measure (MemoryPrecision.Kernel.Sphere d) :=
+  (CubeLaw d).map (CubeSphere hd)
+instance {d : ℕ} (hd : 2 ≤ d) : IsProbabilityMeasure (CubePrior hd) := by
+  unfold CubePrior
+  infer_instance
+
+lemma cubeSphere_preserving {d : ℕ} (hd : 2 ≤ d) :
+    MeasurePreserving (CubeSphere hd) (CubeLaw d) (CubePrior hd) :=
+  ⟨cubeSphere_measurable hd, rfl⟩
+
+namespace Policy
+variable {d M T : ℕ} (K : Policy d M T)
+
+lemma eval_comp {X Y : Type*} (w : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞) (ι : Y → X)
+    (n k : ℕ) (j : MemoryPrecision.Kernel.State M) (s : Y) (obs : Observations d k) :
+    K.eval w n k j (ι s) obs = K.eval (fun n j s => w n j (ι s)) n k j s obs := by
+  induction k generalizing n j with
+  | zero => rfl
+  | succ k ih =>
+    simp only [eval]
+    apply Finset.sum_congr rfl
+    intro a _
+    rw [ih]
+lemma pathValue_comp {X Y : Type*} (w : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞) (ι : Y → X)
+    (s : Y) (obs : Observations d T) :
+    K.pathValue w (ι s) obs = K.pathValue (fun n j s => w n j (ι s)) s obs := by
+  simp only [pathValue, K.eval_comp w ι]
+
+lemma borel_cube_bound (hK : K.Borel) (hd : 16 ≤ d) {ε : ℝ} (hε : 0 < ε) :
+    (∫⁻ z : Cube d × Rows d T,
+      K.pathValue (K.outputTest (chordTest ε)) (CubeSphere (d := d) (by omega) z.1)
+        (records (CubeSphere (d := d) (by omega) z.1) z.2)
+      ∂(CubeLaw d).prod (RowLaw d T)) ≤
+      (T+1:ℝ≥0∞)*ENNReal.ofReal ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) *
+        CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4)) := by
+  have hm₁ : Measurable (fun z : Cube d × Rows d T =>
+      (CubeSphere (d := d) (by omega) z.1,z.2)) :=
+    ((cubeSphere_measurable (d := d) (by omega)).comp measurable_fst).prodMk measurable_snd
+  have hm₀ := K.experiment_fixed_measurable (f := chordTest (d := d) ε) hK (measurable_chordTest ε)
+  have hm := hm₀.comp hm₁
+  have hprod := lintegral_prod (μ := CubeLaw d) (ν := RowLaw d T) _ hm.aemeasurable
+  simp only [Function.comp_apply] at hprod
+  rw [hprod]
+  simp_rw [K.pathValue_comp _ (CubeSphere (d := d) (by omega))]
+  apply K.integral_pathValue_bound (fun n j u => K.outputTest (chordTest ε) n j (CubeSphere (d := d) (by omega) u))
+    (CubeEmbedding d) hK
+    (fun n j => (K.outputTest_measurable (measurable_chordTest ε) n j).comp (cubeSphere_measurable (d := d) (by omega)))
+    (cubeEmbedding_measurable d) (CubeLaw d)
+  intro r hr j
+  apply cube_mass_bound
+  exact stoch_cube_mass hd (show 1 ≤ 2^M from one_le_pow₀ (by norm_num))
+    (K.marginal_measurable hK) (fun n j obs => (K.marginal_sum n j obs).le)
+    (fun n j => (K.outputTest_measurable (measurable_chordTest ε) n j).comp (cubeSphere_measurable (d := d) (by omega)))
+    (fun n j u => K.outputTest_le_one (chordTest_le_one ε) n j (CubeSphere (d := d) (by omega) u))
+    (by positivity) (K.output_chord_cube_local (by omega) hε)
+    (MemoryPrecision.BlockCount T ((d/2)/4)) r
+    (hr.trans (blockCount_mul_ge T (by omega))) 0 j
+
+lemma completed_cube_bound (hK : K.Completed) (hd : 16 ≤ d) {ε : ℝ} (hε : 0 < ε) :
+    (∫⁻ z : Cube d × Rows d T,
+      K.pathValue (K.outputTest (chordTest ε)) (CubeSphere (d := d) (by omega) z.1)
+        (records (CubeSphere (d := d) (by omega) z.1) z.2)
+      ∂(CubeLaw d).prod (RowLaw d T)) ≤
+      (T+1:ℝ≥0∞)*ENNReal.ofReal ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) *
+        CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4)) := by
+  have he := K.version_pathValue_ae ((CubeLaw d).prod (RowLaw d T)) hK
+    (fun z : Cube d × Rows d T => CubeSphere (d := d) (by omega) z.1)
+    (fun z : Cube d × Rows d T => records (CubeSphere (d := d) (by omega) z.1) z.2)
+    (fun i => show Measure.QuasiMeasurePreserving _ _ _ from cube_sample_observation_quasi hd i)
+    (chordTest ε)
+  rw [← lintegral_congr_ae he]
+  exact (K.version hK).borel_cube_bound (K.version_borel hK) hd hε
+
+lemma source_cube_chord_bound {Ω : Type u} [MeasurableSpace Ω] (L : Ω → Policy d M T)
+    (ρ : Measure Ω) [IsProbabilityMeasure ρ] (hd : 16 ≤ d)
+    (hL : Admissible L ρ (CubePrior (by omega))) {ε : ℝ} (hε : 0 < ε) :
+    ChordSuccess L ρ (CubePrior (by omega)) ε ≤
+      (T+1:ℝ≥0∞)*ENNReal.ofReal ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ) *
+        CubeStep d (2^M)^MemoryPrecision.BlockCount T ((d/2)/4)) := by
+  have hp := (cubeSphere_preserving (by omega : 2 ≤ d)).prod
+    (MeasurePreserving.id (ρ.prod (RowLaw d T)))
+  have hf := hL.experiment (chordTest ε) (measurable_chordTest ε) (chordTest_le_one ε)
+  have he : (∫⁻ z : Cube d × (Ω × Rows d T),
+      experiment L (chordTest ε) (CubeSphere (d := d) (by omega) z.1,z.2)
+      ∂(CubeLaw d).prod (ρ.prod (RowLaw d T))) = ChordSuccess L ρ (CubePrior (by omega)) ε := by
+    calc
+      _ = ∫⁻ z, experiment L (chordTest ε) z ∂((CubeLaw d).prod (ρ.prod (RowLaw d T))).map
+          (Prod.map (CubeSphere (d := d) (by omega)) id) :=
+        (lintegral_map' (by simpa only [hp.map_eq] using hf) hp.measurable.aemeasurable).symm
+      _ = _ := by rw [hp.map_eq]; rfl
+  rw [← he]
+  apply seed_average_bound (CubeLaw d) (RowLaw d T) ρ
+    (hf.comp_quasiMeasurePreserving hp.quasiMeasurePreserving)
+  filter_upwards [hL.completed] with ω hω
+  exact (L ω).completed_cube_bound hω hd hε
+end Policy
+end MemoryPrecision.Kernel
+
+
+end
+
+end OAI