Add lean source and binary files (part 18)

lean/OAI/Analysis/FiniteFactor/OrbitSampling/CompactTorus.lean

@@ -0,0 +1,52 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.WeakLimit
+import Mathlib.MeasureTheory.Constructions.Polish.Basic
+import Mathlib.Topology.Instances.AddCircle.Real
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+abbrev SourceSamplingTorus := (SourceCoordinate → UnitAddCircle) × (SourceCoordinate → UnitAddCircle)
+
+instance sourceSamplingTorus_compact : CompactSpace SourceSamplingTorus := inferInstance
+
+instance sourceSamplingTorus_borel : BorelSpace SourceSamplingTorus := Prod.borelSpace
+
+def sourceSamplingTorusMap (p : SourceSamplingPair) : SourceSamplingTorus :=
+  (fun i => (p.1 i : UnitAddCircle),fun i => (p.2 i : UnitAddCircle))
+
+theorem sourceSamplingTorusMap_continuous : Continuous sourceSamplingTorusMap := by
+  exact (continuous_pi (fun i => (AddCircle.continuous_mk' (1 : ℝ)).comp
+    ((continuous_apply i).comp continuous_fst))).prodMk
+    (continuous_pi (fun i => (AddCircle.continuous_mk' (1 : ℝ)).comp
+      ((continuous_apply i).comp continuous_snd)))
+
+def sourceSamplingUntrimmedTorus (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : FiniteMeasure SourceSamplingTorus :=
+  (sourceSamplingUntrimmedFinite I s θ).map sourceSamplingTorusMap
+
+def sourceSamplingLambdaTorus (I : Finset SourceCoordinate) : FiniteMeasure SourceSamplingTorus :=
+  (sourceSamplingLambdaFinite I).map sourceSamplingTorusMap
+
+theorem sourceSamplingUntrimmed_torus_event : ∀ᵐ θ ∂sourceAngleLaw,
+    ∀ I : Finset SourceCoordinate,
+      Tendsto (fun s => sourceSamplingUntrimmedTorus I s θ) atTop
+        (𝓝 (sourceSamplingLambdaTorus I)) ∧
+      ∀ f : C(SourceSamplingTorus,ℝ),
+        Tendsto (fun s => ∫ p, f p ∂(sourceSamplingUntrimmedTorus I s θ : Measure SourceSamplingTorus))
+          atTop (𝓝 (∫ p, f p ∂(sourceSamplingLambdaTorus I : Measure SourceSamplingTorus))) := by
+  filter_upwards [sourceSamplingUntrimmed_weak_event] with θ hθ
+  intro I
+  have h := FiniteMeasure.tendsto_map_of_tendsto_of_continuous _ _ (hθ I)
+    sourceSamplingTorusMap_continuous
+  refine ⟨h,fun f => ?_⟩
+  exact (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp h)
+    (BoundedContinuousFunction.mkOfCompact f)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/CrossProducts.lean

@@ -0,0 +1,98 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.ProductMoments
+import OAI.Analysis.FiniteFactor.OrbitSampling.SingleCorrelation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+/-- A global bound used only to justify finite-stage integrations. -/
+theorem sourceSamplingIdealDensity_bounds (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (x : SourceCoordinate → ℝ) :
+    0 ≤ sourceSamplingIdealDensity stage r b E G x ∧
+      sourceSamplingIdealDensity stage r b E G x ≤
+        (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card := by
+  have hp := sourceSampling_parameters stage
+  have hb (i : SourceCoordinate) := (sampling_kernel_mean unitIntervalMeasure
+    (samplingOrientedWeight r (b i) _ _ (E i) (G i))
+    (samplingOrientedWeight_measurable r (b i) _ _ (E i) (G i) (hE i) (hG i))
+    (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))
+    (samplingOrientedWeight_bounds r (b i) _ _ (E i) (G i) hp.1 hp.2.2)).2
+  refine ⟨prod_nonneg (fun i _ => (hb i (x i)).1),?_⟩
+  calc
+    _ ≤ ∏ _i ∈ sourceSamplingPrefix stage, max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)) :=
+      prod_le_prod₀ (fun i _ => (hb i (x i)).1) (fun i _ => (hb i (x i)).2)
+    _ = _ := by simp
+
+/-- Exact mixed factorization for q_n and the actual ideal density on the
+full countable Haar space. -/
+theorem sourceSamplingProduct_mixed_factorization (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n : ℤ) :
+    (∫ x, ∫ θ, sourceSamplingProduct stage r b E G n θ x * sourceSamplingIdealDensity stage r b E G x
+      ∂sourceAngleLaw ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) =
+    ∏ i ∈ sourceSamplingPrefix stage,
+      ∫ s, samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s *
+        (∫ θ, samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          (E i) (G i) s (Int.fract ((n : ℝ)*θ i)) ∂sourceAngleLaw) ∂unitIntervalMeasure := by
+  let u (i : SourceCoordinate) := samplingOrientedWeight r (b i) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (E i) (G i)
+  let a (i : SourceCoordinate) := samplingOrientedDensity r (b i) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (E i) (G i)
+  let F (i : SourceCoordinate) (s t : ℝ) := u i s (Int.fract ((n : ℝ)*t))*a i s
+  have hF (i : SourceCoordinate) : Measurable (fun p : ℝ × ℝ => F i p.1 p.2) := by
+    have hu := samplingOrientedWeight_measurable r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+      (E i) (G i) (hE i) (hG i)
+    have ha := samplingOrientedDensity_measurable r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+      (E i) (G i) (hE i) (hG i)
+    exact (hu.comp (measurable_fst.prodMk (sourceFract_measurable.comp (measurable_const.mul measurable_snd)))).mul
+      (ha.comp measurable_fst)
+  calc
+    _ = ∫ x, ∏ i ∈ sourceSamplingPrefix stage, ∫ t, F i (x i) t ∂sourceAngleMarginal i
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) := by
+      apply integral_congr_ae
+      filter_upwards [] with x
+      simp only [sourceSamplingProduct,sourceSamplingIdealDensity,← Finset.prod_mul_distrib]
+      exact integral_infinitePi_finset_prod _ _ _
+        (fun i => (hF i).comp (measurable_const.prodMk measurable_id))
+    _ = ∏ i ∈ sourceSamplingPrefix stage, ∫ s, ∫ t, F i s t ∂sourceAngleMarginal i ∂unitIntervalMeasure :=
+      integral_infinitePi_finset_prod _ _ _
+        (fun i => (hF i).stronglyMeasurable.integral_prod_right.measurable)
+    _ = _ := by
+      apply Finset.prod_congr rfl
+      intro i _
+      apply integral_congr_ae
+      filter_upwards [] with s
+      have hm : Measurable (fun t => F i s t) := (hF i).comp (measurable_const.prodMk measurable_id)
+      rw [← sourceAngleLaw_coordinate i,integral_map (measurable_pi_apply i).aemeasurable hm.aestronglyMeasurable]
+      dsimp [F,u,a]
+      rw [integral_mul_const,mul_comm]
+
+/-- Fubini is justified for every finite-stage pair of actual summands. -/
+theorem sourceSamplingProduct_pair_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n k : ℤ) :
+    Integrable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      sourceSamplingProduct stage r b E G n p.1 p.2*sourceSamplingProduct stage r b E G k p.1 p.2)
+      (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))) :=
+  sampling_bounded_product_integrable _ _ _
+    (sourceSamplingProduct_measurable stage r b E G hE hG n)
+    (sourceSamplingProduct_measurable stage r b E G hE hG k) _
+    (fun p => sourceSamplingProduct_bounds stage r b E G n p.1 p.2)
+    (fun p => sourceSamplingProduct_bounds stage r b E G k p.1 p.2)
+
+theorem sourceSamplingProduct_mixed_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n : ℤ) :
+    Integrable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      sourceSamplingProduct stage r b E G n p.1 p.2*sourceSamplingIdealDensity stage r b E G p.2)
+      (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))) :=
+  sampling_bounded_product_integrable _ _ _
+    (sourceSamplingProduct_measurable stage r b E G hE hG n)
+    ((sourceSamplingIdealDensity_measurable stage r b E G hE hG).comp measurable_snd) _
+    (fun p => sourceSamplingProduct_bounds stage r b E G n p.1 p.2)
+    (fun p => sourceSamplingIdealDensity_bounds stage r b E G hE hG p.2)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Cube.lean

@@ -0,0 +1,84 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.LambdaRectangles
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+abbrev SourceSamplingPair := (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)
+
+def sourceSamplingCube : Set SourceSamplingPair :=
+  {p | ∀ i, p.1 i ∈ Set.Icc (0 : ℝ) 1 ∧ p.2 i ∈ Set.Icc (0 : ℝ) 1}
+
+theorem sourceSamplingCube_measurable : MeasurableSet sourceSamplingCube := by
+  exact sourceSamplingRectangle_measurable _ _ (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+
+instance sourceSamplingUntrimmed_finite (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : IsFiniteMeasure (sourceSamplingUntrimmed I s θ) := by
+  constructor
+  unfold sourceSamplingUntrimmed
+  rw [Measure.smul_apply, smul_eq_mul]
+  exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top (measure_lt_top _ _)
+
+theorem sourceSamplingSummand_cube (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    ∀ᵐ p ∂sourceSamplingSummand I s θ n, p ∈ sourceSamplingCube := by
+  apply (ae_map_iff (measurable_id.prodMk (coordinateRotate_preserving θ n).measurable).aemeasurable
+    sourceSamplingCube_measurable).mpr
+  have hh : ∀ᵐ x ∂sourceSamplingWeightedMeasure I s θ n, ∀ i, x i ∈ Set.Ico (0 : ℝ) 1 :=
+    ae_iff.mpr (withDensity_absolutelyContinuous _ _ (ae_iff.mp sourceSamplingHaar_cube))
+  filter_upwards [hh] with x hx
+  intro i
+  exact ⟨⟨(hx i).1,(hx i).2.le⟩,Int.fract_nonneg _,(Int.fract_lt_one _).le⟩
+
+theorem sourceSamplingUntrimmed_cube (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) :
+    ∀ᵐ p ∂sourceSamplingUntrimmed I s θ, p ∈ sourceSamplingCube := by
+  apply Measure.ae_smul_measure
+  rw [ae_iff, Measure.finsetSum_apply]
+  apply Finset.sum_eq_zero
+  intro n hn
+  exact ae_iff.mp (sourceSamplingSummand_cube I s θ n)
+
+theorem sourceSamplingLambda_cube (I : Finset SourceCoordinate) :
+    ∀ᵐ p ∂sourceSamplingLambda I, p ∈ sourceSamplingCube := by
+  apply (ae_map_iff (sourceSamplingLimitMap_measurable I).aemeasurable
+    sourceSamplingCube_measurable).mpr
+  filter_upwards [ae_restrict_of_ae sourceSamplingPairHaar_cube] with p hp
+  intro i
+  refine ⟨⟨(hp i).1.1,(hp i).1.2.le⟩,?_⟩
+  by_cases hi : i ∈ I
+  · simpa [sourceSamplingLimitMap,hi] using And.intro (hp i).2.1 (hp i).2.2.le
+  · simpa [sourceSamplingLimitMap,hi] using And.intro (hp i).1.1 (hp i).1.2.le
+
+def sourceSamplingEmptyTest : SourceSamplingRationalTest := ⟨∅,fun _ => ((0,1),(0,1))⟩
+
+theorem sourceSamplingEmptyTest_rectangle :
+    sourceSamplingRectangle (sourceSamplingRationalX sourceSamplingEmptyTest)
+      (sourceSamplingRationalY sourceSamplingEmptyTest) = sourceSamplingCube := by
+  ext p
+  simp [sourceSamplingRectangle,sourceSamplingRationalX,sourceSamplingRationalY,
+    sourceSamplingRationalEndpoints,sourceSamplingEmptyTest,sourceSamplingCube]
+
+/-- The empty rational test gives actual total-mass convergence. -/
+theorem sourceSampling_mass_limit_event : ∀ᵐ θ ∂sourceAngleLaw,
+    ∀ I : Finset SourceCoordinate,
+      Tendsto (fun s => ((sourceSamplingUntrimmed I s θ) Set.univ).toReal)
+        atTop (𝓝 (((sourceSamplingLambda I) Set.univ).toReal)) := by
+  filter_upwards [sourceSamplingLambda_rectangle_limit_event] with θ hθ
+  intro I
+  have h := hθ I sourceSamplingEmptyTest
+  rw [sourceSamplingEmptyTest_rectangle] at h
+  have hu (s : ℕ) : sourceSamplingUntrimmed I s θ sourceSamplingCube =
+      sourceSamplingUntrimmed I s θ Set.univ :=
+    measure_congr (by filter_upwards [sourceSamplingUntrimmed_cube I s θ] with p hp; exact propext (iff_true_intro hp))
+  have hl : sourceSamplingLambda I sourceSamplingCube = sourceSamplingLambda I Set.univ :=
+    measure_congr (by filter_upwards [sourceSamplingLambda_cube I] with p hp; exact propext (iff_true_intro hp))
+  simpa only [hu,hl] using h
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/CutoffMass.lean

@@ -0,0 +1,92 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.DiagonalIntegral
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- Exact whole-circle first density, including the retained cutoff. -/
+theorem samplingTestedFirstDensity_whole (b : Bool) (h α s : ℝ)
+    (hh : 0 < h) (hh1 : h < 1) (hα : 0 < α) (hs : s ∈ Set.Ico (0 : ℝ) 1) :
+    samplingTestedFirstDensity b h α (Set.Icc 0 1) (Set.Icc 0 1) s =
+      if b then 1-s else if α ≤ samplingDistance s then 1 else 0 := by
+  have he : samplingTestedFirstDensity b h α (Set.Icc 0 1) (Set.Icc 0 1) s =
+      ∫ t, samplingWeight b h α s t ∂unitIntervalMeasure := by
+    apply integral_congr_ae
+    filter_upwards [] with t
+    have hs' : s ∈ Set.Icc (0 : ℝ) 1 := ⟨hs.1,hs.2.le⟩
+    have ht' : Int.fract (s+t) ∈ Set.Icc (0 : ℝ) 1 := ⟨Int.fract_nonneg _,(Int.fract_lt_one _).le⟩
+    simp only [samplingTestedFirstWeight,hs',ht',and_self,ite_true]
+  exact he.trans (samplingWeight_first_integral b h α s hh hh1 hα hs)
+
+/-- The exact lost mass of one untested diagonal coordinate is 2α. -/
+theorem sampling_diagonal_whole_mass (h α : ℝ)
+    (hh : 0 < h) (hh1 : h < 1) (hα : 0 < α) (hα1 : α ≤ 1/2) :
+    (∫ s, samplingTestedFirstDensity false h α (Set.Icc 0 1) (Set.Icc 0 1) s ∂unitIntervalMeasure) = 1-2*α := by
+  have he : samplingTestedFirstDensity false h α (Set.Icc 0 1) (Set.Icc 0 1) =ᵐ[unitIntervalMeasure]
+      (Set.Icc α (1-α)).indicator (fun _ => (1 : ℝ)) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with s hs
+    rw [samplingTestedFirstDensity_whole false h α s hh hh1 hα hs]
+    have hc : α ≤ samplingDistance s ↔ s ∈ Set.Icc α (1-α) := by
+      simp only [samplingDistance,le_min_iff,Set.mem_Icc]
+      constructor <;> intro h <;> constructor <;> linarith [h.1,h.2]
+    simp only [Bool.false_eq_true,ite_false,hc,Set.indicator_apply]
+  rw [integral_congr_ae he,integral_indicator measurableSet_Icc,integral_const]
+  have hsub : Set.Icc α (1-α) ⊆ Set.Ico (0 : ℝ) 1 := by
+    intro s hs
+    exact ⟨hα.le.trans hs.1,hs.2.trans_lt (by linarith)⟩
+  simp only [measureReal_def,Measure.restrict_apply MeasurableSet.univ,Set.univ_inter,
+    smul_eq_mul,mul_one]
+  unfold unitIntervalMeasure
+  rw [Measure.restrict_apply measurableSet_Icc,Set.inter_eq_left.mpr hsub,Real.volume_Icc,
+    ENNReal.toReal_ofReal (by linarith)]
+  ring
+
+/-- The total cutoff budget tends to zero despite the growing dimension. -/
+theorem sourceSampling_cutoff_budget_tendsto :
+    Tendsto (fun stage => 2*((sourceSamplingPrefix stage).card : ℝ)*sourceSamplingCutoff stage)
+      atTop (𝓝 0) := by
+  have ht : Tendsto (fun stage => (101/50 : ℝ)*(sourceBlockSize stage : ℝ)⁻¹) atTop (𝓝 0) := by
+    simpa using (tendsto_inv_atTop_zero.comp
+      (tendsto_natCast_atTop_atTop.comp sourceBlockSize_tendsto)).const_mul (101/50 : ℝ)
+  apply squeeze_zero (fun stage => by have := (sourceSampling_parameters stage).2.2; positivity) _ ht
+  intro stage
+  have hm := sourceBlockSize_pos stage
+  calc
+    _ ≤ 2*((101/100 : ℝ)*sourceBlockSize stage)*sourceSamplingCutoff stage := by
+      exact mul_le_mul_of_nonneg_right
+        (mul_le_mul_of_nonneg_left (sourceSamplingPrefix_card_bound stage) (by norm_num))
+        (sourceSampling_parameters stage).2.2.le
+    _ = (101/50 : ℝ)*(sourceBlockSize stage : ℝ)⁻¹ := by
+      simp only [sourceSamplingCutoff,Real.rpow_neg hm.le,Real.rpow_two]
+      field_simp
+      ring
+
+/-- Any subset of untested coordinates retains asymptotically all its mass.
+The estimate uses its actual varying cardinality, bounded by the prefix. -/
+theorem sourceSampling_untested_mass_tendsto (k : ℕ → ℕ)
+    (hk : ∀ stage, k stage ≤ (sourceSamplingPrefix stage).card) :
+    Tendsto (fun stage => (1-2*sourceSamplingCutoff stage)^(k stage)) atTop (𝓝 1) := by
+  have he : ∀ stage, |(1-2*sourceSamplingCutoff stage)^(k stage)-1| ≤
+      2*((sourceSamplingPrefix stage).card : ℝ)*sourceSamplingCutoff stage := by
+    intro stage
+    have hα := (sourceSampling_parameters stage).2.2
+    have hα1 := sourceSamplingCutoff_le_half stage
+    have hlo : 0 ≤ 1-2*sourceSamplingCutoff stage := by linarith
+    have hup : (1-2*sourceSamplingCutoff stage)^(k stage) ≤ 1 := pow_le_one₀ hlo (by linarith)
+    have hb := one_add_mul_le_pow (show (-2 : ℝ) ≤ -(2*sourceSamplingCutoff stage) by linarith) (k stage)
+    have hk' : (k stage : ℝ) ≤ (sourceSamplingPrefix stage).card := by exact_mod_cast hk stage
+    rw [abs_of_nonpos (by linarith)]
+    have hm := mul_le_mul_of_nonneg_right hk' (show 0 ≤ 2*sourceSamplingCutoff stage by positivity)
+    simp only [mul_neg,← sub_eq_add_neg] at hb
+    nlinarith
+  apply tendsto_iff_norm_sub_tendsto_zero.mpr
+  simp only [Real.norm_eq_abs]
+  exact squeeze_zero (fun stage => abs_nonneg _) he sourceSampling_cutoff_budget_tendsto
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/CylinderBasis.lean

@@ -0,0 +1,63 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.CylinderSystem
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+theorem rational_Icc_nhds {x : ℝ} {u : Set ℝ} (hu : u ∈ 𝓝 x) :
+    ∃ a b : ℚ, Set.Icc (a : ℝ) b ∈ 𝓝 x ∧ Set.Icc (a : ℝ) b ⊆ u := by
+  obtain ⟨l,r,hlr,hsub⟩ := mem_nhds_iff_exists_Ioo_subset.mp hu
+  obtain ⟨a,hla,hax⟩ := exists_rat_btwn hlr.1
+  obtain ⟨b,hxb,hbr⟩ := exists_rat_btwn hlr.2
+  exact ⟨a,b,Icc_mem_nhds hax hxb,fun y hy => hsub ⟨hla.trans_le hy.1,hy.2.trans_lt hbr⟩⟩
+
+/-- The finite rational cylinders contain arbitrarily small neighborhoods
+in the full real product, including points outside the unit cube. -/
+theorem sourceSamplingCylinder_basis (u : Set SourceSamplingPair) (hu : IsOpen u)
+    (p : SourceSamplingPair) (hp : p ∈ u) :
+    ∃ s ∈ Set.range sourceSamplingCylinder, s ∈ 𝓝 p ∧ s ⊆ u := by
+  obtain ⟨ux,hux,uy,huy,hxy⟩ := mem_nhds_prod_iff.mp (hu.mem_nhds hp)
+  rw [nhds_pi,Filter.mem_pi'] at hux huy
+  obtain ⟨Kx,tx,htx,hsubx⟩ := hux
+  obtain ⟨Ky,ty,hty,hsuby⟩ := huy
+  choose ax bx hnx hsx using fun i => rational_Icc_nhds (htx i)
+  choose ay by' hny hsy using fun i => rational_Icc_nhds (hty i)
+  let T : SourceSamplingRationalTest := ⟨Kx ∪ Ky,fun i => ((ax i,bx i),(ay i,by' i))⟩
+  have hTx (i : SourceCoordinate) (hi : i ∈ T.1) :
+      sourceSamplingRationalX T i = Set.Icc (ax i : ℝ) (bx i) := by
+    simp [sourceSamplingRationalX,sourceSamplingRationalEndpoints,hi,T]
+  have hTy (i : SourceCoordinate) (hi : i ∈ T.1) :
+      sourceSamplingRationalY T i = Set.Icc (ay i : ℝ) (by' i) := by
+    simp [sourceSamplingRationalY,sourceSamplingRationalEndpoints,hi,T]
+  refine ⟨sourceSamplingCylinder T,⟨T,rfl⟩,?_,?_⟩
+  · have he : sourceSamplingCylinder T = ⋂ i ∈ T.1,
+        {q : SourceSamplingPair | q.1 i ∈ sourceSamplingRationalX T i ∧
+          q.2 i ∈ sourceSamplingRationalY T i} := by ext q; simp [sourceSamplingCylinder]
+    rw [he]
+    apply (Filter.biInter_mem (Set.toFinite (T.1 : Set SourceCoordinate))).mpr
+    intro i hi
+    have hx := ((continuous_apply i).comp continuous_fst).continuousAt (hnx i)
+    have hy := ((continuous_apply i).comp continuous_snd).continuousAt (hny i)
+    change {q : SourceSamplingPair | q.1 i ∈ Set.Icc (ax i : ℝ) (bx i)} ∈ 𝓝 p at hx
+    change {q : SourceSamplingPair | q.2 i ∈ Set.Icc (ay i : ℝ) (by' i)} ∈ 𝓝 p at hy
+    filter_upwards [hx,hy] with q hq1 hq2
+    exact ⟨by simpa only [hTx i hi] using hq1,by simpa only [hTy i hi] using hq2⟩
+  · intro q hq
+    apply hxy
+    constructor
+    · apply hsubx
+      intro i hi
+      have hmem : i ∈ T.1 := Finset.mem_union_left _ hi
+      exact hsx i (by simpa only [hTx i hmem] using (hq i hmem).1)
+    · apply hsuby
+      intro i hi
+      have hmem : i ∈ T.1 := Finset.mem_union_right _ hi
+      exact hsy i (by simpa only [hTy i hmem] using (hq i hmem).2)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/CylinderSystem.lean

@@ -0,0 +1,75 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Cube
+import Mathlib.Topology.Instances.Rat
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- Finite cylinders in the full real product: coordinates outside the
+finite support are unrestricted. On the conull cube these are the original
+rational tests. The ambient real product is not asserted to be compact. -/
+def sourceSamplingCylinder (T : SourceSamplingRationalTest) : Set SourceSamplingPair :=
+  {p | ∀ i ∈ T.1, p.1 i ∈ sourceSamplingRationalX T i ∧ p.2 i ∈ sourceSamplingRationalY T i}
+
+theorem sourceSamplingCylinder_measurable (T : SourceSamplingRationalTest) :
+    MeasurableSet (sourceSamplingCylinder T) := by
+  simp only [sourceSamplingCylinder,Set.ofPred_forall]
+  exact MeasurableSet.iInter (fun i => MeasurableSet.iInter (fun _ =>
+    (measurableSet_Icc.preimage ((measurable_pi_apply i).comp measurable_fst)).inter
+    (measurableSet_Icc.preimage ((measurable_pi_apply i).comp measurable_snd))))
+
+theorem sourceSamplingCylinder_on_cube (T : SourceSamplingRationalTest) (p : SourceSamplingPair)
+    (hp : p ∈ sourceSamplingCube) :
+    p ∈ sourceSamplingCylinder T ↔
+    p ∈ sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T) := by
+  constructor
+  · intro h i
+    by_cases hi : i ∈ T.1
+    · exact h i hi
+    · simpa [sourceSamplingRationalX,sourceSamplingRationalY,sourceSamplingRationalEndpoints,hi]
+        using hp i
+  · intro h i _
+    exact h i
+
+def sourceSamplingTestMeet (T U : SourceSamplingRationalTest) : SourceSamplingRationalTest :=
+  ⟨T.1 ∪ U.1,fun i =>
+    if i.1 ∈ T.1 then
+      if i.1 ∈ U.1 then
+        ((max (sourceSamplingRationalEndpoints T i).1.1 (sourceSamplingRationalEndpoints U i).1.1,
+          min (sourceSamplingRationalEndpoints T i).1.2 (sourceSamplingRationalEndpoints U i).1.2),
+         (max (sourceSamplingRationalEndpoints T i).2.1 (sourceSamplingRationalEndpoints U i).2.1,
+          min (sourceSamplingRationalEndpoints T i).2.2 (sourceSamplingRationalEndpoints U i).2.2))
+      else sourceSamplingRationalEndpoints T i
+    else sourceSamplingRationalEndpoints U i⟩
+
+theorem sourceSamplingCylinder_inter (T U : SourceSamplingRationalTest) :
+    sourceSamplingCylinder (sourceSamplingTestMeet T U) =
+      sourceSamplingCylinder T ∩ sourceSamplingCylinder U := by
+  have hcoord (p : SourceSamplingPair) (i : SourceCoordinate) :
+      (i ∈ T.1 ∪ U.1 → p.1 i ∈ sourceSamplingRationalX (sourceSamplingTestMeet T U) i ∧
+        p.2 i ∈ sourceSamplingRationalY (sourceSamplingTestMeet T U) i) ↔
+      (i ∈ T.1 → p.1 i ∈ sourceSamplingRationalX T i ∧ p.2 i ∈ sourceSamplingRationalY T i) ∧
+      (i ∈ U.1 → p.1 i ∈ sourceSamplingRationalX U i ∧ p.2 i ∈ sourceSamplingRationalY U i) := by
+    by_cases ht : i ∈ T.1 <;> by_cases hu : i ∈ U.1 <;>
+      simp [sourceSamplingRationalX,sourceSamplingRationalY,sourceSamplingRationalEndpoints,
+        sourceSamplingTestMeet,ht,hu,Set.mem_Icc]
+    tauto
+  ext p
+  change (∀ i, i ∈ T.1 ∪ U.1 → _) ↔ (∀ i, i ∈ T.1 → _) ∧ (∀ i, i ∈ U.1 → _)
+  constructor
+  · intro h
+    exact ⟨fun i => ((hcoord p i).mp (h i)).1,fun i => ((hcoord p i).mp (h i)).2⟩
+  · rintro ⟨hT,hU⟩ i
+    exact (hcoord p i).mpr ⟨hT i,hU i⟩
+
+theorem sourceSamplingCylinder_piSystem : IsPiSystem (Set.range sourceSamplingCylinder) := by
+  rintro _ ⟨T,rfl⟩ _ ⟨U,rfl⟩ _
+  exact ⟨sourceSamplingTestMeet T U,sourceSamplingCylinder_inter T U⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/DiagonalContribution.lean

@@ -0,0 +1,69 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.SelfSummability
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+/-- The self-pair part of the empirical squared norm, with its actual P^-2 weight. -/
+def sourceSamplingDiagonalContribution (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ : SourceCoordinate → ℝ) : ℝ :=
+  (∑ n ∈ sourceSamplingPowers stage,
+    ∫ x, sourceSamplingProduct stage r b E G n θ x ^ 2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) / ((sourceSamplingPowers stage).card : ℝ)^2
+
+theorem sourceSamplingDiagonalContribution_nonneg (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ : SourceCoordinate → ℝ) :
+    0 ≤ sourceSamplingDiagonalContribution stage r b E G θ :=
+  div_nonneg (sum_nonneg (fun _ _ => integral_nonneg (fun _ => sq_nonneg _))) (sq_nonneg _)
+
+theorem sourceSamplingProduct_square_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n : ℤ) :
+    Integrable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      sourceSamplingProduct stage r b E G n p.1 p.2 ^ 2)
+      (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))) :=
+  sampling_square_integrable _ _
+    ((max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card)
+    (sourceSamplingProduct_measurable stage r b E G hE hG n)
+    (fun p => sourceSamplingProduct_bounds stage r b E G n p.1 p.2)
+
+theorem sourceSamplingDiagonalContribution_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Integrable (sourceSamplingDiagonalContribution stage r b E G) sourceAngleLaw := by
+  apply Integrable.div_const
+  exact integrable_finsetSum _ (fun n _ =>
+    (sourceSamplingProduct_square_integrable stage r b E G hE hG n).integral_prod_left)
+
+/-- The diagonal contribution's expectation is bounded by the proved
+summable budget; the finite set is the actual deterministic sample set. -/
+theorem sourceSamplingDiagonalContribution_expectation (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (r : Bool) (b : SourceCoordinate → Bool) (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    (∫ θ, sourceSamplingDiagonalContribution stage r b E G θ ∂sourceAngleLaw) ≤ sourceSamplingSelfBudget stage := by
+  have hP : (0 : ℝ) < (sourceSamplingPowers stage).card :=
+    (Real.rpow_pos_of_pos (sourceBlockSize_pos stage) _).trans_le (sourceSamplingPowers_spec stage hs).2.1
+  unfold sourceSamplingDiagonalContribution
+  rw [integral_div,integral_finsetSum _ (fun n _ =>
+    (sourceSamplingProduct_square_integrable stage r b E G hE hG n).integral_prod_left)]
+  have hsum := Finset.sum_le_sum (fun n hn => sourceSamplingProduct_self_moment stage hs r b E G hE hG n hn)
+  simp only [Finset.sum_const,nsmul_eq_mul] at hsum
+  calc
+    _ ≤ ((sourceSamplingPowers stage).card : ℝ)*
+        (2+8*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ))^(sourceSamplingPrefix stage).card /
+        ((sourceSamplingPowers stage).card : ℝ)^2 := div_le_div_of_nonneg_right hsum (sq_nonneg _)
+    _ = _ := by unfold sourceSamplingSelfBudget; field_simp
+
+/-- Actual self-pair expectations are summable across the constructed stages. -/
+theorem sourceSamplingDiagonalContribution_summable_integral (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Summable (fun stage => ∫ θ, sourceSamplingDiagonalContribution stage r b E G θ ∂sourceAngleLaw) := by
+  apply sourceSamplingSelfBudget_summable.of_norm_bounded_eventually_nat
+  filter_upwards [sourceBlockSize_tendsto.eventually (eventually_ge_atTop 200000)] with stage hs
+  rw [Real.norm_eq_abs,abs_of_nonneg (integral_nonneg (sourceSamplingDiagonalContribution_nonneg stage r b E G))]
+  exact sourceSamplingDiagonalContribution_expectation stage hs r b E G hE hG
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/DiagonalEvent.lean

@@ -0,0 +1,65 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.DiagonalContribution
+import Mathlib.MeasureTheory.Integral.Lebesgue.Markov
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped ENNReal Topology
+noncomputable section
+
+/-- Tonelli converts summable expectations of nonnegative functions into
+pointwise summability on a conull event. -/
+theorem sampling_ae_summable_of_integrals {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) (f : ℕ → Ω → ℝ) (hm : ∀ n, Measurable (f n))
+    (hi : ∀ n, Integrable (f n) μ) (hn : ∀ n x, 0 ≤ f n x)
+    (hs : Summable (fun n => ∫ x, f n x ∂μ)) :
+    ∀ᵐ x ∂μ, Summable (fun n => f n x) := by
+  have he (n : ℕ) : (∫⁻ x, ENNReal.ofReal (f n x) ∂μ) = ENNReal.ofReal (∫ x, f n x ∂μ) :=
+    (ofReal_integral_eq_lintegral_ofReal (hi n) (Eventually.of_forall (hn n))).symm
+  have hfin : (∫⁻ x, ∑' n, ENNReal.ofReal (f n x) ∂μ) ≠ ∞ := by
+    rw [lintegral_tsum (fun n => (hm n).ennreal_ofReal.aemeasurable)]
+    simp_rw [he]
+    exact hs.tsum_ofReal_ne_top
+  have hm' : Measurable (fun x => ∑' n, ENNReal.ofReal (f n x)) :=
+    Measurable.tsum (fun n => (hm n).ennreal_ofReal)
+  filter_upwards [ae_lt_top hm' hfin] with x hx
+  exact (ENNReal.summable_toReal hx.ne).congr (fun n => ENNReal.toReal_ofReal (hn n x))
+
+theorem sourceSamplingDiagonalContribution_measurable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Measurable (sourceSamplingDiagonalContribution stage r b E G) := by
+  apply Measurable.div_const
+  apply Finset.measurable_sum
+  intro n _
+  exact ((sourceSamplingProduct_measurable stage r b E G hE hG n).pow_const 2).stronglyMeasurable.integral_prod_right.measurable
+
+/-- A genuine conull conclusion for the actual diagonal contribution.
+This does not assert convergence of the full empirical sampling error. -/
+theorem sourceSamplingDiagonalContribution_ae (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    ∀ᵐ θ ∂sourceAngleLaw,
+      Summable (fun stage => sourceSamplingDiagonalContribution stage r b E G θ) ∧
+      Tendsto (fun stage => sourceSamplingDiagonalContribution stage r b E G θ) atTop (𝓝 0) := by
+  have ha := sampling_ae_summable_of_integrals sourceAngleLaw
+    (fun stage θ => sourceSamplingDiagonalContribution stage r b E G θ)
+    (fun stage => sourceSamplingDiagonalContribution_measurable stage r b E G hE hG)
+    (fun stage => sourceSamplingDiagonalContribution_integrable stage r b E G hE hG)
+    (fun stage θ => sourceSamplingDiagonalContribution_nonneg stage r b E G θ)
+    (sourceSamplingDiagonalContribution_summable_integral r b E G hE hG)
+  exact ha.mono (fun θ hθ => ⟨hθ,hθ.tendsto_atTop_zero⟩)
+
+/-- One conull event handles every member of any countable family of source
+tests, orientations and triangular-coordinate choices for the diagonal term. -/
+theorem sourceSamplingDiagonalContribution_countable_event {ι : Type*} [Countable ι]
+    (r : ι → Bool) (b : ι → SourceCoordinate → Bool) (E G : ι → SourceCoordinate → Set ℝ)
+    (hE : ∀ j i, MeasurableSet (E j i)) (hG : ∀ j i, MeasurableSet (G j i)) :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ j,
+      Summable (fun stage => sourceSamplingDiagonalContribution stage (r j) (b j) (E j) (G j) θ) ∧
+      Tendsto (fun stage => sourceSamplingDiagonalContribution stage (r j) (b j) (E j) (G j) θ) atTop (𝓝 0) :=
+  (ae_all_iff).mpr (fun j => sourceSamplingDiagonalContribution_ae (r j) (b j) (E j) (G j) (hE j) (hG j))
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/DiagonalIntegral.lean

@@ -0,0 +1,59 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.DiagonalLimit
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- The actual one-coordinate diagonal model converges to uniform diagonal
+mass on every measurable first test and closed-interval second test. -/
+theorem sourceSampling_diagonal_integral_tendsto (E : Set ℝ) (hE : MeasurableSet E) (a c : ℝ) :
+    Tendsto (fun stage => ∫ s,
+      samplingTestedFirstDensity false (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c) s ∂unitIntervalMeasure)
+      atTop (𝓝 ((unitIntervalMeasure (E ∩ Set.Icc a c)).toReal)) := by
+  have : NullSingletonClass unitIntervalMeasure := by unfold unitIntervalMeasure; infer_instance
+  let f : ℝ → ℝ := (E ∩ Set.Icc a c).indicator (fun _ => 1)
+  have hlim : ∀ᵐ s ∂unitIntervalMeasure,
+      Tendsto (fun stage => samplingTestedFirstDensity false
+        (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E (Set.Icc a c) s)
+        atTop (𝓝 (f s)) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ico,unitIntervalMeasure.ae_ne 0,
+      unitIntervalMeasure.ae_ne a,unitIntervalMeasure.ae_ne c] with s hs hs0 hsa hsc
+    have hh := sourceSampling_diagonal_eventually s a c E ⟨lt_of_le_of_ne hs.1 (Ne.symm hs0),hs.2⟩ hsa hsc
+    have he : (fun stage => samplingTestedFirstDensity false (sourceSamplingWidth stage)
+        (sourceSamplingCutoff stage) E (Set.Icc a c) s) =ᶠ[atTop] (fun _ => f s) := by
+      filter_upwards [hh] with stage hstage
+      simpa only [f,Set.indicator_apply,Set.mem_inter_iff] using hstage
+    exact tendsto_const_nhds.congr' he.symm
+  have hm (stage : ℕ) : AEStronglyMeasurable
+      (samplingTestedFirstDensity false (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c)) unitIntervalMeasure := (samplingTestedFirstDensity_measurable false
+    (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E (Set.Icc a c) hE measurableSet_Icc).aestronglyMeasurable
+  have hb (stage : ℕ) : ∀ᵐ s ∂unitIntervalMeasure,
+      ‖samplingTestedFirstDensity false (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c) s‖ ≤ (1 : ℝ) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with s hs
+    have hp := sourceSampling_parameters stage
+    have h := samplingTestedFirstDensity_bounds false _ _ E (Set.Icc a c)
+      hp.1 hp.2.1 hp.2.2 hE measurableSet_Icc s hs
+    rw [Real.norm_eq_abs,abs_of_nonneg h.1]
+    exact h.2
+  have ht := tendsto_integral_of_dominated_convergence (fun _ : ℝ => (1 : ℝ)) hm (integrable_const 1) hb hlim
+  have hf : (∫ s, f s ∂unitIntervalMeasure) = (unitIntervalMeasure (E ∩ Set.Icc a c)).toReal := by
+    rw [integral_indicator (hE.inter measurableSet_Icc)]
+    simp [measureReal_def]
+  rwa [hf] at ht
+
+/-- Triangular tested factors are independent of the sampling width and cutoff. -/
+theorem samplingTestedFirstDensity_triangular_parameters (h α h' α' s : ℝ) (E G : Set ℝ) :
+    samplingTestedFirstDensity true h α E G s = samplingTestedFirstDensity true h' α' E G s := by
+  unfold samplingTestedFirstDensity samplingTestedFirstWeight samplingWeight
+  simp only [ite_true]
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/DiagonalLimit.lean

@@ -0,0 +1,94 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.RationalTests
+import Mathlib.MeasureTheory.Integral.DominatedConvergence
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+theorem sourceSamplingWidth_tendsto : Tendsto sourceSamplingWidth atTop (𝓝 0) := by
+  have hh := (tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 3/5)).comp
+    (tendsto_natCast_atTop_atTop.comp sourceBlockSize_tendsto)
+  convert hh using 1
+  funext stage
+  simp only [sourceSamplingWidth,Function.comp_apply]
+  congr 1; norm_num
+
+theorem sourceSamplingCutoff_tendsto : Tendsto sourceSamplingCutoff atTop (𝓝 0) := by
+  have hh := (tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 2)).comp
+    (tendsto_natCast_atTop_atTop.comp sourceBlockSize_tendsto)
+  exact hh
+
+theorem sampling_interval_small_displacement (s a c t : ℝ)
+    (_ha : s ≠ a) (hc : s ≠ c) (ht : 0 ≤ t)
+    (hta : t < |s-a|) (htc : t < |s-c|) :
+    s+t ∈ Set.Icc a c ↔ s ∈ Set.Icc a c := by
+  have hleft : a ≤ s+t ↔ a ≤ s := by
+    by_cases h : a ≤ s
+    · constructor
+      · exact fun _ => h
+      · intro _; linarith
+    · rw [abs_of_neg (by linarith : s-a < 0)] at hta
+      constructor <;> intro hh <;> linarith
+  have hright : s+t ≤ c ↔ s ≤ c := by
+    by_cases h : s ≤ c
+    · have hsc : s < c := lt_of_le_of_ne h hc
+      rw [abs_of_neg (by linarith : s-c < 0)] at htc
+      constructor <;> intro hh <;> linarith
+    · constructor <;> intro hh <;> linarith
+  exact and_congr hleft hright
+
+/-- Away from the interval endpoints, a sufficiently short retained diagonal
+step has exactly the same interval test as its starting coordinate. -/
+theorem samplingTestedFirstDensity_diagonal_exact (h α s a c : ℝ) (E : Set ℝ)
+    (hh : 0 < h) (hh1 : h < 1) (hα : 0 < α)
+    (hs : s ∈ Set.Ico (0 : ℝ) 1) (hcut : α ≤ samplingDistance s)
+    (ha : s ≠ a) (hc : s ≠ c) (hha : h < |s-a|) (hhc : h < |s-c|) :
+    samplingTestedFirstDensity false h α E (Set.Icc a c) s =
+      if s ∈ E ∧ s ∈ Set.Icc a c then 1 else 0 := by
+  have he (t : ℝ) : samplingTestedFirstWeight false h α E (Set.Icc a c) s t =
+      if s ∈ E ∧ s ∈ Set.Icc a c then samplingWeight false h α s t else 0 := by
+    by_cases hw : samplingWeight false h α s t = 0
+    · simp [samplingTestedFirstWeight,hw]
+    · have ho := samplingWeight_orders false h α s t hh hh1 hα hs hw
+      have hsp : 0 < t ∧ t < h*samplingDistance s := by
+        unfold samplingWeight at hw
+        simp only [Bool.false_eq_true,ite_false] at hw
+        split_ifs at hw with hcond
+        · exact hcond.2
+        · exact False.elim (hw rfl)
+      have hd : samplingDistance s ≤ 1 := (min_le_right s (1-s)).trans (by linarith [hs.1])
+      have hth : t < h := hsp.2.trans_le (by nlinarith)
+      have hmem := sampling_interval_small_displacement s a c t ha hc hsp.1.le
+        (hth.trans hha) (hth.trans hhc)
+      simp only [samplingTestedFirstWeight,ho.1,hmem]
+  unfold samplingTestedFirstDensity
+  simp_rw [he]
+  by_cases htest : s ∈ E ∧ s ∈ Set.Icc a c
+  · simp only [ite_eq_left htest]
+    simpa only [Bool.false_eq_true,ite_false,ite_eq_left hcut] using
+      samplingWeight_first_integral false h α s hh hh1 hα hs
+  · simp only [ite_eq_right htest,integral_zero]
+
+/-- At each interior starting point away from the two tested endpoints, the
+actual diagonal density eventually equals the uniform diagonal test. -/
+theorem sourceSampling_diagonal_eventually (s a c : ℝ) (E : Set ℝ)
+    (hs : s ∈ Set.Ioo (0 : ℝ) 1) (ha : s ≠ a) (hc : s ≠ c) :
+    ∀ᶠ stage in atTop,
+      samplingTestedFirstDensity false (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c) s = if s ∈ E ∧ s ∈ Set.Icc a c then 1 else 0 := by
+  have hd : 0 < samplingDistance s := lt_min hs.1 (by linarith [hs.2])
+  have hcut := sourceSamplingCutoff_tendsto.eventually (gt_mem_nhds hd)
+  have hwa := sourceSamplingWidth_tendsto.eventually (gt_mem_nhds (abs_pos.mpr (sub_ne_zero.mpr ha)))
+  have hwc := sourceSamplingWidth_tendsto.eventually (gt_mem_nhds (abs_pos.mpr (sub_ne_zero.mpr hc)))
+  filter_upwards [hcut,hwa,hwc] with stage hcut hwa hwc
+  have hp := sourceSampling_parameters stage
+  exact samplingTestedFirstDensity_diagonal_exact _ _ s a c E hp.1 hp.2.1 hp.2.2
+    ⟨hs.1.le,hs.2⟩ hcut.le ha hc hwa hwc
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Discrepancy.lean

@@ -0,0 +1,111 @@
+import OAI.Analysis.FiniteFactor.Sampling.Rectangle
+import OAI.Analysis.FiniteFactor.OrbitSampling.Fourier
+import OAI.Analysis.FiniteFactor.Sampling.Periodization
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Finset Filter
+open scoped ENNReal Topology
+noncomputable section
+
+/-- Every constructed power is long enough for density at most two on
+every coordinate in the sampling prefix. -/
+theorem sourceSampling_phase_length (s : ℕ) (hs : 200000 ≤ sourceBlockSize s)
+    (i : SourceCoordinate) (hi : i.1 ≤ s) (n : ℤ) (hn : n ∈ sourceSamplingPowers s) :
+    1 ≤ (n : ℝ)*sourceAngleUnit i := by
+  have hm : (200000 : ℝ) ≤ sourceBlockSize s := by exact_mod_cast hs
+  have hm0 := sourceBlockSize_pos s
+  have hspec := (sourceSamplingPowers_spec s hs).1 n hn
+  have hQ : (sourceBlockSize s : ℝ)^3 ≤ samplingQ (sourceBlockSize s) := by
+    unfold samplingQ
+    rw [← Real.rpow_natCast]
+    exact Real.rpow_le_rpow_of_exponent_le (by linarith) (by norm_num; linarith)
+  have hN : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤ (sourceBlockSize s : ℝ)^2 := by
+    have hh : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤
+        (sourceBlockSize s : ℝ)*(sourceStageState s).K := by exact_mod_cast sourceFrequencyScale_monotone hi
+    have hK : ((sourceStageState s).K : ℝ) ≤ sourceBlockSize s := by exact_mod_cast (sourceStage s).m_ge_K
+    nlinarith
+  have hnp : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤ (n : ℝ) := by
+    nlinarith [hspec.1,sq_nonneg (sourceBlockSize s : ℝ)]
+  unfold sourceAngleUnit
+  rw [mul_one_div,le_div_iff₀ (mul_pos (sourceBlockSize_pos i.1) (sourceCutoff_pos i.1)),one_mul]
+  exact hnp
+
+theorem sourceSampling_phase_domination (s : ℕ) (hs : 200000 ≤ sourceBlockSize s)
+    (i : SourceCoordinate) (hi : i.1 ≤ s) (n : ℤ) (hn : n ∈ sourceSamplingPowers s) :
+    sourceAngleLaw.map (fun θ => Int.fract ((n : ℝ)*θ i)) ≤
+      (2 : ℝ≥0∞) • unitIntervalMeasure := by
+  have hp : Measurable (fun t : ℝ => Int.fract ((n : ℝ)*t)) :=
+    sourceFract_measurable.comp (measurable_const.mul measurable_id)
+  have he : sourceAngleLaw.map (fun θ => Int.fract ((n : ℝ)*θ i)) =
+      (sourceAngleMarginal i).map (fun t => Int.fract ((n : ℝ)*t)) := by
+    rw [← sourceAngleLaw_coordinate i,Measure.map_map hp (measurable_pi_apply i)]
+    rfl
+  rw [he]
+  have hnp : (0 : ℝ) < n := by exact_mod_cast ((sourceSamplingPowers_spec s hs).1 n hn).2.2
+  have hh := (sourceAngle_phase_sandwich i (n : ℝ) hnp).2
+  apply hh.trans
+  have hlen := sourceSampling_phase_length s hs i hi n hn
+  have hiR : 1/(n*sourceAngleUnit i) ≤ (1 : ℝ) := by
+    simpa using one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 1) hlen
+  have heps : ENNReal.ofReal (1+1/(n*sourceAngleUnit i)) ≤ (2 : ℝ≥0∞) := by
+    exact_mod_cast ENNReal.ofReal_le_ofReal (show 1+1/(n*sourceAngleUnit i) ≤ (2 : ℝ) by linarith)
+  gcongr
+
+theorem samplingCharacter_pair_expression (v w : ℤ) (a b : ℝ) :
+    samplingCharacter v a*samplingCharacter w b =
+      Complex.exp (2*Real.pi*Complex.I*((v : ℂ)*(a : ℂ)+(w : ℂ)*(b : ℂ))) := by
+  unfold samplingCharacter
+  rw [← Complex.exp_add]
+  congr 1
+  ring
+
+/-- Rectangle discrepancy for the actual pair law of the deterministic
+selected powers, with every probabilistic hypothesis discharged. -/
+theorem sourceSampling_rectangle_bound (s : ℕ) (hs : 200000 ≤ sourceBlockSize s)
+    (i : SourceCoordinate) (hi : i.1 ≤ s) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers s) (hn' : n' ∈ sourceSamplingPowers s) (hne : n ≠ n')
+    (a b a' b' : ℝ) :
+    |(sourceAngleLaw {θ | Int.fract ((n : ℝ)*θ i) ∈ Set.Icc a b ∧
+        Int.fract ((n' : ℝ)*θ i) ∈ Set.Icc a' b'}).toReal -
+      (unitIntervalMeasure (Set.Icc a b)).toReal*(unitIntervalMeasure (Set.Icc a' b')).toReal| ≤
+      26*(sourceBlockSize s : ℝ)^(-80 : ℝ) := by
+  let m := sourceBlockSize s
+  have hm0 : (0 : ℝ) < m := sourceBlockSize_pos s
+  have hm1 : (1 : ℝ) ≤ m := by
+    have hm : (200000 : ℝ) ≤ m := by exact_mod_cast hs
+    linarith
+  let δ : ℝ := (m : ℝ)^(-80 : ℝ)
+  let ε : ℝ := Real.pi⁻¹*(m : ℝ)^(-1000 : ℝ)
+  have hH : 0 < samplingH m := pow_pos (by exact_mod_cast hm0) 300
+  have hphase (n : ℤ) : Measurable (fun θ : SourceCoordinate → ℝ => Int.fract ((n : ℝ)*θ i)) :=
+    sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i))
+  have hh := sampling_rectangle_discrepancy sourceAngleLaw _ _ (hphase n) (hphase n')
+    (sourceSampling_phase_domination s hs i hi n hn) (sourceSampling_phase_domination s hs i hi n' hn')
+    (samplingH m) hH a b a' b' δ ε (by dsimp [δ]; positivity) (by dsimp [ε]; positivity)
+    (fun v w hv hw hne' => by
+      simp_rw [samplingCharacter_pair_expression]
+      exact sourceSampling_pair_fourier_bound s hs i hi n n' hn hn' hne v w hv.le hw.le hne')
+  apply hh.trans
+  have htail : 1/(2*(samplingH m : ℝ)*δ^2) = (1/2 : ℝ)*(m : ℝ)^(-140 : ℝ) := by
+    dsimp [samplingH,δ]
+    norm_num [Real.rpow_neg,Real.rpow_ofNat,hm0.le]
+    field_simp
+  have hfour : (samplingH m : ℝ)^2*ε = Real.pi⁻¹*(m : ℝ)^(-400 : ℝ) := by
+    dsimp [samplingH,ε]
+    norm_num [Real.rpow_neg,Real.rpow_ofNat,hm0.le]
+    field_simp
+  rw [htail,hfour]
+  have h140 : (m : ℝ)^(-140 : ℝ) ≤ δ := Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num)
+  have h400 : (m : ℝ)^(-400 : ℝ) ≤ δ := Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num)
+  have hpi : Real.pi⁻¹ ≤ 1 := by simpa using one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 1) (show 1 ≤ Real.pi by linarith [Real.two_le_pi])
+  have hδ : 0 ≤ δ := by dsimp [δ]; positivity
+  have hp0 : 0 ≤ (m : ℝ)^(-400 : ℝ) := by positivity
+  change 24*δ+1/2*(m : ℝ)^(-140 : ℝ)+Real.pi⁻¹*(m : ℝ)^(-400 : ℝ) ≤ 26*δ
+  nlinarith
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/EmpiricalL2.lean

@@ -0,0 +1,89 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.ErrorEvent
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical
+noncomputable section
+
+theorem sourceSamplingEmpiricalDensity_measurable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (θ : SourceCoordinate → ℝ) : Measurable (sourceSamplingEmpiricalDensity stage r b E G θ) :=
+  (Finset.measurable_sum _ (fun n _ => (sourceSamplingProduct_measurable stage r b E G hE hG n).comp
+    (measurable_const.prodMk measurable_id))).div_const _
+
+/-- Every empirical density is bounded at its finite stage, including stages
+whose selected set is empty. No asymptotic assumption is used here. -/
+theorem sourceSamplingEmpiricalDensity_bounds (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ x : SourceCoordinate → ℝ) :
+    0 ≤ sourceSamplingEmpiricalDensity stage r b E G θ x ∧
+      sourceSamplingEmpiricalDensity stage r b E G θ x ≤
+        (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card := by
+  let C := (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card
+  have hC : 0 ≤ C := pow_nonneg ((by norm_num : (0 : ℝ) ≤ 1).trans (le_max_left _ _)) _
+  have hb := sourceSamplingProduct_bounds stage r b E G
+  have hn : 0 ≤ sourceSamplingEmpiricalDensity stage r b E G θ x :=
+    div_nonneg (sum_nonneg (fun n _ => (hb n θ x).1)) (by positivity)
+  refine ⟨hn,?_⟩
+  by_cases hS : (sourceSamplingPowers stage).Nonempty
+  · have hP : (0 : ℝ) < (sourceSamplingPowers stage).card := by exact_mod_cast hS.card_pos
+    apply (div_le_iff₀ hP).mpr
+    calc
+      _ ≤ ∑ _n ∈ sourceSamplingPowers stage, C := sum_le_sum (fun n _ => (hb n θ x).2)
+      _ = _ := by simp [C]; ring
+  · have he : sourceSamplingPowers stage = ∅ := Finset.not_nonempty_iff_eq_empty.mp hS
+    simp [sourceSamplingEmpiricalDensity,he]
+
+/-- The empirical densities, not only the ideal products, belong to L2. -/
+theorem sourceSamplingEmpiricalDensity_memLp (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (θ : SourceCoordinate → ℝ) :
+    MemLp (sourceSamplingEmpiricalDensity stage r b E G θ) 2
+      (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) := by
+  apply MemLp.of_bound (sourceSamplingEmpiricalDensity_measurable stage r b E G hE hG θ).aestronglyMeasurable
+    ((max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card)
+  apply Eventually.of_forall
+  intro x
+  rw [Real.norm_eq_abs,abs_of_nonneg (sourceSamplingEmpiricalDensity_bounds stage r b E G θ x).1]
+  exact (sourceSamplingEmpiricalDensity_bounds stage r b E G θ x).2
+
+/-- The full error and the ideal L2 bound control the actual empirical square. -/
+theorem sourceSamplingEmpiricalDensity_square_le (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (θ : SourceCoordinate → ℝ) :
+    (∫ x, sourceSamplingEmpiricalDensity stage r b E G θ x^2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) ≤
+      2*sourceSamplingSquaredError stage r b E G θ+2*Real.exp 5 := by
+  let μ := Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)
+  let z := sourceSamplingEmpiricalDensity stage r b E G θ
+  let g := sourceSamplingIdealDensity stage r b E G
+  let C := (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card
+  have hz := sourceSamplingEmpiricalDensity_measurable stage r b E G hE hG θ
+  have hg := sourceSamplingIdealDensity_measurable stage r b E G hE hG
+  have hzb := sourceSamplingEmpiricalDensity_bounds stage r b E G θ
+  have hgb := sourceSamplingIdealDensity_bounds stage r b E G hE hG
+  have hzi : Integrable (fun x => z x^2) μ := sampling_square_integrable μ z C hz hzb
+  have hgi : Integrable (fun x => g x^2) μ := sampling_square_integrable μ g C hg hgb
+  have hei : Integrable (fun x => (z x-g x)^2) μ := by
+    apply sampling_integrable_bounded μ _ ((hz.sub hg).pow_const 2) (C^2)
+    intro x
+    rw [abs_of_nonneg (sq_nonneg _)]
+    have hz' : 0 ≤ z x ∧ z x ≤ C := hzb x
+    have hg' : 0 ≤ g x ∧ g x ≤ C := hgb x
+    change (z x-g x)^2 ≤ C^2
+    nlinarith [mul_nonneg (show 0 ≤ C-(z x-g x) by linarith) (show 0 ≤ C+(z x-g x) by linarith)]
+  have hi := integral_mono_ae hzi ((hei.const_mul 2).add (hgi.const_mul 2))
+    (Eventually.of_forall (fun x => show z x^2 ≤ 2*(z x-g x)^2+2*g x^2 by nlinarith [sq_nonneg (z x-2*g x)]))
+  simp only [Pi.add_apply] at hi
+  rw [integral_add (hei.const_mul 2) (hgi.const_mul 2),integral_const_mul,integral_const_mul] at hi
+  exact hi.trans (by
+    have hb := sourceSamplingIdealDensity_uniform_square stage r b E G hE hG
+    change (∫ x, g x^2 ∂μ) ≤ Real.exp 5 at hb
+    change _ ≤ 2*(∫ x, (z x-g x)^2 ∂μ)+2*Real.exp 5
+    linarith)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Error.lean

@@ -0,0 +1,120 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.ProductError
+import OAI.Analysis.FiniteFactor.OrbitSampling.DiagonalEvent
+import OAI.Analysis.FiniteFactor.Sampling.Cancellation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+def sourceSamplingEmpiricalDensity (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ x : SourceCoordinate → ℝ) : ℝ :=
+  (∑ n ∈ sourceSamplingPowers stage, sourceSamplingProduct stage r b E G n θ x)/
+    ((sourceSamplingPowers stage).card : ℝ)
+
+/-- The full sampling error, including every distinct-pair and mixed term. -/
+def sourceSamplingSquaredError (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ : SourceCoordinate → ℝ) : ℝ :=
+  ∫ x, (sourceSamplingEmpiricalDensity stage r b E G θ x-sourceSamplingIdealDensity stage r b E G x)^2
+    ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)
+
+theorem sourceSampling_error_joint_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Integrable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      (sourceSamplingEmpiricalDensity stage r b E G p.1 p.2-sourceSamplingIdealDensity stage r b E G p.2)^2)
+      (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))) := by
+  apply sampling_average_square_integrable
+  · intro n _ k _
+    exact sourceSamplingProduct_pair_integrable stage r b E G hE hG n k
+  · intro n _
+    exact sourceSamplingProduct_mixed_integrable stage r b E G hE hG n
+  · have hm : Measurable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) => sourceSamplingIdealDensity stage r b E G p.2) :=
+      (sourceSamplingIdealDensity_measurable stage r b E G hE hG).comp measurable_snd
+    have hi := sampling_bounded_product_integrable
+      (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)))
+      (fun p => sourceSamplingIdealDensity stage r b E G p.2) (fun p => sourceSamplingIdealDensity stage r b E G p.2)
+      hm hm _ (fun p => sourceSamplingIdealDensity_bounds stage r b E G hE hG p.2)
+      (fun p => sourceSamplingIdealDensity_bounds stage r b E G hE hG p.2)
+    simpa only [pow_two] using hi
+
+theorem sourceSamplingSquaredError_integrable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Integrable (sourceSamplingSquaredError stage r b E G) sourceAngleLaw :=
+  (sourceSampling_error_joint_integrable stage r b E G hE hG).integral_prod_left
+
+theorem sourceSamplingSquaredError_measurable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Measurable (sourceSamplingSquaredError stage r b E G) := by
+  have hm : Measurable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      sourceSamplingEmpiricalDensity stage r b E G p.1 p.2) :=
+    (Finset.measurable_sum _ (fun n _ => sourceSamplingProduct_measurable stage r b E G hE hG n)).div_const _
+  exact ((hm.sub ((sourceSamplingIdealDensity_measurable stage r b E G hE hG).comp measurable_snd)).pow_const 2).stronglyMeasurable.integral_prod_right.measurable
+
+theorem sourceSamplingSquaredError_nonneg (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (θ : SourceCoordinate → ℝ) :
+    0 ≤ sourceSamplingSquaredError stage r b E G θ := integral_nonneg (fun _ => sq_nonneg _)
+
+/-- Full expected squared sampling error with the source's actual sample set,
+weights and ideal density. All distinct-pair and mixed assumptions are proved. -/
+theorem sourceSamplingSquaredError_expectation (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (r : Bool) (b : SourceCoordinate → Bool) (a c a' c' : SourceCoordinate → ℝ) :
+    (∫ θ, sourceSamplingSquaredError stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ ∂sourceAngleLaw) ≤
+      (∫ θ, sourceSamplingDiagonalContribution stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ ∂sourceAngleLaw)+
+      3*sourceSamplingCorrelationBudget stage := by
+  let E := fun i => Set.Icc (a i) (c i)
+  let G := fun i => Set.Icc (a' i) (c' i)
+  have hE : ∀ i, MeasurableSet (E i) := fun _ => measurableSet_Icc
+  have hG : ∀ i, MeasurableSet (G i) := fun _ => measurableSet_Icc
+  let μ := sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))
+  let S := sourceSamplingPowers stage
+  let f (n : ℤ) (p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) := sourceSamplingProduct stage r b E G n p.1 p.2
+  let g (p : (SourceCoordinate → ℝ) × (SourceCoordinate → ��)) := sourceSamplingIdealDensity stage r b E G p.2
+  have hpair (n k : ℤ) : Integrable (fun p => f n p*f k p) μ :=
+    sourceSamplingProduct_pair_integrable stage r b E G hE hG n k
+  have hmix (n : ℤ) : Integrable (fun p => f n p*g p) μ :=
+    sourceSamplingProduct_mixed_integrable stage r b E G hE hG n
+  have hg : Integrable (fun p => g p^2) μ := by
+    have hm : Measurable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) => sourceSamplingIdealDensity stage r b E G p.2) :=
+      (sourceSamplingIdealDensity_measurable stage r b E G hE hG).comp measurable_snd
+    simpa only [pow_two] using sampling_bounded_product_integrable μ g g hm hm _
+      (fun p => sourceSamplingIdealDensity_bounds stage r b E G hE hG p.2)
+      (fun p => sourceSamplingIdealDensity_bounds stage r b E G hE hG p.2)
+  have hA : (∫ p, g p^2 ∂μ) = ∫ x, sourceSamplingIdealDensity stage r b E G x^2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) := by
+    rw [integral_prod _ hg]
+    simp [g]
+  have hB (n k : ℤ) : (∫ p, f n p*f k p ∂μ) =
+      ∫ θ, ∫ x, sourceSamplingProduct stage r b E G n θ x*sourceSamplingProduct stage r b E G k θ x
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) ∂sourceAngleLaw := integral_prod _ (hpair n k)
+  have hM (n : ℤ) : (∫ p, f n p*g p ∂μ) =
+      ∫ θ, ∫ x, sourceSamplingProduct stage r b E G n θ x*sourceSamplingIdealDensity stage r b E G x
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) ∂sourceAngleLaw := integral_prod _ (hmix n)
+  have hS : S.Nonempty := by
+    have hP : (0 : ℝ) < (sourceSamplingPowers stage).card :=
+      (Real.rpow_pos_of_pos (sourceBlockSize_pos stage) _).trans_le (sourceSamplingPowers_spec stage hs).2.1
+    exact Finset.card_pos.mp (by exact_mod_cast hP)
+  have hc := sampling_finite_cancellation S hS
+    (fun n k => ∫ p, f n p*f k p ∂μ) (fun n => ∫ p, f n p*g p ∂μ)
+    (∫ p, g p^2 ∂μ) (sourceSamplingCorrelationBudget stage)
+    (integral_nonneg (fun _ => sq_nonneg _)) (by unfold sourceSamplingCorrelationBudget; positivity)
+    (fun n hn k hk hne => by rw [hB,hA]; exact sourceSamplingProduct_pair_error stage hs r b a c a' c' n k hn hk hne)
+    (fun n hn => by rw [hM,hA]; exact sourceSamplingProduct_mixed_error stage hs r b E G hE hG n hn)
+  have hex := sampling_average_square_expansion μ S f g (fun n _ k _ => hpair n k) (fun n _ => hmix n) hg
+  rw [← hex] at hc
+  have hErr : (∫ p, ((∑ n ∈ S, f n p)/(S.card : ℝ)-g p)^2 ∂μ) =
+      ∫ θ, sourceSamplingSquaredError stage r b E G θ ∂sourceAngleLaw :=
+    integral_prod _ (sourceSampling_error_joint_integrable stage r b E G hE hG)
+  have hDiag : (∑ n ∈ S, ∫ p, f n p*f n p ∂μ)/(S.card : ℝ)^2 =
+      ∫ θ, sourceSamplingDiagonalContribution stage r b E G θ ∂sourceAngleLaw := by
+    unfold sourceSamplingDiagonalContribution
+    rw [integral_div,integral_finsetSum _ (fun n _ =>
+      (sourceSamplingProduct_square_integrable stage r b E G hE hG n).integral_prod_left)]
+    simp only [hB,pow_two,f,S]
+  rw [hErr,hDiag] at hc
+  exact hc
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/ErrorEvent.lean

@@ -0,0 +1,80 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Error
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical Topology
+noncomputable section
+
+/-- The distinct and mixed error budget is summable along the actual stages. -/
+theorem sourceSamplingCorrelationBudget_summable : Summable sourceSamplingCorrelationBudget := by
+  apply (sourceSampling_inverse_square_summable.mul_left (208*Real.exp 135)).of_nonneg_of_le
+  · intro stage; unfold sourceSamplingCorrelationBudget; positivity
+  intro stage
+  let m : ℝ := sourceBlockSize stage
+  have hm : 0 < m := sourceBlockSize_pos stage
+  have hm1 : 1 ≤ m := by
+    have hh : 100 ≤ sourceBlockSize stage := (sourceStage stage).m_ge_100
+    dsimp [m]
+    exact_mod_cast (show 1 ≤ sourceBlockSize stage by omega)
+  have hd : ((sourceSamplingPrefix stage).card : ℝ) ≤ 2*m :=
+    (sourceSamplingPrefix_card_bound stage).trans (by dsimp [m]; nlinarith)
+  have he : m*m^(-74 : ℝ) = m^(-73 : ℝ) := by
+    conv_lhs => lhs; rw [← Real.rpow_one m]
+    rw [← Real.rpow_add hm]; norm_num
+  calc
+    sourceSamplingCorrelationBudget stage ≤ (2*m)*(104*m^(-74 : ℝ))*Real.exp 135 := by
+      unfold sourceSamplingCorrelationBudget
+      exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hd (by positivity)) (by positivity)
+    _ = (208*Real.exp 135)*m^(-73 : ℝ) := by rw [← he]; ring
+    _ ≤ (208*Real.exp 135)*m^(-2 : ℝ) := mul_le_mul_of_nonneg_left
+      (Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num)) (by positivity)
+
+/-- Summable expectations for the full empirical sampling error. -/
+theorem sourceSamplingSquaredError_summable_integral (r : Bool) (b : SourceCoordinate → Bool)
+    (a c a' c' : SourceCoordinate → ℝ) :
+    Summable (fun stage => ∫ θ, sourceSamplingSquaredError stage r b
+      (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ ∂sourceAngleLaw) := by
+  have hd := sourceSamplingDiagonalContribution_summable_integral r b
+    (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i))
+    (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+  have hb := hd.add (sourceSamplingCorrelationBudget_summable.mul_left 3)
+  apply hb.of_norm_bounded_eventually_nat
+  filter_upwards [sourceBlockSize_tendsto.eventually (eventually_ge_atTop 200000)] with stage hs
+  rw [Real.norm_eq_abs,abs_of_nonneg (integral_nonneg (sourceSamplingSquaredError_nonneg stage r b _ _))]
+  exact sourceSamplingSquaredError_expectation stage hs r b a c a' c'
+
+/-- The full squared sampling error is summable and converges to zero on a
+conull set of actual source angles. This is not just the self-pair event. -/
+theorem sourceSamplingSquaredError_ae (r : Bool) (b : SourceCoordinate → Bool)
+    (a c a' c' : SourceCoordinate → ℝ) :
+    ∀ᵐ θ ∂sourceAngleLaw,
+      Summable (fun stage => sourceSamplingSquaredError stage r b
+        (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ) ∧
+      Tendsto (fun stage => sourceSamplingSquaredError stage r b
+        (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ) atTop (𝓝 0) := by
+  have he := sampling_ae_summable_of_integrals sourceAngleLaw
+    (fun stage θ => sourceSamplingSquaredError stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) θ)
+    (fun stage => sourceSamplingSquaredError_measurable stage r b _ _ (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc))
+    (fun stage => sourceSamplingSquaredError_integrable stage r b _ _ (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc))
+    (fun stage θ => sourceSamplingSquaredError_nonneg stage r b _ _ θ)
+    (sourceSamplingSquaredError_summable_integral r b a c a' c')
+  exact he.mono (fun θ hθ => ⟨hθ,hθ.tendsto_atTop_zero⟩)
+
+/-- One source-angle event handles any countable family of interval tests,
+orientations and triangular-coordinate choices for the full error. -/
+theorem sourceSamplingSquaredError_countable_event {ι : Type*} [Countable ι]
+    (r : ι → Bool) (b : ι → SourceCoordinate → Bool)
+    (a c a' c' : ι → SourceCoordinate → ℝ) :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ j,
+      Summable (fun stage => sourceSamplingSquaredError stage (r j) (b j)
+        (fun i => Set.Icc (a j i) (c j i)) (fun i => Set.Icc (a' j i) (c' j i)) θ) ∧
+      Tendsto (fun stage => sourceSamplingSquaredError stage (r j) (b j)
+        (fun i => Set.Icc (a j i) (c j i)) (fun i => Set.Icc (a' j i) (c' j i)) θ) atTop (𝓝 0) :=
+  ae_all_iff.mpr (fun j => sourceSamplingSquaredError_ae (r j) (b j) (a j) (c j) (a' j) (c' j))
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/FirstCorrelation.lean

@@ -0,0 +1,74 @@
+import OAI.Analysis.FiniteFactor.Sampling.FirstDiscrepancy
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical
+noncomputable section
+
+theorem sourceSampling_first_height_bound (stage : ℕ) (b : Bool) (s : ℝ) :
+    0 ≤ samplingFirstHeight b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) s ∧
+    samplingFirstHeight b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) s ≤
+      (sourceBlockSize stage : ℝ)^(13/5 : ℝ) := by
+  have hp := sourceSampling_parameters stage
+  have hm := sourceBlockSize_pos stage
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have hh : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+    linarith
+  cases b
+  · unfold samplingFirstHeight
+    simp only [Bool.false_eq_true,ite_false]
+    split_ifs with hc
+    · have hd : 0 < samplingDistance s := hp.2.2.trans_le hc
+      refine ⟨one_div_nonneg.mpr (mul_nonneg hp.1.le hd.le),?_⟩
+      calc
+        _ ≤ 1/(sourceSamplingWidth stage*sourceSamplingCutoff stage) :=
+          one_div_le_one_div_of_le (mul_pos hp.1 hp.2.2) (mul_le_mul_of_nonneg_left hc hp.1.le)
+        _ = _ := by
+          unfold sourceSamplingWidth sourceSamplingCutoff
+          rw [← Real.rpow_add hm]
+          norm_num
+          rw [Real.rpow_neg hm.le,inv_inv]
+    · exact ⟨le_rfl,by positivity⟩
+  · exact ⟨by norm_num [samplingFirstHeight],Real.one_le_rpow hm1 (by norm_num)⟩
+
+/-- Explicit first-oriented pair correlation error for every prefix coordinate,
+every rectangle endpoint and both source coordinate types. -/
+theorem sourceSampling_first_pair_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers stage) (hn' : n' ∈ sourceSamplingPowers stage) (hne : n ≠ n')
+    (b : Bool) (E : Set ℝ) (a c s : ℝ) (hsx : s ∈ Set.Ico (0 : ℝ) 1) :
+    |(∫ θ, samplingTestedFirstWeight b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c) s (Int.fract ((n : ℝ)*θ i)) *
+        samplingTestedFirstWeight b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        E (Set.Icc a c) s (Int.fract ((n' : ℝ)*θ i)) ∂sourceAngleLaw) -
+      samplingTestedFirstDensity b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E (Set.Icc a c) s ^ 2| ≤
+      26*(sourceBlockSize stage : ℝ)^(-74 : ℝ) := by
+  let m : ℝ := sourceBlockSize stage
+  let C := if s ∈ E then samplingFirstHeight b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) s else 0
+  have hm : 0 < m := sourceBlockSize_pos stage
+  have hm1 : 1 ≤ m := by
+    have hh : (200000 : ℝ) ≤ (sourceBlockSize stage : ℝ) := by exact_mod_cast hs
+    dsimp [m]
+    linarith
+  have hheight := sourceSampling_first_height_bound stage b s
+  have hC : 0 ≤ C ∧ C ≤ m^(3 : ℝ) := by
+    dsimp [C]
+    split_ifs
+    · exact ⟨hheight.1,hheight.2.trans (Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num))⟩
+    · exact ⟨le_rfl,by positivity⟩
+  have hC2 : C^2 ≤ m^(6 : ℝ) := by
+    calc
+      C^2 ≤ (m^(3 : ℝ))^2 := by nlinarith [hC.1,hC.2,Real.rpow_nonneg hm.le (3 : ℝ)]
+      _ = _ := by rw [← Real.rpow_natCast,← Real.rpow_mul hm.le]; norm_num
+  apply (sourceSampling_first_pair_bound stage hs i hi n n' hn hn' hne b E a c s hsx).trans
+  change (26*m^(-80 : ℝ))*C^2 ≤ 26*m^(-74 : ℝ)
+  calc
+    _ ≤ (26*m^(-80 : ℝ))*m^(6 : ℝ) := mul_le_mul_of_nonneg_left hC2 (by positivity)
+    _ = _ := by rw [mul_assoc,← Real.rpow_add hm]; norm_num
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/FirstMarginal.lean

@@ -0,0 +1,67 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.UniformEvent
+import OAI.Analysis.FiniteFactor.OrbitSampling.Measures
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal
+noncomputable section
+
+/-- The actual first marginal is the verified empirical interval-test density.
+The whole-circle tests [0,1] are valid on the Haar cube. -/
+theorem sourceSamplingUntrimmed_first_density (I : Finset SourceCoordinate) (stage : ℕ)
+    (θ : SourceCoordinate → ℝ) :
+    (sourceSamplingUntrimmed I stage θ).map Prod.fst =
+      sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingEmpiricalDensity stage false (fun i => decide (i ∈ I))
+          (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) θ x)) := by
+  let S := sourceSamplingPowers stage
+  let c : ℝ≥0∞ := ENNReal.ofReal (1/((sourceSamplingPowers stage).card : ℝ))
+  let w (n : ℤ) := sourceSamplingWeight I stage θ n
+  have hrep : (fun x => ENNReal.ofReal (sourceSamplingEmpiricalDensity stage false (fun i => decide (i ∈ I))
+        (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) θ x)) =ᵐ[sourceSamplingHaar]
+      (fun x => c*(∑ n ∈ S, ENNReal.ofReal (w n x))) := by
+    filter_upwards [sourceSamplingHaar_cube] with x hx
+    have hw (n : ℤ) : sourceSamplingProduct stage false (fun i => decide (i ∈ I))
+        (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) n θ x = w n x := by
+      apply Finset.prod_congr rfl
+      intro i _
+      have hx' : x i ∈ Set.Icc (0 : ℝ) 1 := ⟨(hx i).1,(hx i).2.le⟩
+      have hy : Int.fract (x i+Int.fract ((n : ℝ)*θ i)) ∈ Set.Icc (0 : ℝ) 1 :=
+        ⟨Int.fract_nonneg _,(Int.fract_lt_one _).le⟩
+      simp only [samplingOrientedWeight, Bool.false_eq_true, ite_false, samplingTestedFirstWeight,
+        hx', hy, and_self, ite_true]
+    simp only [sourceSamplingEmpiricalDensity,hw]
+    rw [div_eq_mul_inv,mul_comm,← one_div,
+      ENNReal.ofReal_mul (by positivity),ENNReal.ofReal_sum_of_nonneg (fun n _ => (sourceSamplingWeight_bounds I stage θ n x).1)]
+  rw [withDensity_congr_ae hrep]
+  ext A hA
+  rw [Measure.map_apply measurable_fst hA]
+  unfold sourceSamplingUntrimmed
+  rw [Measure.smul_apply,Measure.finsetSum_apply,withDensity_apply _ hA]
+  have hterm (n : ℤ) : sourceSamplingSummand I stage θ n (Prod.fst ⁻¹' A) =
+      ∫⁻ x in A, ENNReal.ofReal (w n x) ∂sourceSamplingHaar := by
+    rw [← Measure.map_apply measurable_fst hA,sourceSamplingSummand_first_marginal]
+    exact withDensity_apply _ hA
+  simp only [hterm,smul_eq_mul]
+  rw [lintegral_const_mul' c _ ENNReal.ofReal_ne_top]
+  congr 1
+  exact (lintegral_finsetSum S (fun n _ =>
+    (sourceSamplingWeight_measurable I stage θ n).ennreal_ofReal)).symm
+
+/-- Uniform L2 densities for the actual untrimmed first marginals. -/
+theorem sourceSamplingUntrimmed_first_L2 (I : Finset SourceCoordinate) :
+    ∀ᵐ θ ∂sourceAngleLaw, ∃ C : ℝ, ∀ stage,
+      ∃ f : (SourceCoordinate → ℝ) → ℝ,
+        (sourceSamplingUntrimmed I stage θ).map Prod.fst = sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (f x)) ∧
+        MemLp f 2 sourceSamplingHaar ∧ (∫ x, f x^2 ∂sourceSamplingHaar) ≤ C := by
+  filter_upwards [sourceSamplingEmpiricalDensity_uniform false (fun i => decide (i ∈ I))
+    (fun _ => 0) (fun _ => 1) (fun _ => 0) (fun _ => 1)] with θ hθ
+  obtain ⟨C,hC⟩ := hθ
+  refine ⟨C,fun stage => ⟨_,sourceSamplingUntrimmed_first_density I stage θ,(hC stage).1,(hC stage).2⟩⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Fourier.lean

@@ -0,0 +1,92 @@
+import OAI.Analysis.FiniteFactor.Sampling.Fourier
+import OAI.Analysis.FiniteFactor.OrbitSampling.Powers
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+theorem sourceBlockSize_monotone : Monotone sourceBlockSize := by
+  apply monotone_nat_of_le_succ
+  intro s
+  have hp := (sourceStage (s+1)).previous_size
+  have hd : (sourceBlockSize s : ℝ) ≤ (sourceStageState (s+1)).d := by
+    change (sourceBlockSize s : ℝ) ≤ ((sourceStageState s).d+(sourceStage s).m : ℕ)
+    change ((sourceStage s).m : ℝ) ≤ ((sourceStageState s).d+(sourceStage s).m : ℕ)
+    push_cast
+    exact le_add_of_nonneg_left (Nat.cast_nonneg _)
+  have hm : (sourceBlockSize s : ℝ) ≤ sourceBlockSize (s+1) := by
+    change ((sourceStageState (s+1)).d : ℝ) ≤ (sourceBlockSize (s+1) : ℝ)/100 at hp
+    have := Nat.cast_nonneg (α := ℝ) (sourceBlockSize (s+1))
+    linarith
+  exact_mod_cast hm
+
+theorem sourceFrequencyScale_monotone :
+    Monotone (fun s => sourceBlockSize s * (sourceStageState s).K) := by
+  have hK : Monotone (fun s => (sourceStageState s).K) := by
+    apply monotone_nat_of_le_succ
+    intro s
+    have := sourceStage_cutoff_growth s
+    omega
+  intro s t hst
+  exact Nat.mul_le_mul (sourceBlockSize_monotone hst) (hK hst)
+
+/-- The full infinite-product angle expectation has the same coordinate
+Fourier estimate; no independence between two phases is asserted. -/
+theorem sourceAngleLaw_pair_fourier_le (i : SourceCoordinate) (v v' : ℤ) (n n' : ℝ)
+    (hw : (v : ℝ)*n+(v' : ℝ)*n' ≠ 0) :
+    ‖∫ θ, Complex.exp (2 * Real.pi * Complex.I *
+      ((v : ℂ) * (Int.fract (n*θ i) : ℝ) + (v' : ℂ) * (Int.fract (n'*θ i) : ℝ)))
+      ∂sourceAngleLaw‖ ≤
+      1/(Real.pi*sourceAngleUnit i*|(v : ℝ)*n+(v' : ℝ)*n'|) := by
+  have hh := sourceAngle_pair_fourier_le i v v' n n' hw
+  simp_rw [pair_fourier_fract] at hh ⊢
+  rw [← sourceAngleLaw_coordinate i,
+    integral_map (measurable_pi_apply i).aemeasurable (by fun_prop)] at hh
+  exact hh
+
+theorem sourceSampling_pair_fourier_bound (s : ℕ) (hs : 200000 ≤ sourceBlockSize s)
+    (i : SourceCoordinate) (hi : i.1 ≤ s) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers s) (hn' : n' ∈ sourceSamplingPowers s) (hne : n ≠ n')
+    (v v' : ℤ) (hv : |v| ≤ (samplingH (sourceBlockSize s) : ℤ))
+    (hv' : |v'| ≤ (samplingH (sourceBlockSize s) : ℤ)) (hvv' : v ≠ 0 ∨ v' ≠ 0) :
+    ‖∫ θ, Complex.exp (2 * Real.pi * Complex.I *
+      ((v : ℂ) * (Int.fract ((n : ℝ)*θ i) : ℝ) +
+       (v' : ℂ) * (Int.fract ((n' : ℝ)*θ i) : ℝ))) ∂sourceAngleLaw‖ ≤
+      Real.pi⁻¹*(sourceBlockSize s : ℝ)^(-1000 : ℝ) := by
+  have hsep := (sourceSamplingPowers_spec s hs).2.2 hn hn' hne
+  have hfreq : (samplingR (sourceBlockSize s) (sourceStageState s).K : ℤ) < |v*n+v'*n'| := by
+    by_contra hh
+    exact hsep ⟨v,mem_Icc.mpr (abs_le.mp hv),v',mem_Icc.mpr (abs_le.mp hv'),hvv',le_of_not_gt hh⟩
+  let w : ℝ := (v : ℝ)*(n : ℝ)+(v' : ℝ)*(n' : ℝ)
+  have hwR : (samplingR (sourceBlockSize s) (sourceStageState s).K : ℝ) < |w| := by
+    dsimp [w]
+    exact_mod_cast hfreq
+  have hwpos : 0 < |w| := lt_of_le_of_lt (Nat.cast_nonneg _) hwR
+  have hw : w ≠ 0 := abs_pos.mp hwpos
+  apply (sourceAngleLaw_pair_fourier_le i v v' (n : ℝ) (n' : ℝ) hw).trans
+  have hN : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤
+      (sourceBlockSize s : ℝ)*(sourceStageState s).K := by
+    exact_mod_cast sourceFrequencyScale_monotone hi
+  have hmpos := sourceBlockSize_pos s
+  have hNpos := mul_pos (sourceBlockSize_pos i.1) (sourceCutoff_pos i.1)
+  have hscale : (sourceBlockSize s : ℝ)^1000 ≤ sourceAngleUnit i * |w| := by
+    unfold samplingR at hwR
+    push_cast at hwR
+    unfold sourceAngleUnit
+    rw [one_div, inv_mul_eq_div, le_div_iff₀ hNpos]
+    have hh := mul_le_mul_of_nonneg_right hN (pow_nonneg hmpos.le 1000)
+    nlinarith
+  change 1/(Real.pi*sourceAngleUnit i*|w|) ≤ _
+  calc
+    _ = Real.pi⁻¹*(1/(sourceAngleUnit i*|w|)) := by ring
+    _ ≤ Real.pi⁻¹*(1/(sourceBlockSize s : ℝ)^1000) := by
+      exact mul_le_mul_of_nonneg_left
+        (one_div_le_one_div_of_le (pow_pos hmpos 1000) hscale) (inv_nonneg.mpr Real.pi_pos.le)
+    _ = _ := by rw [Real.rpow_neg, Real.rpow_ofNat, one_div]; positivity
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/IdealProduct.lean

@@ -0,0 +1,120 @@
+import OAI.Analysis.FiniteFactor.Sampling.OrientedMoments
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+/-- The actual source prefix dimension, including the current block. -/
+theorem sourceSamplingPrefix_card (stage : ℕ) :
+    (sourceSamplingPrefix stage).card = (sourceStageState stage).d+sourceBlockSize stage := by
+  unfold sourceSamplingPrefix CouplingParameters.blockPrefix
+  simp only [Finset.card_sigma,Finset.card_univ,Fintype.card_fin]
+  change (∑ i ∈ range (stage+1), (sourceStage i).m) = _
+  rw [sum_range_succ,← sourceStage_previous_size]
+  rfl
+
+theorem sourceSamplingPrefix_card_bound (stage : ℕ) :
+    ((sourceSamplingPrefix stage).card : ℝ) ≤ (101/100 : ℝ)*sourceBlockSize stage := by
+  rw [sourceSamplingPrefix_card,Nat.cast_add]
+  have hp := (sourceStage stage).previous_size
+  change ((sourceStageState stage).d : ℝ) ≤ (sourceBlockSize stage : ℝ)/100 at hp
+  linarith
+
+/-- The small quadratic coordinate errors stay bounded in the growing prefix. -/
+theorem sourceSampling_prefix_quadratic_budget (stage : ℕ) :
+    ((sourceSamplingPrefix stage).card : ℝ)*(4*(sourceBlockSize stage : ℝ)^(-6/5 : ℝ)) ≤ 5 := by
+  have hm := sourceBlockSize_pos stage
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have hh : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+    linarith
+  have he : (sourceBlockSize stage : ℝ)*(sourceBlockSize stage : ℝ)^(-6/5 : ℝ) =
+      (sourceBlockSize stage : ℝ)^(-1/5 : ℝ) := by
+    conv_lhs => lhs; rw [← Real.rpow_one (sourceBlockSize stage : ℝ)]
+    rw [← Real.rpow_add hm]
+    norm_num
+  have hp : (sourceBlockSize stage : ℝ)^(-1/5 : ℝ) ≤ 1 :=
+    Real.rpow_le_one_of_one_le_of_nonpos hm1 (by norm_num)
+  calc
+    _ ≤ ((101/100 : ℝ)*sourceBlockSize stage)*(4*(sourceBlockSize stage : ℝ)^(-6/5 : ℝ)) :=
+      mul_le_mul_of_nonneg_right (sourceSamplingPrefix_card_bound stage) (by positivity)
+    _ = (101/25 : ℝ)*(sourceBlockSize stage : ℝ)^(-1/5 : ℝ) := by rw [← he]; ring
+    _ ≤ 5 := by linarith
+
+def sourceSamplingIdealDensity (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (x : SourceCoordinate → ℝ) : ℝ :=
+  ∏ i ∈ sourceSamplingPrefix stage,
+    samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) (x i)
+
+theorem sourceSamplingIdealDensity_measurable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    Measurable (sourceSamplingIdealDensity stage r b E G) :=
+  Finset.measurable_prod _ (fun i _ =>
+    (samplingOrientedDensity_measurable r (b i) _ _ (E i) (G i) (hE i) (hG i)).comp (measurable_pi_apply i))
+
+/-- Exact product factorization of the ideal marginal's quadratic moment. -/
+theorem sourceSamplingIdealDensity_square (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    (∫ x, sourceSamplingIdealDensity stage r b E G x ^ 2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) =
+      ∏ i ∈ sourceSamplingPrefix stage,
+        ∫ s, samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s ^ 2
+          ∂unitIntervalMeasure := by
+  simp only [sourceSamplingIdealDensity,← Finset.prod_pow]
+  exact integral_infinitePi_finset_prod _ _ _ (fun i =>
+    (samplingOrientedDensity_measurable r (b i) _ _ (E i) (G i) (hE i) (hG i)).pow_const 2)
+
+/-- Uniform-in-stage ideal marginal bound. The second orientation uses the
+quadratic cancellation established for the actual cutoff diagonal density. -/
+theorem sourceSamplingIdealDensity_uniform_square (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    (∫ x, sourceSamplingIdealDensity stage r b E G x ^ 2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) ≤ Real.exp 5 := by
+  rw [sourceSamplingIdealDensity_square stage r b E G hE hG,← Finset.prod_coe_sort]
+  have he := product_energy_le_exp
+    (fun i : sourceSamplingPrefix stage => ∫ s, samplingOrientedDensity r (b i)
+      (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s ^ 2 ∂unitIntervalMeasure)
+    (fun _ : sourceSamplingPrefix stage => 4*(sourceBlockSize stage : ℝ)^(-6/5 : ℝ))
+    (fun i => integral_nonneg (fun _ => sq_nonneg _))
+    (fun i => (sourceSampling_oriented_moment stage r (b i) (E i) (G i) (hE i) (hG i)).2)
+  apply he.trans
+  apply Real.exp_le_exp.mpr
+  simpa using sourceSampling_prefix_quadratic_budget stage
+
+/-- Each ideal marginal is genuinely in L2; the preceding integral bound is
+therefore a norm bound, not an integral of a nonintegrable function. -/
+theorem sourceSamplingIdealDensity_memLp (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    MemLp (sourceSamplingIdealDensity stage r b E G) 2
+      (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) := by
+  let C := max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage))
+  have hp := sourceSampling_parameters stage
+  have hb (i : SourceCoordinate) (s : ℝ) :
+      0 ≤ samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s ∧
+      samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s ≤ C := by
+    have hm : Measurable (samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s) :=
+      (samplingOrientedWeight_measurable r (b i) _ _ (E i) (G i) (hE i) (hG i)).comp
+        (measurable_const.prodMk measurable_id)
+    have hw := samplingOrientedWeight_bounds r (b i) _ _ (E i) (G i) hp.1 hp.2.2 s
+    have hi : Integrable (samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (E i) (G i) s)
+        unitIntervalMeasure := (integrable_const C).mono' hm.aestronglyMeasurable
+      (Eventually.of_forall (fun t => by rw [Real.norm_eq_abs,abs_of_nonneg (hw t).1]; exact (hw t).2))
+    refine ⟨integral_nonneg (fun t => (hw t).1),?_⟩
+    simpa [samplingOrientedDensity] using integral_mono_ae hi (integrable_const C)
+      (Eventually.of_forall (fun t => (hw t).2))
+  apply MemLp.of_bound (sourceSamplingIdealDensity_measurable stage r b E G hE hG).aestronglyMeasurable
+    (C^(sourceSamplingPrefix stage).card)
+  apply Eventually.of_forall
+  intro x
+  have hnon : 0 ≤ sourceSamplingIdealDensity stage r b E G x := prod_nonneg (fun i _ => (hb i (x i)).1)
+  rw [Real.norm_eq_abs,abs_of_nonneg hnon]
+  calc
+    _ ≤ ∏ _i ∈ sourceSamplingPrefix stage, C :=
+      prod_le_prod₀ (fun i _ => (hb i (x i)).1) (fun i _ => (hb i (x i)).2)
+    _ = _ := by simp
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/IdealRectangleLimit.lean

@@ -0,0 +1,105 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.CutoffMass
+import OAI.Analysis.FiniteFactor.OrbitSampling.RectangleApproximation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- Explicit finite-coordinate rectangle mass of the triangular/diagonal
+model. The triangular term retains the actual source weight integral. -/
+def sourceSamplingLimitRectangleMass (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest) : ℝ :=
+  ∏ i ∈ I ∪ T.1,
+    if i ∈ I then
+      ∫ s, samplingTestedFirstDensity true (sourceSamplingWidth 0) (sourceSamplingCutoff 0)
+        (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure
+    else (unitIntervalMeasure (sourceSamplingRationalX T i ∩ sourceSamplingRationalY T i)).toReal
+
+/-- Exact finite-coordinate factorization of the first ideal integral. -/
+theorem sourceSamplingIdealDensity_integral (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    (∫ x, sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I)) E G x ∂sourceSamplingHaar) =
+      ∏ i ∈ sourceSamplingPrefix stage, ∫ s,
+        samplingTestedFirstDensity (decide (i ∈ I)) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          (E i) (G i) s ∂unitIntervalMeasure := by
+  exact integral_infinitePi_finset_prod _ _ _ (fun i =>
+    samplingTestedFirstDensity_measurable (decide (i ∈ I)) _ _ (E i) (G i) (hE i) (hG i))
+
+/-- Tests and triangular coordinates occupy a fixed finite set. Every other
+prefix coordinate contributes its exact retained mass, 1-2α. -/
+theorem sourceSamplingIdeal_rectangle_split (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest)
+    (stage : ℕ) (hK : I ∪ T.1 ⊆ sourceSamplingPrefix stage) :
+    (∫ x, sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I))
+      (sourceSamplingRationalX T) (sourceSamplingRationalY T) x ∂sourceSamplingHaar) =
+    (∏ i ∈ I ∪ T.1, ∫ s,
+      samplingTestedFirstDensity (decide (i ∈ I)) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure) *
+    (1-2*sourceSamplingCutoff stage)^((sourceSamplingPrefix stage \ (I ∪ T.1)).card) := by
+  rw [sourceSamplingIdealDensity_integral I stage (sourceSamplingRationalX T) (sourceSamplingRationalY T) (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)]
+  let F := fun i => ∫ s, samplingTestedFirstDensity (decide (i ∈ I)) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure
+  have hf (i : SourceCoordinate) (hi : i ∈ sourceSamplingPrefix stage \ (I ∪ T.1)) :
+      F i = 1-2*sourceSamplingCutoff stage := by
+    have hnot := (Finset.mem_sdiff.mp hi).2
+    have hI : i ∉ I := fun h => hnot (Finset.mem_union_left _ h)
+    have hT : i ∉ T.1 := fun h => hnot (Finset.mem_union_right _ h)
+    simp only [F,decide_eq_false hI,sourceSamplingRationalX,sourceSamplingRationalY,
+      sourceSamplingRationalEndpoints,dite_eq_right hT,Rat.cast_zero,Rat.cast_one]
+    have hp := sourceSampling_parameters stage
+    exact sampling_diagonal_whole_mass _ _ hp.1 hp.2.1 hp.2.2 (sourceSamplingCutoff_le_half stage)
+  have hp := Finset.prod_sdiff hK (f := F)
+  rw [Finset.prod_congr rfl hf,Finset.prod_const] at hp
+  simpa only [mul_comm] using hp.symm
+
+/-- The deterministic ideal product limit includes all growing-prefix cutoff
+losses and has exactly the tested diagonal-coordinate limits. -/
+theorem sourceSamplingIdeal_rectangle_tendsto (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest) :
+    Tendsto (fun stage => ∫ x, sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I))
+      (sourceSamplingRationalX T) (sourceSamplingRationalY T) x ∂sourceSamplingHaar)
+      atTop (𝓝 (sourceSamplingLimitRectangleMass I T)) := by
+  let F := fun stage i => ∫ s, samplingTestedFirstDensity (decide (i ∈ I)) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure
+  have hcoord (i : SourceCoordinate) : Tendsto (fun stage => F stage i) atTop
+      (𝓝 (if i ∈ I then ∫ s, samplingTestedFirstDensity true (sourceSamplingWidth 0) (sourceSamplingCutoff 0)
+        (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure
+      else (unitIntervalMeasure (sourceSamplingRationalX T i ∩ sourceSamplingRationalY T i)).toReal)) := by
+    by_cases hi : i ∈ I
+    · simp only [ite_eq_left hi,F,decide_eq_true hi]
+      have he (stage : ℕ) : (∫ s, samplingTestedFirstDensity true (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure) =
+        ∫ s, samplingTestedFirstDensity true (sourceSamplingWidth 0) (sourceSamplingCutoff 0)
+          (sourceSamplingRationalX T i) (sourceSamplingRationalY T i) s ∂unitIntervalMeasure := by
+        apply integral_congr_ae
+        exact Eventually.of_forall (fun s => samplingTestedFirstDensity_triangular_parameters _ _ _ _ _ _ _)
+      simp_rw [he]
+      exact tendsto_const_nhds
+    · simp only [ite_eq_right hi,F,decide_eq_false hi]
+      exact sourceSampling_diagonal_integral_tendsto _ measurableSet_Icc _ _
+  have hfixed := tendsto_finsetProd (I ∪ T.1) (fun i _ => hcoord i)
+  have htail := sourceSampling_untested_mass_tendsto
+    (fun stage => (sourceSamplingPrefix stage \ (I ∪ T.1)).card)
+    (fun stage => Finset.card_le_card Finset.sdiff_subset)
+  have hall := hfixed.mul htail
+  simp only [mul_one] at hall
+  apply hall.congr'
+  filter_upwards [sourceSamplingPrefix_eventually_covers (I ∪ T.1)] with stage hstage
+  exact (sourceSamplingIdeal_rectangle_split I T stage hstage).symm
+
+/-- Actual untrimmed rational rectangle masses converge to the explicit
+triangular/diagonal product value on one conull event for all I and tests. -/
+theorem sourceSampling_rectangle_limit_event :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest),
+      Tendsto (fun stage => ((sourceSamplingUntrimmed I stage θ)
+        (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).toReal)
+        atTop (𝓝 (sourceSamplingLimitRectangleMass I T)) := by
+  filter_upwards [sourceSampling_rectangle_approximation_event] with θ hθ
+  intro I T
+  have hh := (hθ I T).add (sourceSamplingIdeal_rectangle_tendsto I T)
+  simpa only [sub_add_cancel,zero_add] using hh
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/LambdaMarginals.lean

@@ -0,0 +1,69 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Cube
+import OAI.Analysis.FiniteFactor.SubmeasureL2Density
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+def sourceSamplingLimitCoordinate (I : Finset SourceCoordinate) (r : Bool)
+    (i : SourceCoordinate) (z : ℝ × ℝ) : ℝ := if r = true ∧ i ∈ I then z.2 else z.1
+
+theorem sourceSamplingLimitCoordinate_preserving (I : Finset SourceCoordinate) (r : Bool)
+    (i : SourceCoordinate) : MeasurePreserving (sourceSamplingLimitCoordinate I r i)
+      (unitIntervalMeasure.prod unitIntervalMeasure) unitIntervalMeasure := by
+  by_cases h : r = true ∧ i ∈ I
+  · have he : sourceSamplingLimitCoordinate I r i = Prod.snd := by funext z; simp [sourceSamplingLimitCoordinate,h]
+    rw [he]
+    exact measurePreserving_snd
+  · have he : sourceSamplingLimitCoordinate I r i = Prod.fst := by funext z; simp [sourceSamplingLimitCoordinate,h]
+    rw [he]
+    exact measurePreserving_fst
+
+theorem sourceSamplingLimitEndpoint_eq (I : Finset SourceCoordinate) (r : Bool) :
+    sourceSamplingEndpoint r ∘ sourceSamplingLimitMap I =
+      (fun p i => sourceSamplingLimitCoordinate I r i (p i)) := by
+  funext p i
+  cases r <;> simp [sourceSamplingEndpoint,sourceSamplingLimitMap,sourceSamplingLimitCoordinate]
+
+/-- Before the triangular restriction, either selected endpoint is exactly
+product Haar, including the mixed first/second selection in the second endpoint. -/
+theorem sourceSamplingLimitEndpoint_preserving (I : Finset SourceCoordinate) (r : Bool) :
+    MeasurePreserving (sourceSamplingEndpoint r ∘ sourceSamplingLimitMap I)
+      sourceSamplingPairHaar sourceSamplingHaar := by
+  rw [sourceSamplingLimitEndpoint_eq]
+  refine ⟨Measurable.of_eval (fun i => (sourceSamplingLimitCoordinate_preserving I r i).measurable.comp
+    (measurable_pi_apply i)),?_⟩
+  rw [Measure.infinitePi_map_pi _ (fun i => (sourceSamplingLimitCoordinate_preserving I r i).measurable)]
+  simp only [(sourceSamplingLimitCoordinate_preserving I r _).map_eq]
+
+/-- Both actual limiting marginals are submeasures of Haar. This proves the
+absolute continuity needed for the later Lusin transfer without assuming a marginal law. -/
+theorem sourceSamplingLambda_marginal_le (I : Finset SourceCoordinate) (r : Bool) :
+    (sourceSamplingLambda I).map (sourceSamplingEndpoint r) ≤ sourceSamplingHaar := by
+  rw [sourceSamplingLambda,Measure.map_map (sourceSamplingEndpoint_measurable r)
+    (sourceSamplingLimitMap_measurable I)]
+  have h := Measure.map_mono (μ := sourceSamplingPairHaar.restrict (sourceSamplingTriangleSet I))
+    (ν := sourceSamplingPairHaar) Measure.restrict_le_self (sourceSamplingLimitEndpoint_preserving I r).measurable
+  rwa [(sourceSamplingLimitEndpoint_preserving I r).map_eq] at h
+
+theorem sourceSamplingLambda_marginal_density (I : Finset SourceCoordinate) (r : Bool) :
+    ∃ g : (SourceCoordinate → ℝ) → ℝ,
+      Measurable g ∧ (∀ x, 0 ≤ g x) ∧
+      (sourceSamplingLambda I).map (sourceSamplingEndpoint r) =
+        sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (g x)) ∧
+      (∀ᵐ x ∂sourceSamplingHaar, g x ≤ 1) ∧ MemLp g 2 sourceSamplingHaar ∧
+      (∫ x, g x^2 ∂sourceSamplingHaar) ≤ 1 := by
+  have h := sourceSamplingLambda_marginal_le I r
+  have h' : (sourceSamplingLambda I).map (sourceSamplingEndpoint r) ≤
+      sourceSamplingHaar.withDensity (fun _ => ENNReal.ofReal (1 : ℝ)) := by simpa using h
+  obtain ⟨g,hg,hg0,hgm,hgle,hglp,hgint⟩ := submeasure_L2_density sourceSamplingHaar
+    ((sourceSamplingLambda I).map (sourceSamplingEndpoint r)) (fun _ => 1) (memLp_const (1 : ℝ)) h'
+  exact ⟨g,hg,hg0,hgm,by simpa using hgle,hglp,by simpa using hgint⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/LambdaMass.lean

@@ -0,0 +1,53 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Cube
+import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+theorem sourceSampling_triangle_mass :
+    ((unitIntervalMeasure.prod unitIntervalMeasure)
+      {p : ℝ × ℝ | p.1 ∈ Set.Icc (0 : ℝ) 1 ∧ p.2 ∈ Set.Icc (0 : ℝ) 1 ∧ p.1 < p.2}).toReal = 1/2 := by
+  rw [← samplingTestedFirstDensity_triangular_mass (1/2) 1 _ _ measurableSet_Icc measurableSet_Icc]
+  have he : samplingTestedFirstDensity true (1/2) 1 (Set.Icc 0 1) (Set.Icc 0 1) =ᵐ[unitIntervalMeasure]
+      (fun s => 1-s) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with s hs
+    simpa only [ite_true] using samplingTestedFirstDensity_whole true (1/2) 1 s
+      (by norm_num) (by norm_num) (by norm_num) hs
+  rw [integral_congr_ae he,unitIntervalMeasure,restrict_Ico_eq_restrict_Ioc,
+    ← intervalIntegral.integral_of_le (show (0 : ℝ) ≤ 1 by norm_num)]
+  rw [intervalIntegral.integral_sub (f := fun _ : ℝ => (1 : ℝ)) (g := fun x : ℝ => x)
+    intervalIntegrable_const (continuous_id.intervalIntegrable _ _)]
+  norm_num [intervalIntegral.integral_const]
+
+theorem sourceSamplingLambda_mass (I : Finset SourceCoordinate) :
+    ((sourceSamplingLambda I) Set.univ).toReal = (1/2 : ℝ)^I.card := by
+  have he : sourceSamplingLambda I sourceSamplingCube = sourceSamplingLambda I Set.univ :=
+    measure_congr (by filter_upwards [sourceSamplingLambda_cube I] with p hp; exact propext (iff_true_intro hp))
+  rw [← he,← sourceSamplingEmptyTest_rectangle,sourceSamplingLambda_rectangle,
+    sourceSamplingLimitRectangleMass_formula]
+  have hE (i : SourceCoordinate) : sourceSamplingRationalX sourceSamplingEmptyTest i = Set.Icc (0 : ℝ) 1 ∧
+      sourceSamplingRationalY sourceSamplingEmptyTest i = Set.Icc (0 : ℝ) 1 := by
+    simp [sourceSamplingRationalX,sourceSamplingRationalY,sourceSamplingRationalEndpoints,sourceSamplingEmptyTest]
+  change (∏ i ∈ I ∪ ∅, _) = _
+  rw [Finset.union_empty]
+  calc
+    _ = ∏ _i ∈ I, (1/2 : ℝ) := by
+      apply Finset.prod_congr rfl
+      intro i hi
+      rw [ite_eq_left hi,(hE i).1,(hE i).2]
+      exact sourceSampling_triangle_mass
+    _ = _ := by simp
+
+theorem sourceSamplingLambda_mass_pos (I : Finset SourceCoordinate) :
+    0 < ((sourceSamplingLambda I) Set.univ).toReal := by
+  rw [sourceSamplingLambda_mass]
+  positivity
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/LambdaRectangles.lean

@@ -0,0 +1,122 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.LimitMeasure
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+def sourceSamplingLambdaTest (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest)
+    (i : SourceCoordinate) (p : ℝ × ℝ) : Prop :=
+  if i ∈ I then p.1 ∈ sourceSamplingRationalX T i ∧ p.2 ∈ sourceSamplingRationalY T i ∧ p.1 < p.2
+  else p.1 ∈ sourceSamplingRationalX T i ∧ p.1 ∈ sourceSamplingRationalY T i
+
+theorem sourceSamplingLambdaTest_measurable (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest)
+    (i : SourceCoordinate) : MeasurableSet {p | sourceSamplingLambdaTest I T i p} := by
+  by_cases hi : i ∈ I
+  · simp only [sourceSamplingLambdaTest,ite_eq_left hi]
+    exact (measurableSet_Icc.preimage measurable_fst).inter
+      ((measurableSet_Icc.preimage measurable_snd).inter (measurableSet_lt measurable_fst measurable_snd))
+  · simp only [sourceSamplingLambdaTest,ite_eq_right hi]
+    exact (measurableSet_Icc.preimage measurable_fst).inter (measurableSet_Icc.preimage measurable_fst)
+
+/-- The finite coordinate conditions are equivalent to restriction by the
+triangle and the full cylinder rectangle on the conull Haar cube. -/
+theorem sourceSamplingLambdaTest_iff (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest)
+    (p : SourceCoordinate → ℝ × ℝ)
+    (hp : ∀ i, (p i).1 ∈ Set.Ico (0 : ℝ) 1 ∧ (p i).2 ∈ Set.Ico (0 : ℝ) 1) :
+    (∀ i ∈ I ∪ T.1, sourceSamplingLambdaTest I T i (p i)) ↔
+      sourceSamplingLimitMap I p ∈ sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T) ∧
+      p ∈ sourceSamplingTriangleSet I := by
+  constructor
+  · intro h
+    constructor
+    · intro i
+      by_cases hi : i ∈ I
+      · have hh := h i (Finset.mem_union_left _ hi)
+        simp only [sourceSamplingLambdaTest,ite_eq_left hi] at hh
+        exact ⟨hh.1,by simpa only [sourceSamplingLimitMap,ite_eq_left hi] using hh.2.1⟩
+      · by_cases ht : i ∈ T.1
+        · have hh := h i (Finset.mem_union_right _ ht)
+          simpa only [sourceSamplingLambdaTest,sourceSamplingLimitMap,ite_eq_right hi] using hh
+        · have hx : (p i).1 ∈ Set.Icc (0 : ℝ) 1 := ⟨(hp i).1.1,(hp i).1.2.le⟩
+          simpa only [sourceSamplingLimitMap,ite_eq_right hi,sourceSamplingRationalX,sourceSamplingRationalY,
+            sourceSamplingRationalEndpoints,dite_eq_right ht,Rat.cast_zero,Rat.cast_one] using And.intro hx hx
+    · intro i hi
+      have hh := h i (Finset.mem_union_left _ hi)
+      simp only [sourceSamplingLambdaTest,ite_eq_left hi] at hh
+      exact hh.2.2
+  · rintro ⟨hrect,htri⟩ i _
+    have hh := hrect i
+    by_cases hi : i ∈ I
+    · simp only [sourceSamplingLambdaTest,ite_eq_left hi]
+      exact ⟨hh.1,by simpa only [sourceSamplingLimitMap,ite_eq_left hi] using hh.2,htri i hi⟩
+    · simpa only [sourceSamplingLambdaTest,sourceSamplingLimitMap,ite_eq_right hi] using hh
+
+/-- The constructed infinite-coordinate measure has exactly the rectangle
+values previously obtained as sampling limits. -/
+theorem sourceSamplingLambda_rectangle (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest) :
+    ((sourceSamplingLambda I)
+      (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).toReal =
+      sourceSamplingLimitRectangleMass I T := by
+  let R := sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T)
+  let C := sourceSamplingLimitMap I ⁻¹' R ∩ sourceSamplingTriangleSet I
+  have hR : MeasurableSet R := sourceSamplingRectangle_measurable _ _
+    (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+  have hmap := sourceSamplingLimitMap_measurable I
+  have hC : MeasurableSet C := (hmap hR).inter (sourceSamplingTriangleSet_measurable I)
+  have he : C.indicator (fun _ => (1 : ℝ)) =ᵐ[sourceSamplingPairHaar]
+      (fun p => ∏ i ∈ I ∪ T.1, if sourceSamplingLambdaTest I T i (p i) then (1 : ℝ) else 0) := by
+    filter_upwards [sourceSamplingPairHaar_cube] with p hp
+    simp only [Finset.prod_ite_zero,Finset.prod_const_one,
+      sourceSamplingLambdaTest_iff I T p hp,Set.indicator_apply]
+    rfl
+  rw [sourceSamplingLambda,Measure.map_apply hmap hR,Measure.restrict_apply (hmap hR)]
+  change (sourceSamplingPairHaar C).toReal = _
+  calc
+    _ = ∫ p, C.indicator (fun _ => (1 : ℝ)) p ∂sourceSamplingPairHaar := by
+      rw [integral_indicator hC]; simp [measureReal_def]
+    _ = ∫ p, ∏ i ∈ I ∪ T.1, if sourceSamplingLambdaTest I T i (p i) then (1 : ℝ) else 0
+        ∂sourceSamplingPairHaar := integral_congr_ae he
+    _ = ∏ i ∈ I ∪ T.1, ∫ z, (if sourceSamplingLambdaTest I T i z then (1 : ℝ) else 0)
+        ∂unitIntervalMeasure.prod unitIntervalMeasure :=
+      integral_infinitePi_finset_prod _ _ _ (fun i =>
+        Measurable.ite (sourceSamplingLambdaTest_measurable I T i) measurable_const measurable_const)
+    _ = _ := by
+      rw [sourceSamplingLimitRectangleMass_formula]
+      apply Finset.prod_congr rfl
+      intro i _
+      have hA := sourceSamplingLambdaTest_measurable I T i
+      have hh : (∫ z, (if sourceSamplingLambdaTest I T i z then (1 : ℝ) else 0)
+          ∂unitIntervalMeasure.prod unitIntervalMeasure) =
+          ((unitIntervalMeasure.prod unitIntervalMeasure) {z | sourceSamplingLambdaTest I T i z}).toReal := by
+        change (∫ z, {z | sourceSamplingLambdaTest I T i z}.indicator (fun _ => (1 : ℝ)) z
+          ∂unitIntervalMeasure.prod unitIntervalMeasure) = _
+        rw [integral_indicator hA]; simp [measureReal_def]
+      rw [hh]
+      by_cases hi : i ∈ I
+      · simp only [sourceSamplingLambdaTest,ite_eq_left hi]
+      · simp only [sourceSamplingLambdaTest,ite_eq_right hi]
+        have heq : {z : ℝ × ℝ | z.1 ∈ sourceSamplingRationalX T i ∧ z.1 ∈ sourceSamplingRationalY T i} =
+            (sourceSamplingRationalX T i ∩ sourceSamplingRationalY T i) ×ˢ Set.univ := by ext z; simp
+        rw [heq,Measure.prod_prod]
+        simp
+
+/-- Actual untrimmed measures converge to the actual source limiting measure
+on every rational cylinder rectangle, on a single conull event. -/
+theorem sourceSamplingLambda_rectangle_limit_event :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest),
+      Tendsto (fun stage => ((sourceSamplingUntrimmed I stage θ)
+        (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).toReal)
+        atTop (𝓝 (((sourceSamplingLambda I)
+          (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).toReal)) := by
+  filter_upwards [sourceSampling_rectangle_limit_event] with θ hθ
+  intro I T
+  rw [sourceSamplingLambda_rectangle]
+  exact hθ I T
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/LimitMeasure.lean

@@ -0,0 +1,98 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.TriangleLaw
+import OAI.Analysis.FiniteFactor.OrbitSampling.IdealRectangleLimit
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+abbrev sourceSamplingPairHaar : Measure (SourceCoordinate → ℝ × ℝ) :=
+  Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure.prod unitIntervalMeasure)
+
+def sourceSamplingTriangleSet (I : Finset SourceCoordinate) : Set (SourceCoordinate → ℝ × ℝ) :=
+  {p | ∀ i ∈ I, (p i).1 < (p i).2}
+
+def sourceSamplingLimitMap (I : Finset SourceCoordinate) (p : SourceCoordinate → ℝ × ℝ) :
+    (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) :=
+  (fun i => (p i).1,fun i => if i ∈ I then (p i).2 else (p i).1)
+
+def sourceSamplingLambda (I : Finset SourceCoordinate) :
+    Measure ((SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) :=
+  (sourceSamplingPairHaar.restrict (sourceSamplingTriangleSet I)).map (sourceSamplingLimitMap I)
+
+theorem sourceSamplingTriangleSet_measurable (I : Finset SourceCoordinate) :
+    MeasurableSet (sourceSamplingTriangleSet I) := by
+  simp only [sourceSamplingTriangleSet,Set.ofPred_forall]
+  apply MeasurableSet.iInter
+  intro i
+  apply MeasurableSet.iInter
+  intro _
+  exact measurableSet_lt (measurable_fst.comp (measurable_pi_apply i))
+    (measurable_snd.comp (measurable_pi_apply i))
+
+theorem sourceSamplingLimitMap_measurable (I : Finset SourceCoordinate) :
+    Measurable (sourceSamplingLimitMap I) := by
+  apply Measurable.prodMk
+  · exact Measurable.of_eval (fun i => measurable_fst.comp (measurable_pi_apply i))
+  · apply Measurable.of_eval
+    intro i
+    by_cases hi : i ∈ I
+    · simpa only [hi,ite_true,Function.comp_def] using measurable_snd.comp (measurable_pi_apply i)
+    · simpa only [hi,ite_false,Function.comp_def] using measurable_fst.comp (measurable_pi_apply i)
+
+instance sourceSamplingLambda_finite (I : Finset SourceCoordinate) : IsFiniteMeasure (sourceSamplingLambda I) := by
+  unfold sourceSamplingLambda
+  infer_instance
+
+theorem sourceSamplingPairHaar_cube : ∀ᵐ p ∂sourceSamplingPairHaar,
+    ∀ i, (p i).1 ∈ Set.Ico (0 : ℝ) 1 ∧ (p i).2 ∈ Set.Ico (0 : ℝ) 1 := by
+  apply ae_all_iff.mpr
+  intro i
+  have hp : ∀ᵐ z ∂unitIntervalMeasure.prod unitIntervalMeasure,
+      z.1 ∈ Set.Ico (0 : ℝ) 1 ∧ z.2 ∈ Set.Ico (0 : ℝ) 1 := by
+    apply (Measure.ae_prod_iff_ae_ae (measurableSet_Ico.prod measurableSet_Ico)).mpr
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with x hx
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with y hy
+    exact ⟨hx,hy⟩
+  have hh : ∀ᵐ z ∂sourceSamplingPairHaar.map (fun p => p i),
+      z.1 ∈ Set.Ico (0 : ℝ) 1 ∧ z.2 ∈ Set.Ico (0 : ℝ) 1 := by
+    rw [Measure.infinitePi_map_eval]
+    exact hp
+  exact ae_of_ae_map (measurable_pi_apply i).aemeasurable hh
+
+/-- The actual limiting measure is carried by ordered pairs. -/
+theorem sourceSamplingLambda_ordered (I : Finset SourceCoordinate) :
+    ∀ᵐ p ∂sourceSamplingLambda I, ∀ i, p.1 i ≤ p.2 i := by
+  have horder : MeasurableSet {p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) |
+      ∀ i, p.1 i ≤ p.2 i} := by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter (fun i => measurableSet_le
+      ((measurable_pi_apply i).comp measurable_fst) ((measurable_pi_apply i).comp measurable_snd))
+  apply (ae_map_iff (sourceSamplingLimitMap_measurable I).aemeasurable horder).mpr
+  filter_upwards [ae_restrict_mem (sourceSamplingTriangleSet_measurable I)] with p hp
+  intro i
+  by_cases hi : i ∈ I
+  · simpa only [sourceSamplingLimitMap,ite_eq_left hi] using (hp i hi).le
+  · simp [sourceSamplingLimitMap,hi]
+
+/-- The finite rectangle formula for the source limit, written using actual
+Lebesgue triangular and diagonal masses. -/
+theorem sourceSamplingLimitRectangleMass_formula (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest) :
+    sourceSamplingLimitRectangleMass I T = ∏ i ∈ I ∪ T.1,
+      if i ∈ I then ((unitIntervalMeasure.prod unitIntervalMeasure)
+        {p : ℝ × ℝ | p.1 ∈ sourceSamplingRationalX T i ∧
+          p.2 ∈ sourceSamplingRationalY T i ∧ p.1 < p.2}).toReal
+      else (unitIntervalMeasure (sourceSamplingRationalX T i ∩ sourceSamplingRationalY T i)).toReal := by
+  apply Finset.prod_congr rfl
+  intro i _
+  by_cases hi : i ∈ I
+  · simp only [ite_eq_left hi]
+    exact samplingTestedFirstDensity_triangular_mass _ _ _ _ measurableSet_Icc measurableSet_Icc
+  · simp only [ite_eq_right hi]
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Measures.lean

@@ -0,0 +1,79 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Weights
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Finset Filter
+open scoped ENNReal
+noncomputable section
+
+abbrev sourceSamplingHaar : Measure (SourceCoordinate → ℝ) :=
+  Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)
+
+def sourceSamplingWeightedMeasure (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) : Measure (SourceCoordinate → ℝ) :=
+  sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (sourceSamplingWeight I s θ n x))
+
+instance sourceSamplingWeightedMeasure_finite (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) : IsFiniteMeasure (sourceSamplingWeightedMeasure I s θ n) := by
+  apply isFiniteMeasure_withDensity
+  let C := ((sourceBlockSize s : ℝ)^(13/5 : ℝ))^(sourceSamplingPrefix s).card
+  have hh : (∫⁻ x, ENNReal.ofReal (sourceSamplingWeight I s θ n x) ∂sourceSamplingHaar) ≤ ENNReal.ofReal C := by
+    calc
+      _ ≤ ∫⁻ _x, ENNReal.ofReal C ∂sourceSamplingHaar :=
+        lintegral_mono (fun x => ENNReal.ofReal_le_ofReal (sourceSamplingWeight_bounds I s θ n x).2)
+      _ = _ := by simp
+  exact ne_top_of_le_ne_top ENNReal.ofReal_ne_top hh
+
+def sourceSamplingSummand (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    Measure ((SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) :=
+  (sourceSamplingWeightedMeasure I s θ n).map (fun x => (x,coordinateRotate θ n x))
+
+instance sourceSamplingSummand_finite (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) : IsFiniteMeasure (sourceSamplingSummand I s θ n) := by
+  unfold sourceSamplingSummand
+  infer_instance
+
+theorem sourceSamplingSummand_first_marginal (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    (sourceSamplingSummand I s θ n).map Prod.fst = sourceSamplingWeightedMeasure I s θ n := by
+  unfold sourceSamplingSummand
+  have hp : Measurable (fun x : SourceCoordinate → ℝ => (x,coordinateRotate θ n x)) :=
+    measurable_id.prodMk (coordinateRotate_preserving θ n).measurable
+  rw [Measure.map_map measurable_fst hp]
+  exact Measure.map_id
+
+/-- Finite positive untrimmed measures averaged over the constructed powers.
+No weak limit or uniform marginal bound is asserted by this definition. -/
+def sourceSamplingUntrimmed (I : Finset SourceCoordinate) (s : ℕ) (θ : SourceCoordinate → ℝ) :
+    Measure ((SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) :=
+  ENNReal.ofReal (1/((sourceSamplingPowers s).card : ℝ)) •
+    ∑ n ∈ sourceSamplingPowers s, sourceSamplingSummand I s θ n
+
+theorem sourceSamplingHaar_cube : ∀ᵐ x ∂sourceSamplingHaar,
+    ∀ i : SourceCoordinate, x i ∈ Set.Ico (0 : ℝ) 1 := by
+  rw [ae_all_iff]
+  intro i
+  have hh : ∀ᵐ t ∂sourceSamplingHaar.map (fun x => x i), t ∈ Set.Ico (0 : ℝ) 1 := by
+    rw [Measure.infinitePi_map_eval]
+    exact ae_restrict_mem measurableSet_Ico
+  exact (ae_map_iff (measurable_pi_apply i).aemeasurable measurableSet_Ico).mp hh
+
+/-- The weighted source law already orders every coordinate in its prefix. -/
+theorem sourceSamplingWeightedMeasure_orders (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    ∀ᵐ x ∂sourceSamplingWeightedMeasure I s θ n,
+      ∀ i ∈ sourceSamplingPrefix s, x i < coordinateRotate θ n x i := by
+  rw [sourceSamplingWeightedMeasure,ae_withDensity_iff
+    ((sourceSamplingWeight_measurable I s θ n).ennreal_ofReal)]
+  filter_upwards [sourceSamplingHaar_cube] with x hx hw
+  have hw' : sourceSamplingWeight I s θ n x ≠ 0 := by
+    intro he
+    exact hw (by rw [he]; simp)
+  exact sourceSamplingWeight_orders_prefix I s θ n x hx hw'
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Moments.lean

@@ -0,0 +1,50 @@
+import OAI.Analysis.FiniteFactor.Sampling.TestedSecondMoment
+import OAI.Analysis.FiniteFactor.OrbitSampling.Weights
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+noncomputable section
+
+theorem sourceSamplingWidth_le_half (s : ℕ) : sourceSamplingWidth s ≤ 1/2 := by
+  have hm : (100 : ℝ) ≤ sourceBlockSize s := by exact_mod_cast (sourceStage s).m_ge_100
+  have hm0 : 0 ≤ (sourceBlockSize s : ℝ) := by positivity
+  have he : sourceSamplingWidth s ≤ (sourceBlockSize s : ℝ)^(-1/2 : ℝ) :=
+    Real.rpow_le_rpow_of_exponent_le (by linarith) (by norm_num)
+  have hs : 2 ≤ Real.sqrt (sourceBlockSize s : ℝ) := by
+    nlinarith [Real.sq_sqrt hm0,Real.sqrt_nonneg (sourceBlockSize s : ℝ)]
+  apply he.trans
+  rw [show (-1/2 : ℝ) = -(1/2) by ring,Real.rpow_neg hm0,← Real.sqrt_eq_rpow]
+  simpa only [one_div] using (one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 2) hs)
+
+/-- Exact stage parameters discharge all cutoff/width assumptions in the
+source's tested second-diagonal one-coordinate moment bound. -/
+theorem sourceSampling_tested_second_moment (s : ℕ) (E G : Set ℝ)
+    (hE : MeasurableSet E) (hG : MeasurableSet G) :
+    (∀ᵐ x ∂unitIntervalMeasure,
+      0 ≤ samplingTestedSecondDensity (sourceSamplingWidth s) (sourceSamplingCutoff s) E G x ∧
+      samplingTestedSecondDensity (sourceSamplingWidth s) (sourceSamplingCutoff s) E G x ≤ 2) ∧
+    (∫ x, samplingTestedSecondDensity (sourceSamplingWidth s) (sourceSamplingCutoff s) E G x^2
+      ∂unitIntervalMeasure) ≤ 1+4*(sourceBlockSize s : ℝ)^(-6/5 : ℝ) := by
+  have hp := sourceSampling_parameters s
+  have hhalf := sourceSamplingWidth_le_half s
+  have hden : 0 < 1-sourceSamplingWidth s := by linarith [hp.2.1]
+  have hb := samplingTestedSecondDensity_square (sourceSamplingWidth s) (sourceSamplingCutoff s)
+    E G hp.1 hp.2.1 hp.2.2 hE hG
+  have hi : 1/(1-sourceSamplingWidth s) ≤ 2 := (div_le_iff₀ hden).mpr (by linarith)
+  have herror : (sourceSamplingWidth s)^2/(1-sourceSamplingWidth s)^2 ≤ 4*(sourceSamplingWidth s)^2 := by
+    apply (div_le_iff₀ (sq_pos_of_pos hden)).mpr
+    have hsq : (1/4 : ℝ) ≤ (1-sourceSamplingWidth s)^2 := by nlinarith
+    nlinarith [sq_nonneg (sourceSamplingWidth s),mul_nonneg (sq_nonneg (sourceSamplingWidth s))
+      (show 0 ≤ (1-sourceSamplingWidth s)^2-1/4 by linarith)]
+  have he : (sourceSamplingWidth s)^2 = (sourceBlockSize s : ℝ)^(-6/5 : ℝ) := by
+    unfold sourceSamplingWidth
+    rw [← Real.rpow_natCast,← Real.rpow_mul (sourceBlockSize_pos s).le]
+    norm_num
+  exact ⟨hb.1.mono (fun x hx => ⟨hx.1,hx.2.trans hi⟩),hb.2.trans (by rw [← he]; linarith)⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/OrbitSupport.lean

@@ -0,0 +1,48 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.OrderedRestriction
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+def sourceSamplingPositiveOrbits (s : ℕ) (θ : SourceCoordinate → ℝ) : Set SourceSamplingPair :=
+  {p | ∃ n ∈ sourceSamplingPowers s, 0 < n ∧ p.2 = coordinateRotate θ n p.1}
+
+theorem sourceSamplingPositiveOrbits_measurable (s : ℕ) (θ : SourceCoordinate → ℝ) :
+    MeasurableSet (sourceSamplingPositiveOrbits s θ) := by
+  simp only [sourceSamplingPositiveOrbits,Set.ofPred_exists]
+  apply MeasurableSet.iUnion
+  intro n
+  by_cases hn : n ∈ sourceSamplingPowers s
+  · simp only [hn,true_and]
+    by_cases hp : 0 < n
+    · simp only [hp,true_and]
+      exact measurableSet_eq_fun measurable_snd ((coordinateRotate_preserving θ n).measurable.comp measurable_fst)
+    · simp [hp]
+  · simp [hn]
+
+theorem sourceSamplingSummand_positive_orbit (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) (hn : n ∈ sourceSamplingPowers s) :
+    ∀ᵐ p ∂sourceSamplingSummand I s θ n, p ∈ sourceSamplingPositiveOrbits s θ := by
+  apply (ae_map_iff (measurable_id.prodMk (coordinateRotate_preserving θ n).measurable).aemeasurable
+    (sourceSamplingPositiveOrbits_measurable s θ)).mpr
+  exact Eventually.of_forall (fun x => ⟨n,hn,(sourceSamplingPowers_positive s n hn).1,rfl⟩)
+
+/-- Trimming preserves the constructed finite set of strictly positive
+orbit powers while imposing coordinatewise order everywhere. -/
+theorem sourceSamplingTrimmed_orbits (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : ∀ᵐ p ∂sourceSamplingTrimmed I s θ,
+      (∀ i, p.1 i ≤ p.2 i) ∧ ∃ n ∈ sourceSamplingPowers s, 0 < n ∧ p.2 = coordinateRotate θ n p.1 := by
+  have hu : ∀ᵐ p ∂sourceSamplingUntrimmed I s θ, p ∈ sourceSamplingPositiveOrbits s θ := by
+    apply Measure.ae_smul_measure
+    rw [ae_iff,Measure.finsetSum_apply]
+    exact Finset.sum_eq_zero (fun n hn => ae_iff.mp (sourceSamplingSummand_positive_orbit I s θ n hn))
+  filter_upwards [sourceSamplingTrimmed_ordered I s θ,ae_restrict_of_ae hu] with p ho hp
+  exact ⟨ho,hp⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/OrderedRestriction.lean

@@ -0,0 +1,100 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Cube
+import OAI.Analysis.FiniteFactor.OrbitSampling.WeightedTail
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+def sourceSamplingOrdered : Set SourceSamplingPair := {p | ∀ i, p.1 i ≤ p.2 i}
+
+theorem sourceSamplingOrdered_measurable : MeasurableSet sourceSamplingOrdered := by
+  simp only [sourceSamplingOrdered,Set.ofPred_forall]
+  exact MeasurableSet.iInter (fun i => measurableSet_le
+    ((measurable_pi_apply i).comp measurable_fst) ((measurable_pi_apply i).comp measurable_snd))
+
+/-- The actual ordered restriction of the already constructed average. -/
+def sourceSamplingTrimmed (I : Finset SourceCoordinate) (s : ℕ) (θ : SourceCoordinate → ℝ) :
+    Measure SourceSamplingPair := (sourceSamplingUntrimmed I s θ).restrict sourceSamplingOrdered
+
+instance sourceSamplingTrimmed_finite (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : IsFiniteMeasure (sourceSamplingTrimmed I s θ) := by
+  unfold sourceSamplingTrimmed
+  infer_instance
+
+theorem sourceSamplingTrimmed_ordered (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : ∀ᵐ p ∂sourceSamplingTrimmed I s θ, ∀ i, p.1 i ≤ p.2 i :=
+  ae_restrict_mem sourceSamplingOrdered_measurable
+
+theorem sourceSamplingTrimmed_le (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : sourceSamplingTrimmed I s θ ≤ sourceSamplingUntrimmed I s θ :=
+  Measure.restrict_le_self
+
+theorem sourceSamplingPowers_positive (s : ℕ) (n : ℤ) (hn : n ∈ sourceSamplingPowers s) :
+    0 < n ∧ (n : ℝ) ≤ samplingQ (sourceBlockSize s) := by
+  by_cases hs : 200000 ≤ sourceBlockSize s
+  · exact ⟨((sourceSamplingPowers_spec s hs).1 n hn).2.2,
+      ((sourceSamplingPowers_spec s hs).1 n hn).2.1⟩
+  · simp [sourceSamplingPowers,hs] at hn
+
+/-- Outside the finite prefix, every failure of global order is an actual
+member of the source's countable tail-failure event. -/
+theorem sourceSampling_order_failure_tail (s n : ℕ) (θ x : SourceCoordinate → ℝ)
+    (hprefix : ∀ i ∈ sourceSamplingPrefix s, x i < coordinateRotate θ (n : ℤ) x i)
+    (hbad : (x,coordinateRotate θ (n : ℤ) x) ∉ sourceSamplingOrdered) :
+    x ∈ sourceTailOrderFailure θ (s+1) n := by
+  have hb : ∃ i, coordinateRotate θ (n : ℤ) x i < x i := by
+    simpa only [sourceSamplingOrdered,Set.mem_ofPred_eq,not_forall,not_le] using hbad
+  obtain ⟨i,hi⟩ := hb
+  have hout : i ∉ sourceSamplingPrefix s := fun hh => (hprefix i hh).asymm hi
+  have hk : s+1 ≤ i.1 := by
+    have hh := (CouplingParameters.mem_blockPrefix sourceBlockSize (s+1) i)
+    change i ∉ CouplingParameters.blockPrefix sourceBlockSize (s+1) at hout
+    have hnot : ¬ i.1 < s+1 := fun hi => hout (hh.mpr hi)
+    omega
+  rcases i with ⟨k,j⟩
+  obtain ⟨r,rfl⟩ := Nat.exists_eq_add_of_le hk
+  apply Set.mem_iUnion.mpr ⟨r,?_⟩
+  apply Set.mem_iUnion.mpr ⟨j,?_⟩
+  simpa only [coordinateRotate,Int.cast_natCast,Set.mem_ofPred_eq] using hi
+
+/-- Discarded mass of each real summand obeys the preserved relative
+weighted-tail estimate. This includes summands of mass zero. -/
+theorem sourceSamplingSummand_discarded_le (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (hθ : SourceAngles θ) (n : ℤ)
+    (hn : n ∈ sourceSamplingPowers s) :
+    sourceSamplingSummand I s θ n sourceSamplingOrderedᶜ ≤
+      sourceSamplingSummand I s θ n Set.univ *
+        ENNReal.ofReal (4*(sourceBlockSize s : ℝ)^(-(sourceBlockSize s : ℝ)/20)) := by
+  have hp := sourceSamplingPowers_positive s n hn
+  have he : (n.toNat : ℤ) = n := Int.toNat_of_nonneg hp.1.le
+  have hm : Measurable (fun x => (x,coordinateRotate θ n x)) :=
+    measurable_id.prodMk (coordinateRotate_preserving θ n).measurable
+  rw [sourceSamplingSummand,Measure.map_apply hm sourceSamplingOrdered_measurable.compl,
+    Measure.map_apply hm MeasurableSet.univ,Set.preimage_univ]
+  have hc : (n.toNat : ℝ) = (n : ℝ) := by exact_mod_cast he
+  have hb := sourceSampling_weighted_tail_small I s θ hθ n.toNat (by rw [hc]; exact hp.2)
+  rw [he] at hb
+  apply le_trans _ hb
+  apply measure_mono_ae
+  filter_upwards [sourceSamplingWeightedMeasure_orders I s θ n] with x hx
+  intro hb
+  change (x,coordinateRotate θ n x) ∉ sourceSamplingOrdered at hb
+  exact sourceSampling_order_failure_tail s n.toNat θ x (by simpa [he] using hx) (by simpa [he] using hb)
+
+/-- The average loses at most the same relative error as each summand. -/
+theorem sourceSamplingUntrimmed_discarded_le (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (hθ : SourceAngles θ) :
+    sourceSamplingUntrimmed I s θ sourceSamplingOrderedᶜ ≤
+      sourceSamplingUntrimmed I s θ Set.univ *
+        ENNReal.ofReal (4*(sourceBlockSize s : ℝ)^(-(sourceBlockSize s : ℝ)/20)) := by
+  simp only [sourceSamplingUntrimmed,Measure.smul_apply,smul_eq_mul,Measure.finsetSum_apply]
+  rw [mul_assoc,Finset.sum_mul]
+  exact mul_le_mul' le_rfl (Finset.sum_le_sum (fun n hn => sourceSamplingSummand_discarded_le I s θ hθ n hn))
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/PairMoments.lean

@@ -0,0 +1,78 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.SecondCorrelation
+import OAI.Analysis.FiniteFactor.Sampling.SecondTriangular
+import OAI.Analysis.FiniteFactor.Sampling.IntegratedCorrelation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical
+noncomputable section
+
+/-- All four actual tested coordinate cases have the same pair-error budget. -/
+theorem sourceSampling_oriented_pair_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers stage) (hn' : n' ∈ sourceSamplingPowers stage) (hne : n ≠ n')
+    (r b : Bool) (a c a' c' s : ℝ) (hsx : s ∈ Set.Ioo (0 : ℝ) 1) :
+    |(∫ θ, samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s (Int.fract ((n : ℝ)*θ i)) *
+        samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s (Int.fract ((n' : ℝ)*θ i)) ∂sourceAngleLaw) -
+      samplingOrientedDensity r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s ^ 2| ≤
+      104*(sourceBlockSize stage : ℝ)^(-74 : ℝ) := by
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have h := (sourceStage stage).m_ge_100
+    exact_mod_cast (by omega : 1 ≤ sourceBlockSize stage)
+  cases r
+  · have hb := sourceSampling_first_pair_error stage hs i hi n n' hn hn' hne b
+      (Set.Icc a c) a' c' s ⟨hsx.1.le,hsx.2⟩
+    exact hb.trans (by nlinarith [Real.rpow_nonneg (sourceBlockSize_pos stage).le (-74 : ℝ)])
+  · cases b
+    · exact sourceSampling_second_pair_error stage hs i hi n n' hn hn' hne
+        (Set.Icc a' c') measurableSet_Icc a c s ⟨hsx.1.le,hsx.2⟩
+    · have := sourceSampling_phase_null_singletons stage hs i hi n hn
+      have := sourceSampling_phase_null_singletons stage hs i hi n' hn'
+      have hm (k : ℤ) : Measurable (fun θ : SourceCoordinate → ℝ => Int.fract ((k : ℝ)*θ i)) :=
+        sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i))
+      have hp := sourceSampling_parameters stage
+      have hb := samplingSecondTriangular_pair_bound sourceAngleLaw
+        (fun θ => Int.fract ((n : ℝ)*θ i)) (fun θ => Int.fract ((n' : ℝ)*θ i)) (hm n) (hm n')
+        (Eventually.of_forall (fun θ => ⟨Int.fract_nonneg _,Int.fract_lt_one _⟩))
+        (Eventually.of_forall (fun θ => ⟨Int.fract_nonneg _,Int.fract_lt_one _⟩))
+        _ (by positivity) (sourceSampling_rectangle_bound stage hs i hi n n' hn hn' hne)
+        _ _ (Set.Icc a' c') a c s hp.1 hp.2.1 hp.2.2 hsx
+      apply hb.trans
+      have he := Real.rpow_le_rpow_of_exponent_le hm1 (show (-80 : ℝ) ≤ -74 by norm_num)
+      nlinarith [Real.rpow_nonneg (sourceBlockSize_pos stage).le (-74 : ℝ)]
+
+theorem sourceSampling_coordinate_pair_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers stage) (hn' : n' ∈ sourceSamplingPowers stage) (hne : n ≠ n')
+    (r b : Bool) (a c a' c' : ℝ) :
+    |(∫ s, ∫ θ, samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s (Int.fract ((n : ℝ)*θ i)) *
+        samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s (Int.fract ((n' : ℝ)*θ i)) ∂sourceAngleLaw ∂unitIntervalMeasure) -
+      (∫ s, samplingOrientedDensity r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) (Set.Icc a' c') s ^ 2 ∂unitIntervalMeasure)| ≤
+      104*(sourceBlockSize stage : ℝ)^(-74 : ℝ) := by
+  have hp := sourceSampling_parameters stage
+  apply sampling_integrated_pair_error sourceAngleLaw
+    (fun θ => Int.fract ((n : ℝ)*θ i)) (fun θ => Int.fract ((n' : ℝ)*θ i))
+    (sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i)))
+    (sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i)))
+    (samplingOrientedWeight r b _ _ (Set.Icc a c) (Set.Icc a' c'))
+    (samplingOrientedWeight_measurable r b _ _ _ _ measurableSet_Icc measurableSet_Icc)
+    (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage))) _
+    (samplingOrientedWeight_bounds r b _ _ _ _ hp.1 hp.2.2)
+  have : NullSingletonClass unitIntervalMeasure := by unfold unitIntervalMeasure; infer_instance
+  filter_upwards [self_mem_ae_restrict measurableSet_Ico,
+    ae_iff.mpr (show unitIntervalMeasure {s | ¬s ≠ 0} = 0 by simp)] with s hsx hs0
+  exact sourceSampling_oriented_pair_error stage hs i hi n n' hn hn' hne r b a c a' c' s
+    ⟨lt_of_le_of_ne hsx.1 (Ne.symm hs0),hsx.2⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/PhaseSelfMoment.lean

@@ -0,0 +1,61 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.SelfMoment
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped ENNReal
+noncomputable section
+
+/-- Marginal phase domination controls the joint self-pair integral.
+This is the source's one-phase step before taking coordinate products. -/
+theorem sampling_phase_square_bound {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ] (X : Ω → ℝ) (hX : Measurable X)
+    (hdom : μ.map X ≤ (2 : ℝ≥0∞) • unitIntervalMeasure)
+    (u : ℝ → ℝ → ℝ) (C : ℝ) (hu : Measurable (fun p : ℝ × ℝ => u p.1 p.2))
+    (hb : ∀ s t, 0 ≤ u s t ∧ u s t ≤ C) :
+    (∫ s, ∫ ω, u s (X ω)^2 ∂μ ∂unitIntervalMeasure) ≤
+      2*(∫ s, ∫ t, u s t^2 ∂unitIntervalMeasure ∂unitIntervalMeasure) := by
+  have hΩ : Measurable (fun p : ℝ × Ω => u p.1 (X p.2)) :=
+    hu.comp (measurable_fst.prodMk (hX.comp measurable_snd))
+  have hiΩ := sampling_square_integrable (unitIntervalMeasure.prod μ) _ C hΩ
+    (fun p => hb p.1 (X p.2))
+  have hiU := sampling_square_integrable (unitIntervalMeasure.prod unitIntervalMeasure) _ C hu
+    (fun p => hb p.1 p.2)
+  have hpoint (s : ℝ) : (∫ ω, u s (X ω)^2 ∂μ) ≤ 2*(∫ t, u s t^2 ∂unitIntervalMeasure) := by
+    have hm : Measurable (fun t => u s t) := hu.comp (measurable_const.prodMk measurable_id)
+    have hi := sampling_square_integrable unitIntervalMeasure _ C hm (hb s)
+    have hbig := hi.smul_measure (c := (2 : ℝ≥0∞)) (by norm_num)
+    have hle := integral_mono_measure hdom (Eventually.of_forall (fun t => sq_nonneg (u s t))) hbig
+    rw [integral_map hX.aemeasurable (hm.pow_const 2).aestronglyMeasurable,
+      integral_smul_measure] at hle
+    simpa using hle
+  calc
+    _ ≤ ∫ s, 2*(∫ t, u s t^2 ∂unitIntervalMeasure) ∂unitIntervalMeasure :=
+      integral_mono_ae hiΩ.integral_prod_left (hiU.integral_prod_left.const_mul 2)
+        (Eventually.of_forall hpoint)
+    _ = _ := integral_const_mul _ _
+
+/-- Actual angle expectation of the tested self-pair, at every admissible
+selected power, for all source orientations and coordinate types. -/
+theorem sourceSampling_phase_self_moment (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n : ℤ) (hn : n ∈ sourceSamplingPowers stage)
+    (r b : Bool) (E G : Set ℝ) (hE : MeasurableSet E) (hG : MeasurableSet G) :
+    (∫ s, ∫ θ, samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+      E G s (Int.fract ((n : ℝ)*θ i)) ^ 2 ∂sourceAngleLaw ∂unitIntervalMeasure) ≤
+      2+8*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ) := by
+  have hp := sourceSampling_parameters stage
+  have hbound := sampling_phase_square_bound sourceAngleLaw (fun θ => Int.fract ((n : ℝ)*θ i))
+    (sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i)))
+    (sourceSampling_phase_domination stage hs i hi n hn)
+    (samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G)
+    (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))
+    (samplingOrientedWeight_measurable r b _ _ E G hE hG)
+    (samplingOrientedWeight_bounds r b _ _ E G hp.1 hp.2.2)
+  have hself := sourceSampling_oriented_self_moment stage r b E G hE hG
+  exact hbound.trans (by nlinarith)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Powers.lean

@@ -0,0 +1,153 @@
+import OAI.Analysis.FiniteFactor.Sampling.Selection
+import OAI.Analysis.FiniteFactor.CrossedProduct.PhaseDecay
+
+namespace OAI
+
+namespace FiniteFactor
+open Finset Filter
+open scoped Topology
+noncomputable section
+
+def samplingQ (m : ℕ) : ℝ := (m : ℝ)^((7/10 : ℝ)*(m : ℝ))
+def samplingH (m : ℕ) : ℕ := m^300
+def samplingR (m K : ℕ) : ℕ := m*K*m^1000
+
+theorem sampling_integer_candidates (Q : ℝ) (hQ : 4 ≤ Q) :
+    Q/4 ≤ ((Finset.Icc ⌈Q/2⌉ ⌊Q⌋).card : ℝ) := by
+  have hf := Int.sub_one_lt_floor Q
+  have hc := Int.ceil_lt_add_one (Q/2)
+  have horder : ⌈Q/2⌉ ≤ ⌊Q⌋ := by
+    have : (⌈Q/2⌉ : ℝ) < (⌊Q⌋ : ℝ)+1 := by linarith
+    have ht : ⌈Q/2⌉ < ⌊Q⌋+1 := by exact_mod_cast this
+    omega
+  rw [Int.card_Icc]
+  have hcast : ((⌊Q⌋+1-⌈Q/2⌉).toNat : ℝ) = (⌊Q⌋ : ℝ)+1-(⌈Q/2⌉ : ℝ) := by
+    exact_mod_cast Int.toNat_of_nonneg (by omega : 0 ≤ ⌊Q⌋+1-⌈Q/2⌉)
+  rw [hcast]
+  linarith
+
+theorem sampling_forbidden_budget (m K : ℕ) (hm : 4 ≤ m) (hK : K ≤ m) :
+    (((2*samplingH m+1)^2*(2*samplingR m K+1) : ℕ) : ℝ) ≤ (m : ℝ)^1605 := by
+  have hm1 : 1 ≤ m := by omega
+  have hh : 1 ≤ samplingH m := one_le_pow₀ hm1
+  have hr : samplingR m K ≤ m^1002 := by
+    unfold samplingR
+    calc
+      m*K*m^1000 ≤ m*m*m^1000 := by gcongr
+      _ = m^1002 := by ring
+  have hp : 1 ≤ m^1002 := one_le_pow₀ hm1
+  have hD : (2*samplingH m+1)^2*(2*samplingR m K+1) ≤ 27*m^1602 := by
+    calc
+      _ ≤ (3*samplingH m)^2*(3*m^1002) := by gcongr <;> omega
+      _ = _ := by unfold samplingH; ring
+  have h27 : 27 ≤ m^3 := (by norm_num : 27 ≤ (4 : ℕ)^3).trans (Nat.pow_le_pow_left hm 3)
+  have hhD : (2*samplingH m+1)^2*(2*samplingR m K+1) ≤ m^1605 := by
+    calc
+      _ ≤ 27*m^1602 := hD
+      _ ≤ m^3*m^1602 := Nat.mul_le_mul_right _ h27
+      _ = _ := by ring
+  exact_mod_cast hhD
+
+/-- An explicit sufficiently-large threshold discharges the source's greedy
+asymptotics, retaining Q, H, R and the exponent 0.69m exactly. -/
+theorem exists_source_sampling_powers (m K : ℕ) (hm : 200000 ≤ m) (hK : K ≤ m) :
+    ∃ N : Finset ℤ,
+      (∀ n ∈ N, samplingQ m/2 ≤ (n : ℝ) ∧ (n : ℝ) ≤ samplingQ m ∧ 0 < n) ∧
+      (m : ℝ)^((69/100 : ℝ)*(m : ℝ)) ≤ (N.card : ℝ) ∧
+      (N : Set ℤ).Pairwise (fun n n' => ¬SamplingConflict (samplingH m) (samplingR m K) n n') := by
+  have hmR : (200000 : ℝ) ≤ m := by exact_mod_cast hm
+  have hm0 : (0 : ℝ) < m := by linarith
+  have hm1 : (1 : ℝ) ≤ m := by linarith
+  have hQ : (m : ℝ)^1606 ≤ samplingQ m := by
+    unfold samplingQ
+    rw [← Real.rpow_natCast]
+    apply Real.rpow_le_rpow_of_exponent_le hm1
+    norm_num
+    linarith
+  have hmQ : (m : ℝ) ≤ samplingQ m := by
+    calc
+      _ ≤ (m : ℝ)^1606 := le_self_pow₀ hm1 (by norm_num)
+      _ ≤ _ := hQ
+  have hQ4 : 4 ≤ samplingQ m := by linarith
+  have hR : (samplingR m K : ℝ) < samplingQ m/2 := by
+    have hr : samplingR m K ≤ m^1002 := by
+      unfold samplingR
+      calc
+        m*K*m^1000 ≤ m*m*m^1000 := by gcongr
+        _ = _ := by ring
+    have hsmall : (m : ℝ)^1002 * (m : ℝ) ≤ (m : ℝ)^1606 := by
+      rw [← pow_succ]
+      exact pow_le_pow_right₀ hm1 (by norm_num)
+    have hrR : (samplingR m K : ℝ) ≤ (m : ℝ)^1002 := by exact_mod_cast hr
+    have hpos : 0 < (m : ℝ)^1002 := by positivity
+    nlinarith
+  let S := Finset.Icc ⌈samplingQ m/2⌉ ⌊samplingQ m⌋
+  have hS (n : ℤ) (hn : n ∈ S) :
+      samplingQ m/2 ≤ (n : ℝ) ∧ (n : ℝ) ≤ samplingQ m := by
+    have hh := mem_Icc.mp hn
+    constructor
+    · exact (Int.le_ceil _).trans (by exact_mod_cast hh.1)
+    · exact (show (n : ℝ) ≤ (⌊samplingQ m⌋ : ℝ) by exact_mod_cast hh.2).trans (Int.floor_le _)
+  obtain ⟨N,hNS,hpair,hcard⟩ := exists_sampling_separated (samplingH m) (samplingR m K)
+    (one_le_pow₀ (by omega)) S (fun n hn => by exact_mod_cast hR.trans_le (hS n hn).1)
+  refine ⟨N, fun n hn => ⟨(hS n (hNS hn)).1, (hS n (hNS hn)).2, ?_⟩, ?_, hpair⟩
+  · have hh := (hS n (hNS hn)).1
+    have : (0 : ℝ) < n := by linarith
+    exact_mod_cast this
+  · have hcount : samplingQ m/4 ≤
+        (((2*samplingH m+1)^2*(2*samplingR m K+1) : ℕ) : ℝ)*(N.card : ℝ) :=
+      (sampling_integer_candidates _ hQ4).trans (by exact_mod_cast hcard)
+    have hDb := sampling_forbidden_budget m K (by omega) hK
+    have hcount' : samplingQ m/4 ≤ (m : ℝ)^1605*(N.card : ℝ) :=
+      hcount.trans (mul_le_mul_of_nonneg_right hDb (Nat.cast_nonneg _))
+    have hexp : (m : ℝ)^1605*(m : ℝ)^((69/100 : ℝ)*(m : ℝ))*(m : ℝ) ≤ samplingQ m := by
+      unfold samplingQ
+      calc
+        _ = (m : ℝ)^(1605+(69/100 : ℝ)*(m : ℝ)+1) := by
+          rw [Real.rpow_add hm0, Real.rpow_one, Real.rpow_add hm0]
+          norm_num [Real.rpow_ofNat]
+        _ ≤ _ := by
+          apply Real.rpow_le_rpow_of_exponent_le hm1
+          norm_num
+          linarith
+    have hprod : 0 < (m : ℝ)^1605 := by positivity
+    have htarget : 0 ≤ (m : ℝ)^((69/100 : ℝ)*(m : ℝ)) := by positivity
+    apply (mul_le_mul_iff_right₀ hprod).mp
+    nlinarith
+
+/-- A deterministic finite set fixed from the numerical stages alone. -/
+def sourceSamplingPowers (s : ℕ) : Finset ℤ :=
+  if h : 200000 ≤ sourceBlockSize s then
+    Classical.choose (exists_source_sampling_powers (sourceBlockSize s)
+      (sourceStageState s).K h (sourceStage s).m_ge_K)
+  else ∅
+
+theorem sourceSamplingPowers_spec (s : ℕ) (hs : 200000 ≤ sourceBlockSize s) :
+    (∀ n ∈ sourceSamplingPowers s,
+      samplingQ (sourceBlockSize s)/2 ≤ (n : ℝ) ∧
+      (n : ℝ) ≤ samplingQ (sourceBlockSize s) ∧ 0 < n) ∧
+    (sourceBlockSize s : ℝ)^((69/100 : ℝ)*(sourceBlockSize s : ℝ)) ≤
+      ((sourceSamplingPowers s).card : ℝ) ∧
+    ((sourceSamplingPowers s : Finset ℤ) : Set ℤ).Pairwise (fun n n' =>
+      ¬SamplingConflict (samplingH (sourceBlockSize s))
+        (samplingR (sourceBlockSize s) (sourceStageState s).K) n n') := by
+  unfold sourceSamplingPowers
+  rw [dite_eq_left hs]
+  exact Classical.choose_spec (exists_source_sampling_powers _ _ hs (sourceStage s).m_ge_K)
+
+theorem sourceSamplingPowers_eventually : ∀ᶠ s in atTop,
+    (∀ n ∈ sourceSamplingPowers s,
+      samplingQ (sourceBlockSize s)/2 ≤ (n : ℝ) ∧
+      (n : ℝ) ≤ samplingQ (sourceBlockSize s) ∧ 0 < n) ∧
+    (sourceBlockSize s : ℝ)^((69/100 : ℝ)*(sourceBlockSize s : ℝ)) ≤
+      ((sourceSamplingPowers s).card : ℝ) ∧
+    ((sourceSamplingPowers s : Finset ℤ) : Set ℤ).Pairwise (fun n n' =>
+      ¬SamplingConflict (samplingH (sourceBlockSize s))
+        (samplingR (sourceBlockSize s) (sourceStageState s).K) n n') := by
+  filter_upwards [sourceBlockSize_tendsto.eventually (eventually_ge_atTop 200000)] with s hs
+  exact sourceSamplingPowers_spec s hs
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/ProductError.lean

@@ -0,0 +1,114 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.CrossProducts
+import OAI.Analysis.FiniteFactor.Sampling.ProductError
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+def sourceSamplingCorrelationBudget (stage : ℕ) : ℝ :=
+  ((sourceSamplingPrefix stage).card : ℝ)*(104*(sourceBlockSize stage : ℝ)^(-74 : ℝ))*Real.exp 135
+
+/-- Uniform telescoping budget from the actual ideal coordinate moments. -/
+theorem sourceSampling_coordinate_product_error (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (f : SourceCoordinate → ℝ) (hf : ∀ i ∈ sourceSamplingPrefix stage, 0 ≤ f i)
+    (he : ∀ i ∈ sourceSamplingPrefix stage,
+      |f i-(∫ s, samplingOrientedDensity r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (E i) (G i) s^2 ∂unitIntervalMeasure)| ≤ 104*(sourceBlockSize stage : ℝ)^(-74 : ℝ)) :
+    |(∏ i ∈ sourceSamplingPrefix stage, f i)-
+      (∫ x, sourceSamplingIdealDensity stage r b E G x^2
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))| ≤ sourceSamplingCorrelationBudget stage := by
+  let A (i : SourceCoordinate) := ∫ s, samplingOrientedDensity r (b i) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (E i) (G i) s^2 ∂unitIntervalMeasure
+  let x := (sourceBlockSize stage : ℝ)^(-6/5 : ℝ)
+  let ε := 104*(sourceBlockSize stage : ℝ)^(-74 : ℝ)
+  let M := 1+108*x
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have h : 100 ≤ sourceBlockSize stage := (sourceStage stage).m_ge_100
+    exact_mod_cast (show 1 ≤ sourceBlockSize stage by omega)
+  have hx : 0 ≤ x := by dsimp [x]; positivity
+  have hε : 0 ≤ ε := by dsimp [ε]; positivity
+  have hεx : ε ≤ 104*x := mul_le_mul_of_nonneg_left
+    (Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num : (-74 : ℝ) ≤ -6/5)) (by norm_num)
+  have hA (i : SourceCoordinate) : 0 ≤ A i ∧ A i ≤ 1+4*x :=
+    ⟨integral_nonneg (fun _ => sq_nonneg _),(sourceSampling_oriented_moment stage r (b i) (E i) (G i) (hE i) (hG i)).2⟩
+  have hfb (i : SourceCoordinate) (hi : i ∈ sourceSamplingPrefix stage) : 0 ≤ f i ∧ f i ≤ M := by
+    refine ⟨hf i hi,?_⟩
+    have hh := (abs_le.mp (he i hi)).2
+    have ha := (hA i).2
+    dsimp [M]
+    change f i-A i ≤ ε at hh
+    linarith
+  have hAb (i : SourceCoordinate) (_hi : i ∈ sourceSamplingPrefix stage) : 0 ≤ A i ∧ A i ≤ M :=
+    ⟨(hA i).1,(hA i).2.trans (by dsimp [M]; linarith)⟩
+  have hpow : M^(sourceSamplingPrefix stage).card ≤ Real.exp 135 := by
+    have hp := product_energy_le_exp (fun _i : sourceSamplingPrefix stage => M)
+      (fun _i : sourceSamplingPrefix stage => 108*x)
+      (fun _ => by dsimp [M]; positivity) (fun _ => le_rfl)
+    have hbudget : ((sourceSamplingPrefix stage).card : ℝ)*(108*x) ≤ 135 := by
+      have hh := sourceSampling_prefix_quadratic_budget stage
+      change ((sourceSamplingPrefix stage).card : ℝ)*(4*x) ≤ 5 at hh
+      nlinarith
+    have hp' : M^(sourceSamplingPrefix stage).card ≤
+        Real.exp (((sourceSamplingPrefix stage).card : ℝ)*(108*x)) := by simpa using hp
+    exact hp'.trans (Real.exp_le_exp.mpr hbudget)
+  rw [sourceSamplingIdealDensity_square stage r b E G hE hG]
+  apply (sampling_product_error (sourceSamplingPrefix stage) f A M ε (by dsimp [M]; linarith) hε hfb hAb he).trans
+  exact mul_le_mul_of_nonneg_left hpow (by positivity)
+
+/-- Distinct products under the actual angle and Haar laws. -/
+theorem sourceSamplingProduct_pair_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (r : Bool) (b : SourceCoordinate → Bool) (a c a' c' : SourceCoordinate → ℝ)
+    (n k : ℤ) (hn : n ∈ sourceSamplingPowers stage) (hk : k ∈ sourceSamplingPowers stage) (hne : n ≠ k) :
+    |(∫ θ, ∫ x, sourceSamplingProduct stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) n θ x *
+        sourceSamplingProduct stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) k θ x
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) ∂sourceAngleLaw)-
+      (∫ x, sourceSamplingIdealDensity stage r b (fun i => Set.Icc (a i) (c i)) (fun i => Set.Icc (a' i) (c' i)) x^2
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))| ≤ sourceSamplingCorrelationBudget stage := by
+  rw [integral_integral_swap (sourceSamplingProduct_pair_integrable stage r b _ _
+    (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc) n k),
+    sourceSamplingProduct_inner_factorization stage r b _ _ (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc) n k]
+  apply sourceSampling_coordinate_product_error stage r b _ _ (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+  · intro i _
+    have hp := sourceSampling_parameters stage
+    exact integral_nonneg (fun s => integral_nonneg (fun θ => mul_nonneg
+      (samplingOrientedWeight_bounds r (b i) _ _ _ _ hp.1 hp.2.2 s _).1
+      (samplingOrientedWeight_bounds r (b i) _ _ _ _ hp.1 hp.2.2 s _).1))
+  · intro i hi
+    have hip : i.1 ≤ stage := by
+      have hh := (CouplingParameters.mem_blockPrefix sourceBlockSize (stage+1) i).mp hi
+      omega
+    exact sourceSampling_coordinate_pair_error stage hs i hip n k hn hk hne r (b i) (a i) (c i) (a' i) (c' i)
+
+/-- Actual mixed products have the same uniform error budget. -/
+theorem sourceSamplingProduct_mixed_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (r : Bool) (b : SourceCoordinate → Bool) (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (n : ℤ) (hn : n ∈ sourceSamplingPowers stage) :
+    |(∫ θ, ∫ x, sourceSamplingProduct stage r b E G n θ x*sourceSamplingIdealDensity stage r b E G x
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) ∂sourceAngleLaw)-
+      (∫ x, sourceSamplingIdealDensity stage r b E G x^2
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure))| ≤ sourceSamplingCorrelationBudget stage := by
+  rw [integral_integral_swap (sourceSamplingProduct_mixed_integrable stage r b E G hE hG n),
+    sourceSamplingProduct_mixed_factorization stage r b E G hE hG n]
+  apply sourceSampling_coordinate_product_error stage r b E G hE hG
+  · intro i _
+    have hp := sourceSampling_parameters stage
+    exact integral_nonneg (fun s => mul_nonneg
+      (integral_nonneg (fun t => (samplingOrientedWeight_bounds r (b i) _ _ _ _ hp.1 hp.2.2 s t).1))
+      (integral_nonneg (fun θ => (samplingOrientedWeight_bounds r (b i) _ _ _ _ hp.1 hp.2.2 s _).1)))
+  · intro i hi
+    have hip : i.1 ≤ stage := by
+      have hh := (CouplingParameters.mem_blockPrefix sourceBlockSize (stage+1) i).mp hi
+      omega
+    apply (sourceSampling_coordinate_mixed_error stage hs i hip n hn r (b i) (E i) (G i) (hE i) (hG i)).trans
+    have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (show 1 ≤ sourceBlockSize stage by omega)
+    have he := Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num : (-80 : ℝ) ≤ -74)
+    nlinarith [Real.rpow_nonneg (sourceBlockSize_pos stage).le (-74 : ℝ)]
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/ProductMoments.lean

@@ -0,0 +1,116 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.PhaseSelfMoment
+import OAI.Analysis.FiniteFactor.OrbitSampling.IdealProduct
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+def sourceSamplingProduct (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (n : ℤ) (θ x : SourceCoordinate → ℝ) : ℝ :=
+  ∏ i ∈ sourceSamplingPrefix stage,
+    samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+      (E i) (G i) (x i) (Int.fract ((n : ℝ)*θ i))
+
+theorem sourceSamplingProduct_measurable (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n : ℤ) :
+    Measurable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) => sourceSamplingProduct stage r b E G n p.1 p.2) := by
+  unfold sourceSamplingProduct
+  apply Finset.measurable_prod
+  intro i _
+  have hm : Measurable (fun p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ) =>
+      (p.2 i,Int.fract ((n : ℝ)*p.1 i))) :=
+    ((measurable_pi_apply i).comp measurable_snd).prodMk
+      (sourceFract_measurable.comp (measurable_const.mul ((measurable_pi_apply i).comp measurable_fst)))
+  exact (samplingOrientedWeight_measurable r (b i) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (E i) (G i) (hE i) (hG i)).comp hm
+
+theorem sourceSamplingProduct_bounds (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (n : ℤ) (θ x : SourceCoordinate → ℝ) :
+    0 ≤ sourceSamplingProduct stage r b E G n θ x ∧
+    sourceSamplingProduct stage r b E G n θ x ≤
+      (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card := by
+  have hp := sourceSampling_parameters stage
+  have hb (i : SourceCoordinate) := samplingOrientedWeight_bounds r (b i) _ _ (E i) (G i) hp.1 hp.2.2
+    (x i) (Int.fract ((n : ℝ)*θ i))
+  refine ⟨prod_nonneg (fun i _ => (hb i).1),?_⟩
+  calc
+    _ ≤ ∏ _i ∈ sourceSamplingPrefix stage, max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)) :=
+      prod_le_prod₀ (fun i _ => (hb i).1) (fun i _ => (hb i).2)
+    _ = _ := by simp
+
+/-- Exact coordinate factorization under the two actual infinite product laws.
+Dependence of the two phases within one coordinate is retained in each factor. -/
+theorem sourceSamplingProduct_inner_factorization (stage : ℕ) (r : Bool) (b : SourceCoordinate → Bool)
+    (E G : SourceCoordinate → Set ℝ) (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) (n k : ℤ) :
+    (∫ x, ∫ θ, sourceSamplingProduct stage r b E G n θ x * sourceSamplingProduct stage r b E G k θ x
+      ∂sourceAngleLaw ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)) =
+    ∏ i ∈ sourceSamplingPrefix stage,
+      ∫ s, ∫ θ, samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          (E i) (G i) s (Int.fract ((n : ℝ)*θ i)) *
+        samplingOrientedWeight r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          (E i) (G i) s (Int.fract ((k : ℝ)*θ i)) ∂sourceAngleLaw ∂unitIntervalMeasure := by
+  let u (i : SourceCoordinate) := samplingOrientedWeight r (b i) (sourceSamplingWidth stage)
+    (sourceSamplingCutoff stage) (E i) (G i)
+  let F (i : SourceCoordinate) (s a : ℝ) := u i s (Int.fract ((n : ℝ)*a))*u i s (Int.fract ((k : ℝ)*a))
+  have hF (i : SourceCoordinate) : Measurable (fun p : ℝ × ℝ => F i p.1 p.2) := by
+    have hu := samplingOrientedWeight_measurable r (b i) (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+      (E i) (G i) (hE i) (hG i)
+    exact (hu.comp (measurable_fst.prodMk (sourceFract_measurable.comp (measurable_const.mul measurable_snd)))).mul
+      (hu.comp (measurable_fst.prodMk (sourceFract_measurable.comp (measurable_const.mul measurable_snd))))
+  calc
+    _ = ∫ x, ∏ i ∈ sourceSamplingPrefix stage, ∫ a, F i (x i) a ∂sourceAngleMarginal i
+        ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) := by
+      apply integral_congr_ae
+      filter_upwards [] with x
+      simp only [sourceSamplingProduct,← Finset.prod_mul_distrib]
+      exact integral_infinitePi_finset_prod _ _ _
+        (fun i => (hF i).comp (measurable_const.prodMk measurable_id))
+    _ = ∏ i ∈ sourceSamplingPrefix stage, ∫ s, ∫ a, F i s a ∂sourceAngleMarginal i ∂unitIntervalMeasure :=
+      integral_infinitePi_finset_prod _ _ _
+        (fun i => (hF i).stronglyMeasurable.integral_prod_right.measurable)
+    _ = _ := by
+      apply Finset.prod_congr rfl
+      intro i _
+      apply integral_congr_ae
+      filter_upwards [] with s
+      have hm : Measurable (fun a => F i s a) := (hF i).comp (measurable_const.prodMk measurable_id)
+      rw [← sourceAngleLaw_coordinate i,integral_map (measurable_pi_apply i).aemeasurable hm.aestronglyMeasurable]
+
+/-- The actual full-prefix self-pair estimate, with the source's angle
+expectation outside the L2 square integral. -/
+theorem sourceSamplingProduct_self_moment (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (r : Bool) (b : SourceCoordinate → Bool) (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (n : ℤ) (hn : n ∈ sourceSamplingPowers stage) :
+    (∫ θ, ∫ x, sourceSamplingProduct stage r b E G n θ x ^ 2
+      ∂Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure) ∂sourceAngleLaw) ≤
+      (2+8*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ))^(sourceSamplingPrefix stage).card := by
+  have hint := sampling_square_integrable
+    (sourceAngleLaw.prod (Measure.infinitePi (fun _ : SourceCoordinate => unitIntervalMeasure)))
+    (fun p => sourceSamplingProduct stage r b E G n p.1 p.2)
+    ((max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card)
+    (sourceSamplingProduct_measurable stage r b E G hE hG n)
+    (fun p => sourceSamplingProduct_bounds stage r b E G n p.1 p.2)
+  rw [integral_integral_swap hint]
+  simp only [pow_two]
+  rw [sourceSamplingProduct_inner_factorization stage r b E G hE hG n n]
+  calc
+    _ ≤ ∏ _i ∈ sourceSamplingPrefix stage,
+        (2+8*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ)) := by
+      apply Finset.prod_le_prod₀
+      · intro i _
+        exact integral_nonneg (fun s => integral_nonneg (fun θ => mul_self_nonneg _))
+      · intro i hi
+        have hip : i.1 ≤ stage := by
+          have ht := (CouplingParameters.mem_blockPrefix sourceBlockSize (stage+1) i).mp hi
+          omega
+        simpa only [pow_two] using sourceSampling_phase_self_moment stage hs i hip n hn r (b i)
+          (E i) (G i) (hE i) (hG i)
+    _ = _ := by simp
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/RationalTests.lean

@@ -0,0 +1,108 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.TestedMarginals
+import OAI.Analysis.FiniteFactor.OrbitSampling.FirstMarginal
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- A finite rational cylinder test, with two closed intervals per tested
+coordinate. Whole-circle tests fill the remaining coordinates. -/
+abbrev SourceSamplingRationalTest :=
+  Σ K : Finset SourceCoordinate, K → (ℚ × ℚ) × (ℚ × ℚ)
+
+instance : Countable SourceSamplingRationalTest := inferInstance
+
+def sourceSamplingRationalEndpoints (T : SourceSamplingRationalTest) (i : SourceCoordinate) :
+    (ℚ × ℚ) × (ℚ × ℚ) :=
+  if hi : i ∈ T.1 then T.2 ⟨i,hi⟩ else ((0,1),(0,1))
+
+def sourceSamplingRationalX (T : SourceSamplingRationalTest) (i : SourceCoordinate) : Set ℝ :=
+  Set.Icc (sourceSamplingRationalEndpoints T i).1.1 (sourceSamplingRationalEndpoints T i).1.2
+
+def sourceSamplingRationalY (T : SourceSamplingRationalTest) (i : SourceCoordinate) : Set ℝ :=
+  Set.Icc (sourceSamplingRationalEndpoints T i).2.1 (sourceSamplingRationalEndpoints T i).2.2
+
+theorem sourceSamplingRationalTests_outside (T : SourceSamplingRationalTest) (stage : ℕ)
+    (hK : T.1 ⊆ sourceSamplingPrefix stage) :
+    ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ sourceSamplingRationalX T i ∧
+      Set.Ico (0 : ℝ) 1 ⊆ sourceSamplingRationalY T i := by
+  intro i hi
+  have hnot : i ∉ T.1 := fun h => hi (hK h)
+  simp only [sourceSamplingRationalX,sourceSamplingRationalY,sourceSamplingRationalEndpoints,
+    dite_eq_right hnot,Rat.cast_zero,Rat.cast_one]
+  exact ⟨Set.Ico_subset_Icc_self,Set.Ico_subset_Icc_self⟩
+
+theorem sourceSamplingPrefix_eventually_covers (K : Finset SourceCoordinate) :
+    ∀ᶠ stage : ℕ in atTop, K ⊆ sourceSamplingPrefix stage := by
+  filter_upwards [eventually_ge_atTop (K.sup (fun i => i.1))] with stage hstage
+  intro i hi
+  apply (CouplingParameters.mem_blockPrefix sourceBlockSize (stage+1) i).mpr
+  exact Nat.lt_succ_of_le ((Finset.le_sup (f := fun i => i.1) hi).trans hstage)
+
+/-- A concrete single conull event for every finite I, both orientations, and
+all rational cylinder tests. It includes the actual tested measure identity
+at every admissible stage, as well as the full-error convergence and L2 bound. -/
+theorem sourceSampling_rational_event :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ (I : Finset SourceCoordinate) (r : Bool)
+      (T : SourceSamplingRationalTest),
+      Tendsto (fun stage => sourceSamplingSquaredError stage r (fun i => decide (i ∈ I))
+        (sourceSamplingRationalX T) (sourceSamplingRationalY T) θ) atTop (𝓝 0) ∧
+      ∃ C : ℝ, ∀ stage,
+        MemLp (sourceSamplingEmpiricalDensity stage r (fun i => decide (i ∈ I))
+          (sourceSamplingRationalX T) (sourceSamplingRationalY T) θ) 2 sourceSamplingHaar ∧
+        (∫ x, sourceSamplingEmpiricalDensity stage r (fun i => decide (i ∈ I))
+          (sourceSamplingRationalX T) (sourceSamplingRationalY T) θ x ^ 2 ∂sourceSamplingHaar) ≤ C ∧
+        (T.1 ⊆ sourceSamplingPrefix stage →
+          ((sourceSamplingUntrimmed I stage θ).restrict
+            (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).map
+              (sourceSamplingEndpoint r) =
+          sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+            (sourceSamplingEmpiricalDensity stage r (fun i => decide (i ∈ I))
+              (sourceSamplingRationalX T) (sourceSamplingRationalY T) θ x))) := by
+  apply ae_all_iff.mpr
+  intro I
+  apply ae_all_iff.mpr
+  intro r
+  apply ae_all_iff.mpr
+  intro T
+  filter_upwards [sourceSamplingSquaredError_ae r (fun i => decide (i ∈ I))
+    (fun i => (sourceSamplingRationalEndpoints T i).1.1)
+    (fun i => (sourceSamplingRationalEndpoints T i).1.2)
+    (fun i => (sourceSamplingRationalEndpoints T i).2.1)
+    (fun i => (sourceSamplingRationalEndpoints T i).2.2),
+    sourceSamplingEmpiricalDensity_uniform r (fun i => decide (i ∈ I))
+    (fun i => (sourceSamplingRationalEndpoints T i).1.1)
+    (fun i => (sourceSamplingRationalEndpoints T i).1.2)
+    (fun i => (sourceSamplingRationalEndpoints T i).2.1)
+    (fun i => (sourceSamplingRationalEndpoints T i).2.2)] with θ he hu
+  obtain ⟨C,hC⟩ := hu
+  refine ⟨he.2,C,fun stage => ⟨(hC stage).1,(hC stage).2,?_⟩⟩
+  intro hK
+  exact sourceSamplingUntrimmed_tested_marginal I stage r _ _
+    (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+    (sourceSamplingRationalTests_outside T stage hK) θ
+
+/-- Both actual untested marginal densities are uniformly L2 bounded on one
+conull event, simultaneously for all finite I. -/
+theorem sourceSampling_both_marginals_event :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ (I : Finset SourceCoordinate) (r : Bool),
+      ∃ C : ℝ, ∀ stage, ∃ f : (SourceCoordinate → ℝ) → ℝ,
+        (sourceSamplingUntrimmed I stage θ).map (sourceSamplingEndpoint r) =
+          sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (f x)) ∧
+        MemLp f 2 sourceSamplingHaar ∧ (∫ x, f x^2 ∂sourceSamplingHaar) ≤ C := by
+  apply ae_all_iff.mpr
+  intro I
+  apply ae_all_iff.mpr
+  intro r
+  cases r
+  · exact sourceSamplingUntrimmed_first_L2 I
+  · exact sourceSamplingUntrimmed_second_L2 I
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/RectangleApproximation.lean

@@ -0,0 +1,38 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.RectangleError
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- Actual rational rectangle masses approach their ideal product integrals
+on a single conull event. This is the stochastic approximation step; the
+identification of the ideal limiting law is a separate obligation. -/
+theorem sourceSampling_rectangle_approximation_event :
+    ∀ᵐ θ ∂sourceAngleLaw, ∀ (I : Finset SourceCoordinate) (T : SourceSamplingRationalTest),
+      Tendsto (fun stage =>
+        ((sourceSamplingUntrimmed I stage θ)
+          (sourceSamplingRectangle (sourceSamplingRationalX T) (sourceSamplingRationalY T))).toReal -
+        ∫ x, sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I))
+          (sourceSamplingRationalX T) (sourceSamplingRationalY T) x ∂sourceSamplingHaar)
+      atTop (𝓝 0) := by
+  filter_upwards [sourceSampling_rational_event] with θ hθ
+  intro I T
+  have he := (hθ I false T).1
+  have hs := Real.continuous_sqrt.continuousAt.tendsto.comp he
+  simp only [Real.sqrt_zero] at hs
+  apply tendsto_zero_iff_norm_tendsto_zero.mpr
+  simp only [Real.norm_eq_abs]
+  apply squeeze_zero' (Eventually.of_forall (fun stage => abs_nonneg _)) _ hs
+  filter_upwards [sourceSamplingPrefix_eventually_covers T.1] with stage hstage
+  exact Real.abs_le_sqrt (sourceSamplingUntrimmed_rectangle_error I stage
+    (sourceSamplingRationalX T) (sourceSamplingRationalY T)
+    (fun _ => measurableSet_Icc) (fun _ => measurableSet_Icc)
+    (sourceSamplingRationalTests_outside T stage hstage) θ)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/RectangleError.lean

@@ -0,0 +1,91 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.RationalTests
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- The elementary probability-space Cauchy--Schwarz bound, proved by
+integrating the nonnegative square centered at the mean. -/
+theorem sampling_integral_square_le {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ] (f : Ω → ℝ)
+    (hf : Integrable f μ) (hf2 : Integrable (fun x => f x^2) μ) :
+    (∫ x, f x ∂μ)^2 ≤ ∫ x, f x^2 ∂μ := by
+  let c := ∫ x, f x ∂μ
+  have he : (fun x => (f x-c)^2) = (fun x => f x^2-2*c*f x+c^2) := by funext x; ring
+  have hh : 0 ≤ ∫ x, (f x-c)^2 ∂μ := integral_nonneg (fun x => sq_nonneg _)
+  have hi : Integrable (fun x => f x^2-2*c*f x) μ := hf2.sub (hf.const_mul (2*c))
+  have hc : Integrable (fun _x : Ω => c^2) μ := integrable_const _
+  rw [he,integral_add hi hc,integral_sub hf2 (hf.const_mul (2*c)),integral_const_mul] at hh
+  simp only [integral_const,measureReal_def,measure_univ,ENNReal.toReal_one,smul_eq_mul,one_mul] at hh
+  change c^2 ≤ _
+  change 0 ≤ (∫ x, f x^2 ∂μ)-2*c*c+c^2 at hh
+  nlinarith
+
+/-- Actual rectangle mass equals the integral of the first tested empirical
+density at every admissible stage. -/
+theorem sourceSamplingUntrimmed_rectangle_mass (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ : SourceCoordinate → ℝ) :
+    ((sourceSamplingUntrimmed I stage θ) (sourceSamplingRectangle E G)).toReal =
+      ∫ x, sourceSamplingEmpiricalDensity stage false (fun i => decide (i ∈ I)) E G θ x
+        ∂sourceSamplingHaar := by
+  let z := sourceSamplingEmpiricalDensity stage false (fun i => decide (i ∈ I)) E G θ
+  have hm := sourceSamplingEmpiricalDensity_measurable stage false (fun i => decide (i ∈ I)) E G hE hG θ
+  have hb := sourceSamplingEmpiricalDensity_bounds stage false (fun i => decide (i ∈ I)) E G θ
+  have hi : Integrable z sourceSamplingHaar :=
+    sampling_integrable_bounded sourceSamplingHaar z hm _ (fun x => by
+      rw [abs_of_nonneg (hb x).1]; exact (hb x).2)
+  have hh := congrArg (fun ν : Measure (SourceCoordinate → ℝ) => ν Set.univ)
+    (sourceSamplingUntrimmed_tested_marginal I stage false E G hE hG houtside θ)
+  rw [Measure.map_apply (sourceSamplingEndpoint_measurable false) MeasurableSet.univ,
+    Set.preimage_univ,Measure.restrict_apply MeasurableSet.univ,Set.univ_inter,
+    withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] at hh
+  rw [hh,← ofReal_integral_eq_lintegral_ofReal hi (Eventually.of_forall (fun x => (hb x).1)),
+    ENNReal.toReal_ofReal (integral_nonneg (fun x => (hb x).1))]
+
+/-- Full squared sampling error bounds the squared discrepancy of the actual
+rectangle mass and the ideal product integral. -/
+theorem sourceSamplingUntrimmed_rectangle_error (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ : SourceCoordinate → ℝ) :
+    (((sourceSamplingUntrimmed I stage θ) (sourceSamplingRectangle E G)).toReal -
+      ∫ x, sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I)) E G x ∂sourceSamplingHaar)^2 ≤
+    sourceSamplingSquaredError stage false (fun i => decide (i ∈ I)) E G θ := by
+  rw [sourceSamplingUntrimmed_rectangle_mass I stage E G hE hG houtside θ]
+  let z := sourceSamplingEmpiricalDensity stage false (fun i => decide (i ∈ I)) E G θ
+  let g := sourceSamplingIdealDensity stage false (fun i => decide (i ∈ I)) E G
+  let C := (max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)))^(sourceSamplingPrefix stage).card
+  have hzm := sourceSamplingEmpiricalDensity_measurable stage false (fun i => decide (i ∈ I)) E G hE hG θ
+  have hgm := sourceSamplingIdealDensity_measurable stage false (fun i => decide (i ∈ I)) E G hE hG
+  have hzb := sourceSamplingEmpiricalDensity_bounds stage false (fun i => decide (i ∈ I)) E G θ
+  have hgb := sourceSamplingIdealDensity_bounds stage false (fun i => decide (i ∈ I)) E G hE hG
+  have hzi : Integrable z sourceSamplingHaar := sampling_integrable_bounded sourceSamplingHaar z hzm C
+    (fun x => by rw [abs_of_nonneg (hzb x).1]; exact (hzb x).2)
+  have hgi : Integrable g sourceSamplingHaar := sampling_integrable_bounded sourceSamplingHaar g hgm C
+    (fun x => by rw [abs_of_nonneg (hgb x).1]; exact (hgb x).2)
+  have hei : Integrable (fun x => (z x-g x)^2) sourceSamplingHaar := by
+    apply sampling_integrable_bounded sourceSamplingHaar _ ((hzm.sub hgm).pow_const 2) (C^2)
+    intro x
+    rw [abs_of_nonneg (sq_nonneg _)]
+    have hz' : 0 ≤ z x ∧ z x ≤ C := hzb x
+    have hg' : 0 ≤ g x ∧ g x ≤ C := hgb x
+    change (z x-g x)^2 ≤ C^2
+    nlinarith [sq_nonneg (z x+g x),mul_nonneg (show 0 ≤ C-(z x-g x) by linarith)
+      (show 0 ≤ C+(z x-g x) by linarith)]
+  have hh := sampling_integral_square_le sourceSamplingHaar (fun x => z x-g x) (hzi.sub hgi) hei
+  rw [integral_sub hzi hgi] at hh
+  exact hh
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/RotationTransport.lean

@@ -0,0 +1,61 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.Measures
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical ENNReal
+noncomputable section
+
+theorem coordinateRotate_neg_cube (θ x : SourceCoordinate → ℝ) (n : ℤ)
+    (hx : ∀ i, x i ∈ Set.Ico (0 : ℝ) 1) :
+    coordinateRotate θ (-n) (coordinateRotate θ n x) = x := by
+  funext i
+  unfold coordinateRotate
+  rw [Int.cast_neg,neg_mul]
+  have he : Int.fract (x i+(n : ℝ)*θ i) + -((n : ℝ)*θ i) =
+      x i - (⌊x i+(n : ℝ)*θ i⌋ : ℝ) := by
+    linarith [Int.fract_add_floor (x i+(n : ℝ)*θ i)]
+  rw [he,Int.fract_sub_intCast,Int.fract_eq_self.mpr (hx i)]
+
+theorem coordinateRotate_phase (θ x : SourceCoordinate → ℝ) (n : ℤ) (i : SourceCoordinate) :
+    coordinateRotate θ n x i = Int.fract (x i+Int.fract ((n : ℝ)*θ i)) := by
+  unfold coordinateRotate
+  have he : x i+(n : ℝ)*θ i = (x i+Int.fract ((n : ℝ)*θ i)) + (⌊(n : ℝ)*θ i⌋ : ℝ) := by
+    linarith [Int.fract_add_floor ((n : ℝ)*θ i)]
+  rw [he,Int.fract_add_intCast]
+
+theorem coordinateRotate_neg_phase (θ x : SourceCoordinate → ℝ) (n : ℤ) (i : SourceCoordinate) :
+    coordinateRotate θ (-n) x i = Int.fract (x i-Int.fract ((n : ℝ)*θ i)) := by
+  unfold coordinateRotate
+  rw [Int.cast_neg,neg_mul]
+  have he : x i + -((n : ℝ)*θ i) = (x i-Int.fract ((n : ℝ)*θ i)) - (⌊(n : ℝ)*θ i⌋ : ℝ) := by
+    linarith [Int.fract_add_floor ((n : ℝ)*θ i)]
+  rw [he,Int.fract_sub_intCast]
+
+/-- Change of variables for an actual weighted Haar law. The inverse identity
+is needed only on the conull cube of representatives. -/
+theorem sourceSamplingHaar_rotate_withDensity (θ : SourceCoordinate → ℝ) (n : ℤ)
+    (w : (SourceCoordinate → ℝ) → ℝ≥0∞) (hw : Measurable w) :
+    (sourceSamplingHaar.withDensity w).map (coordinateRotate θ n) =
+      sourceSamplingHaar.withDensity (fun y => w (coordinateRotate θ (-n) y)) := by
+  let R := coordinateRotate θ n
+  let R' := coordinateRotate θ (-n)
+  have hR := coordinateRotate_preserving θ n
+  have hR' := coordinateRotate_preserving θ (-n)
+  ext A hA
+  rw [Measure.map_apply hR.measurable hA,withDensity_apply _ (hR.measurable hA),withDensity_apply _ hA]
+  rw [← lintegral_indicator (hR.measurable hA),← lintegral_indicator hA]
+  have hm : Measurable (A.indicator (fun y => w (R' y))) := (hw.comp hR'.measurable).indicator hA
+  calc
+    _ = ∫⁻ x, A.indicator (fun y => w (R' y)) (R x) ∂sourceSamplingHaar := by
+      apply lintegral_congr_ae
+      filter_upwards [sourceSamplingHaar_cube] with x hx
+      change (if R x ∈ A then w x else 0) = (if R x ∈ A then w (R' (R x)) else 0)
+      rw [show R' (R x) = x from coordinateRotate_neg_cube θ x n hx]
+    _ = _ := hR.lintegral_comp hm
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/SecondCorrelation.lean

@@ -0,0 +1,73 @@
+import OAI.Analysis.FiniteFactor.Sampling.SecondDiscrepancy
+import OAI.Analysis.FiniteFactor.OrbitSampling.FirstCorrelation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical
+noncomputable section
+
+/-- Uniform source height bound, for either marginal orientation. -/
+theorem sourceSampling_max_height (stage : ℕ) :
+    max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage)) ≤
+      (sourceBlockSize stage : ℝ)^(3 : ℝ) := by
+  have hm := sourceBlockSize_pos stage
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have hh : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+    linarith
+  apply max_le
+  · exact Real.one_le_rpow hm1 (by norm_num)
+  · have he : 1/(sourceSamplingWidth stage*sourceSamplingCutoff stage) =
+        (sourceBlockSize stage : ℝ)^(13/5 : ℝ) := by
+      unfold sourceSamplingWidth sourceSamplingCutoff
+      rw [← Real.rpow_add hm]
+      norm_num
+      rw [Real.rpow_neg hm.le,inv_inv]
+    rw [he]
+    exact Real.rpow_le_rpow_of_exponent_le hm1 (by norm_num)
+
+/-- Actual second-diagonal pair error for the selected source powers.
+All phase support, atomlessness and discrepancy hypotheses are discharged. -/
+theorem sourceSampling_second_pair_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n n' : ℤ)
+    (hn : n ∈ sourceSamplingPowers stage) (hn' : n' ∈ sourceSamplingPowers stage) (hne : n ≠ n')
+    (G : Set ℝ) (hG : MeasurableSet G) (a c s : ℝ) (hsx : s ∈ Set.Ico (0 : ℝ) 1) :
+    |(∫ θ, samplingTestedSecondWeight (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) G s (Int.fract ((n : ℝ)*θ i)) *
+        samplingTestedSecondWeight (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+        (Set.Icc a c) G s (Int.fract ((n' : ℝ)*θ i)) ∂sourceAngleLaw) -
+      samplingTestedSecondDensity (sourceSamplingWidth stage) (sourceSamplingCutoff stage) (Set.Icc a c) G s ^ 2| ≤
+      104*(sourceBlockSize stage : ℝ)^(-74 : ℝ) := by
+  have := sourceSampling_phase_null_singletons stage hs i hi n hn
+  have := sourceSampling_phase_null_singletons stage hs i hi n' hn'
+  have hm (k : ℤ) : Measurable (fun θ : SourceCoordinate → ℝ => Int.fract ((k : ℝ)*θ i)) :=
+    sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i))
+  have hsupport (k : ℤ) : ∀ᵐ t ∂sourceAngleLaw.map (fun θ => Int.fract ((k : ℝ)*θ i)),
+      t ∈ Set.Ico (0 : ℝ) 1 := by
+    apply (ae_map_iff (hm k).aemeasurable
+      (show MeasurableSet {t : ℝ | t ∈ Set.Ico (0 : ℝ) 1} from measurableSet_Ico)).mpr
+    exact Eventually.of_forall (fun θ => ⟨Int.fract_nonneg _,Int.fract_lt_one _⟩)
+  have hp := sourceSampling_parameters stage
+  have hb := samplingTestedSecond_pair_bound sourceAngleLaw
+    (fun θ => Int.fract ((n : ℝ)*θ i)) (fun θ => Int.fract ((n' : ℝ)*θ i))
+    (hm n) (hm n') (hsupport n) (hsupport n') _
+    (sourceSampling_rectangle_bound stage hs i hi n n' hn hn' hne)
+    _ _ G a c s hp.1 hp.2.1 hp.2.2 hG hsx
+  let m : ℝ := sourceBlockSize stage
+  let C := max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage))
+  have hC : 0 ≤ C := (by norm_num : (0 : ℝ) ≤ 1).trans (le_max_left _ _)
+  have hC2 : C^2 ≤ m^(6 : ℝ) := by
+    calc
+      _ ≤ (m^(3 : ℝ))^2 := by nlinarith [sourceSampling_max_height stage,Real.rpow_nonneg (sourceBlockSize_pos stage).le (3 : ℝ)]
+      _ = _ := by dsimp [m]; rw [← Real.rpow_natCast,← Real.rpow_mul (sourceBlockSize_pos stage).le]; norm_num
+  apply hb.trans
+  change (4*(26*m^(-80 : ℝ)))*C^2 ≤ 104*m^(-74 : ℝ)
+  calc
+    _ ≤ (4*(26*m^(-80 : ℝ)))*m^(6 : ℝ) := mul_le_mul_of_nonneg_left hC2 (by positivity)
+    _ = _ := by rw [mul_assoc, mul_assoc,← Real.rpow_add (sourceBlockSize_pos stage)]; norm_num; ring
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/SecondMarginal.lean

@@ -0,0 +1,80 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.UniformEvent
+import OAI.Analysis.FiniteFactor.OrbitSampling.RotationTransport
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal
+noncomputable section
+
+/-- The actual second marginal of one orbit summand, obtained by weighted
+Haar transport and not supplied as an assumption. -/
+theorem sourceSamplingSummand_second_density (I : Finset SourceCoordinate) (stage : ℕ)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    (sourceSamplingSummand I stage θ n).map Prod.snd =
+      sourceSamplingHaar.withDensity (fun y => ENNReal.ofReal
+        (sourceSamplingWeight I stage θ n (coordinateRotate θ (-n) y))) := by
+  unfold sourceSamplingSummand
+  have hp : Measurable (fun x : SourceCoordinate → ℝ => (x,coordinateRotate θ n x)) :=
+    measurable_id.prodMk (coordinateRotate_preserving θ n).measurable
+  rw [Measure.map_map measurable_snd hp]
+  exact sourceSamplingHaar_rotate_withDensity θ n _
+    (sourceSamplingWeight_measurable I stage θ n).ennreal_ofReal
+
+/-- The actual second marginal is the second-oriented empirical density. -/
+theorem sourceSamplingUntrimmed_second_density (I : Finset SourceCoordinate) (stage : ℕ)
+    (θ : SourceCoordinate → ℝ) :
+    (sourceSamplingUntrimmed I stage θ).map Prod.snd =
+      sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingEmpiricalDensity stage true (fun i => decide (i ∈ I))
+          (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) θ x)) := by
+  let S := sourceSamplingPowers stage
+  let c : ℝ≥0∞ := ENNReal.ofReal (1/((sourceSamplingPowers stage).card : ℝ))
+  let w (n : ℤ) := fun x => sourceSamplingWeight I stage θ n (coordinateRotate θ (-n) x)
+  have hrep : (fun x => ENNReal.ofReal (sourceSamplingEmpiricalDensity stage true (fun i => decide (i ∈ I))
+        (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) θ x)) =ᵐ[sourceSamplingHaar]
+      (fun x => c*(∑ n ∈ S, ENNReal.ofReal (w n x))) := by
+    filter_upwards [sourceSamplingHaar_cube] with x hx
+    have hw (n : ℤ) : sourceSamplingProduct stage true (fun i => decide (i ∈ I))
+        (fun _ => Set.Icc 0 1) (fun _ => Set.Icc 0 1) n θ x = w n x := by
+      apply Finset.prod_congr rfl
+      intro i _
+      have hx' : x i ∈ Set.Icc (0 : ℝ) 1 := ⟨(hx i).1,(hx i).2.le⟩
+      have hz : Int.fract (x i-Int.fract ((n : ℝ)*θ i)) ∈ Set.Icc (0 : ℝ) 1 :=
+        ⟨Int.fract_nonneg _,(Int.fract_lt_one _).le⟩
+      simp only [samplingOrientedWeight,ite_true,hz,hx',and_self]
+      rw [coordinateRotate_neg_phase]
+    simp only [sourceSamplingEmpiricalDensity,hw]
+    rw [div_eq_mul_inv,mul_comm,← one_div,
+      ENNReal.ofReal_mul (by positivity),ENNReal.ofReal_sum_of_nonneg (fun n _ => (sourceSamplingWeight_bounds I stage θ n (coordinateRotate θ (-n) x)).1)]
+  rw [withDensity_congr_ae hrep]
+  ext A hA
+  rw [Measure.map_apply measurable_snd hA]
+  unfold sourceSamplingUntrimmed
+  rw [Measure.smul_apply,Measure.finsetSum_apply,withDensity_apply _ hA]
+  have hterm (n : ℤ) : sourceSamplingSummand I stage θ n (Prod.snd ⁻¹' A) =
+      ∫⁻ x in A, ENNReal.ofReal (w n x) ∂sourceSamplingHaar := by
+    rw [← Measure.map_apply measurable_snd hA,sourceSamplingSummand_second_density]
+    exact withDensity_apply _ hA
+  simp only [hterm,smul_eq_mul]
+  rw [lintegral_const_mul' c _ ENNReal.ofReal_ne_top]
+  congr 1
+  exact (lintegral_finsetSum S (fun n _ =>
+    ((sourceSamplingWeight_measurable I stage θ n).comp (coordinateRotate_preserving θ (-n)).measurable).ennreal_ofReal)).symm
+
+/-- Uniform L2 densities for the actual untrimmed second marginals. -/
+theorem sourceSamplingUntrimmed_second_L2 (I : Finset SourceCoordinate) :
+    ∀ᵐ θ ∂sourceAngleLaw, ∃ C : ℝ, ∀ stage,
+      ∃ f : (SourceCoordinate → ℝ) → ℝ,
+        (sourceSamplingUntrimmed I stage θ).map Prod.snd = sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (f x)) ∧
+        MemLp f 2 sourceSamplingHaar ∧ (∫ x, f x^2 ∂sourceSamplingHaar) ≤ C := by
+  filter_upwards [sourceSamplingEmpiricalDensity_uniform true (fun i => decide (i ∈ I))
+    (fun _ => 0) (fun _ => 1) (fun _ => 0) (fun _ => 1)] with θ hθ
+  obtain ⟨C,hC⟩ := hθ
+  refine ⟨C,fun stage => ⟨_,sourceSamplingUntrimmed_second_density I stage θ,(hC stage).1,(hC stage).2⟩⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/SelfMoment.lean

@@ -0,0 +1,74 @@
+import OAI.Analysis.FiniteFactor.Sampling.OrientedMoments
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+noncomputable section
+
+theorem sourceSamplingCutoff_le_half (s : ℕ) : sourceSamplingCutoff s ≤ 1/2 := by
+  have hm : (100 : ℝ) ≤ sourceBlockSize s := by exact_mod_cast (sourceStage s).m_ge_100
+  have hp := sourceBlockSize_pos s
+  calc
+    sourceSamplingCutoff s ≤ (sourceBlockSize s : ℝ)^(-1 : ℝ) :=
+      Real.rpow_le_rpow_of_exponent_le (by linarith) (by norm_num)
+    _ = 1/(sourceBlockSize s : ℝ) := by rw [Real.rpow_neg_one,one_div]
+    _ ≤ 1/2 := one_div_le_one_div_of_le (by norm_num) (by linarith)
+
+theorem sourceSampling_log_self_bound (s : ℕ) :
+    (2/sourceSamplingWidth s)*Real.log (1/(2*sourceSamplingCutoff s)) ≤
+      4*(sourceBlockSize s : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize s : ℝ) := by
+  have hp := sourceSampling_parameters s
+  have hm := sourceBlockSize_pos s
+  have hl : Real.log (1/(2*sourceSamplingCutoff s)) ≤ Real.log (1/sourceSamplingCutoff s) :=
+    Real.log_le_log (one_div_pos.mpr (mul_pos (by norm_num) hp.2.2)) (one_div_le_one_div_of_le hp.2.2 (by linarith [hp.2.2]))
+  have he : Real.log (1/sourceSamplingCutoff s) = 2*Real.log (sourceBlockSize s : ℝ) := by
+    unfold sourceSamplingCutoff
+    rw [one_div,Real.log_inv,Real.log_rpow hm]
+    ring
+  have hw : (sourceSamplingWidth s)⁻¹ = (sourceBlockSize s : ℝ)^(3/5 : ℝ) := by
+    unfold sourceSamplingWidth
+    rw [show (-3/5 : ℝ) = -(3/5) by ring,Real.rpow_neg hm.le,inv_inv]
+  calc
+    _ ≤ (2/sourceSamplingWidth s)*(2*Real.log (sourceBlockSize s : ℝ)) :=
+      mul_le_mul_of_nonneg_left (hl.trans_eq he) (div_nonneg (by norm_num) hp.1.le)
+    _ = _ := by rw [div_eq_mul_inv,hw]; ring
+
+/-- All tested source weights have the logarithmic self-pair bound in both
+orientations. The harmless extra 1 includes triangular coordinates. -/
+theorem sourceSampling_oriented_self_moment (stage : ℕ) (r b : Bool) (E G : Set ℝ)
+    (hE : MeasurableSet E) (hG : MeasurableSet G) :
+    (∫ s, ∫ t, samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G s t ^ 2
+      ∂unitIntervalMeasure ∂unitIntervalMeasure) ≤
+      1+4*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ) := by
+  have hp := sourceSampling_parameters stage
+  have hc := sourceSamplingCutoff_le_half stage
+  have hlog : 0 ≤ Real.log (sourceBlockSize stage : ℝ) := Real.log_nonneg (by
+    have hm : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+    linarith)
+  have herr : (0 : ℝ) ≤ 4*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ) := by positivity
+  cases b
+  · have hb : (∫ s, ∫ t, samplingOrientedWeight r false (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G s t ^ 2
+        ∂unitIntervalMeasure ∂unitIntervalMeasure) ≤
+        (2/sourceSamplingWidth stage)*Real.log (1/(2*sourceSamplingCutoff stage)) := by
+      cases r
+      · exact samplingTestedFirstWeight_square_integral _ _ E G hp.1 hp.2.1 hp.2.2 hc hE hG
+      · exact samplingTestedSecondWeight_square_integral _ _ E G hp.1 hp.2.1 hp.2.2 hc hE hG
+    exact (hb.trans (sourceSampling_log_self_bound stage)).trans (by linarith)
+  · have hm := samplingOrientedWeight_measurable r true (sourceSamplingWidth stage)
+      (sourceSamplingCutoff stage) E G hE hG
+    have hb := samplingOrientedWeight_triangular_bounds r (sourceSamplingWidth stage)
+      (sourceSamplingCutoff stage) E G
+    have hi := sampling_square_integrable (unitIntervalMeasure.prod unitIntervalMeasure) _ 1 hm
+      (fun p => hb p.1 p.2)
+    rw [← integral_prod _ hi]
+    have hle : (∫ p : ℝ × ℝ, samplingOrientedWeight r true (sourceSamplingWidth stage)
+        (sourceSamplingCutoff stage) E G p.1 p.2 ^ 2 ∂unitIntervalMeasure.prod unitIntervalMeasure) ≤ 1 := by
+      simpa using integral_mono_ae hi (integrable_const (1 : ℝ))
+        (Eventually.of_forall (fun p => by nlinarith [(hb p.1 p.2).1,(hb p.1 p.2).2]))
+    exact hle.trans (by linarith)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/SelfSummability.lean

@@ -0,0 +1,96 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.ProductMoments
+import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+noncomputable section
+
+def sourceSamplingSelfBudget (stage : ℕ) : ℝ :=
+  (2+8*(sourceBlockSize stage : ℝ)^(3/5 : ℝ)*Real.log (sourceBlockSize stage : ℝ))^(sourceSamplingPrefix stage).card /
+    ((sourceSamplingPowers stage).card : ℝ)
+
+/-- A concrete logarithmic estimate sufficient for the source exponent gap. -/
+theorem sampling_self_base_bound (m : ℝ) (hm1 : 1 ≤ m) (hlarge : 802 ≤ m^(1/50 : ℝ)) :
+    2+8*m^(3/5 : ℝ)*Real.log m ≤ m^(63/100 : ℝ) := by
+  have hm : 0 < m := lt_of_lt_of_le zero_lt_one hm1
+  have hl := Real.log_le_rpow_div hm.le (by norm_num : (0 : ℝ) < 1/100)
+  have he : m^(3/5 : ℝ)*m^(1/100 : ℝ) = m^(61/100 : ℝ) := by
+    rw [← Real.rpow_add hm]; norm_num
+  have hpow : 1 ≤ m^(61/100 : ℝ) := Real.one_le_rpow hm1 (by norm_num)
+  have hmul : m^(3/5 : ℝ)*Real.log m ≤ 100*m^(61/100 : ℝ) := by
+    have hh := mul_le_mul_of_nonneg_left hl (Real.rpow_nonneg hm.le (3/5 : ℝ))
+    rw [← mul_div_assoc,he] at hh
+    linarith
+  calc
+    _ ≤ 802*m^(61/100 : ℝ) := by linarith
+    _ ≤ m^(1/50 : ℝ)*m^(61/100 : ℝ) := mul_le_mul_of_nonneg_right hlarge (by positivity)
+    _ = _ := by rw [← Real.rpow_add hm]; norm_num
+
+theorem sourceSamplingSelfBudget_eventually : ∀ᶠ stage in atTop,
+    sourceSamplingSelfBudget stage ≤ (sourceBlockSize stage : ℝ)^(-(1/25 : ℝ)*(sourceBlockSize stage : ℝ)) := by
+  have ht : Tendsto (fun stage => (sourceBlockSize stage : ℝ)^(1/50 : ℝ)) atTop atTop :=
+    (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 1/50)).comp
+      (tendsto_natCast_atTop_atTop.comp sourceBlockSize_tendsto)
+  filter_upwards [ht.eventually (eventually_ge_atTop 802),sourceSamplingPowers_eventually] with stage hlarge hspec
+  let m : ℝ := sourceBlockSize stage
+  let B := 2+8*m^(3/5 : ℝ)*Real.log m
+  let P : ℝ := (sourceSamplingPowers stage).card
+  have hm : 0 < m := sourceBlockSize_pos stage
+  have hm1 : 1 ≤ m := by
+    have hh : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+    dsimp [m]; linarith
+  have hB0 : 0 ≤ B := by dsimp [B]; positivity [Real.log_nonneg hm1]
+  have hB : B ≤ m^(63/100 : ℝ) := sampling_self_base_bound m hm1 hlarge
+  have hnum : B^(sourceSamplingPrefix stage).card ≤ m^((65/100 : ℝ)*m) := by
+    calc
+      _ ≤ (m^(63/100 : ℝ))^(sourceSamplingPrefix stage).card := pow_le_pow_left₀ hB0 hB _
+      _ = m^((63/100 : ℝ)*((sourceSamplingPrefix stage).card : ℝ)) := by
+        rw [← Real.rpow_natCast,← Real.rpow_mul hm.le]
+      _ ≤ _ := Real.rpow_le_rpow_of_exponent_le hm1 (by
+        have hd := sourceSamplingPrefix_card_bound stage
+        change ((sourceSamplingPrefix stage).card : ℝ) ≤ (101/100 : ℝ)*m at hd
+        nlinarith)
+  have hP : m^((69/100 : ℝ)*m) ≤ P := hspec.2.1
+  have hPpos : 0 < P := (Real.rpow_pos_of_pos hm _).trans_le hP
+  change B^(sourceSamplingPrefix stage).card/P ≤ m^(-(1/25 : ℝ)*m)
+  calc
+    _ ≤ m^((65/100 : ℝ)*m)/P := div_le_div_of_nonneg_right hnum hPpos.le
+    _ ≤ m^((65/100 : ℝ)*m)/m^((69/100 : ℝ)*m) :=
+      div_le_div_of_nonneg_left (by positivity) (by positivity) hP
+    _ = _ := by rw [← Real.rpow_sub hm]; congr 1; ring
+
+/-- The actual block growth makes the inverse-square stage sequence summable. -/
+theorem sourceSampling_inverse_square_summable : Summable (fun stage => (sourceBlockSize stage : ℝ)^(-2 : ℝ)) := by
+  have hg : Summable (fun stage : ℕ => (1/4 : ℝ)^stage) :=
+    summable_geometric_of_lt_one (by norm_num) (by norm_num)
+  apply hg.of_nonneg_of_le (fun _ => by positivity)
+  intro stage
+  have hp : (2 : ℝ)^stage ≤ sourceBlockSize stage := by
+    have hh := (sourceStage stage).m_ge_pow
+    have hle : 2^stage ≤ 2^(stage+1) := Nat.pow_le_pow_right (by norm_num) (by omega)
+    exact_mod_cast hle.trans hh
+  calc
+    _ ≤ ((2 : ℝ)^stage)^(-2 : ℝ) := Real.rpow_le_rpow_of_nonpos (by positivity) hp (by norm_num)
+    _ = _ := by
+      rw [Real.rpow_neg (by positivity),Real.rpow_two]
+      rw [← pow_mul, Nat.mul_comm stage 2, pow_mul, ← inv_pow]
+      norm_num
+
+/-- Summability of the actual full-product self-pair budget. -/
+theorem sourceSamplingSelfBudget_summable : Summable sourceSamplingSelfBudget := by
+  apply sourceSampling_inverse_square_summable.of_norm_bounded_eventually_nat
+  filter_upwards [sourceSamplingSelfBudget_eventually] with stage hb
+  have hm : (100 : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_100
+  have hn : 0 ≤ sourceSamplingSelfBudget stage := by
+    unfold sourceSamplingSelfBudget
+    have hl := Real.log_nonneg (show (1 : ℝ) ≤ sourceBlockSize stage by linarith)
+    positivity
+  rw [Real.norm_eq_abs,abs_of_nonneg hn]
+  exact hb.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by nlinarith))
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/SingleCorrelation.lean

@@ -0,0 +1,96 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.PairMoments
+import OAI.Analysis.FiniteFactor.Sampling.MixedCorrelation
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical
+noncomputable section
+
+/-- The source powers make the single-phase relative error at most m^-80. -/
+theorem sourceSampling_single_phase_budget (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n : ℤ) (hn : n ∈ sourceSamplingPowers stage) :
+    1/((n : ℝ)*sourceAngleUnit i) ≤ (sourceBlockSize stage : ℝ)^(-80 : ℝ) := by
+  let m : ℝ := sourceBlockSize stage
+  have hm : 0 < m := sourceBlockSize_pos stage
+  have hm2 : 2 ≤ m := by dsimp [m]; exact_mod_cast (show 2 ≤ sourceBlockSize stage by omega)
+  have hspec := (sourceSamplingPowers_spec stage hs).1 n hn
+  have hQ : m^(83 : ℝ) ≤ samplingQ (sourceBlockSize stage) := by
+    unfold samplingQ
+    change m^(83 : ℝ) ≤ m^((7/10 : ℝ)*m)
+    exact Real.rpow_le_rpow_of_exponent_le (by linarith) (by
+      have hh : (200000 : ℝ) ≤ m := by dsimp [m]; exact_mod_cast hs
+      linarith)
+  have hN : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤ m^2 := by
+    have hh : (sourceBlockSize i.1 : ℝ)*(sourceStageState i.1).K ≤
+        (sourceBlockSize stage : ℝ)*(sourceStageState stage).K := by exact_mod_cast sourceFrequencyScale_monotone hi
+    have hK : ((sourceStageState stage).K : ℝ) ≤ sourceBlockSize stage := by exact_mod_cast (sourceStage stage).m_ge_K
+    dsimp [m]
+    nlinarith
+  have hp : 0 < (n : ℝ) := by exact_mod_cast hspec.2.2
+  have h82 : m^(82 : ℝ) ≤ (n : ℝ) := by
+    have he : m^(83 : ℝ) = m^(82 : ℝ)*m := by
+      rw [show (83 : ℝ) = 82+1 by norm_num,Real.rpow_add hm,Real.rpow_one]
+    have hh : 2*m^(82 : ℝ) ≤ m^(83 : ℝ) := by rw [he]; nlinarith [Real.rpow_pos_of_pos hm (82 : ℝ)]
+    nlinarith [hspec.1]
+  have hlen : m^(80 : ℝ) ≤ (n : ℝ)*sourceAngleUnit i := by
+    unfold sourceAngleUnit
+    rw [mul_one_div,le_div_iff₀ (mul_pos (sourceBlockSize_pos i.1) (sourceCutoff_pos i.1))]
+    calc
+      _ ≤ m^(80 : ℝ)*m^2 := mul_le_mul_of_nonneg_left hN (by positivity)
+      _ = m^(82 : ℝ) := by rw [← Real.rpow_natCast,← Real.rpow_add hm]; norm_num
+      _ ≤ _ := h82
+  have he := one_div_le_one_div_of_le (Real.rpow_pos_of_pos hm (80 : ℝ)) hlen
+  simpa only [m,one_div,Real.rpow_neg (sourceBlockSize_pos stage).le] using he
+
+/-- Actual full-angle single-phase test, with all source sampling hypotheses. -/
+theorem sourceSampling_single_phase_relative (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n : ℤ) (hn : n ∈ sourceSamplingPowers stage)
+    (g : ℝ → ℝ) (hg : ∀ t, 0 ≤ g t) (hgm : Measurable g) (hgi : Integrable g unitIntervalMeasure) :
+    |(∫ θ, g (Int.fract ((n : ℝ)*θ i)) ∂sourceAngleLaw)-(∫ t, g t ∂unitIntervalMeasure)| ≤
+      (sourceBlockSize stage : ℝ)^(-80 : ℝ)*(∫ t, g t ∂unitIntervalMeasure) := by
+  have hnp : (0 : ℝ) < n := by exact_mod_cast ((sourceSamplingPowers_spec stage hs).1 n hn).2.2
+  have hh := sourceAngle_single_phase_test i (n : ℝ) hnp (sourceSampling_phase_length stage hs i hi n hn) g hg hgm hgi
+  have hm : Measurable (fun t : ℝ => g (Int.fract ((n : ℝ)*t))) :=
+    hgm.comp (sourceFract_measurable.comp (measurable_const.mul measurable_id))
+  rw [← sourceAngleLaw_coordinate i,integral_map (measurable_pi_apply i).aemeasurable hm.aestronglyMeasurable] at hh
+  exact hh.trans (mul_le_mul_of_nonneg_right (sourceSampling_single_phase_budget stage hs i hi n hn) (integral_nonneg hg))
+
+/-- The actual mixed q_n/Z_l^0 coordinate factor, for every orientation and
+all measurable tests, has error at most 5*m^-80. -/
+theorem sourceSampling_coordinate_mixed_error (stage : ℕ) (hs : 200000 ≤ sourceBlockSize stage)
+    (i : SourceCoordinate) (hi : i.1 ≤ stage) (n : ℤ) (hn : n ∈ sourceSamplingPowers stage)
+    (r b : Bool) (E G : Set ℝ) (hE : MeasurableSet E) (hG : MeasurableSet G) :
+    |(∫ s, samplingOrientedDensity r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G s *
+        (∫ θ, samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage)
+          E G s (Int.fract ((n : ℝ)*θ i)) ∂sourceAngleLaw) ∂unitIntervalMeasure)-
+      (∫ s, samplingOrientedDensity r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G s^2 ∂unitIntervalMeasure)| ≤
+      5*(sourceBlockSize stage : ℝ)^(-80 : ℝ) := by
+  let u := samplingOrientedWeight r b (sourceSamplingWidth stage) (sourceSamplingCutoff stage) E G
+  let C := max 1 (1/(sourceSamplingWidth stage*sourceSamplingCutoff stage))
+  have hp := sourceSampling_parameters stage
+  have hu : Measurable (fun p : ℝ × ℝ => u p.1 p.2) := samplingOrientedWeight_measurable r b _ _ E G hE hG
+  have hb : ∀ s t, 0 ≤ u s t ∧ u s t ≤ C := samplingOrientedWeight_bounds r b _ _ E G hp.1 hp.2.2
+  have he := sampling_integrated_mixed_error sourceAngleLaw (fun θ => Int.fract ((n : ℝ)*θ i))
+    (sourceFract_measurable.comp (measurable_const.mul (measurable_pi_apply i)))
+    u hu C ((sourceBlockSize stage : ℝ)^(-80 : ℝ)) hb (fun s =>
+      sourceSampling_single_phase_relative stage hs i hi n hn (u s) (fun t => (hb s t).1)
+        (hu.comp (measurable_const.prodMk measurable_id))
+        (sampling_integrable_bounded unitIntervalMeasure (u s)
+          (hu.comp (measurable_const.prodMk measurable_id)) C (fun t => by
+            rw [abs_of_nonneg (hb s t).1]; exact (hb s t).2)))
+  apply he.trans
+  have hA := (sourceSampling_oriented_moment stage r b E G hE hG).2
+  have hm1 : (1 : ℝ) ≤ sourceBlockSize stage := by
+    have h := (sourceStage stage).m_ge_100
+    exact_mod_cast (show 1 ≤ sourceBlockSize stage by omega)
+  have hpow : (sourceBlockSize stage : ℝ)^(-6/5 : ℝ) ≤ 1 := Real.rpow_le_one_of_one_le_of_nonpos hm1 (by norm_num)
+  have hA5 : (∫ s, (∫ t, u s t ∂unitIntervalMeasure)^2 ∂unitIntervalMeasure) ≤ 5 := by
+    exact hA.trans (by linarith)
+  nlinarith [Real.rpow_nonneg (sourceBlockSize_pos stage).le (-80 : ℝ)]
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/Tail.lean

@@ -0,0 +1,86 @@
+import OAI.Analysis.FiniteFactor.CrossedProduct.StageOperator
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped ENNReal Topology
+noncomputable section
+
+theorem sourceCutoff_ge_shift (s n : ℕ) :
+    2^n * (sourceStageState s).K ≤ (sourceStageState (s+n)).K := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    have hh := sourceStage_cutoff_growth (s+n)
+    rw [pow_succ, Nat.add_succ]
+    nlinarith
+
+/-- The exact geometric tail estimate used in scales and tail trimming. -/
+theorem sourceCutoff_tail_bound (s : ℕ) :
+    (∑' n : ℕ, 1 / ((sourceStageState (s+n)).K : ℝ)) ≤
+      2 / ((sourceStageState s).K : ℝ) := by
+  let b (n : ℕ) : ℝ := (1 / ((sourceStageState s).K : ℝ)) * (1/2 : ℝ)^n
+  have hb : Summable b := (summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1/2)
+    (by norm_num : (1/2 : ℝ) < 1)).mul_left _
+  have hle (n : ℕ) : 1 / ((sourceStageState (s+n)).K : ℝ) ≤ b n := by
+    have hh : (2 : ℝ)^n * (sourceStageState s).K ≤ (sourceStageState (s+n)).K :=
+      by exact_mod_cast sourceCutoff_ge_shift s n
+    have hp : (0 : ℝ) < 2^n * (sourceStageState s).K := mul_pos (by positivity) (sourceCutoff_pos s)
+    have ht := one_div_le_one_div_of_le hp hh
+    simpa [b, one_div_pow, mul_comm, mul_left_comm] using ht
+  calc
+    _ ≤ ∑' n, b n := (hb.of_nonneg_of_le (fun _ => by positivity) hle).tsum_le_tsum hle hb
+    _ = 2 / ((sourceStageState s).K : ℝ) := by
+      rw [tsum_mul_left, tsum_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1/2) (by norm_num)]
+      ring
+
+def sourceTailAngleSum (θ : SourceCoordinate → ℝ) (s : ℕ) : ℝ :=
+  ∑' n : ℕ, ∑ i : Fin (sourceBlockSize (s+n)), θ ⟨s+n,i⟩
+
+theorem SourceAngles.tail_sum_bound {θ : SourceCoordinate → ℝ} (hθ : SourceAngles θ) (s : ℕ) :
+    sourceTailAngleSum θ s ≤ 4 / ((sourceStageState s).K : ℝ) := by
+  have hb (n : ℕ) :
+      (∑ i : Fin (sourceBlockSize (s+n)), θ ⟨s+n,i⟩) ≤ 2 / ((sourceStageState (s+n)).K : ℝ) := by
+    have hh := Finset.sum_le_sum (fun i (_ : i ∈ Finset.univ) => (hθ ⟨s+n,i⟩).2)
+    have he : (∑ _i : Fin (sourceBlockSize (s+n)),
+        2 / ((sourceBlockSize (s+n) : ℝ)*(sourceStageState (s+n)).K)) =
+        2 / ((sourceStageState (s+n)).K : ℝ) := by
+      simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+      field_simp [(sourceBlockSize_pos (s+n)).ne', (sourceCutoff_pos (s+n)).ne']
+    exact hh.trans_eq he
+  have hs : Summable (fun n => 2 / ((sourceStageState (s+n)).K : ℝ)) := by
+    have hh := sourceCutoff_reciprocal_summable.comp_injective (add_right_injective s)
+    simpa [div_eq_mul_inv] using hh.mul_left 2
+  calc
+    sourceTailAngleSum θ s ≤ ∑' n, 2 / ((sourceStageState (s+n)).K : ℝ) :=
+      (hs.of_nonneg_of_le (fun n => Finset.sum_nonneg (fun i _ => hθ.nonneg _)) hb).tsum_le_tsum hb hs
+    _ = 2 * ∑' n, 1 / ((sourceStageState (s+n)).K : ℝ) := by
+      rw [← tsum_mul_left]; congr; funext n; ring
+    _ ≤ 2 * (2 / ((sourceStageState s).K : ℝ)) :=
+      mul_le_mul_of_nonneg_left (sourceCutoff_tail_bound s) (by norm_num)
+    _ = 4 / ((sourceStageState s).K : ℝ) := by ring
+
+/-- The largest proposed sampling power divided by the next cutoff has the
+source exponent gap 7/10 - 3/4 = -1/20. -/
+theorem sourceSampling_tail_ratio (s : ℕ) :
+    4 * (sourceBlockSize s : ℝ)^((7/10 : ℝ)*(sourceBlockSize s : ℝ)) /
+      ((sourceStageState (s+1)).K : ℝ) ≤
+    4 * (sourceBlockSize s : ℝ)^(-(sourceBlockSize s : ℝ)/20) := by
+  have hm := sourceBlockSize_pos s
+  have hK := sourceCutoff_pos (s+1)
+  have hc : (sourceBlockSize s : ℝ)^((3/4 : ℝ)*(sourceBlockSize s : ℝ)) ≤
+      (sourceStageState (s+1)).K := Nat.le_ceil _
+  apply (div_le_iff₀ hK).mpr
+  calc
+    _ = (4 * (sourceBlockSize s : ℝ)^(-(sourceBlockSize s : ℝ)/20)) *
+        (sourceBlockSize s : ℝ)^((3/4 : ℝ)*(sourceBlockSize s : ℝ)) := by
+      rw [mul_assoc, ← Real.rpow_add hm]
+      congr 2
+      ring
+    _ ≤ _ := mul_le_mul_of_nonneg_left hc (by positivity)
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TestedMarginals.lean

@@ -0,0 +1,94 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.TestedTransport
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal
+noncomputable section
+
+def sourceSamplingEndpoint (r : Bool)
+    (p : (SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) : SourceCoordinate → ℝ :=
+  if r then p.2 else p.1
+
+theorem sourceSamplingEndpoint_measurable (r : Bool) : Measurable (sourceSamplingEndpoint r) := by
+  cases r
+  · exact measurable_fst
+  · exact measurable_snd
+
+/-- Both actual rectangle-restricted marginal measures for a single power. -/
+theorem sourceSamplingSummand_tested_marginal (I : Finset SourceCoordinate) (stage : ℕ)
+    (r : Bool) (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    ((sourceSamplingSummand I stage θ n).restrict (sourceSamplingRectangle E G)).map
+        (sourceSamplingEndpoint r) =
+      sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingProduct stage r (fun i => decide (i ∈ I)) E G n θ x)) := by
+  rw [sourceSamplingSummand_restrict_rectangle I stage E G hE hG houtside θ n]
+  have hp : Measurable (fun x : SourceCoordinate → ℝ => (x,coordinateRotate θ n x)) :=
+    measurable_id.prodMk (coordinateRotate_preserving θ n).measurable
+  rw [Measure.map_map (sourceSamplingEndpoint_measurable r) hp]
+  cases r
+  · exact Measure.map_id
+  · change (sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingProduct stage false (fun i => decide (i ∈ I)) E G n θ x))).map
+      (coordinateRotate θ n) = _
+    have hw : Measurable (fun x => ENNReal.ofReal
+        (sourceSamplingProduct stage false (fun i => decide (i ∈ I)) E G n θ x)) :=
+      (((sourceSamplingProduct_measurable stage false (fun i => decide (i ∈ I)) E G hE hG n).comp
+        (measurable_const.prodMk measurable_id)).ennreal_ofReal)
+    rw [sourceSamplingHaar_rotate_withDensity θ n _ hw]
+    apply withDensity_congr_ae
+    filter_upwards [sourceSamplingHaar_cube] with y hy
+    rw [sourceSamplingProduct_second_inverse I stage E G θ y n hy]
+
+/-- Averaging commutes with rectangle restriction and either endpoint map.
+The density is the previously estimated empirical function, exactly. -/
+theorem sourceSamplingUntrimmed_tested_marginal (I : Finset SourceCoordinate) (stage : ℕ)
+    (r : Bool) (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ : SourceCoordinate → ℝ) :
+    ((sourceSamplingUntrimmed I stage θ).restrict (sourceSamplingRectangle E G)).map
+        (sourceSamplingEndpoint r) =
+      sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingEmpiricalDensity stage r (fun i => decide (i ∈ I)) E G θ x)) := by
+  let S := sourceSamplingPowers stage
+  let c : ℝ≥0∞ := ENNReal.ofReal (1/((sourceSamplingPowers stage).card : ℝ))
+  let w := fun n => sourceSamplingProduct stage r (fun i => decide (i ∈ I)) E G n θ
+  have hrep : (fun x => ENNReal.ofReal (sourceSamplingEmpiricalDensity stage r
+      (fun i => decide (i ∈ I)) E G θ x)) =
+      (fun x => c*∑ n ∈ S, ENNReal.ofReal (w n x)) := by
+    funext x
+    simp only [sourceSamplingEmpiricalDensity]
+    rw [div_eq_mul_inv,mul_comm,← one_div,ENNReal.ofReal_mul (by positivity),
+      ENNReal.ofReal_sum_of_nonneg (fun n _ => (sourceSamplingProduct_bounds stage r
+        (fun i => decide (i ∈ I)) E G n θ x).1)]
+  rw [hrep]
+  have hf := sourceSamplingEndpoint_measurable r
+  have hR := sourceSamplingRectangle_measurable E G hE hG
+  ext A hA
+  rw [Measure.map_apply hf hA,Measure.restrict_apply (hf hA)]
+  unfold sourceSamplingUntrimmed
+  rw [Measure.smul_apply,Measure.finsetSum_apply,withDensity_apply _ hA]
+  have hterm (n : ℤ) : sourceSamplingSummand I stage θ n
+      (sourceSamplingEndpoint r ⁻¹' A ∩ sourceSamplingRectangle E G) =
+      ∫⁻ x in A, ENNReal.ofReal (w n x) ∂sourceSamplingHaar := by
+    rw [← Measure.restrict_apply (hf hA),← Measure.map_apply hf hA,
+      sourceSamplingSummand_tested_marginal I stage r E G hE hG houtside θ n]
+    exact withDensity_apply _ hA
+  simp only [hterm,smul_eq_mul]
+  rw [lintegral_const_mul' c _ ENNReal.ofReal_ne_top]
+  congr 1
+  exact (lintegral_finsetSum S (fun n _ =>
+    (((sourceSamplingProduct_measurable stage r (fun i => decide (i ∈ I)) E G hE hG n).comp
+      (measurable_const.prodMk measurable_id)).ennreal_ofReal))).symm
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TestedTransport.lean

@@ -0,0 +1,92 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.SecondMarginal
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal
+noncomputable section
+
+def sourceSamplingRectangle (E G : SourceCoordinate → Set ℝ) :
+    Set ((SourceCoordinate → ℝ) × (SourceCoordinate → ℝ)) :=
+  {p | ∀ i, p.1 i ∈ E i ∧ p.2 i ∈ G i}
+
+theorem sourceSamplingRectangle_measurable (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i)) :
+    MeasurableSet (sourceSamplingRectangle E G) := by
+  simp only [sourceSamplingRectangle,Set.ofPred_forall]
+  apply MeasurableSet.iInter
+  intro i
+  exact ((hE i).preimage ((measurable_pi_apply i).comp measurable_fst)).inter
+    ((hG i).preimage ((measurable_pi_apply i).comp measurable_snd))
+
+theorem sourceSamplingProduct_first_indicator (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ)
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ x : SourceCoordinate → ℝ) (n : ℤ)
+    (hx : ∀ i, x i ∈ Set.Ico (0 : ℝ) 1) :
+    sourceSamplingProduct stage false (fun i => decide (i ∈ I)) E G n θ x =
+      if (x,coordinateRotate θ n x) ∈ sourceSamplingRectangle E G
+      then sourceSamplingWeight I stage θ n x else 0 := by
+  have hy (i) : coordinateRotate θ n x i ∈ Set.Ico (0 : ℝ) 1 :=
+    ⟨Int.fract_nonneg _,Int.fract_lt_one _⟩
+  have he : (∀ i ∈ sourceSamplingPrefix stage, x i ∈ E i ∧ coordinateRotate θ n x i ∈ G i) ↔
+      (x,coordinateRotate θ n x) ∈ sourceSamplingRectangle E G := by
+    constructor
+    · intro h i
+      by_cases hi : i ∈ sourceSamplingPrefix stage
+      · exact h i hi
+      · exact ⟨(houtside i hi).1 (hx i),(houtside i hi).2 (hy i)⟩
+    · intro h i _
+      exact h i
+  unfold sourceSamplingProduct samplingOrientedWeight samplingTestedFirstWeight
+  simp only [Bool.false_eq_true,ite_false,← coordinateRotate_phase]
+  simp only [Finset.prod_ite_zero,he]
+  rfl
+
+/-- Inverse rotation exchanges the two actual tested product orientations. -/
+theorem sourceSamplingProduct_second_inverse (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ) (θ y : SourceCoordinate → ℝ) (n : ℤ)
+    (hy : ∀ i, y i ∈ Set.Ico (0 : ℝ) 1) :
+    sourceSamplingProduct stage false (fun i => decide (i ∈ I)) E G n θ
+      (coordinateRotate θ (-n) y) =
+    sourceSamplingProduct stage true (fun i => decide (i ∈ I)) E G n θ y := by
+  have hinv : coordinateRotate θ n (coordinateRotate θ (-n) y) = y := by
+    simpa only [neg_neg] using coordinateRotate_neg_cube θ y (-n) hy
+  apply Finset.prod_congr rfl
+  intro i _
+  have hi := congrFun hinv i
+  rw [coordinateRotate_phase] at hi
+  simp only [samplingOrientedWeight,Bool.false_eq_true,ite_false,ite_true,samplingTestedFirstWeight,hi]
+  rw [coordinateRotate_neg_phase]
+
+/-- The restricted orbit-pair summand is exactly the pushforward of its
+first tested product, with no assumed marginal law. -/
+theorem sourceSamplingSummand_restrict_rectangle (I : Finset SourceCoordinate) (stage : ℕ)
+    (E G : SourceCoordinate → Set ℝ)
+    (hE : ∀ i, MeasurableSet (E i)) (hG : ∀ i, MeasurableSet (G i))
+    (houtside : ∀ i ∉ sourceSamplingPrefix stage,
+      Set.Ico (0 : ℝ) 1 ⊆ E i ∧ Set.Ico (0 : ℝ) 1 ⊆ G i)
+    (θ : SourceCoordinate → ℝ) (n : ℤ) :
+    (sourceSamplingSummand I stage θ n).restrict (sourceSamplingRectangle E G) =
+      (sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal
+        (sourceSamplingProduct stage false (fun i => decide (i ∈ I)) E G n θ x))).map
+          (fun x => (x,coordinateRotate θ n x)) := by
+  have hp : Measurable (fun x : SourceCoordinate → ℝ => (x,coordinateRotate θ n x)) :=
+    measurable_id.prodMk (coordinateRotate_preserving θ n).measurable
+  have hR := sourceSamplingRectangle_measurable E G hE hG
+  unfold sourceSamplingSummand sourceSamplingWeightedMeasure
+  rw [Measure.restrict_map hp hR,restrict_withDensity (hp hR),← withDensity_indicator (hp hR)]
+  congr 1
+  apply withDensity_congr_ae
+  filter_upwards [sourceSamplingHaar_cube] with x hx
+  rw [sourceSamplingProduct_first_indicator I stage E G houtside θ x n hx]
+  change (if (x,coordinateRotate θ n x) ∈ sourceSamplingRectangle E G
+    then ENNReal.ofReal (sourceSamplingWeight I stage θ n x) else 0) = _
+  split_ifs <;> simp
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TorusLimitMarginals.lean

@@ -0,0 +1,69 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.TorusMarginals
+import OAI.Analysis.FiniteFactor.OrbitSampling.LambdaMarginals
+import OAI.Analysis.FiniteFactor.OrbitSampling.TorusSupport
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped ENNReal
+noncomputable section
+
+/-- The actual compact-torus limiting marginals are dominated by product
+Haar, the exact absolute continuity premise needed in the Lusin transfer. -/
+theorem sourceSamplingLambdaTorus_marginal_le (I : Finset SourceCoordinate) (r : Bool) :
+    (sourceSamplingLambdaTorus I : Measure SourceSamplingTorus).map (sourceTorusEndpoint r) ≤ sourceTorusHaar := by
+  have he : sourceTorusEndpoint r ∘ sourceSamplingTorusMap = sourceTorusQuotient ∘ sourceSamplingEndpoint r := by
+    funext p
+    cases r <;> rfl
+  change ((sourceSamplingLambda I).map sourceSamplingTorusMap).map (sourceTorusEndpoint r) ≤ _
+  rw [Measure.map_map (sourceTorusEndpoint_measurable r) sourceSamplingTorusMap_continuous.measurable,he,
+    ← Measure.map_map sourceTorusQuotient_preserving.measurable (sourceSamplingEndpoint_measurable r)]
+  have h := Measure.map_mono (sourceSamplingLambda_marginal_le I r) sourceTorusQuotient_preserving.measurable
+  rwa [sourceTorusQuotient_preserving.map_eq] at h
+
+theorem sourceSamplingLambdaTorus_marginal_ac (I : Finset SourceCoordinate) (r : Bool) :
+    (sourceSamplingLambdaTorus I : Measure SourceSamplingTorus).map (sourceTorusEndpoint r) ≪ sourceTorusHaar :=
+  Measure.absolutelyContinuous_of_le (sourceSamplingLambdaTorus_marginal_le I r)
+
+theorem sourceSamplingLambda_representatives (I : Finset SourceCoordinate) :
+    ∀ᵐ p ∂sourceSamplingLambda I, sourceSamplingPairRepresentative (sourceSamplingTorusMap p) = p := by
+  have hmeas : MeasurableSet {p : SourceSamplingPair |
+      sourceSamplingPairRepresentative (sourceSamplingTorusMap p) = p} :=
+    measurableSet_eq_fun (sourceSamplingPairRepresentative_measurable.comp sourceSamplingTorusMap_continuous.measurable)
+      measurable_id
+  apply (ae_map_iff (sourceSamplingLimitMap_measurable I).aemeasurable hmeas).mpr
+  filter_upwards [ae_restrict_of_ae sourceSamplingPairHaar_cube] with p hp
+  apply Prod.ext
+  · exact sourceTorusRepresentative_quotient _ (fun i => (hp i).1)
+  · apply sourceTorusRepresentative_quotient
+    intro i
+    by_cases hi : i ∈ I
+    · simpa only [sourceSamplingLimitMap,ite_eq_left hi] using (hp i).2
+    · simpa only [sourceSamplingLimitMap,ite_eq_right hi] using (hp i).1
+
+/-- The actual limiting torus measure has the same representative order
+as the trimmed measures. No closure of the order set in torus topology is assumed. -/
+theorem sourceSamplingLambdaTorus_ordered (I : Finset SourceCoordinate) :
+    ∀ᵐ p ∂(sourceSamplingLambdaTorus I : Measure SourceSamplingTorus),
+      ∀ i, sourceTorusRepresentative p.1 i ≤ sourceTorusRepresentative p.2 i := by
+  have hmeas : MeasurableSet {p : SourceSamplingTorus |
+      ∀ i, sourceTorusRepresentative p.1 i ≤ sourceTorusRepresentative p.2 i} := by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter (fun i => measurableSet_le
+      ((measurable_pi_apply i).comp (sourceTorusRepresentative_preserving.measurable.comp measurable_fst))
+      ((measurable_pi_apply i).comp (sourceTorusRepresentative_preserving.measurable.comp measurable_snd)))
+  apply (ae_map_iff sourceSamplingTorusMap_continuous.measurable.aemeasurable hmeas).mpr
+  filter_upwards [sourceSamplingLambda_ordered I,sourceSamplingLambda_representatives I] with p hp he
+  have h1 := congrArg Prod.fst he
+  have h2 := congrArg Prod.snd he
+  change sourceTorusRepresentative (sourceTorusQuotient p.1) = p.1 at h1
+  change sourceTorusRepresentative (sourceTorusQuotient p.2) = p.2 at h2
+  change ∀ i, sourceTorusRepresentative (sourceTorusQuotient p.1) i ≤ sourceTorusRepresentative (sourceTorusQuotient p.2) i
+  rw [h1,h2]
+  exact hp
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TorusMarginals.lean

@@ -0,0 +1,58 @@
+import OAI.Analysis.FiniteFactor.CrossedProduct.TorusModel
+import OAI.Analysis.FiniteFactor.OrbitSampling.TrimmedMarginals
+import OAI.Analysis.FiniteFactor.OrbitSampling.TrimmedWeak
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped ENNReal
+noncomputable section
+
+def sourceTorusEndpoint (r : Bool) (p : SourceSamplingTorus) : SourceTorus := if r then p.2 else p.1
+
+theorem sourceTorusEndpoint_measurable (r : Bool) : Measurable (sourceTorusEndpoint r) := by
+  cases r
+  · exact measurable_fst
+  · exact measurable_snd
+
+theorem sourceSamplingTorus_marginal_transport (μ : Measure SourceSamplingPair) (r : Bool)
+    (g : (SourceCoordinate → ℝ) → ℝ) (hg : Measurable g)
+    (hm : μ.map (sourceSamplingEndpoint r) = sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (g x))) :
+    (μ.map sourceSamplingTorusMap).map (sourceTorusEndpoint r) =
+      sourceTorusHaar.withDensity (fun z => ENNReal.ofReal (g (sourceTorusRepresentative z))) := by
+  have he : sourceTorusEndpoint r ∘ sourceSamplingTorusMap = sourceTorusQuotient ∘ sourceSamplingEndpoint r := by
+    funext p
+    cases r <;> rfl
+  rw [Measure.map_map (sourceTorusEndpoint_measurable r) sourceSamplingTorusMap_continuous.measurable,he,
+    ← Measure.map_map sourceTorusQuotient_preserving.measurable (sourceSamplingEndpoint_measurable r),hm]
+  exact sourceTorusQuotient_withDensity _ hg.ennreal_ofReal
+
+/-- The actual torus marginals, rather than only the representative-space
+marginals, have uniformly bounded L2 densities with respect to product Haar. -/
+theorem sourceSamplingTrimmed_torus_marginals_event : ∀ᵐ θ ∂sourceAngleLaw,
+    ∀ (I : Finset SourceCoordinate) (r : Bool), ∃ C : ℝ, ∀ s,
+      ∃ g : SourceTorus → ℝ,
+        Measurable g ∧ (∀ z, 0 ≤ g z) ∧
+        (sourceSamplingTrimmedTorus I s θ : Measure SourceSamplingTorus).map (sourceTorusEndpoint r) =
+          sourceTorusHaar.withDensity (fun z => ENNReal.ofReal (g z)) ∧
+        MemLp g 2 sourceTorusHaar ∧ (∫ z, g z^2 ∂sourceTorusHaar) ≤ C := by
+  filter_upwards [sourceSamplingTrimmed_marginals_event] with θ hθ
+  intro I r
+  obtain ⟨C,hC⟩ := hθ I r
+  refine ⟨C,fun s => ?_⟩
+  obtain ⟨g,hg,hg0,hgm,hglp,hgint⟩ := hC s
+  refine ⟨g ∘ sourceTorusRepresentative,hg.comp sourceTorusRepresentative_preserving.measurable,
+    fun z => hg0 _,sourceSamplingTorus_marginal_transport _ r g hg hgm,?_,?_⟩
+  · exact hglp.comp_measurePreserving sourceTorusRepresentative_preserving
+  · have he : (∫ z, (g (sourceTorusRepresentative z))^2 ∂sourceTorusHaar) =
+        ∫ x, g x^2 ∂sourceSamplingHaar := by
+      rw [← sourceTorusRepresentative_preserving.map_eq]
+      exact (integral_map sourceTorusRepresentative_preserving.measurable.aemeasurable
+        (hg.pow_const 2).aestronglyMeasurable).symm
+    exact he.trans_le hgint
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TorusSupport.lean

@@ -0,0 +1,107 @@
+import OAI.Analysis.FiniteFactor.CrossedProduct.TorusModel
+import OAI.Analysis.FiniteFactor.OrbitSampling.OrbitSupport
+import OAI.Analysis.FiniteFactor.OrbitSampling.TrimmedWeak
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped ENNReal Classical
+noncomputable section
+
+def sourceSamplingPairRepresentative (z : SourceSamplingTorus) : SourceSamplingPair :=
+  (sourceTorusRepresentative z.1,sourceTorusRepresentative z.2)
+
+theorem sourceSamplingPairRepresentative_measurable : Measurable sourceSamplingPairRepresentative :=
+  (sourceTorusRepresentative_preserving.measurable.comp measurable_fst).prodMk
+    (sourceTorusRepresentative_preserving.measurable.comp measurable_snd)
+
+def sourceTorusRotate (θ : SourceCoordinate → ℝ) (n : ℤ) (z : SourceTorus) : SourceTorus :=
+  fun i => z i + n • (θ i : UnitAddCircle)
+
+theorem sourceTorusRotate_continuous (θ : SourceCoordinate → ℝ) (n : ℤ) : Continuous (sourceTorusRotate θ n) :=
+  continuous_pi (fun i => (continuous_apply i).add continuous_const)
+
+theorem sourceTorusQuotient_rotate (θ x : SourceCoordinate → ℝ) (n : ℤ) :
+    sourceTorusQuotient (coordinateRotate θ n x) = sourceTorusRotate θ n (sourceTorusQuotient x) := by
+  funext i
+  simp only [sourceTorusQuotient,coordinateRotate,sourceTorusRotate,AddCircle.coe_fract,
+    AddCircle.coe_add,← zsmul_eq_mul,AddCircle.coe_zsmul]
+
+/-- The chosen real representatives recover the actual orbit measures;
+closed-cube endpoints are not silently identified with distinct real points. -/
+theorem sourceSamplingTrimmed_representatives (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : ∀ᵐ p ∂sourceSamplingTrimmed I s θ,
+      sourceSamplingPairRepresentative (sourceSamplingTorusMap p) = p := by
+  have hmeas : MeasurableSet {p : SourceSamplingPair |
+      sourceSamplingPairRepresentative (sourceSamplingTorusMap p) = p} :=
+    measurableSet_eq_fun (sourceSamplingPairRepresentative_measurable.comp sourceSamplingTorusMap_continuous.measurable)
+      measurable_id
+  have hu : ∀ᵐ p ∂sourceSamplingUntrimmed I s θ,
+      sourceSamplingPairRepresentative (sourceSamplingTorusMap p) = p := by
+    apply Measure.ae_smul_measure
+    rw [ae_iff,Measure.finsetSum_apply]
+    apply Finset.sum_eq_zero
+    intro n hn
+    apply ae_iff.mp
+    apply (ae_map_iff (measurable_id.prodMk (coordinateRotate_preserving θ n).measurable).aemeasurable hmeas).mpr
+    have hh : ∀ᵐ x ∂sourceSamplingWeightedMeasure I s θ n, ∀ i, x i ∈ Set.Ico (0 : ℝ) 1 :=
+      ae_iff.mpr (withDensity_absolutelyContinuous _ _ (ae_iff.mp sourceSamplingHaar_cube))
+    filter_upwards [hh] with x hx
+    apply Prod.ext
+    · exact sourceTorusRepresentative_quotient x hx
+    · exact sourceTorusRepresentative_quotient _ (fun i => ⟨Int.fract_nonneg _,Int.fract_lt_one _⟩)
+  exact ae_restrict_of_ae hu
+
+def sourceSamplingTorusOrderedOrbits (s : ℕ) (θ : SourceCoordinate → ℝ) : Set SourceSamplingTorus :=
+  {p | (∀ i, sourceTorusRepresentative p.1 i ≤ sourceTorusRepresentative p.2 i) ∧
+    ∃ n ∈ sourceSamplingPowers s, 0 < n ∧ p.2 = sourceTorusRotate θ n p.1}
+
+theorem sourceSamplingTorusOrderedOrbits_measurable (s : ℕ) (θ : SourceCoordinate → ℝ) :
+    MeasurableSet (sourceSamplingTorusOrderedOrbits s θ) := by
+  change MeasurableSet ({p : SourceSamplingTorus | ∀ i, sourceTorusRepresentative p.1 i ≤ sourceTorusRepresentative p.2 i} ∩
+    {p : SourceSamplingTorus | ∃ n ∈ sourceSamplingPowers s, 0 < n ∧ p.2 = sourceTorusRotate θ n p.1})
+  apply MeasurableSet.inter
+  · simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter (fun i => measurableSet_le
+      ((measurable_pi_apply i).comp (sourceTorusRepresentative_preserving.measurable.comp measurable_fst))
+      ((measurable_pi_apply i).comp (sourceTorusRepresentative_preserving.measurable.comp measurable_snd)))
+  · simp only [Set.ofPred_exists]
+    apply MeasurableSet.iUnion
+    intro n
+    by_cases hn : n ∈ sourceSamplingPowers s ∧ 0 < n
+    · simp only [hn.1,hn.2,true_and]
+      exact measurableSet_eq_fun measurable_snd ((sourceTorusRotate_continuous θ n).measurable.comp measurable_fst)
+    · have he : {p : SourceSamplingTorus | n ∈ sourceSamplingPowers s ∧ 0 < n ∧ p.2 = sourceTorusRotate θ n p.1} = ∅ := by
+        ext p; simp only [Set.mem_ofPred_eq,Set.mem_empty_iff_false,iff_false]; tauto
+      rw [he]
+      exact MeasurableSet.empty
+
+/-- Actual compact-torus support: representatives are ordered, and each pair
+lies on one of the constructed finitely many strictly positive rotation graphs. -/
+theorem sourceSamplingTrimmed_torus_orbits (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) :
+    ∀ᵐ p ∂(sourceSamplingTrimmedTorus I s θ : Measure SourceSamplingTorus),
+      (∀ i, sourceTorusRepresentative p.1 i ≤ sourceTorusRepresentative p.2 i) ∧
+      ∃ n ∈ sourceSamplingPowers s, 0 < n ∧ p.2 = sourceTorusRotate θ n p.1 := by
+  apply (ae_map_iff sourceSamplingTorusMap_continuous.measurable.aemeasurable
+    (sourceSamplingTorusOrderedOrbits_measurable s θ)).mpr
+  filter_upwards [sourceSamplingTrimmed_orbits I s θ,sourceSamplingTrimmed_representatives I s θ] with p hp he
+  refine ⟨?_,?_⟩
+  · have h1 := congrArg Prod.fst he
+    have h2 := congrArg Prod.snd he
+    change sourceTorusRepresentative (sourceTorusQuotient p.1) = p.1 at h1
+    change sourceTorusRepresentative (sourceTorusQuotient p.2) = p.2 at h2
+    change ∀ i, sourceTorusRepresentative (sourceTorusQuotient p.1) i ≤ sourceTorusRepresentative (sourceTorusQuotient p.2) i
+    rw [h1,h2]
+    exact hp.1
+  · obtain ⟨n,hn,hpos,hrot⟩ := hp.2
+    refine ⟨n,hn,hpos,?_⟩
+    change sourceTorusQuotient p.2 = sourceTorusRotate θ n (sourceTorusQuotient p.1)
+    rw [hrot]
+    exact sourceTorusQuotient_rotate θ p.1 n
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TriangleLaw.lean

@@ -0,0 +1,79 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.CutoffMass
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- The actual triangular phase weight is precisely the order indicator
+of the rotated endpoint, on the Haar representatives. -/
+theorem samplingWeight_triangular_order (h α s t : ℝ)
+    (hs : s ∈ Set.Ico (0 : ℝ) 1) (ht : t ∈ Set.Ico (0 : ℝ) 1) :
+    samplingWeight true h α s t = if s < Int.fract (s+t) then 1 else 0 := by
+  by_cases hst : s+t < 1
+  · have hf : Int.fract (s+t) = s+t := Int.fract_eq_self.mpr ⟨by linarith [hs.1,ht.1],hst⟩
+    simp only [samplingWeight,ite_true,hf]
+    have he : (0 < t ∧ t < 1-s) ↔ s < s+t := by
+      constructor
+      · intro h; linarith [h.1]
+      · intro h; constructor <;> linarith
+    simp only [he]
+  · have hf : ⌊s+t⌋ = (1 : ℤ) := Int.floor_eq_iff.mpr ⟨by norm_num; linarith,by norm_num; linarith [hs.2,ht.2]⟩
+    have hn : ¬ (0 < t ∧ t < 1-s) := by intro h; linarith [h.2]
+    have ho : ¬ s < Int.fract (s+t) := by rw [Int.fract,hf]; norm_num; linarith [ht.2]
+    simp only [samplingWeight,ite_true,ite_eq_right hn,ite_eq_right ho]
+
+/-- The first tested triangular density is its actual vertical section of
+Lebesgue measure on 0≤x<y<1. No triangular marginal identity is assumed. -/
+theorem samplingTestedFirstDensity_triangular_section (h α s : ℝ) (E G : Set ℝ)
+    (hG : MeasurableSet G) (hs : s ∈ Set.Ico (0 : ℝ) 1) :
+    samplingTestedFirstDensity true h α E G s =
+      ∫ y, (if s ∈ E ∧ y ∈ G ∧ s < y then (1 : ℝ) else 0) ∂unitIntervalMeasure := by
+  let F := fun y : ℝ => if s ∈ E ∧ y ∈ G ∧ s < y then (1 : ℝ) else 0
+  have hm : Measurable F := by
+    apply Measurable.ite _ measurable_const measurable_const
+    by_cases htest : s ∈ E
+    · simp only [htest,true_and]
+      change MeasurableSet (G ∩ {y : ℝ | s < y})
+      exact hG.inter (measurableSet_lt measurable_const measurable_id)
+    · simp [htest]
+  have hp : MeasurePreserving (fun t : ℝ => Int.fract (s+t)) unitIntervalMeasure unitIntervalMeasure := by
+    simpa only [add_comm] using unitInterval_rotate_preserving s
+  have he : samplingTestedFirstWeight true h α E G s =ᵐ[unitIntervalMeasure]
+      (fun t => F (Int.fract (s+t))) := by
+    filter_upwards [ae_restrict_mem measurableSet_Ico] with t ht
+    rw [samplingTestedFirstWeight,samplingWeight_triangular_order h α s t hs ht]
+    simp only [F]
+    split_ifs <;> simp_all
+  rw [samplingTestedFirstDensity,integral_congr_ae he]
+  rw [← integral_map hp.measurable.aemeasurable hm.aestronglyMeasurable,hp.map_eq]
+
+/-- The two-dimensional tested source integral equals the genuine triangular
+restriction of product Lebesgue measure. -/
+theorem samplingTestedFirstDensity_triangular_mass (h α : ℝ) (E G : Set ℝ)
+    (hE : MeasurableSet E) (hG : MeasurableSet G) :
+    (∫ s, samplingTestedFirstDensity true h α E G s ∂unitIntervalMeasure) =
+      ((unitIntervalMeasure.prod unitIntervalMeasure)
+        {p : ℝ × ℝ | p.1 ∈ E ∧ p.2 ∈ G ∧ p.1 < p.2}).toReal := by
+  let A := {p : ℝ × ℝ | p.1 ∈ E ∧ p.2 ∈ G ∧ p.1 < p.2}
+  have hA : MeasurableSet A := (hE.preimage measurable_fst).inter
+    ((hG.preimage measurable_snd).inter (measurableSet_lt measurable_fst measurable_snd))
+  have hm : Measurable (A.indicator (fun _ => (1 : ℝ))) := measurable_const.indicator hA
+  have hi : Integrable (A.indicator (fun _ => (1 : ℝ))) (unitIntervalMeasure.prod unitIntervalMeasure) :=
+    (integrable_const (1 : ℝ)).indicator hA
+  calc
+    _ = ∫ s, ∫ y, A.indicator (fun _ => (1 : ℝ)) (s,y) ∂unitIntervalMeasure ∂unitIntervalMeasure := by
+      apply integral_congr_ae
+      filter_upwards [ae_restrict_mem measurableSet_Ico] with s hs
+      simpa only [A,Set.indicator_apply,Set.mem_ofPred_eq] using
+        samplingTestedFirstDensity_triangular_section h α s E G hG hs
+    _ = ∫ p, A.indicator (fun _ => (1 : ℝ)) p ∂unitIntervalMeasure.prod unitIntervalMeasure :=
+      (integral_prod _ hi).symm
+    _ = _ := by rw [integral_indicator hA]; simp [measureReal_def,A]
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TrimmedMarginals.lean

@@ -0,0 +1,42 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.OrderedRestriction
+import OAI.Analysis.FiniteFactor.SubmeasureL2Density
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+/-- Each actual trimmed marginal is dominated by the actual untrimmed
+marginal, for both orientations. -/
+theorem sourceSamplingTrimmed_marginal_le (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) (r : Bool) :
+    (sourceSamplingTrimmed I s θ).map (sourceSamplingEndpoint r) ≤
+      (sourceSamplingUntrimmed I s θ).map (sourceSamplingEndpoint r) :=
+  Measure.map_mono (sourceSamplingTrimmed_le I s θ) (sourceSamplingEndpoint_measurable r)
+
+/-- The actual Radon--Nikodym densities after trimming have the same uniform
+squared L2 bound, on a single event for every finite I and both endpoints. -/
+theorem sourceSamplingTrimmed_marginals_event : ∀ᵐ θ ∂sourceAngleLaw,
+    ∀ (I : Finset SourceCoordinate) (r : Bool), ∃ C : ℝ, ∀ s : ℕ,
+      ∃ g : (SourceCoordinate → ℝ) → ℝ,
+        Measurable g ∧ (∀ x, 0 ≤ g x) ∧
+        (sourceSamplingTrimmed I s θ).map (sourceSamplingEndpoint r) =
+          sourceSamplingHaar.withDensity (fun x => ENNReal.ofReal (g x)) ∧
+        MemLp g 2 sourceSamplingHaar ∧ (∫ x, g x^2 ∂sourceSamplingHaar) ≤ C := by
+  filter_upwards [sourceSampling_both_marginals_event] with θ hθ
+  intro I r
+  obtain ⟨C,hC⟩ := hθ I r
+  refine ⟨C,fun s => ?_⟩
+  obtain ⟨f,hf,hLp,hbound⟩ := hC s
+  have hsub := sourceSamplingTrimmed_marginal_le I s θ r
+  rw [hf] at hsub
+  obtain ⟨g,hg,hg0,hgμ,hle,hgLp,hgint⟩ := submeasure_L2_density sourceSamplingHaar
+    ((sourceSamplingTrimmed I s θ).map (sourceSamplingEndpoint r)) f hLp hsub
+  exact ⟨g,hg,hg0,hgμ,hgLp,hgint.trans hbound⟩
+
+end
+end FiniteFactor
+
+end OAI

lean/OAI/Analysis/FiniteFactor/OrbitSampling/TrimmedWeak.lean

@@ -0,0 +1,88 @@
+import OAI.Analysis.FiniteFactor.OrbitSampling.OrderedRestriction
+import OAI.Analysis.FiniteFactor.OrbitSampling.CompactTorus
+
+namespace OAI
+
+namespace FiniteFactor
+open MeasureTheory Filter Finset
+open scoped Classical ENNReal Topology
+noncomputable section
+
+def sourceSamplingTrimmedFinite (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : FiniteMeasure SourceSamplingPair :=
+  ⟨sourceSamplingTrimmed I s θ,inferInstance⟩
+
+def sourceSamplingTrimmedTorus (I : Finset SourceCoordinate) (s : ℕ)
+    (θ : SourceCoordinate → ℝ) : FiniteMeasure SourceSamplingTorus :=
+  (sourceSamplingTrimmedFinite I s θ).map sourceSamplingTorusMap
+
+theorem sourceSampling_discarded_tendsto (I : Finset SourceCoordinate)
+    (θ : SourceCoordinate → ℝ) (hθ : SourceAngles θ)
+    (hmass : Tendsto (fun s => ((sourceSamplingUntrimmed I s θ) Set.univ).toReal)
+      atTop (𝓝 (((sourceSamplingLambda I) Set.univ).toReal))) :
+    Tendsto (fun s => ((sourceSamplingUntrimmed I s θ) sourceSamplingOrderedᶜ).toReal)
+      atTop (𝓝 0) := by
+  have hlim := hmass.mul sourceSampling_tail_error_tendsto
+  rw [mul_zero] at hlim
+  apply squeeze_zero (fun s => ENNReal.toReal_nonneg) _ hlim
+  intro s
+  have h := ENNReal.toReal_mono (by finiteness)
+    (sourceSamplingUntrimmed_discarded_le I s θ hθ)
+  simpa only [ENNReal.toReal_mul,ENNReal.toReal_ofReal (by positivity :
+    0 ≤ 4*(sourceBlockSize s : ℝ)^(-(sourceBlockSize s : ℝ)/20))] using h
+
+def finiteMeasureRestrict {Ω : Type*} [MeasurableSpace Ω]
+    (μ : FiniteMeasure Ω) (A : Set Ω) : FiniteMeasure Ω :=
+  ⟨(μ : Measure Ω).restrict A,inferInstance⟩
+
+/-- A restriction whose discarded mass tends to zero has the same finite
+weak limit. The norm bound gives the actual error for every test function. -/
+theorem finiteMeasure_restrict_tendsto {Ω : Type*} [MeasurableSpace Ω]
+    [TopologicalSpace Ω] [OpensMeasurableSpace Ω]
+    (μ : ℕ → FiniteMeasure Ω) (ν : FiniteMeasure Ω) (A : Set Ω) (hA : MeasurableSet A)
+    (hμ : Tendsto μ atTop (𝓝 ν))
+    (hloss : Tendsto (fun n => ((μ n : Measure Ω) Aᶜ).toReal) atTop (𝓝 0)) :
+    Tendsto (fun n => finiteMeasureRestrict (μ n) A)
+      atTop (𝓝 ν) := by
+  apply FiniteMeasure.tendsto_of_forall_integral_tendsto
+  intro f
+  have hf := FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp hμ f
+  have he : Tendsto (fun n => ∫ x in Aᶜ, f x ∂(μ n : Measure Ω)) atTop (𝓝 0) := by
+    apply tendsto_zero_iff_norm_tendsto_zero.mpr
+    have hb := hloss.const_mul ‖f‖
+    rw [mul_zero] at hb
+    apply squeeze_zero (fun n => norm_nonneg _) _ hb
+    intro n
+    have hh := norm_integral_le_of_norm_le_const
+      (μ := (μ n : Measure Ω).restrict Aᶜ)
+      (Eventually.of_forall (fun x => f.norm_coe_le_norm x))
+    simpa only [measureReal_def,Measure.restrict_apply MeasurableSet.univ,Set.univ_inter] using hh
+  have hsub := hf.sub he
+  rw [sub_zero] at hsub
+  convert hsub using 1
+  funext n
+  exact (eq_sub_iff_add_eq.mpr (integral_add_compl (μ := (μ n : Measure Ω)) hA (f.integrable (μ := (μ n : Measure Ω)))))
+
+/-- Actual ordered measures have the same compact-torus weak limit, for
+all continuous tests, on one probability-one angle event. -/
+theorem sourceSamplingTrimmed_weak_event : ∀ᵐ θ ∂sourceAngleLaw,
+    ∀ I : Finset SourceCoordinate,
+      Tendsto (fun s => sourceSamplingTrimmedFinite I s θ) atTop (𝓝 (sourceSamplingLambdaFinite I)) ∧
+      Tendsto (fun s => sourceSamplingTrimmedTorus I s θ) atTop (𝓝 (sourceSamplingLambdaTorus I)) ∧
+      ∀ f : C(SourceSamplingTorus,ℝ),
+        Tendsto (fun s => ∫ p, f p ∂(sourceSamplingTrimmedTorus I s θ : Measure SourceSamplingTorus))
+          atTop (𝓝 (∫ p, f p ∂(sourceSamplingLambdaTorus I : Measure SourceSamplingTorus))) := by
+  filter_upwards [sourceSamplingUntrimmed_weak_event,sourceSampling_mass_limit_event,sourceAngleLaw_admissible]
+    with θ hw hm ha
+  intro I
+  have h := finiteMeasure_restrict_tendsto (fun s => sourceSamplingUntrimmedFinite I s θ)
+    (sourceSamplingLambdaFinite I) sourceSamplingOrdered sourceSamplingOrdered_measurable
+    (hw I) (sourceSampling_discarded_tendsto I θ ha (hm I))
+  have ht := FiniteMeasure.tendsto_map_of_tendsto_of_continuous _ _ h sourceSamplingTorusMap_continuous
+  refine ⟨h,ht,fun f => ?_⟩
+  exact (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp ht) (BoundedContinuousFunction.mkOfCompact f)
+
+end
+end FiniteFactor
+
+end OAI