lean/OAI/Analysis/BackwardIntertwiners/OrdinaryStructure.lean

import OAI.Analysis.BackwardIntertwiners.ErgodicTransitivity

namespace OAI

namespace BackwardIntertwiners
open Filter
open scoped Topology
noncomputable section

open Topology MeasureTheory Set
open scoped ENNReal


def globalTail (h : ℤ) : Submodule ℂ GlobalHilbert :=
  ⨅ j : ℤ, ⨅ _ : j < h, (coordinateL2 j).ker
lemma mem_globalTail (h : ℤ) (f : GlobalHilbert) :
    f ∈ globalTail h ↔ ∀ᵐ x ∂baseMeasure, f x ∈ coordinateTail h := by
  simp only [globalTail, Submodule.mem_iInf, LinearMap.mem_ker]
  constructor
  · intro hf
    have h (j : ℤ) : ∀ᵐ x ∂baseMeasure, j < h → f x j = 0 := by
      by_cases hj : j < h
      · have hh := (Lp.eq_zero_iff_ae_eq_zero.mp (hf j hj))
        filter_upwards [coordinateL2_ae j f, hh] with x hx hzero
        intro _
        exact hx.symm.trans hzero
      · exact Filter.Eventually.of_forall fun _ => fun h => False.elim (hj h)
    exact ae_all_iff.mpr h
  · intro hf j hj
    apply Lp.eq_zero_iff_ae_eq_zero.mpr
    filter_upwards [hf, coordinateL2_ae j f] with x hx hcoord
    exact hcoord.trans (hx j hj)
lemma globalTail_closed (h : ℤ) : IsClosed (globalTail h : Set GlobalHilbert) := by
  have he : (globalTail h : Set GlobalHilbert) = ⋂ j : ℤ, ⋂ _ : j < h,
      {f : GlobalHilbert | coordinateL2 j f = 0} := by ext; simp [globalTail]
  rw [he]
  exact isClosed_iInter fun j => isClosed_iInter fun _ =>
    isClosed_eq (coordinateL2 j).continuous continuous_const
lemma constantBasis_mem_globalTail {h j : ℤ} (hj : h ≤ j) : constantBasis j ∈ globalTail h := by
  rw [mem_globalTail]
  filter_upwards [constantBasis_ae j] with x hx
  rw [hx]
  exact single_mem_coordinateTail hj 1
lemma constantBasis_not_mem_globalTail {h j : ℤ} (hj : j < h) : constantBasis j ∉ globalTail h := by
  intro hm
  have hh := (mem_globalTail h _).mp hm
  have hz : ∀ᵐ x ∂baseMeasure, (1:ℂ) = 0 := by
    filter_upwards [hh, constantBasis_ae j] with x hx he
    simpa only [he, lp.single_apply_self] using hx j hj
  exact one_ne_zero hz.exists.choose_spec
lemma globalTail_nonzero (h : ℤ) : globalTail h ≠ ⊥ := by
  intro he
  have hmem := constantBasis_mem_globalTail (le_refl h)
  rw [he] at hmem
  have hm : constantBasis h = 0 := hmem
  have hn := constantBasis_norm h
  rw [hm, norm_zero] at hn
  norm_num at hn
lemma globalTail_proper (h : ℤ) : globalTail h ≠ ⊤ := by
  intro he
  apply constantBasis_not_mem_globalTail (show h-1<h by omega)
  rw [he]; trivial
lemma globalTail_forward (h : ℤ) : OperatorInvariant (globalTail h) forwardOperator := by
  intro f hf
  rw [mem_globalTail] at hf ⊢
  filter_upwards [hf, forwardOperator_ae f] with x hx he
  rw [he]
  exact forwardFiber_tail x h hx
lemma globalTail_not_backward (h : ℤ) : ¬OperatorInvariant (globalTail h) backwardOperator := by
  intro hinv
  have hm := (mem_globalTail h _).mp (hinv _ (constantBasis_mem_globalTail (le_refl h)))
  have hgood := inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually ae_goodBase
  have he := (constantBasis_ae h).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae
  have hh : ∀ᵐ x ∂baseMeasure, False := by
    filter_upwards [hm, backwardOperator_ae_inverse (constantBasis h), he, hgood] with x hx hV h₀ hg
    dsimp only [Function.comp_def] at h₀
    have hz := hx (h-1) (by omega)
    rw [hV, backwardFiber_apply, sub_add_cancel, h₀, lp.single_apply_self, mul_one] at hz
    exact (ne_of_gt (backwardCoeff_pos hg h)) (Complex.ofReal_eq_zero.mp hz)
  exact hh.exists.choose_spec


def sliceProjection (j : ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert :=
  (singleL2 j).comp (coordinateL2 j)
lemma sliceProjection_ae (j : ℤ) (f : GlobalHilbert) :
    sliceProjection j f =ᵐ[baseMeasure] fun x => lp.single 2 j (f x j) := by
  filter_upwards [singleL2_ae j (coordinateL2 j f), coordinateL2_ae j f] with x h₁ h₂
  change singleL2 j (coordinateL2 j f) x = _
  rw [h₁, h₂]
lemma sliceProjection_singleL2 (j : ℤ) (f : ScalarHilbert) :
    sliceProjection j (singleL2 j f) = singleL2 j f := by
  change singleL2 j (coordinateL2 j (singleL2 j f)) = _
  rw [coordinateL2_singleL2]
lemma sliceProjection_idempotent (j : ℤ) : sliceProjection j * sliceProjection j = sliceProjection j := by
  ext1 f
  exact sliceProjection_singleL2 j (coordinateL2 j f)
lemma sliceProjection_constantBasis (j k : ℤ) :
    sliceProjection j (constantBasis k) = if j=k then constantBasis k else 0 := by
  classical
  apply Lp.ext
  filter_upwards [sliceProjection_ae j (constantBasis k), constantBasis_ae k,
    Lp.coeFn_zero (E:=Fiber) (p:=2) (μ:=baseMeasure)] with x hx he hz
  rw [hx, he]
  by_cases hh : j=k
  · simp [hh, he]
  · simp only [ite_eq_right hh, lp.single_apply_ne _ _ _ hh, lp.single_zero, hz, Pi.zero_apply]
lemma sliceProjection_scalar_commute (j : ℤ) (g : Lp ℂ ∞ baseMeasure) :
    sliceProjection j * scalarMultiplier g = scalarMultiplier g * sliceProjection j := by
  ext1 f
  apply Lp.ext
  filter_upwards [sliceProjection_ae j (scalarMultiplier g f), scalarMultiplier_ae g f,
    scalarMultiplier_ae g (sliceProjection j f), sliceProjection_ae j f] with x h₁ h₂ h₃ h₄
  change sliceProjection j (scalarMultiplier g f) x = scalarMultiplier g (sliceProjection j f) x
  rw [h₁,h₂,h₃,h₄]
  exact lp.single_smul (E:=fun _ : ℤ => ℂ) 2 j (g x) (f x j)
lemma sliceProjection_zero_not_commute :
    sliceProjection 0 * forwardOperator ≠ forwardOperator * sliceProjection 0 := by
  intro he
  have h := congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T (constantBasis 0)) he
  simp only [mul_apply_eq_comp, forwardOperator_constantBasis_zero, map_smul,
    sliceProjection_constantBasis] at h
  norm_num at h
  have hh := congrArg norm h
  rw [norm_zero, forwardOperator_constantBasis_zero, norm_smul, constantBasis_norm, mul_one, Complex.norm_real,
    Real.norm_of_nonneg (Real.exp_pos _).le] at hh
  exact (Real.exp_ne_zero (-10)) hh.symm
lemma sliceProjection_zero_not_scalar :
    sliceProjection 0 ∉ Set.range (scalarMultiplier (μ:=baseMeasure)) := by
  rintro ⟨g,hg⟩
  have he0 : scalarMultiplier g (constantBasis 0) = constantBasis 0 := by
    rw [hg, sliceProjection_constantBasis]; simp
  have he1 : scalarMultiplier g (constantBasis 1) = 0 := by
    rw [hg, sliceProjection_constantBasis]; norm_num
  have h₀ := scalarMultiplier_ae g (constantBasis 0)
  have h₁ := scalarMultiplier_ae g (constantBasis 1)
  rw [he0] at h₀
  rw [he1] at h₁
  have hfalse : ∀ᵐ x ∂baseMeasure, False := by
    filter_upwards [h₀,h₁,constantBasis_ae 0, constantBasis_ae 1,
      Lp.coeFn_zero (E:=Fiber) (p:=2) (μ:=baseMeasure)] with x hv₀ hv₁ he₀ he₁ hz
    have hc₀ := congrArg (fun v : Fiber => v 0) hv₀
    have hc₁ := congrArg (fun v : Fiber => v 1) hv₁
    simp only [he₀, lp.single_apply_self, lp.coeFn_smul, Pi.smul_apply, smul_eq_mul, mul_one] at hc₀
    simp only [hz, he₁, lp.single_apply_self, lp.coeFn_smul, Pi.smul_apply, smul_eq_mul, mul_one, lp.coeFn_zero, Pi.zero_apply] at hc₁
    exact one_ne_zero (hc₀.trans hc₁.symm)
  exact hfalse.exists.choose_spec

lemma residue_separates {x y : Base} (h : ∀ m : ℕ, residue m x = residue m y) : x = y := by
  apply PadicInt.ext_of_toZModPow.mp
  intro m
  apply ZMod.val_injective
  exact h m

def residueClass (m t : ℕ) : Set Base := {x | residue m x = t}
lemma measurableSet_residueClass (m t : ℕ) : MeasurableSet (residueClass m t) :=
  measurableSet_eq_fun (measurable_residue m) measurable_const
lemma residueClass_nonnull {m t : ℕ} (ht : t < 2^m) : baseMeasure (residueClass m t) ≠ 0 := by
  change baseHaar {x : PadicInt 2 | twoResidue m x = t} ≠ 0
  have hcont : Continuous (twoResidue m) :=
    continuous_of_discreteTopology.comp (continuous_twoResidue m)
  have hOpen : IsOpen {x : PadicInt 2 | twoResidue m x = t} :=
    (isOpen_discrete ({t}:Set ℕ)).preimage hcont
  have hmem : twoResidue m (t : PadicInt 2) = t := by
    simp only [twoResidue, map_natCast]
    exact ZMod.val_natCast_of_lt ht
  exact (hOpen.measure_pos baseHaar ⟨(t : PadicInt 2),hmem⟩).ne'


def residueIndicator (m t : ℕ) : ScalarHilbert :=
  indicatorConstLp 2 (measurableSet_residueClass m t) (measure_ne_top baseMeasure _) (1:ℂ)
lemma residueIndicator_ae (m t : ℕ) : residueIndicator m t =ᵐ[baseMeasure]
    (residueClass m t).indicator (fun _ => (1:ℂ)) := indicatorConstLp_coeFn
lemma residueIndicator_ne_zero {m t : ℕ} (ht : t < 2^m) : residueIndicator m t ≠ 0 := by
  intro hz
  apply residueClass_nonnull ht
  rw [measure_eq_zero_iff_ae_notMem]
  have he := Lp.eq_zero_iff_ae_eq_zero.mp hz
  filter_upwards [he,residueIndicator_ae m t] with x hx hi
  intro hmem
  have h10 : (1:ℂ)=0 := by rw [← Set.indicator_of_mem hmem (fun _ => (1:ℂ)), ← hi]; exact hx
  exact one_ne_zero h10
lemma residueIndicator_orthogonal (m : ℕ) {s t : ℕ} (hst : s ≠ t) :
    inner ℂ (residueIndicator m s) (residueIndicator m t) = 0 := by
  rw [L2.inner_def]
  apply integral_eq_zero_of_ae
  filter_upwards [residueIndicator_ae m s, residueIndicator_ae m t] with x hs ht
  rw [hs,ht]
  by_cases hxs : x ∈ residueClass m s
  · have hxt : x ∉ residueClass m t := fun hx => hst (hxs.symm.trans hx)
    simp [Set.indicator_of_notMem hxt]
  · simp [Set.indicator_of_notMem hxs]
lemma residueIndicator_independent (m : ℕ) :
    LinearIndependent ℂ (fun t : Fin (2^m) => residueIndicator m t) := by
  apply linearIndependent_of_ne_zero_of_inner_eq_zero
  · intro t; exact residueIndicator_ne_zero t.isLt
  · intro s t hst
    exact residueIndicator_orthogonal m (fun he => hst (Fin.ext he))
lemma scalarHilbert_infinite : ¬FiniteDimensional ℂ ScalarHilbert := by
  intro hfin
  let := hfin
  have hh := (residueIndicator_independent (Module.finrank ℂ ScalarHilbert + 1)).fintype_card_le_finrank
  simp only [Fintype.card_fin] at hh
  have hlt := Nat.lt_two_pow_self (n:=Module.finrank ℂ ScalarHilbert + 1)
  omega

lemma forwardOperator_singleL2_zero (f : ScalarHilbert) :
    forwardOperator (singleL2 0 f) = (Real.exp (-10):ℂ) • singleL2 1 f := by
  apply Lp.ext
  filter_upwards [forwardOperator_ae (singleL2 0 f), singleL2_ae 0 f, singleL2_ae 1 f,
    Lp.coeFn_smul (Real.exp (-10):ℂ) (singleL2 1 f)] with x h₁ h₂ h₃ h₄
  rw [h₁,h₂,h₄,Pi.smul_apply,h₃,forwardFiber_single,explicitBeta_zero]
  exact lp.single_smul (E:=fun _ : ℤ => ℂ) 2 1 (Real.exp (-10):ℂ) (f x)
lemma coordinate_forward_single :
    (coordinateL2 1).comp (forwardOperator.comp (singleL2 0)) =
      (Real.exp (-10):ℂ) • (1 : ScalarHilbert →L[ℂ] ScalarHilbert) := by
  ext1 f
  change coordinateL2 1 (forwardOperator (singleL2 0 f)) = (Real.exp (-10):ℂ) • f
  rw [forwardOperator_singleL2_zero, map_smul, coordinateL2_singleL2]
lemma forwardOperator_not_compact : ¬IsCompactOperator forwardOperator := by
  intro hcomp
  have hc : IsCompactOperator ((coordinateL2 1).comp (forwardOperator.comp (singleL2 0))) :=
    (hcomp.comp_clm (singleL2 0)).clm_comp (coordinateL2 1)
  rw [coordinate_forward_single] at hc
  have he : (Real.exp (-10):ℂ) ≠ 0 := by exact_mod_cast Real.exp_ne_zero (-10)
  have hid : IsCompactOperator (id : ScalarHilbert → ScalarHilbert) :=
    (IsCompactOperator.smul_iff₀ he).mp hc
  exact scalarHilbert_infinite (FiniteDimensional.of_isCompactOperator_id hid)
lemma globalHilbert_infinite : ¬FiniteDimensional ℂ GlobalHilbert := by
  intro hfin
  let := hfin
  apply scalarHilbert_infinite
  apply FiniteDimensional.of_injective (singleL2 0).toLinearMap
  intro f g he
  have he' : singleL2 0 f = singleL2 0 g := he
  simpa only [coordinateL2_singleL2] using congrArg (coordinateL2 0) he'

lemma sliceProjection_selfAdjoint (j : ℤ) : IsSelfAdjoint (sliceProjection j) := by
  apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr
  intro f g
  change inner ℂ (sliceProjection j f) g = inner ℂ f (sliceProjection j g)
  simp only [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [sliceProjection_ae j f, sliceProjection_ae j g] with x hf hg
  rw [hf,hg,lp.inner_single_left,lp.inner_single_right]
lemma sliceProjection_isStarProjection (j : ℤ) : IsStarProjection (sliceProjection j) :=
  ⟨sliceProjection_idempotent j, sliceProjection_selfAdjoint j⟩



end
end BackwardIntertwiners

end OAI