| import OAI.MeasureTheory.CompactFactors.Functions |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open scoped ComplexConjugate |
| open scoped BigOperators |
| open scoped BigOperators BoundedContinuousFunction |
| open Filter Topology |
| open MeasureTheory Filter |
| open scoped ENNReal ComplexConjugate |
| open MeasureTheory ProbabilityTheory |
| open scoped ComplexConjugate |
| open scoped BigOperators |
| open scoped BigOperators |
| open Polynomial |
| open MeasureTheory |
| open scoped BigOperators |
| open MeasureTheory |
| open scoped BigOperators |
| open MeasureTheory |
| open MeasureTheory ProbabilityTheory |
| open scoped BigOperators |
| open MeasureTheory |
| open scoped BigOperators ComplexConjugate |
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal BigOperators |
| open MeasureTheory Filter |
| open scoped Topology ENNReal NNReal |
| open MeasureTheory |
| open scoped ENNReal |
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal |
| open MeasureTheory ProbabilityTheory |
| open MeasureTheory ProbabilityTheory |
| open MeasureTheory ProbabilityTheory |
| open scoped ENNReal |
| namespace EuclideanFiveColor |
| open MeasureTheory |
| structure OrbitSpace (K : Type*) where |
| val : K → ℂ |
|
|
| namespace OrbitSpace |
| variable {K : Type*} |
| def equiv (K : Type*) : OrbitSpace K ≃ (K → ℂ) where |
| toFun := val |
| invFun := mk |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| instance : Inhabited (OrbitSpace K) := ⟨⟨fun _ => 0⟩⟩ |
| instance : TopologicalSpace (OrbitSpace K) := (equiv K).topologicalSpace |
| instance : MeasurableSpace (OrbitSpace K) := borel _ |
| instance : BorelSpace (OrbitSpace K) := ⟨rfl⟩ |
| instance [Countable K] : PolishSpace (OrbitSpace K) := (equiv K).polishSpace_induced |
|
|
| @[ext] lemma ext {a b : OrbitSpace K} (h : ∀ k, a.val k = b.val k) : a = b := by |
| cases a; cases b; congr; funext k; exact h k |
|
|
| lemma continuous_val : Continuous (val : OrbitSpace K → K → ℂ) := |
| (equiv K).homeomorph.continuous |
| lemma continuous_mk : Continuous (mk : (K → ℂ) → OrbitSpace K) := |
| (equiv K).homeomorph.symm.continuous |
| lemma measurable_val [Countable K] : Measurable (val : OrbitSpace K → K → ℂ) := continuous_val.measurable |
| lemma measurable_mk [Countable K] : Measurable (mk : (K → ℂ) → OrbitSpace K) := continuous_mk.measurable |
|
|
| instance [Monoid K] : MulAction K (OrbitSpace K) where |
| smul k f := ⟨fun l => f.val (l*k)⟩ |
| one_smul f := by ext l; exact congrArg f.val (mul_one l) |
| mul_smul a b f := by ext l; exact congrArg f.val (mul_assoc l a b).symm |
|
|
| @[simp] lemma smul_val [Monoid K] (k : K) (f : OrbitSpace K) (l : K) : |
| (k • f).val l = f.val (l*k) := rfl |
|
|
| instance [Monoid K] : ContinuousConstSMul K (OrbitSpace K) where |
| continuous_const_smul k := continuous_mk.comp |
| (continuous_pi fun l => (continuous_apply (l*k)).comp continuous_val) |
| instance [Monoid K] : MeasurableConstSMul K (OrbitSpace K) where |
| measurable_const_smul k := (continuous_const_smul k).measurable |
|
|
| end OrbitSpace |
|
|
| namespace OrbitFactor |
| variable {K X Y : Type*} [Monoid K] [MulAction K X] [MulAction K Y] |
| [MeasurableSpace X] [MeasurableSpace Y] |
|
|
| def orbit (H : X → ℂ) (x : X) : OrbitSpace K := ⟨fun k => H (k • x)⟩ |
|
|
| omit [MulAction K Y] [MeasurableSpace Y] in |
| lemma measurable_orbit [Countable K] [MeasurableConstSMul K X] |
| {H : X → ℂ} (hH : Measurable H) : Measurable (orbit (K := K) H) := |
| OrbitSpace.measurable_mk.comp (Measurable.of_eval fun k => hH.comp (measurable_const_smul k)) |
|
|
| omit [MulAction K Y] [MeasurableSpace X] [MeasurableSpace Y] in |
| lemma orbit_equivariant (H : X → ℂ) (k : K) (x : X) : |
| orbit (K := K) H (k • x) = k • orbit H x := by |
| ext l |
| exact congrArg H (mul_smul l k x).symm |
|
|
| def extend (q : X → Y) (H : X → ℂ) (x : X) : Y × OrbitSpace K := (q x, orbit H x) |
|
|
| omit [MulAction K Y] in |
| lemma measurable_extend [Countable K] [MeasurableConstSMul K X] |
| {q : X → Y} (hq : Measurable q) {H : X → ℂ} (hH : Measurable H) : |
| Measurable (extend (K := K) q H) := hq.prodMk (measurable_orbit hH) |
|
|
| omit [MeasurableSpace Y] in |
| lemma extend_equivariant (μ : Measure X) {q : X → Y} (H : X → ℂ) |
| (hqcov : ∀ k : K, ∀ᵐ x ∂μ, q (k • x) = k • q x) (k : K) : |
| ∀ᵐ x ∂μ, extend (K := K) q H (k • x) = k • extend q H x := by |
| filter_upwards [hqcov k] with x hx |
| exact Prod.ext hx (orbit_equivariant H k x) |
|
|
| omit [MeasurableSpace X] in |
| @[simp] lemma orbit_one (H : X → ℂ) (x : X) : (orbit (K := K) H x).val 1 = H x := by |
| simp only [orbit, one_smul] |
|
|
| end OrbitFactor |
| end EuclideanFiveColor |
|
|
| namespace EuclideanFiveColor.OrbitFactor |
| open MeasureTheory ProbabilityTheory CompactFunctions |
| variable {K X Y : Type*} [Monoid K] [Countable K] [MulAction K X] [MulAction K Y] |
| [MeasurableSpace X] [MeasurableSpace Y] |
| [StandardBorelSpace X] [Nonempty X] [StandardBorelSpace Y] [Nonempty Y] |
| [MeasurableConstSMul K X] [MeasurableConstSMul K Y] |
|
|
| omit [StandardBorelSpace X] [Nonempty X] [StandardBorelSpace Y] [Nonempty Y] in |
| lemma measurable_extend_compactSigma (μ : Measure X) [IsProbabilityMeasure μ] |
| (q : X → Y) (hq : Measurable q) |
| (hpres : ∀ k : K, MeasurePreserving (fun x : X => k • x) μ μ) |
| (hqcov : ∀ k : K, ∀ᵐ x ∂μ, q (k • x) = k • q x) |
| (H : X → ℂ) (hH : Measurable H) (hc : Compact (K := K) μ q H) : |
| @Measurable X (Y × OrbitSpace K) (compactSigma μ q hq hpres) inferInstance |
| (extend (K := K) q H) := by |
| have hHm := measurable_compactSigma hq hpres hH hc |
| have hpm : @Measurable X (K → ℂ) (compactSigma μ q hq hpres) inferInstance |
| (fun x k => H (k • x)) := |
| @Measurable.of_eval X K (fun _ => ℂ) (compactSigma μ q hq hpres) (fun _ => inferInstance) _ (fun k => hHm.comp (measurable_shift_compactSigma hq hpres k)) |
| exact (measurable_base_compactSigma hq hpres hqcov).prodMk |
| (OrbitSpace.measurable_mk.comp hpm) |
|
|
| /-- The orbit factor generated by a compact scalar function is an actual |
| compact extension; the finite module is projected onto that factor. -/ |
| lemma compact_orbit_extension (μ : Measure X) [IsProbabilityMeasure μ] |
| (q : X → Y) (hq : Measurable q) |
| (hpres : ∀ k : K, MeasurePreserving (fun x : X => k • x) μ μ) |
| (hqcov : ∀ k : K, ∀ᵐ x ∂μ, q (k • x) = k • q x) |
| (H : X → ℂ) (hH : Measurable H) (hc : Compact (K := K) μ q H) |
| (F : Y × OrbitSpace K → ℂ) (hF : Measurable F) |
| (D : ℝ) (hD : 0 ≤ D) (hFD : ∀ z, ‖F z‖ ≤ D) : |
| Compact (K := K) (μ.map (extend (K := K) q H)) Prod.fst F := by |
| let : MeasurableConstSMul K (Y × OrbitSpace K) := ⟨fun k => |
| ((measurable_const_smul k).comp measurable_fst).prodMk |
| ((measurable_const_smul k).comp measurable_snd)⟩ |
| apply compact_descend μ (extend (K := K) q H) (measurable_extend hq hH) |
| Prod.fst measurable_fst (extend_equivariant μ H hqcov) F hF D hD hFD |
| change Compact (K := K) μ q (F ∘ extend (K := K) q H) |
| exact compact_of_measurable_compactSigma hq hpres |
| (hF.comp (measurable_extend_compactSigma μ q hq hpres hqcov H hH hc)) D hD |
| (fun x => hFD _) |
|
|
| end EuclideanFiveColor.OrbitFactor |
| namespace EuclideanFiveColor.KernelCompact |
| open MeasureTheory ProbabilityTheory |
| open scoped BigOperators |
| variable {K X Y : Type*} [Group K] [MulAction K X] [MulAction K Y] |
| [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace.CountablyGenerated X] |
| [MeasurableConstSMul K X] [MeasurableConstSMul K Y] |
|
|
| omit [MeasurableConstSMul K Y] in |
| lemma compact_applyKernel (μ : Measure X) [IsProbabilityMeasure μ] |
| (κ : Kernel Y X) [IsMarkovKernel κ] (q : X → Y) (hq : Measurable q) |
| (L : X × X → ℂ) (hL : Measurable L) (C : ℝ) (hC : 0 ≤ C) |
| (hLC : ∀ z, ‖L z‖ ≤ C) |
| (hqcov : ∀ k : K, ∀ᵐ x ∂μ, q (k • x) = k • q x) |
| (hκcov : ∀ k : K, ∀ᵐ y ∂μ.map q, κ (k • y) = (κ y).map (fun x => k • x)) |
| (hLcov : ∀ k : K, ∀ᵐ z ∂μ ⊗ₘ κ.comap q hq, L (k • z.1, k • z.2) = L z) |
| (f : X → ℂ) (hfm : Measurable f) (hfB : ∀ x, ‖f x‖ ≤ 1) : |
| CompactFunctions.Compact (K := K) μ q (applyKernel κ q L f) := by |
| intro ε hε |
| obtain ⟨r, B, C₀, Hf, hB, hC₀, hHm, hHb, ha⟩ := |
| bounded_range_approximation μ κ q hq L hL C hC hLC ε hε |
| refine ⟨r, B, C₀, Hf, hB, hC₀, hHm, hHb, ?_⟩ |
| intro k |
| obtain ⟨a, ham, hab, hai, hae⟩ := ha (fun x => f (k • x)) |
| (hfm.comp (measurable_const_smul k)) (fun x => hfB (k • x)) |
| have he := applyKernel_covariance μ κ q hq L hL hqcov hκcov hLcov f hfm k |
| have hd : (fun x => dist (applyKernel κ q L f (k • x)) |
| (∑ i, a (q x) i * Hf i x)^2) =ᵐ[μ] |
| (fun x => dist (applyKernel κ q L (fun x => f (k • x)) x) |
| (∑ i, a (q x) i * Hf i x)^2) := he.mono fun x hx => by dsimp only at hx ⊢; rw [hx] |
| exact ⟨a, ham, hab, hai.congr hd.symm, by rw [integral_congr_ae hd]; exact hae⟩ |
|
|
| end EuclideanFiveColor.KernelCompact |
| namespace EuclideanFiveColor.CompactTower |
| open MeasureTheory ProbabilityTheory KernelCompact CompactFunctions OrbitFactor |
| variable {K X Y : Type*} [Group K] [Countable K] [MulAction K X] [MulAction K Y] |
| [MeasurableSpace X] [MeasurableSpace Y] |
| [StandardBorelSpace X] [Nonempty X] [StandardBorelSpace Y] [Nonempty Y] |
| [MeasurableConstSMul K X] [MeasurableConstSMul K Y] |
|
|
| /-- The strict compact-successor step of the compact tower. The new coordinate |
| is constructed from a centered invariant conditional-product kernel. -/ |
| theorem strict_compact_successor (μ : Measure X) [IsProbabilityMeasure μ] |
| [ErgodicSMul K X μ] (q : X → Y) (hq : Measurable q) |
| (hqcov : ∀ k : K, ∀ᵐ x ∂μ, q (k • x) = k • q x) |
| (hn : ¬ ErgodicSMul K (X × X) (RelativeProduct.law μ q hq)) : |
| ∃ H : X → ℂ, Measurable H ∧ (∀ x, ‖H x‖ ≤ 2) ∧ |
| (¬ ∃ b : Y → ℂ, Measurable b ∧ H =ᵐ[μ] b ∘ q) ∧ |
| (∀ F : Y × OrbitSpace K → ℂ, Measurable F → |
| (∃ C : ℝ, ∀ z, ‖F z‖ ≤ C) → |
| Compact (K := K) (μ.map (extend (K := K) q H)) Prod.fst F) := by |
| have hpres (k : K) := measurePreserving_smul k μ |
| let κ := condDistrib id q μ |
| let : SMulInvariantMeasure K (X × X) (μ ⊗ₘ κ.comap q hq) := |
| RelativeProduct.law_invariant μ q hq hpres hqcov |
| have hκcov := RelativeProduct.conditional_covariance μ q hq hpres hqcov |
| obtain ⟨L, hLm, hLB, hLcov, hLn, _hrow, hcol⟩ := centered_kernel μ κ q hq |
| (RelativeProduct.law_swap μ q hq) hqcov hκcov hn |
| obtain ⟨f, hfm, hfB, hfn⟩ := exists_nonzero_image μ κ q hq L hLm 2 (by norm_num) hLB hLn |
| let H := applyKernel κ q L f |
| have hHm : Measurable H := measurable_applyKernel κ q hq L hLm f hfm |
| have hHc : Compact (K := K) μ q H := compact_applyKernel μ κ q hq L hLm 2 |
| (by norm_num) hLB hqcov hκcov hLcov f hfm hfB |
| refine ⟨H, hHm, applyKernel_bound κ q L 2 hLB f hfB, ?_, ?_⟩ |
| · exact nonzero_not_factorizable μ q hq H hfn |
| (image_conditional_mean_zero μ q hq L hLm 2 hLB f hfm hfB hcol) |
| · intro F hF hFB |
| obtain ⟨C,hC⟩ := hFB |
| have hC0 : 0 ≤ C := (norm_nonneg (F (Classical.choice inferInstance))).trans (hC _) |
| exact compact_orbit_extension μ q hq hpres hqcov H hHm hHc F hF C hC0 hC |
|
|
| end EuclideanFiveColor.CompactTower |
|
|
| namespace EuclideanFiveColor.FactorCode |
| open MeasureTheory |
| variable {K X Y : Type*} [Group K] [Countable K] |
| [MeasurableSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MulAction K X] [MeasurableConstSMul K X] |
|
|
| def scalar (Y : Type*) [MeasurableSpace Y] [StandardBorelSpace Y] (y : Y) : ℂ := |
| Real.arctan (embeddingReal Y y) |
|
|
| lemma scalar_measurable : Measurable (scalar Y) := |
| Complex.measurable_ofReal.comp (Real.continuous_arctan.measurable.comp (measurable_embeddingReal Y)) |
|
|
| lemma scalar_injective : Function.Injective (scalar Y) := by |
| intro x y h |
| apply (measurableEmbedding_embeddingReal Y).injective |
| apply Real.arctan_injective |
| exact_mod_cast (show (Real.arctan (embeddingReal Y x) : ℂ) = Real.arctan (embeddingReal Y y) from h) |
|
|
| lemma scalar_embedding : MeasurableEmbedding (scalar Y) := |
| scalar_measurable.measurableEmbedding scalar_injective |
|
|
| lemma scalar_bound (y : Y) : ‖scalar Y y‖ ≤ 2 := by |
| rw [scalar, Complex.norm_real, Real.norm_eq_abs] |
| apply abs_le.mpr |
| constructor |
| · have := Real.neg_pi_div_two_lt_arctan (embeddingReal Y y) |
| linarith [Real.pi_lt_four] |
| · have := Real.arctan_lt_pi_div_two (embeddingReal Y y) |
| linarith [Real.pi_lt_four] |
|
|
| def encode (p : X → Y) : X → OrbitSpace K := OrbitFactor.orbit (scalar Y ∘ p) |
|
|
| lemma encode_measurable {p : X → Y} (hp : Measurable p) : Measurable (encode (K := K) p) := |
| OrbitFactor.measurable_orbit (scalar_measurable.comp hp) |
|
|
| omit [Countable K] [MeasurableSpace X] [MeasurableConstSMul K X] in |
| lemma encode_equivariant (p : X → Y) (k : K) (x : X) : |
| encode (K := K) p (k • x) = k • encode (K := K) p x := OrbitFactor.orbit_equivariant _ _ _ |
|
|
| omit [Countable K] [MeasurableSpace X] [MeasurableConstSMul K X] in |
| lemma encode_bound (p : X → Y) (x : X) (k : K) : ‖(encode p x).val k‖ ≤ 2 := scalar_bound _ |
|
|
| variable [Nonempty Y] |
| def decode : OrbitSpace K → Y := fun z => scalar_embedding.invFun (z.val 1) |
|
|
| lemma decode_measurable : Measurable (decode (K := K) (Y := Y)) := |
| scalar_embedding.measurable_invFun.comp ((measurable_pi_apply 1).comp OrbitSpace.measurable_val) |
|
|
| omit [Countable K] [MeasurableSpace X] [MeasurableConstSMul K X] in |
| lemma decode_encode (p : X → Y) (x : X) : decode (encode (K := K) p x) = p x := by |
| dsimp only [decode, encode] |
| rw [OrbitFactor.orbit_one] |
| exact scalar_embedding.leftInverse_invFun _ |
|
|
| omit [Nonempty Y] [MeasurableConstSMul K X] in |
| lemma encode_as_comp [MulAction K Y] [MeasurableConstSMul K Y] |
| (μ : Measure X) (p : X → Y) (hpe : ∀ k : K, ∀ᵐ x ∂μ, p (k • x) = k • p x) : |
| ∀ᵐ x ∂μ, encode (K := K) p x = encode (K := K) (id : Y → Y) (p x) := by |
| filter_upwards [ae_all_iff.mpr hpe] with x hx |
| ext k |
| exact congrArg (scalar Y) (hx k) |
|
|
| end EuclideanFiveColor.FactorCode |
| namespace EuclideanFiveColor.FactorLp |
| open MeasureTheory |
| variable {X Y Z : Type*} [MeasurableSpace X] [MeasurableSpace Y] [MeasurableSpace Z] |
| [StandardBorelSpace Y] [Nonempty Y] |
|
|
| def space (μ : Measure X) (p : X → Y) : Submodule ℂ (Lp ℂ 2 μ) := |
| lpMeas ℂ ℂ (MeasurableSpace.comap p inferInstance) 2 μ |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma isClosed (μ : Measure X) {p : X → Y} (hp : Measurable p) : |
| IsClosed (space μ p : Set (Lp ℂ 2 μ)) := |
| isClosed_aestronglyMeasurable hp.comap_le |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma exists_rep (μ : Measure X) (p : X → Y) (f : Lp ℂ 2 μ) (hf : f ∈ space μ p) : |
| ∃ g : Y → ℂ, Measurable g ∧ (f : X → ℂ) =ᵐ[μ] g ∘ p := by |
| obtain ⟨h, hh, hfe⟩ := hf |
| obtain ⟨g, hg, he⟩ := hh.measurable.exists_eq_measurable_comp (f := p) |
| exact ⟨g, hg, by simpa only [he] using hfe⟩ |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma mem_of_rep (μ : Measure X) (p : X → Y) (f : Lp ℂ 2 μ) |
| (g : Y → ℂ) (hg : Measurable g) (he : (f : X → ℂ) =ᵐ[μ] g ∘ p) : f ∈ space μ p := by |
| exact ⟨g ∘ p, (hg.comp (Measurable.of_comap_le le_rfl)).stronglyMeasurable, he⟩ |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma le_of_factor (μ : Measure X) (p : X → Y) (q : X → Z) |
| (r : Z → Y) (hr : Measurable r) (he : p =ᵐ[μ] r ∘ q) : space μ p ≤ space μ q := by |
| intro f hf |
| obtain ⟨g, hg, hfe⟩ := exists_rep μ p f hf |
| apply mem_of_rep μ q f (g ∘ r) (hg.comp hr) |
| filter_upwards [hfe, he] with x hx he |
| simpa only [Function.comp_apply, he] using hx |
|
|
| lemma factor_of_le (μ : Measure X) [IsFiniteMeasure μ] |
| (p : X → Y) (q : X → Z) (hp : Measurable p) (hle : space μ p ≤ space μ q) : |
| ∃ r : Z → Y, Measurable r ∧ p =ᵐ[μ] r ∘ q := by |
| let f := FactorCode.scalar Y ∘ p |
| have hfm : Measurable f := FactorCode.scalar_measurable.comp hp |
| have hf : MemLp f 2 μ := MemLp.of_bound hfm.aestronglyMeasurable 2 |
| (Filter.Eventually.of_forall fun x => FactorCode.scalar_bound (p x)) |
| have hmem : hf.toLp f ∈ space μ p := mem_of_rep μ p _ _ FactorCode.scalar_measurable hf.coeFn_toLp |
| obtain ⟨g, hg, he⟩ := exists_rep μ q _ (hle hmem) |
| refine ⟨FactorCode.scalar_embedding.invFun ∘ g, |
| FactorCode.scalar_embedding.measurable_invFun.comp hg, ?_⟩ |
| filter_upwards [hf.coeFn_toLp, he] with x hx hex |
| have hh : f x = g (q x) := hx.symm.trans hex |
| change p x = FactorCode.scalar_embedding.invFun (g (q x)) |
| rw [← hh] |
| exact (FactorCode.scalar_embedding.leftInverse_invFun (p x)).symm |
|
|
| end EuclideanFiveColor.FactorLp |
| namespace EuclideanFiveColor.CountableApprox |
| open MeasureTheory |
| variable {Y : Type*} [MeasurableSpace Y] |
|
|
| def truncate (n : ℕ) (y : ℕ → Y) : Fin n → Y := fun i => y i |
|
|
| lemma truncate_measurable (n : ℕ) : Measurable (truncate (Y := Y) n) := |
| Measurable.of_eval fun i => measurable_pi_apply (i : ℕ) |
|
|
| lemma truncate_mono : Monotone (fun n => (inferInstance : MeasurableSpace (Fin n → Y)).comap (truncate n)) := by |
| intro n m hnm |
| rw [← measurable_iff_comap_le] |
| have hm : Measurable[(inferInstance : MeasurableSpace (Fin m → Y)).comap (truncate m)] |
| (truncate (Y := Y) m) := Measurable.of_comap_le le_rfl |
| refine @Measurable.of_eval (ℕ → Y) (Fin n) (fun _ => Y) |
| (MeasurableSpace.comap (truncate m) inferInstance) (fun _ => inferInstance) (truncate n) ?_ |
| intro i |
| exact (measurable_pi_apply (⟨i, lt_of_lt_of_le i.isLt hnm⟩ : Fin m)).comp hm |
|
|
| lemma truncate_generate : (⨆ n, (inferInstance : MeasurableSpace (Fin n → Y)).comap (truncate n)) = |
| (inferInstance : MeasurableSpace (ℕ → Y)) := by |
| apply le_antisymm (iSup_le fun n => (truncate_measurable n).comap_le) |
| have hm (n : ℕ) : Measurable[⨆ n, (inferInstance : MeasurableSpace (Fin n → Y)).comap (truncate n)] |
| (truncate (Y := Y) n) := Measurable.of_comap_le (le_iSup (fun n => MeasurableSpace.comap (truncate (Y := Y) n) (inferInstance : MeasurableSpace (Fin n → Y))) n) |
| have hi : Measurable[⨆ n, (inferInstance : MeasurableSpace (Fin n → Y)).comap (truncate n)] |
| (id : (ℕ → Y) → (ℕ → Y)) := by |
| refine @Measurable.of_eval (ℕ → Y) ℕ (fun _ => Y) |
| (⨆ n, MeasurableSpace.comap (truncate n) (inferInstance : MeasurableSpace (Fin n → Y))) |
| (fun _ => inferInstance) id ?_ |
| intro n |
| exact (measurable_pi_apply (⟨n, Nat.lt_succ_self n⟩ : Fin (n+1))).comp (hm (n+1)) |
| simpa using hi.comap_le |
|
|
| lemma bounded_approximation (ν : Measure (ℕ → Y)) [IsProbabilityMeasure ν] |
| (m : ℕ) (H : (ℕ → Y) → Fin m → ℂ) (hH : Measurable H) |
| (C : ℝ) (hC : 0 ≤ C) (hB : ∀ y, ‖H y‖ ≤ C) (ε : ℝ) (hε : 0 < ε) : |
| ∃ n, ∃ H₀ : (Fin n → Y) → Fin m → ℂ, Measurable H₀ ∧ (∀ y, ‖H₀ y‖ ≤ 2*C) ∧ |
| Integrable (fun y => dist (H y) (H₀ (truncate n y))^2) ν ∧ |
| (∫ y, dist (H y) (H₀ (truncate n y))^2 ∂ν) < ε^2 := |
| LimitDensity.generated_factor_approximation ν truncate truncate_measurable truncate_mono truncate_generate |
| m H hH C hC hB ε hε |
|
|
| end EuclideanFiveColor.CountableApprox |
| namespace EuclideanFiveColor.ChainJoin |
| open MeasureTheory |
| variable {K X Y : Type*} [Group K] [Countable K] |
| [MeasurableSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] [Nonempty Y] |
| [MulAction K X] [MulAction K Y] [MeasurableConstSMul K X] [MeasurableConstSMul K Y] |
|
|
| def joint (q : ℕ → X → Y) (x : X) : ℕ → Y := fun n => q n x |
|
|
| def code (q : ℕ → X → Y) : X → OrbitSpace K := FactorCode.encode (joint q) |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma joint_measurable (q : ℕ → X → Y) (hq : ∀ n, Measurable (q n)) : Measurable (joint q) := |
| Measurable.of_eval hq |
|
|
| omit [Nonempty Y] [MulAction K Y] [MeasurableConstSMul K Y] in |
| lemma code_measurable (q : ℕ → X → Y) (hq : ∀ n, Measurable (q n)) : Measurable (code (K := K) q) := |
| FactorCode.encode_measurable (joint_measurable q hq) |
|
|
| omit [Countable K] [MeasurableSpace X] [Nonempty Y] [MulAction K Y] [MeasurableConstSMul K X] [MeasurableConstSMul K Y] in |
| lemma code_equivariant (q : ℕ → X → Y) (k : K) (x : X) : |
| code (K := K) q (k • x) = k • code q x := FactorCode.encode_equivariant _ _ _ |
|
|
| omit [MulAction K Y] [MeasurableConstSMul K X] [MeasurableConstSMul K Y] in |
| lemma le_code (μ : Measure X) (q : ℕ → X → Y) (n : ℕ) : |
| FactorLp.space μ (q n) ≤ FactorLp.space μ (code (K := K) q) := by |
| apply FactorLp.le_of_factor μ (q n) (code q) |
| (fun z => (FactorCode.decode (K := K) (Y := ℕ → Y) z) n) |
| ((measurable_pi_apply n).comp FactorCode.decode_measurable) |
| exact Filter.Eventually.of_forall fun x => by |
| dsimp only [Function.comp_apply, code] |
| rw [FactorCode.decode_encode] |
| rfl |
|
|
| omit [Countable K] [MeasurableSpace Y] [MeasurableConstSMul K X] [MeasurableConstSMul K Y] [Nonempty Y] [StandardBorelSpace Y] in |
| lemma joint_equivariant (μ : Measure X) (q : ℕ → X → Y) |
| (hqe : ∀ n (k : K), ∀ᵐ x ∂μ, q n (k • x) = k • q n x) (k : K) : |
| ∀ᵐ x ∂μ, joint q (k • x) = k • joint q x := by |
| filter_upwards [ae_all_iff.mpr (fun n => hqe n k)] with x hx |
| exact funext hx |
|
|
| omit [StandardBorelSpace Y] [Nonempty Y] in |
| lemma finite_upper (μ : Measure X) (q : ℕ → X → Y) |
| (hc : ∀ i j, FactorLp.space μ (q i) ≤ FactorLp.space μ (q j) ∨ |
| FactorLp.space μ (q j) ≤ FactorLp.space μ (q i)) (n : ℕ) : |
| ∃ j, ∀ i < n, FactorLp.space μ (q i) ≤ FactorLp.space μ (q j) := by |
| induction n with |
| | zero => exact ⟨0, by simp⟩ |
| | succ n ih => |
| obtain ⟨j, hj⟩ := ih |
| obtain hij | hji := hc j n |
| · refine ⟨n, fun i hi => ?_⟩ |
| obtain hi | rfl := Nat.lt_or_eq_of_le (Nat.le_of_lt_succ hi) |
| · exact (hj i hi).trans hij |
| · exact le_rfl |
| · refine ⟨j, fun i hi => ?_⟩ |
| obtain hi | rfl := Nat.lt_or_eq_of_le (Nat.le_of_lt_succ hi) |
| · exact hj i hi |
| · exact hji |
|
|
| omit [MeasurableConstSMul K X] in |
| lemma approximation (μ : Measure X) [IsProbabilityMeasure μ] |
| (q : ℕ → X → Y) (hq : ∀ n, Measurable (q n)) |
| (hqe : ∀ n (k : K), ∀ᵐ x ∂μ, q n (k • x) = k • q n x) |
| (hc : ∀ i j, FactorLp.space μ (q i) ≤ FactorLp.space μ (q j) ∨ |
| FactorLp.space μ (q j) ≤ FactorLp.space μ (q i)) |
| (m : ℕ) (H : OrbitSpace K → Fin m → ℂ) (hH : Measurable H) |
| (hB : ∃ C : ℝ, ∀ z, ‖H z‖ ≤ C) (ε : ℝ) (hε : 0 < ε) : |
| ∃ j, ∃ H₀ : Y → Fin m → ℂ, Measurable H₀ ∧ (∃ C : ℝ, ∀ y, ‖H₀ y‖ ≤ C) ∧ |
| Integrable (fun x => dist (H (code q x)) (H₀ (q j x))^2) μ ∧ |
| (∫ x, dist (H (code q x)) (H₀ (q j x))^2 ∂μ) < ε^2 := by |
| classical |
| obtain ⟨C, hC⟩ := hB |
| let C' := max C 0 |
| have hC' : 0 ≤ C' := le_max_right _ _ |
| let J := joint q |
| have hJ := joint_measurable q hq |
| let E : (ℕ → Y) → OrbitSpace K := FactorCode.encode id |
| have hE : Measurable E := FactorCode.encode_measurable measurable_id |
| obtain ⟨n, Hn, hHn, hHnB, hi, he⟩ := CountableApprox.bounded_approximation (μ.map J) |
| m (H ∘ E) (hH.comp hE) C' hC' (fun y => (hC _).trans (le_max_left _ _)) ε hε |
| obtain ⟨j, hj⟩ := finite_upper μ q hc n |
| have hfac (i : Fin n) : ∃ r : Y → Y, Measurable r ∧ q i =ᵐ[μ] r ∘ q j := |
| FactorLp.factor_of_le μ (q i) (q j) (hq i) (hj i i.isLt) |
| choose r hr hre using hfac |
| let R : Y → Fin n → Y := fun y i => r i y |
| have hR : Measurable R := Measurable.of_eval hr |
| have hEq := FactorCode.encode_as_comp (K := K) μ J (joint_equivariant μ q hqe) |
| have hEq' : (fun x => dist ((H ∘ E) (J x)) (Hn (CountableApprox.truncate n (J x)))^2) =ᵐ[μ] |
| (fun x => dist (H (code q x)) ((Hn ∘ R) (q j x))^2) := by |
| filter_upwards [hEq, ae_all_iff.mpr hre] with x hx hxr |
| have hp : CountableApprox.truncate n (J x) = R (q j x) := funext hxr |
| change dist (H (E (J x))) _ ^ 2 = _ |
| change code (K := K) q x = E (J x) at hx |
| rw [← hx, hp] |
| rfl |
| refine ⟨j, Hn ∘ R, hHn.comp hR, ⟨2*C', fun y => hHnB _⟩, ?_, ?_⟩ |
| · exact (hi.comp_measurable hJ).congr hEq' |
| · rw [← integral_congr_ae hEq', ← integral_map hJ.aemeasurable hi.aestronglyMeasurable] |
| exact he |
| |
| end EuclideanFiveColor.ChainJoin |
| namespace EuclideanFiveColor.SeparableZorn |
| open TopologicalSpace |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [SecondCountableTopology E] |
| |
| lemma countable_cover (S : Set (Submodule ℂ E)) (hS : S.Nonempty) : |
| ∃ p : ℕ → S, ∀ V : Submodule ℂ E, IsClosed (V : Set E) → |
| (∀ n, (p n).val ≤ V) → ∀ U ∈ S, U ≤ V := by |
| classical |
| let D : Set E := {x | ∃ U ∈ S, x ∈ U} |
| have : Nonempty D := by |
| obtain ⟨U, hU⟩ := hS |
| exact ⟨⟨0, U, hU, U.zero_mem⟩⟩ |
| obtain ⟨u, hu⟩ := exists_dense_seq D |
| have hU (n : ℕ) : ∃ U : S, (u n).val ∈ U.val := by |
| obtain ⟨U, hU, hx⟩ := (u n).property |
| exact ⟨⟨U, hU⟩, hx⟩ |
| choose p hp using hU |
| refine ⟨p, ?_⟩ |
| intro V hc hV U hUS x hx |
| have hcl : IsClosed ((Subtype.val : D → E) ⁻¹' (V : Set E)) := hc.preimage continuous_subtype_val |
| have hsub : Set.range u ⊆ (Subtype.val : D → E) ⁻¹' (V : Set E) := by |
| rintro _ ⟨n, rfl⟩ |
| exact hV n (hp n) |
| have hwhole := closure_minimal hsub hcl |
| rw [hu.closure_range] at hwhole |
| exact hwhole (Set.mem_univ (⟨x, U, hUS, hx⟩ : D)) |
| |
| lemma exists_maximal {A : Type*} [Preorder A] [Nonempty A] |
| (F : A → Submodule ℂ E) (hF : ∀ a, IsClosed (F a : Set E)) |
| (hord : ∀ a b, a ≤ b ↔ F a ≤ F b) |
| (hseq : ∀ p : ℕ → A, (∀ i j, p i ≤ p j ∨ p j ≤ p i) → |
| ∃ a, ∀ i, p i ≤ a) : ∃ a : A, IsMax a := by |
| classical |
| apply zorn_le_nonempty |
| intro c hc hne |
| obtain ⟨p, hp⟩ := countable_cover (F '' c) (hne.image F) |
| have hrep (n : ℕ) : ∃ a : c, F a = (p n).val := by |
| obtain ⟨a, ha, he⟩ := (p n).property |
| exact ⟨⟨a, ha⟩, he⟩ |
| choose a ha using hrep |
| have haorder (i j : ℕ) : (a i).val ≤ (a j).val ∨ (a j).val ≤ (a i).val := |
| hc.total (a i).property (a j).property |
| obtain ⟨b, hb⟩ := hseq (fun n => (a n).val) haorder |
| refine ⟨b, ?_⟩ |
| intro d hd |
| apply (hord d b).mpr |
| exact hp (F b) (hF b) (fun n => by rw [← ha n]; exact (hord _ _).mp (hb n)) |
| (F d) ⟨d, hd, rfl⟩ |
| |
| end EuclideanFiveColor.SeparableZorn |
| namespace EuclideanFiveColor.CodedMax |
| open MeasureTheory |
| variable {K X : Type*} [Group K] [Countable K] [MeasurableSpace X] |
| [MulAction K X] [MeasurableConstSMul K X] |
| |
| structure Model (μ : Measure X) (Good : (X → OrbitSpace K) → Prop) where |
| map : X → OrbitSpace K |
| measurable : Measurable map |
| equivariant : ∀ k : K, ∀ᵐ x ∂μ, map (k • x) = k • map x |
| good : Good map |
| |
| instance (μ : Measure X) (Good : (X → OrbitSpace K) → Prop) : Preorder (Model μ Good) where |
| le a b := FactorLp.space μ a.map ≤ FactorLp.space μ b.map |
| le_refl _ := le_rfl |
| le_trans _ _ _ := le_trans |
| |
| lemma exists_maximal (μ : Measure X) [IsProbabilityMeasure μ] [StandardBorelSpace X] |
| (Good : (X → OrbitSpace K) → Prop) (hbase : Nonempty (Model μ Good)) |
| (hjoin : ∀ q : ℕ → X → OrbitSpace K, (∀ n, Measurable (q n)) → |
| (∀ n (k : K), ∀ᵐ x ∂μ, q n (k • x) = k • q n x) → (∀ n, Good (q n)) → |
| (∀ i j, FactorLp.space μ (q i) ≤ FactorLp.space μ (q j) ∨ |
| FactorLp.space μ (q j) ≤ FactorLp.space μ (q i)) → Good (ChainJoin.code q)) : |
| ∃ a : Model μ Good, IsMax a := by |
| have := hbase |
| have : Fact ((2 : ENNReal) ≠ ⊤) := ⟨by norm_num⟩ |
| apply SeparableZorn.exists_maximal (fun a : Model μ Good => FactorLp.space μ a.map) |
| (fun a => FactorLp.isClosed μ a.measurable) (fun _ _ => Iff.rfl) |
| intro p hc |
| let q := fun n => (p n).map |
| have hq (n : ℕ) := (p n).measurable |
| have hqe (n : ℕ) := (p n).equivariant |
| have hcg : Good (ChainJoin.code q) := hjoin q hq hqe (fun n => (p n).good) hc |
| let a : Model μ Good := ⟨ChainJoin.code q, ChainJoin.code_measurable q hq, |
| fun k => Filter.Eventually.of_forall (ChainJoin.code_equivariant q k), hcg⟩ |
| exact ⟨a, fun n => ChainJoin.le_code μ q n⟩ |
| |
| end EuclideanFiveColor.CodedMax |
| |
| end |
| |
| end OAI |
| |
