import OAI.Analysis.BackwardIntertwiners.GlobalOperators namespace OAI namespace BackwardIntertwiners open Filter open scoped Topology noncomputable section open Topology MeasureTheory Set open scoped ENNReal lemma ergodic_late_intersection {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ] {θ : X → X} (hθ : Ergodic θ μ) {A B : Set X} (_ : MeasurableSet A) (hB : MeasurableSet B) (hA0 : μ A ≠ 0) (hB0 : μ B ≠ 0) (N : ℕ) : ∃ n : ℕ, N ≤ n ∧ μ (A ∩ (θ^[n]) ⁻¹' B) ≠ 0 := by let U : Set X := ⋃ n : ℕ, (θ^[n+N]) ⁻¹' B have hUmeas : MeasurableSet U := MeasurableSet.iUnion fun n => hB.preimage (hθ.measurable.iterate (n+N)) have hsub : θ ⁻¹' U ⊆ U := by intro x hx obtain ⟨n,hn⟩ := Set.mem_iUnion.mp hx apply Set.mem_iUnion.mpr refine ⟨n+1, ?_⟩ change θ^[n+1+N] x ∈ B have hi : n+1+N = (n+N)+1 := by omega rw [hi,Function.iterate_succ_apply] exact hn have hU0 : μ U ≠ 0 := by intro h have hs : (θ^[N]) ⁻¹' B ⊆ U := by intro x hx exact Set.mem_iUnion.mpr ⟨0, by simpa using hx⟩ have he := (hθ.toMeasurePreserving.iterate N).measure_preimage hB.nullMeasurableSet exact hB0 (le_antisymm (by rw [← he]; exact (measure_mono hs).trans (by rw [h])) bot_le) have hUfull : U =ᵐ[μ] Set.univ := by obtain he | he := hθ.ae_empty_or_univ_of_preimage_ae_le hUmeas.nullMeasurableSet (Filter.Eventually.of_forall hsub) · exact False.elim (hU0 (by rw [measure_congr he,measure_empty])) · exact he by_contra! hn have hzero : μ (A ∩ U) = 0 := by rw [show A ∩ U = ⋃ n : ℕ, A ∩ (θ^[n+N]) ⁻¹' B from Set.inter_iUnion _ _] exact measure_iUnion_null fun n => hn (n+N) (by omega) have he : (A ∩ U : Set X) =ᵐ[μ] A := by filter_upwards [hUfull] with x hx apply propext change (x ∈ A ∧ x ∈ U) ↔ x ∈ A have hxU : x ∈ U := (eq_iff_iff.mp hx).mpr (Set.mem_univ x) simp [hxU] exact hA0 ((measure_congr he).symm.trans hzero) section Localization variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [finiteMeasure : IsFiniteMeasure μ] omit finiteMeasure in lemma measurable_global_coordinate [IsFiniteMeasure μ] (f : Lp Fiber 2 μ) (j : ℤ) : Measurable (fun x => f x j) := ((lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).continuous.comp_stronglyMeasurable (Lp.stronglyMeasurable f)).measurable omit finiteMeasure in lemma exists_coordinate_support_nonnull [IsFiniteMeasure μ] {f : Lp Fiber 2 μ} (hf : f ≠ 0) : ∃ j : ℤ, μ {x | f x j ≠ 0} ≠ 0 := by by_contra! h apply hf rw [Lp.eq_zero_iff_ae_eq_zero] have ha : ∀ j : ℤ, ∀ᵐ x ∂μ, f x j = 0 := fun j => by exact ae_iff.mpr (h j) filter_upwards [ae_all_iff.mpr ha] with x hx ext j exact hx j lemma scalar_invariant_pointwise_orthogonal {L : Submodule ℂ (Lp Fiber 2 μ)} (hL : ∀ g : Lp ℂ ∞ μ, ∀ f ∈ L, scalarMultiplier g f ∈ L) {f z : Lp Fiber 2 μ} (hf : f ∈ L) (hz : z ∈ L.orthogonal) : ∀ᵐ x ∂μ, inner ℂ (z x) (f x) = 0 := by apply (L2.integrable_inner z f).ae_eq_zero_of_forall_setIntegral_eq_zero intro s hs _ let g : Lp ℂ ∞ μ := indicatorConstLp ∞ hs (measure_ne_top μ s) (1:ℂ) have hg : g =ᵐ[μ] s.indicator (fun _ => (1:ℂ)) := indicatorConstLp_coeFn rw [← integral_indicator hs] calc _ = ∫ x, inner ℂ (z x) (scalarMultiplier g f x) ∂μ := by apply integral_congr_ae filter_upwards [scalarMultiplier_ae g f, hg] with x hx hgx rw [hx,hgx] by_cases hxs : x ∈ s · simp [Set.indicator_of_mem hxs] · simp [Set.indicator_of_notMem hxs] _ = inner ℂ z (scalarMultiplier g f) := (L2.inner_def _ _).symm _ = 0 := Submodule.inner_left_of_mem_orthogonal (hL g f hf) hz end Localization lemma fiber_cyclic_orthogonal_order {w : ℤ → ℝ} (hw : QuadraticWeights w) {T : Fiber →L[ℂ] Fiber} (hT : ∀ v j, T v j = (w j / w (j-1) : ℂ) * v (j-1)) {v z : Fiber} (horth : ∀ r : ℕ, inner ℂ z ((T^r) v) = 0) {i j : ℤ} (hzi : z i ≠ 0) (hvj : v j ≠ 0) : i < j := by let b := fun k : ℤ => star (z k) * (w k:ℂ) let c := fun k : ℤ => v k / (w k:ℂ) have hwC (k : ℤ) : (w k:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt (hw.positive k)) have hbi : b i ≠ 0 := mul_ne_zero (by simpa using hzi) (hwC i) have hcj : c j ≠ 0 := div_ne_zero hvj (hwC j) have hb (k : ℤ) : ‖b k‖ ≤ (‖z‖+1)*w k := by dsimp [b] rw [norm_mul, RCLike.norm_conj, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le] apply mul_le_mul_of_nonneg_right _ (hw.positive k).le exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) z k).trans (by linarith) have hc (k : ℤ) : ‖c k‖*w k ≤ ‖v‖+1 := by dsimp [c] rw [norm_div, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le, div_mul_cancel₀ _ (ne_of_gt (hw.positive k))] exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) v k).trans (by linarith) have hcor (r : ℕ) : (∑' k : ℤ, b k*c (k-r)) = 0 := by calc (∑' k : ℤ, b k*c (k-r)) = inner ℂ z ((T^r) v) := by rw [lp.inner_eq_tsum] apply tsum_congr intro k rw [RCLike.inner_apply, weighted_shift_pow hw.positive hT] dsimp [b, c] simp only [← Complex.star_def] ring _ = 0 := horth r exact (quadratic_support_separation w hw).strict_order ⟨i,hbi⟩ ⟨j,hcj⟩ (by positivity : 0 < ‖z‖+1) (by positivity : 0 < ‖v‖+1) hb hc hcor hbi hcj lemma explicitWeight_quadratic (x : Base) : QuadraticWeights (explicitWeight x) := bilateralWeight_quadratic (plusResidue_bounds x) (minusResidue_bounds x) lemma forwardFiber_weight_coordinates (x : Base) (v : Fiber) (j : ℤ) : forwardFiber x v j = (explicitWeight x j / explicitWeight x (j-1) : ℂ) * v (j-1) := by rw [forwardFiber_apply, ← explicitWeight_ratio x (j-1)] simp only [sub_add_cancel, Complex.ofReal_div] lemma forwardFiber_lattice (x : Base) (L : Submodule ℂ Fiber) : (IsClosed (L : Set Fiber) ∧ OperatorInvariant L (forwardFiber x)) ↔ L = ⊥ ∨ L = ⊤ ∨ ∃ h : ℤ, L = coordinateTail h := by constructor · rintro ⟨hcl, hinv⟩ exact quadratic_fiber_tails _ (explicitWeight_quadratic x) _ (forwardFiber_weight_coordinates x) L hcl hinv · rintro (rfl | rfl | ⟨h,rfl⟩) · refine ⟨?_, ?_⟩ · simpa only [Submodule.bot_coe] using (isClosed_singleton : IsClosed ({0} : Set Fiber)) · intro v hv simpa only [Submodule.mem_bot, map_zero] using congrArg (forwardFiber x) (show v = 0 from hv) · exact ⟨isClosed_univ, fun _ _ => trivial⟩ · exact ⟨coordinateTail_isClosed h, fun _ hv => forwardFiber_tail x h hv⟩ lemma inverseOdometer_ergodic : Ergodic inverseOdometer baseMeasure := Ergodic.symm (e := odometerMeasurableEquiv) odometer_ergodic lemma backwardOperator_power_nonzero (n : ℕ) (f : GlobalHilbert) (j : ℤ) : ∀ᵐ x ∂baseMeasure, f (inverseOdometer^[n] x) j ≠ 0 → ((backwardOperator^n) f) x (j-n) ≠ 0 := by induction n with | zero => filter_upwards [] with x; simp | succ n ih => rw [pow_succ', mul_apply_eq_comp] filter_upwards [backwardOperator_ae_inverse ((backwardOperator^n) f), inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually ih, inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually backwardCoeff_ae_pos] with x hx hi hp intro hn rw [hx, backwardFiber_apply] have he : j - (n+1:ℕ) + 1 = j - n := by omega rw [he] apply mul_ne_zero · exact_mod_cast (ne_of_gt (hp (j-n))) · apply hi simpa only [Function.iterate_succ_apply] using hn lemma global_invariant_pow {T : GlobalHilbert →L[ℂ] GlobalHilbert} {L : Submodule ℂ GlobalHilbert} (hi : OperatorInvariant L T) {v : GlobalHilbert} (hv : v ∈ L) (n : ℕ) : (T^n) v ∈ L := by induction n with | zero => simpa using hv | succ n ih => simpa only [pow_succ', mul_apply_eq_comp] using hi _ ih lemma invariant_pointwise_order {L : Submodule ℂ GlobalHilbert} (hS : OperatorInvariant L forwardOperator) (hM : ∀ g : Lp ℂ ∞ baseMeasure, OperatorInvariant L (scalarMultiplier g)) {f z : GlobalHilbert} (hf : f ∈ L) (hz : z ∈ L.orthogonal) : ∀ᵐ x ∂baseMeasure, ∀ i j : ℤ, z x i ≠ 0 → f x j ≠ 0 → i < j := by have horth (r : ℕ) : ∀ᵐ x ∂baseMeasure, inner ℂ (z x) (((forwardOperator^r) f) x) = 0 := scalar_invariant_pointwise_orthogonal hM (global_invariant_pow hS hf r) hz filter_upwards [ae_all_iff.mpr horth, ae_all_iff.mpr (fun r => forwardOperator_power_ae r f)] with x hx hxpow intro i j hzi hfj apply fiber_cyclic_orthogonal_order (explicitWeight_quadratic x) (forwardFiber_weight_coordinates x) ?_ hzi hfj intro r rw [← hxpow r] exact hx r lemma forward_backward_scalar_transitive (L : Submodule ℂ GlobalHilbert) (hclosed : IsClosed (L : Set GlobalHilbert)) (hS : OperatorInvariant L forwardOperator) (hV : OperatorInvariant L backwardOperator) (hM : ∀ g : Lp ℂ ∞ baseMeasure, OperatorInvariant L (scalarMultiplier g)) : L = ⊥ ∨ L = ⊤ := by by_contra! hproper have hOO : L.orthogonal.orthogonal = L := by rw [Submodule.orthogonal_orthogonal_eq_closure, hclosed.submodule_topologicalClosure_eq] have hnotOrth : L.orthogonal ≠ ⊥ := by intro hh rw [hh, Submodule.bot_orthogonal_eq_top] at hOO exact hproper.2 hOO.symm obtain ⟨f,hf,hf0⟩ := (Submodule.ne_bot_iff L).mp hproper.1 obtain ⟨z,hz,hz0⟩ := (Submodule.ne_bot_iff L.orthogonal).mp hnotOrth obtain ⟨j,hA0⟩ := exists_coordinate_support_nonnull hf0 obtain ⟨i,hB0⟩ := exists_coordinate_support_nonnull hz0 let A : Set Base := {x | f x j ≠ 0} let B : Set Base := {x | z x i ≠ 0} have hA : MeasurableSet A := (measurableSet_eq_fun (measurable_global_coordinate f j) measurable_const).compl have hB : MeasurableSet B := (measurableSet_eq_fun (measurable_global_coordinate z i) measurable_const).compl obtain ⟨n,hn,hinter⟩ := ergodic_late_intersection inverseOdometer_ergodic hB hA hB0 hA0 (j-i).toNat have horder := invariant_pointwise_order hS hM (global_invariant_pow hV hf n) hz have hnull : ∀ᵐ x ∂baseMeasure, x ∉ B ∩ (inverseOdometer^[n]) ⁻¹' A := by filter_upwards [horder, backwardOperator_power_nonzero n f j] with x hx hp intro hmem have hzi : z x i ≠ 0 := hmem.1 have hfj : f (inverseOdometer^[n] x) j ≠ 0 := hmem.2 have hh := hx i (j-n) hzi (hp hfj) have hnat : (j-i) ≤ ((j-i).toNat : ℤ) := by omega have hnn : ((j-i).toNat : ℤ) ≤ (n:ℤ) := by exact_mod_cast hn omega apply hinter convert ae_iff.mp hnull using 1 congr 1 ext x simp only [Set.mem_ofPred_eq, not_not] lemma generated_transitive : AlgebraTransitive (generatedAlgebra forwardOperator backwardOperator) := by intro L hclosed hInv apply forward_backward_scalar_transitive L hclosed · exact hInv _ (Algebra.subset_adjoin (Or.inl (Set.mem_insert _ _))) · exact hInv _ (Algebra.subset_adjoin (Or.inl (Set.mem_insert_of_mem _ (Set.mem_singleton _)))) · intro g exact hInv _ (Algebra.subset_adjoin (Or.inr ⟨g,rfl⟩)) def explicitDirectModel : DirectModelData := ⟨forwardFiber, forwardOperator, backwardCoeff, backwardFiber, backwardOperator⟩ lemma explicitDirectModel_properties : DirectModelProperties explicitDirectModel where beta_measurable := measurable_explicitBeta beta_positive := explicitBeta_pos forward_coordinates := forwardFiber_apply forward_field := forwardOperator_ae fiber_lattice := forwardFiber_lattice S_nonzero := forwardOperator_ne_zero S_norm := forwardOperator_norm power_bound := fun n _ => forwardOperator_power_norm n V_contraction := backwardOperator_norm commute := forward_backward_commute backward_measurable := measurable_backwardCoeff backward_bounds := backwardCoeff_bounds backward_coordinates := backwardFiber_apply backward_field := backwardOperator_ae common_conull := by refine ⟨goodBase, measurableSet_goodBase, ?_, ?_, ?_⟩ · exact ae_iff.mp ae_goodBase · ext x exact goodBase_odometer x · intro x hx exact ⟨backwardCoeff_pos hx, backwardFiber_tail_closure hx, backwardFiber_denseRange hx⟩ transitive := generated_transitive theorem direct_model : ∃ D : DirectModelData, DirectModelProperties D := ⟨explicitDirectModel, explicitDirectModel_properties⟩ def rankOneCoordinate (i j : ℤ) : Fiber →L[ℂ] Fiber := (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 i).comp (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j) @[simp] lemma rankOneCoordinate_apply (i j : ℤ) (v : Fiber) : rankOneCoordinate i j v = lp.single 2 i (v j) := rfl lemma rankOneCoordinate_compact (i j : ℤ) : IsCompactOperator (rankOneCoordinate i j) := (isCompactOperator_of_locallyCompactSpace_dom (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j)).clm_comp (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 i) def finiteShift (x : Base) (n : ℕ) : Fiber →L[ℂ] Fiber := ∑ j ∈ Finset.Icc (-(n:ℤ)) n, (explicitBeta x j:ℂ) • rankOneCoordinate (j+1) j lemma finiteShift_compact (x : Base) (n : ℕ) : IsCompactOperator (finiteShift x n) := by change finiteShift x n ∈ compactOperator (RingHom.id ℂ) Fiber Fiber exact Submodule.sum_mem _ fun j hj => Submodule.smul_mem _ _ (rankOneCoordinate_compact (j+1) j) lemma finiteShift_apply (x : Base) (n : ℕ) (v : Fiber) (j : ℤ) : finiteShift x n v (j+1) = if j ∈ Finset.Icc (-(n:ℤ)) n then (explicitBeta x j:ℂ) * v j else 0 := by classical simp only [finiteShift, sum_apply, smul_apply, lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply, rankOneCoordinate_apply] by_cases hj : j ∈ Finset.Icc (-(n:ℤ)) n · rw [ite_eq_left hj, Finset.sum_eq_single_of_mem j hj] · simp only [lp.single_apply_self, smul_eq_mul] · intro k hk hkj rw [lp.single_apply_ne _ _ _ (by omega), smul_zero] · rw [ite_eq_right hj] apply Finset.sum_eq_zero intro k hk have hkj : j+1 ≠ k+1 := by intro hh have he : j=k := by omega subst k exact hj hk rw [lp.single_apply_ne _ _ _ hkj, smul_zero] lemma explicitBeta_outside_bound (x : Base) (n : ℕ) (j : ℤ) (hj : j ∉ Finset.Icc (-(n:ℤ)) n) : explicitBeta x j ≤ Real.exp (-10*(n:ℝ)) := by apply Real.exp_le_exp.mpr change -explicitExponent x j ≤ -10*(n:ℝ) have hd := explicitExponent_distance x j have hh : (n:ℤ) ≤ coordinateDistance j := by simp only [Finset.mem_Icc, not_and_or, not_le] at hj rcases hj with hj | hj · exact (by omega : (n:ℤ) ≤ -j).trans (le_max_right _ _) · exact (by omega : (n:ℤ) ≤ j+1).trans (le_max_left _ _) have hR : (n:ℝ) ≤ (coordinateDistance j : ℝ) := by exact_mod_cast hh linarith lemma finiteShift_error (x : Base) (n : ℕ) : ‖forwardFiber x - finiteShift x n‖ ≤ Real.exp (-10*(n:ℝ)) := by let C := Real.exp (-10*(n:ℝ)) have hC : 0 ≤ C := (Real.exp_pos _).le apply ContinuousLinearMap.opNorm_le_bound _ hC intro v calc _ ≤ ‖(C:ℂ) • v‖ := by let vr := fiberReindex (Equiv.addRight (1:ℤ)) ((forwardFiber x - finiteShift x n) v) rw [← (fiberReindex (Equiv.addRight (1:ℤ))).norm_map ((forwardFiber x - finiteShift x n) v)] apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0) intro j change ‖(forwardFiber x - finiteShift x n) v (j+1)‖ ≤ ‖(C:ℂ) * v j‖ rw [sub_apply, lp.coeFn_sub, Pi.sub_apply, forwardFiber_apply, add_sub_cancel_right, finiteShift_apply] by_cases hj : j ∈ Finset.Icc (-(n:ℤ)) n · rw [ite_eq_left hj, sub_self, norm_zero] exact norm_nonneg _ · rw [ite_eq_right hj, sub_zero, norm_mul, norm_mul, Complex.norm_real, Complex.norm_real, Real.norm_of_nonneg (explicitBeta_pos x j).le, Real.norm_of_nonneg hC] exact mul_le_mul_of_nonneg_right (explicitBeta_outside_bound x n j hj) (norm_nonneg _) _ = C*‖v‖ := by rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg hC] lemma forwardFiber_compact (x : Base) : IsCompactOperator (forwardFiber x) := by apply isCompactOperator_of_tendsto (l:=atTop) (F:=finiteShift x) ?_ (Filter.Eventually.of_forall (finiteShift_compact x)) rw [tendsto_iff_norm_sub_tendsto_zero] have he : Tendsto (fun n : ℕ => Real.exp (-10*(n:ℝ))) atTop (𝓝 0) := by apply Real.tendsto_exp_atBot.comp exact tendsto_const_nhds.neg_mul_atTop (by norm_num) tendsto_natCast_atTop_atTop apply squeeze_zero (fun _ => norm_nonneg _) ?_ he intro n rw [norm_sub_rev] exact finiteShift_error x n abbrev ScalarHilbert := Lp ℂ 2 baseMeasure def coordinateL2 (j : ℤ) : GlobalHilbert →L[ℂ] ScalarHilbert := (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).compLpL 2 baseMeasure def singleL2 (j : ℤ) : ScalarHilbert →L[ℂ] GlobalHilbert := (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 j).compLpL 2 baseMeasure lemma coordinateL2_ae (j : ℤ) (f : GlobalHilbert) : coordinateL2 j f =ᵐ[baseMeasure] fun x => f x j := ContinuousLinearMap.coeFn_compLpL _ _ lemma singleL2_ae (j : ℤ) (f : ScalarHilbert) : singleL2 j f =ᵐ[baseMeasure] fun x => lp.single 2 j (f x) := ContinuousLinearMap.coeFn_compLpL _ _ lemma coordinateL2_singleL2 (j : ℤ) (f : ScalarHilbert) : coordinateL2 j (singleL2 j f) = f := by apply Lp.ext filter_upwards [coordinateL2_ae j (singleL2 j f), singleL2_ae j f] with x h₁ h₂ simp only [h₁, h₂, lp.single_apply_self] end end BackwardIntertwiners end OAI