Download data/lean/OAI/Analysis/BackwardIntertwiners/GlobalOperators.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 23.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/BackwardIntertwiners/GlobalOperators.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/BackwardIntertwiners/GlobalOperators.lean
-
curl -L -o GlobalOperators.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/BackwardIntertwiners/GlobalOperators.lean
23.6 kB
| import OAI.Analysis.BackwardIntertwiners.BackwardWeights | |
| namespace OAI | |
| namespace BackwardIntertwiners | |
| open Filter | |
| open scoped Topology | |
| noncomputable section | |
| open Topology MeasureTheory Set | |
| open scoped ENNReal | |
| section Fields | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} | |
| lemma weightedPermutation_stronglyMeasurable (e : β€ β β€) (a : X β β€ β β) | |
| (C : β) (hC : 0 β€ C) (ha : β x j, βa x jβ β€ C) | |
| (hm : β j, Measurable (fun x => a x j)) | |
| {f : X β Fiber} (hf : StronglyMeasurable f) : | |
| StronglyMeasurable (fun x => fiberWeightedPermutation e (a x) C hC (ha x) (f x)) := by | |
| apply fiberCoordinates_stronglyMeasurable | |
| intro j | |
| exact (hm (e j)).mul (((lp.evalCLM β (fun _ : β€ => β) 2 (e j)).continuous.comp_stronglyMeasurable hf).measurable) | |
| lemma weightedPermutation_aestronglyMeasurable (e : β€ β β€) (a : X β β€ β β) | |
| (C : β) (hC : 0 β€ C) (ha : β x j, βa x jβ β€ C) | |
| (hm : β j, Measurable (fun x => a x j)) | |
| {f : X β Fiber} (hf : AEStronglyMeasurable f ΞΌ) : | |
| AEStronglyMeasurable (fun x => fiberWeightedPermutation e (a x) C hC (ha x) (f x)) ΞΌ := by | |
| apply (weightedPermutation_stronglyMeasurable e a C hC ha hm hf.stronglyMeasurable_mk).aestronglyMeasurable.congr | |
| filter_upwards [hf.ae_eq_mk] with x hx | |
| rw [hx] | |
| def scalarMultiplier (g : Lp β β ΞΌ) : Lp Fiber 2 ΞΌ βL[β] Lp Fiber 2 ΞΌ := | |
| LinearMap.mkContinuous | |
| { toFun := fun f => g β’ f | |
| map_add' := Lp.add_smul g | |
| map_smul' := fun c f => (Lp.smul_comm c g f).symm } | |
| βgβ (Lp.norm_smul_le g) | |
| def fieldVector (A : X β Fiber βL[β] Fiber) (C : β) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) | |
| (f : Lp Fiber 2 ΞΌ) : Lp Fiber 2 ΞΌ := | |
| ((Lp.memLp f).of_le_mul (hm f (Lp.aestronglyMeasurable f)) | |
| (Filter.Eventually.of_forall fun x => | |
| (A x).le_opNorm (f x) |>.trans (mul_le_mul_of_nonneg_right (hA x) (norm_nonneg _)))).toLp _ | |
| lemma fieldVector_ae (A : X β Fiber βL[β] Fiber) (C : β) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) | |
| (f : Lp Fiber 2 ΞΌ) : fieldVector A C hA hm f =α΅[ΞΌ] fun x => A x (f x) := | |
| MemLp.coeFn_toLp _ | |
| lemma fieldVector_norm (A : X β Fiber βL[β] Fiber) (C : β) (hC : 0 β€ C) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) | |
| (f : Lp Fiber 2 ΞΌ) : βfieldVector A C hA hm fβ β€ C*βfβ := by | |
| calc | |
| _ β€ β(C:β) β’ fβ := by | |
| apply Lp.norm_le_norm_of_ae_le | |
| filter_upwards [fieldVector_ae A C hA hm f, Lp.coeFn_smul (C:β) f] with x hx hs | |
| rw [hx, hs, Pi.smul_apply, norm_smul, Complex.norm_real, Real.norm_of_nonneg hC] | |
| exact (A x).le_opNorm (f x) |>.trans (mul_le_mul_of_nonneg_right (hA x) (norm_nonneg _)) | |
| _ = C*βfβ := by rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg hC] | |
| def fieldOperator (A : X β Fiber βL[β] Fiber) (C : β) (hC : 0 β€ C) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) : | |
| Lp Fiber 2 ΞΌ βL[β] Lp Fiber 2 ΞΌ := | |
| LinearMap.mkContinuous | |
| { toFun := fieldVector A C hA hm | |
| map_add' := by | |
| intro f g | |
| apply Lp.ext | |
| filter_upwards [fieldVector_ae A C hA hm (f+g), fieldVector_ae A C hA hm f, | |
| fieldVector_ae A C hA hm g, Lp.coeFn_add f g, | |
| Lp.coeFn_add (fieldVector A C hA hm f) (fieldVector A C hA hm g)] with x hβ hβ hβ hβ hβ | |
| simp only [hβ,hβ,hβ,hβ,hβ ,Pi.add_apply,map_add] | |
| map_smul' := by | |
| intro c f | |
| apply Lp.ext | |
| filter_upwards [fieldVector_ae A C hA hm (c β’ f), fieldVector_ae A C hA hm f, | |
| Lp.coeFn_smul c f, Lp.coeFn_smul c (fieldVector A C hA hm f)] with x hβ hβ hβ hβ | |
| simp only [RingHom.id_apply, hβ,hβ,hβ,hβ,Pi.smul_apply,map_smul] } | |
| C (fieldVector_norm A C hC hA hm) | |
| lemma fieldOperator_ae (A : X β Fiber βL[β] Fiber) (C : β) (hC : 0 β€ C) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) | |
| (f : Lp Fiber 2 ΞΌ) : fieldOperator A C hC hA hm f =α΅[ΞΌ] fun x => A x (f x) := | |
| fieldVector_ae A C hA hm f | |
| lemma fieldOperator_norm (A : X β Fiber βL[β] Fiber) (C : β) (hC : 0 β€ C) | |
| (hA : β x, βA xβ β€ C) | |
| (hm : β f : X β Fiber, AEStronglyMeasurable f ΞΌ β AEStronglyMeasurable (fun x => A x (f x)) ΞΌ) : | |
| βfieldOperator A C hC hA hmβ β€ C := | |
| ContinuousLinearMap.opNorm_le_bound _ hC (fieldVector_norm A C hC hA hm) | |
| lemma scalarMultiplier_ae (g : Lp β β ΞΌ) (f : Lp Fiber 2 ΞΌ) : | |
| scalarMultiplier g f =α΅[ΞΌ] fun x => g x β’ f x := Lp.coeFn_lpSMul g f | |
| lemma scalarMultiplier_norm_le (g : Lp β β ΞΌ) : βscalarMultiplier (ΞΌ := ΞΌ) gβ β€ βgβ := | |
| ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg g) (Lp.norm_smul_le g) | |
| end Fields | |
| abbrev GlobalHilbert := Lp Fiber 2 baseMeasure | |
| def OperatorInvariant {H : Type*} [NormedAddCommGroup H] [NormedSpace β H] | |
| (L : Submodule β H) (T : H βL[β] H) : Prop := β v β L, T v β L | |
| def generatedAlgebra (S V : GlobalHilbert βL[β] GlobalHilbert) : | |
| Subalgebra β (GlobalHilbert βL[β] GlobalHilbert) := | |
| Algebra.adjoin β ({S,V} βͺ Set.range (scalarMultiplier (ΞΌ := baseMeasure))) | |
| def AlgebraTransitive (A : Subalgebra β (GlobalHilbert βL[β] GlobalHilbert)) : Prop := | |
| β L : Submodule β GlobalHilbert, IsClosed (L : Set GlobalHilbert) β | |
| (β T β A, OperatorInvariant L T) β L = β₯ β¨ L = β€ | |
| structure DirectModelData where | |
| Sx : Base β Fiber βL[β] Fiber | |
| S : GlobalHilbert βL[β] GlobalHilbert | |
| b : Base β β€ β β | |
| Vx : Base β Fiber βL[β] Fiber | |
| V : GlobalHilbert βL[β] GlobalHilbert | |
| structure DirectModelProperties (D : DirectModelData) : Prop where | |
| beta_measurable : β j, Measurable (fun x => explicitBeta x j) | |
| beta_positive : β x j, 0 < explicitBeta x j | |
| forward_coordinates : β x v j, D.Sx x v j = (explicitBeta x (j-1):β)*v (j-1) | |
| forward_field : β f, D.S f =α΅[baseMeasure] fun x => D.Sx x (f x) | |
| fiber_lattice : β x (L : Submodule β Fiber), | |
| (IsClosed (L : Set Fiber) β§ OperatorInvariant L (D.Sx x)) β | |
| L = β₯ β¨ L = β€ β¨ β h : β€, L = coordinateTail h | |
| S_nonzero : D.S β 0 | |
| S_norm : βD.Sβ = Real.exp (-10) | |
| power_bound : β n : β, 1 β€ n β βD.S^nβ β€ Real.exp (-10*(((n+1)^2/4:β):β)) | |
| V_contraction : βD.Vβ β€ 1 | |
| commute : D.S * D.V = D.V * D.S | |
| backward_measurable : β j, Measurable (fun x => D.b x j) | |
| backward_bounds : β x j, 0 β€ D.b x j β§ D.b x j β€ 1 | |
| backward_coordinates : β x v j, D.Vx x v j = (D.b x (j+1):β)*v (j+1) | |
| backward_field : β f, βα΅ x βbaseMeasure, D.V f (odometer x) = D.Vx x (f x) | |
| common_conull : β Xstar : Set Base, MeasurableSet Xstar β§ baseMeasure XstarαΆ = 0 β§ | |
| odometer β»ΒΉ' Xstar = Xstar β§ β x β Xstar, | |
| (β j, 0 < D.b x j) β§ | |
| (β h : β€, ((coordinateTail h).map (D.Vx x).toLinearMap).topologicalClosure = coordinateTail (h-1)) β§ | |
| DenseRange (D.Vx x) | |
| transitive : AlgebraTransitive (generatedAlgebra D.S D.V) | |
| def forwardFiber (x : Base) : Fiber βL[β] Fiber := | |
| fiberWeightedPermutation (Equiv.subRight 1) (fun j => (explicitBeta x j:β)) | |
| (Real.exp (-10)) (Real.exp_pos _).le | |
| (fun j => by simpa only [Complex.norm_real, Real.norm_of_nonneg (explicitBeta_pos x j).le] using explicitBeta_le x j) | |
| def backwardFiber (x : Base) : Fiber βL[β] Fiber := | |
| fiberWeightedPermutation (Equiv.addRight 1) (fun j => (backwardCoeff x j:β)) 1 (by norm_num) | |
| (fun j => by simpa only [Complex.norm_real, Real.norm_of_nonneg (backwardCoeff_bounds x j).1] using (backwardCoeff_bounds x j).2) | |
| @[simp] lemma forwardFiber_apply (x : Base) (v : Fiber) (j : β€) : | |
| forwardFiber x v j = (explicitBeta x (j-1):β) * v (j-1) := rfl | |
| @[simp] lemma backwardFiber_apply (x : Base) (v : Fiber) (j : β€) : | |
| backwardFiber x v j = (backwardCoeff x (j+1):β) * v (j+1) := rfl | |
| lemma forwardFiber_norm_le (x : Base) : βforwardFiber xβ β€ Real.exp (-10) := | |
| fiberWeightedPermutation_norm_le _ _ _ _ _ | |
| lemma backwardFiber_norm_le (x : Base) : βbackwardFiber xβ β€ 1 := | |
| fiberWeightedPermutation_norm_le _ _ _ _ _ | |
| lemma forwardFiber_single (x : Base) (j : β€) (c : β) : | |
| forwardFiber x (lp.single 2 j c) = lp.single 2 (j+1) ((explicitBeta x j:β)*c) := by | |
| ext k | |
| rw [forwardFiber_apply] | |
| by_cases hk : k = j+1 | |
| Β· subst k | |
| simp | |
| Β· have hj : k-1 β j := by omega | |
| simp only [lp.single_apply_ne _ _ _ hk, lp.single_apply_ne _ _ _ hj, mul_zero] | |
| lemma backwardFiber_single (x : Base) (j : β€) (c : β) : | |
| backwardFiber x (lp.single 2 j c) = lp.single 2 (j-1) ((backwardCoeff x j:β)*c) := by | |
| ext k | |
| rw [backwardFiber_apply] | |
| by_cases hk : k = j-1 | |
| Β· subst k | |
| simp | |
| Β· have hj : k+1 β j := by omega | |
| simp only [lp.single_apply_ne _ _ _ hk, lp.single_apply_ne _ _ _ hj, mul_zero] | |
| lemma forwardFiber_norm (x : Base) : βforwardFiber xβ = Real.exp (-10) := by | |
| apply le_antisymm (forwardFiber_norm_le x) | |
| have hh := (forwardFiber x).le_opNorm (lp.single 2 0 (1:β)) | |
| rw [forwardFiber_single, explicitBeta_zero, mul_one, lp.norm_single (by norm_num : (0:ENNReal)<2), | |
| lp.norm_single (by norm_num : (0:ENNReal)<2), norm_one, mul_one, | |
| Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le] at hh | |
| exact hh | |
| lemma backwardFiber_intertwines (x : Base) : | |
| forwardFiber (odometer x) * backwardFiber x = backwardFiber x * forwardFiber x := by | |
| ext v j | |
| simp only [mul_apply_eq_comp, forwardFiber_apply, backwardFiber_apply, | |
| sub_add_cancel, add_sub_cancel_right] | |
| have hc := congrArg (fun r : β => (r:β)) (backwardCoeff_recurrence x j) | |
| push_cast at hc | |
| linear_combination -hc * v j | |
| lemma coordinateTail_isClosed (h : β€) : IsClosed (coordinateTail h : Set Fiber) := by | |
| have he : (coordinateTail h : Set Fiber) = β j : β€, β _ : j < h, {v : Fiber | v j = 0} := by | |
| ext v | |
| change (β j : β€, j < h β v j = 0) β _ | |
| simp only [Set.mem_iInter, Set.mem_ofPred_eq] | |
| rw [he] | |
| exact isClosed_iInter fun j => isClosed_iInter fun _ => | |
| isClosed_eq (lp.evalCLM β (fun _ : β€ => β) 2 j).continuous continuous_const | |
| lemma forwardFiber_tail (x : Base) (h : β€) {v : Fiber} (hv : v β coordinateTail h) : | |
| forwardFiber x v β coordinateTail h := by | |
| intro j hj | |
| rw [forwardFiber_apply, hv _ (by omega), mul_zero] | |
| lemma backwardFiber_tail (x : Base) (h : β€) {v : Fiber} (hv : v β coordinateTail h) : | |
| backwardFiber x v β coordinateTail (h-1) := by | |
| intro j hj | |
| rw [backwardFiber_apply, hv _ (by omega), mul_zero] | |
| lemma single_mem_coordinateTail {h j : β€} (hj : h β€ j) (c : β) : | |
| (lp.single 2 j c : Fiber) β coordinateTail h := by | |
| intro k hk | |
| exact lp.single_apply_ne _ _ _ (by omega) | |
| lemma backwardFiber_tail_closure {x : Base} (hx : x β goodBase) (h : β€) : | |
| ((coordinateTail h).map (backwardFiber x).toLinearMap).topologicalClosure = coordinateTail (h-1) := by | |
| apply le_antisymm | |
| Β· apply Submodule.topologicalClosure_minimal _ ?_ (coordinateTail_isClosed (h-1)) | |
| rintro _ β¨v,hv,rflβ© | |
| exact backwardFiber_tail x h hv | |
| Β· intro v hv | |
| let P := ((coordinateTail h).map (backwardFiber x).toLinearMap).topologicalClosure | |
| have hP : IsClosed (P : Set Fiber) := Submodule.isClosed_topologicalClosure _ | |
| apply hP.mem_of_tendsto (lp.hasSum_single (by norm_num : (2:ENNReal) β β) v) | |
| apply Filter.Eventually.of_forall | |
| intro s | |
| apply P.sum_mem | |
| intro j _ | |
| by_cases hj : j < h-1 | |
| Β· rw [hv j hj, lp.single_zero] | |
| exact P.zero_mem | |
| Β· apply (Submodule.le_topologicalClosure ((coordinateTail h).map (backwardFiber x).toLinearMap)) | |
| refine β¨lp.single 2 (j+1) (v j / (backwardCoeff x (j+1):β)), | |
| single_mem_coordinateTail (by omega) _, ?_β© | |
| change backwardFiber x (_) = _ | |
| rw [backwardFiber_single, add_sub_cancel_right, mul_div_cancelβ] | |
| exact_mod_cast ne_of_gt (backwardCoeff_pos hx (j+1)) | |
| lemma backwardFiber_denseRange {x : Base} (hx : x β goodBase) : DenseRange (backwardFiber x) := by | |
| intro v | |
| have hcl : IsClosed (closure (Set.range (backwardFiber x))) := isClosed_closure | |
| apply hcl.mem_of_tendsto (lp.hasSum_single (by norm_num : (2:ENNReal) β β) v) | |
| apply Filter.Eventually.of_forall | |
| intro s | |
| apply subset_closure | |
| refine β¨β j β s, lp.single 2 (j+1) (v j / (backwardCoeff x (j+1):β)), ?_β© | |
| rw [map_sum] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| rw [backwardFiber_single, add_sub_cancel_right, mul_div_cancelβ] | |
| exact_mod_cast ne_of_gt (backwardCoeff_pos hx (j+1)) | |
| lemma explicitExponent_distance (x : Base) (j : β€) : | |
| 10*(coordinateDistance j:β) β€ explicitExponent x j := by | |
| cases j with | |
| | ofNat n => | |
| have hd : coordinateDistance (n:β€) = (n:β€)+1 := by | |
| unfold coordinateDistance | |
| omega | |
| change 10*(coordinateDistance (n:β€):β) β€ halfExponent (plusResidue x) n | |
| rw [hd] | |
| simpa only [Int.cast_add, Int.cast_one, Int.cast_natCast] using halfExponent_lower (plusResidue x) n | |
| | negSucc n => | |
| have hd : coordinateDistance (Int.negSucc n) = (n:β€)+1 := by | |
| unfold coordinateDistance | |
| omega | |
| rw [hd] | |
| change _ β€ halfExponent (minusResidue x) n | |
| simpa only [Int.cast_add, Int.cast_one, Int.cast_natCast] using halfExponent_lower (minusResidue x) n | |
| lemma interval_exponent_lower (x : Base) (n : β) (j : β€) : | |
| 10*(powerCost n:β) β€ β r β Finset.range n, explicitExponent x (j+(r:β€)) := by | |
| have hc : (powerCost n:β) β€ β r β Finset.range n, (coordinateDistance (j+(r:β€)):β) := by | |
| exact_mod_cast sum_coordinateDistance_lower n j | |
| calc | |
| _ β€ 10*(β r β Finset.range n, (coordinateDistance (j+(r:β€)):β)) := by linarith | |
| _ = β r β Finset.range n, 10*(coordinateDistance (j+(r:β€)):β) := by rw [Finset.mul_sum] | |
| _ β€ _ := Finset.sum_le_sum fun _ _ => explicitExponent_distance x _ | |
| lemma forwardFiber_power_input (x : Base) (n : β) (v : Fiber) (j : β€) : | |
| (forwardFiber x ^ n) v (j+(n:β€)) = | |
| (Real.exp (-(β r β Finset.range n, explicitExponent x (j+(r:β€)))):β)*v j := by | |
| induction n with | |
| | zero => simp | |
| | succ n ih => | |
| rw [pow_succ', mul_apply_eq_comp, forwardFiber_apply] | |
| have hi : j+((n+1:β):β€)-1 = j+(n:β€) := by omega | |
| rw [hi, ih, Finset.sum_range_succ] | |
| change (Real.exp (-explicitExponent x (j+(n:β€))):β)* | |
| ((Real.exp (-(β r β Finset.range n, explicitExponent x (j+(r:β€)))):β)*v j) = _ | |
| rw [β mul_assoc, β Complex.ofReal_mul, β Real.exp_add] | |
| rw [neg_add_rev] | |
| lemma forwardFiber_power_norm (x : Base) (n : β) : | |
| βforwardFiber x ^ nβ β€ Real.exp (-10*(powerCost n:β)) := by | |
| let C := Real.exp (-10*(powerCost n:β)) | |
| have hC : 0 β€ C := (Real.exp_pos _).le | |
| apply ContinuousLinearMap.opNorm_le_bound _ (Real.exp_pos _).le | |
| intro v | |
| calc | |
| _ β€ β(C:β) β’ fiberReindex (Equiv.subRight (n:β€)) vβ := by | |
| apply lp.norm_mono (by norm_num : (2:ENNReal) β 0) | |
| intro j | |
| have hi : j = (j-(n:β€))+(n:β€) := by omega | |
| conv_lhs => rw [hi, forwardFiber_power_input] | |
| simp only [lp.coeFn_smul, Pi.smul_apply, norm_smul, fiberReindex_apply, Equiv.subRight_apply, | |
| norm_mul, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le, Real.norm_of_nonneg hC] | |
| apply mul_le_mul_of_nonneg_right _ (norm_nonneg _) | |
| apply Real.exp_le_exp.mpr | |
| simpa only [neg_mul] using neg_le_neg (interval_exponent_lower x n (j-(n:β€))) | |
| _ = C*βvβ := by | |
| rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le, (fiberReindex _).norm_map] | |
| lemma forwardFiber_aestronglyMeasurable (f : Base β Fiber) (hf : AEStronglyMeasurable f baseMeasure) : | |
| AEStronglyMeasurable (fun x => forwardFiber x (f x)) baseMeasure := by | |
| apply weightedPermutation_aestronglyMeasurable | |
| Β· exact fun j => Complex.measurable_ofReal.comp (measurable_explicitBeta j) | |
| Β· exact hf | |
| lemma backwardFiber_aestronglyMeasurable (f : Base β Fiber) (hf : AEStronglyMeasurable f baseMeasure) : | |
| AEStronglyMeasurable (fun x => backwardFiber x (f x)) baseMeasure := by | |
| apply weightedPermutation_aestronglyMeasurable | |
| Β· exact fun j => Complex.measurable_ofReal.comp (measurable_backwardCoeff j) | |
| Β· exact hf | |
| def forwardOperator : GlobalHilbert βL[β] GlobalHilbert := | |
| fieldOperator forwardFiber (Real.exp (-10)) (Real.exp_pos _).le | |
| forwardFiber_norm_le forwardFiber_aestronglyMeasurable | |
| lemma forwardOperator_ae (f : GlobalHilbert) : | |
| forwardOperator f =α΅[baseMeasure] fun x => forwardFiber x (f x) := | |
| fieldOperator_ae _ _ _ _ _ f | |
| lemma forwardOperator_norm_le : βforwardOperatorβ β€ Real.exp (-10) := | |
| fieldOperator_norm _ _ _ _ _ | |
| def inverseOdometer (x : Base) : Base := (show PadicInt 2 from x)-1 | |
| @[simp] lemma inverseOdometer_odometer (x : Base) : inverseOdometer (odometer x) = x := by | |
| change ((show PadicInt 2 from x)+1)-1 = _ | |
| exact add_sub_cancel_right _ _ | |
| @[simp] lemma odometer_inverseOdometer (x : Base) : odometer (inverseOdometer x) = x := by | |
| change ((show PadicInt 2 from x)-1)+1 = _ | |
| exact sub_add_cancel _ _ | |
| lemma inverseOdometer_preserving : MeasurePreserving inverseOdometer baseMeasure baseMeasure := by | |
| have hh := measurePreserving_completion (Ξ± := PadicInt 2) (measurePreserving_add_right baseHaar (-1)) | |
| have he : inverseOdometer = (show Base β Base from fun x : PadicInt 2 => x + (-1)) := by | |
| funext x | |
| exact @sub_eq_add_neg (PadicInt 2) _ (show PadicInt 2 from x) 1 | |
| rw [he] | |
| exact hh | |
| def odometerMeasurableEquiv : Base βα΅ Base where | |
| toFun := odometer | |
| invFun := inverseOdometer | |
| left_inv := inverseOdometer_odometer | |
| right_inv := odometer_inverseOdometer | |
| measurable_toFun := odometer_ergodic.measurable | |
| measurable_invFun := inverseOdometer_preserving.measurable | |
| def backwardFieldOperator : GlobalHilbert βL[β] GlobalHilbert := | |
| fieldOperator backwardFiber 1 (by norm_num) backwardFiber_norm_le backwardFiber_aestronglyMeasurable | |
| def backwardOperator : GlobalHilbert βL[β] GlobalHilbert := | |
| (Lp.compMeasurePreservingβα΅’ β inverseOdometer inverseOdometer_preserving).toContinuousLinearMap.comp backwardFieldOperator | |
| lemma backwardOperator_ae_inverse (f : GlobalHilbert) : | |
| backwardOperator f =α΅[baseMeasure] fun x => backwardFiber (inverseOdometer x) (f (inverseOdometer x)) := by | |
| have hβ := Lp.coeFn_compMeasurePreserving (backwardFieldOperator f) inverseOdometer_preserving | |
| have hβ := (fieldOperator_ae backwardFiber 1 (by norm_num) backwardFiber_norm_le | |
| backwardFiber_aestronglyMeasurable f).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae | |
| exact hβ.trans hβ | |
| lemma backwardOperator_ae (f : GlobalHilbert) : | |
| βα΅ x βbaseMeasure, backwardOperator f (odometer x) = backwardFiber x (f x) := by | |
| filter_upwards [(backwardOperator_ae_inverse f).comp_tendsto | |
| odometer_ergodic.quasiMeasurePreserving.tendsto_ae] with x hx | |
| simpa only [Function.comp_def,inverseOdometer_odometer] using hx | |
| lemma backwardOperator_norm : βbackwardOperatorβ β€ 1 := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (by norm_num) | |
| intro f | |
| change βLp.compMeasurePreserving inverseOdometer inverseOdometer_preserving (backwardFieldOperator f)β β€ _ | |
| rw [Lp.norm_compMeasurePreserving] | |
| exact fieldVector_norm backwardFiber 1 (by norm_num) backwardFiber_norm_le backwardFiber_aestronglyMeasurable f | |
| lemma forward_backward_commute : forwardOperator * backwardOperator = backwardOperator * forwardOperator := by | |
| ext1 f | |
| apply Lp.ext | |
| filter_upwards [forwardOperator_ae (backwardOperator f), backwardOperator_ae_inverse f, | |
| backwardOperator_ae_inverse (forwardOperator f), | |
| (forwardOperator_ae f).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae] with x hβ hβ hβ hβ | |
| change forwardOperator (backwardOperator f) x = backwardOperator (forwardOperator f) x | |
| rw [hβ,hβ,hβ] | |
| dsimp only [Function.comp_def] at hβ | |
| rw [hβ] | |
| have hh := congrArg (fun A : Fiber βL[β] Fiber => A (f (inverseOdometer x))) (backwardFiber_intertwines (inverseOdometer x)) | |
| simpa only [mul_apply_eq_comp, odometer_inverseOdometer] using hh | |
| lemma forward_scalar_commute (g : Lp β β baseMeasure) : | |
| forwardOperator * scalarMultiplier g = scalarMultiplier g * forwardOperator := by | |
| ext1 f | |
| apply Lp.ext | |
| filter_upwards [forwardOperator_ae (scalarMultiplier g f), scalarMultiplier_ae g f, | |
| scalarMultiplier_ae g (forwardOperator f), forwardOperator_ae f] with x hβ hβ hβ hβ | |
| change forwardOperator (scalarMultiplier g f) x = scalarMultiplier g (forwardOperator f) x | |
| simp only [hβ,hβ,hβ,hβ,map_smul] | |
| def constantBasis (j : β€) : GlobalHilbert := Lp.const 2 baseMeasure (lp.single 2 j (1:β)) | |
| lemma constantBasis_norm (j : β€) : βconstantBasis jβ = 1 := by | |
| rw [constantBasis, Lp.norm_const 2 baseMeasure _ (by norm_num), lp.norm_single (by norm_num : (0:ENNReal)<2)] | |
| simp | |
| lemma constantBasis_ae (j : β€) : constantBasis j =α΅[baseMeasure] fun _ => lp.single 2 j (1:β) := | |
| Lp.coeFn_const _ _ _ | |
| lemma forwardOperator_constantBasis_zero : | |
| forwardOperator (constantBasis 0) = (Real.exp (-10):β) β’ constantBasis 1 := by | |
| apply Lp.ext | |
| filter_upwards [forwardOperator_ae (constantBasis 0), constantBasis_ae 0, constantBasis_ae 1, | |
| Lp.coeFn_smul (Real.exp (-10):β) (constantBasis 1)] with x hβ hβ hβ hβ | |
| rw [hβ,hβ,hβ,Pi.smul_apply,hβ,forwardFiber_single,explicitBeta_zero,mul_one] | |
| rw [β lp.single_smul] | |
| simp | |
| lemma forwardOperator_norm : βforwardOperatorβ = Real.exp (-10) := by | |
| apply le_antisymm forwardOperator_norm_le | |
| have h := forwardOperator.le_opNorm (constantBasis 0) | |
| rw [forwardOperator_constantBasis_zero, norm_smul, constantBasis_norm, constantBasis_norm, | |
| mul_one, mul_one, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le] at h | |
| exact h | |
| lemma forwardOperator_ne_zero : forwardOperator β 0 := by | |
| intro h | |
| have hh := forwardOperator_norm | |
| rw [h, norm_zero] at hh | |
| exact (Real.exp_ne_zero (-10)) hh.symm | |
| lemma forwardOperator_power_ae (n : β) (f : GlobalHilbert) : | |
| (forwardOperator^n) f =α΅[baseMeasure] fun x => (forwardFiber x ^ n) (f x) := by | |
| induction n with | |
| | zero => filter_upwards [] with x; rfl | |
| | succ n ih => | |
| rw [pow_succ', mul_apply_eq_comp] | |
| filter_upwards [forwardOperator_ae ((forwardOperator^n) f), ih] with x hβ hβ | |
| simp only [hβ,hβ,pow_succ',mul_apply_eq_comp] | |
| lemma forwardOperator_power_norm (n : β) : | |
| βforwardOperator^nβ β€ Real.exp (-10*(powerCost n:β)) := by | |
| let C := Real.exp (-10*(powerCost n:β)) | |
| have hC : 0 β€ C := (Real.exp_pos _).le | |
| apply ContinuousLinearMap.opNorm_le_bound _ hC | |
| intro f | |
| calc | |
| _ β€ β(C:β) β’ fβ := by | |
| apply Lp.norm_le_norm_of_ae_le | |
| filter_upwards [forwardOperator_power_ae n f, Lp.coeFn_smul (C:β) f] with x hβ hβ | |
| rw [hβ,hβ,Pi.smul_apply,norm_smul,Complex.norm_real,Real.norm_of_nonneg hC] | |
| exact (forwardFiber x ^ n).le_opNorm (f x) |>.trans | |
| (mul_le_mul_of_nonneg_right (forwardFiber_power_norm x n) (norm_nonneg _)) | |
| _ = C*βfβ := by rw [norm_smul,Complex.norm_real,Real.norm_of_nonneg hC] | |
| end | |
| end BackwardIntertwiners | |
| end OAI | |