lean/OAI/Probability/FreeIsing/Conditioning/CopyDifference.lean

import Mathlib

namespace OAI

noncomputable section
open MeasureTheory

namespace Problem367.CopyDifference

variable {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]

def pullback {μ : Measure A} {ν : Measure B} {p : B → A}
    (hp : MeasurePreserving p ν μ) : Lp ℝ 2 μ →L[ℝ] Lp ℝ 2 ν :=
  (Lp.compMeasurePreservingₗᵢ ℝ p hp).toContinuousLinearMap

theorem pullback_ae {μ : Measure A} {ν : Measure B} {p : B → A}
    (hp : MeasurePreserving p ν μ) (f : Lp ℝ 2 μ) :
    pullback hp f =ᵐ[ν] fun z => f (p z) :=
  Lp.coeFn_compMeasurePreserving f hp

@[simp] theorem norm_pullback {μ : Measure A} {ν : Measure B} {p : B → A}
    (hp : MeasurePreserving p ν μ) (f : Lp ℝ 2 μ) :
    ‖pullback hp f‖ = ‖f‖ :=
  Lp.norm_compMeasurePreserving f hp

theorem pullback_comp {μ : Measure A} {ν : Measure B} {ρ : Measure C}
    {p : B → A} {q : C → B}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ρ ν) :
    pullback (hp.comp hq) = (pullback hq).comp (pullback hp) := by
  ext1 f
  exact Lp.compMeasurePreserving_comp_apply f hp hq

def operator {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ) :
    Lp ℝ 2 μ →L[ℝ] Lp ℝ 2 ν := pullback hp - pullback hq

theorem operator_ae {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ)
    (f : Lp ℝ 2 μ) :
    operator hp hq f =ᵐ[ν] fun z => f (p z) - f (q z) := by
  have hd := Lp.coeFn_sub (pullback hp f) (pullback hq f)
  exact hd.trans ((pullback_ae hp f).sub (pullback_ae hq f))

theorem norm_operator_apply_le {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ)
    (f : Lp ℝ 2 μ) : ‖operator hp hq f‖ ≤ 2 * ‖f‖ := by
  calc
    ‖operator hp hq f‖ ≤ ‖pullback hp f‖ + ‖pullback hq f‖ := norm_sub_le _ _
    _ = 2 * ‖f‖ := by rw [norm_pullback, norm_pullback]; ring

theorem norm_operator_le {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ) :
    ‖operator hp hq‖ ≤ 2 :=
  ContinuousLinearMap.opNorm_le_bound _ (by norm_num) (norm_operator_apply_le hp hq)

theorem operator_eq_zero_of_ae_const
    {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ)
    (f : Lp ℝ 2 μ) (c : ℝ) (hf : f =ᵐ[μ] fun _ => c) :
    operator hp hq f = 0 := by
  apply Lp.ext
  filter_upwards [operator_ae hp hq f, hp.quasiMeasurePreserving.ae hf,
    hq.quasiMeasurePreserving.ae hf, Lp.coeFn_zero ℝ 2 ν] with z hz hpz hqz hzero
  simpa only [hz, hpz, hqz, sub_self, Pi.zero_apply] using hzero.symm

theorem operator_eq_zero_iff
    {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ)
    (f : Lp ℝ 2 μ) :
    operator hp hq f = 0 ↔ (fun z => f (p z)) =ᵐ[ν] (fun z => f (q z)) := by
  constructor
  · intro h
    have hzero := Lp.coeFn_zero ℝ 2 ν
    have hae := operator_ae hp hq f
    rw [h] at hae
    filter_upwards [hae, hzero] with z hz hz0
    exact sub_eq_zero.mp (hz.symm.trans hz0)
  · intro h
    apply Lp.ext
    filter_upwards [operator_ae hp hq f, h, Lp.coeFn_zero ℝ 2 ν] with z hz he hz0
    simpa only [hz, he, sub_self, Pi.zero_apply] using hz0.symm

theorem intertwines
    {μ : Measure A} {ν : Measure B} {p q : B → A}
    (hp : MeasurePreserving p ν μ) (hq : MeasurePreserving q ν μ)
    {T : A → A} {S : B → B}
    (hT : MeasurePreserving T μ μ) (hS : MeasurePreserving S ν ν)
    (hpT : p ∘ S = T ∘ p) (hqT : q ∘ S = T ∘ q) :
    (pullback hS).comp (operator hp hq) =
      (operator hp hq).comp (pullback hT) := by
  unfold operator
  rw [ContinuousLinearMap.comp_sub, ContinuousLinearMap.sub_comp,
    ← pullback_comp hp hS, ← pullback_comp hq hS,
    ← pullback_comp hT hp, ← pullback_comp hT hq]
  have congr_pullback {r s : B → A} (hr : MeasurePreserving r ν μ)
      (hs : MeasurePreserving s ν μ) (h : r = s) : pullback hr = pullback hs := by
    subst s
    rfl
  rw [congr_pullback (hp.comp hS) (hT.comp hp) hpT,
    congr_pullback (hq.comp hS) (hT.comp hq) hqT]

section ClosedRange

variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

def rangeClosure (D : E →L[ℝ] F) : Submodule ℝ F :=
  D.toLinearMap.range.topologicalClosure

instance rangeClosure_completeSpace [CompleteSpace F] (D : E →L[ℝ] F) :
    CompleteSpace (rangeClosure D) := by
  unfold rangeClosure
  infer_instance

def toRangeClosure (D : E →L[ℝ] F) : E →L[ℝ] rangeClosure D :=
  D.codRestrict (rangeClosure D) fun x =>
    D.toLinearMap.range.le_topologicalClosure ⟨x, rfl⟩

@[simp] theorem coe_toRangeClosure (D : E →L[ℝ] F) (x : E) :
    (toRangeClosure D x : F) = D x := rfl

theorem denseRange_toRangeClosure (D : E →L[ℝ] F) :
    DenseRange (toRangeClosure D) := by
  rw [DenseRange, Topology.IsInducing.subtypeVal.dense_iff]
  intro y
  rw [← Set.range_comp]
  exact y.property

theorem mapsTo_rangeClosure (D : E →L[ℝ] F) (A : E →L[ℝ] E) (T : F →L[ℝ] F)
    (h : ∀ x, T (D x) = D (A x)) :
    Set.MapsTo T (rangeClosure D) (rangeClosure D) := by
  have hr : Set.MapsTo T (Set.range D) (Set.range D) := by
    rintro y ⟨x, rfl⟩
    exact ⟨A x, (h x).symm⟩
  exact hr.closure T.continuous

def restrictToRangeClosure (D : E →L[ℝ] F) (A : E →L[ℝ] E) (T : F →L[ℝ] F)
    (h : ∀ x, T (D x) = D (A x)) : rangeClosure D →L[ℝ] rangeClosure D :=
  T.restrict (mapsTo_rangeClosure D A T h)

theorem intertwines_toRangeClosure (D : E →L[ℝ] F)
    (A : E →L[ℝ] E) (T : F →L[ℝ] F) (h : ∀ x, T (D x) = D (A x)) :
    (restrictToRangeClosure D A T h).comp (toRangeClosure D) =
      (toRangeClosure D).comp A := by
  ext1 x
  apply Subtype.ext
  exact h x

end ClosedRange

section HilbertRange

variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F] [CompleteSpace F]

theorem isSelfAdjoint_restrictToRangeClosure (D : E →L[ℝ] F)
    (A : E →L[ℝ] E) (T : F →L[ℝ] F) (h : ∀ x, T (D x) = D (A x))
    (hT : IsSelfAdjoint T) : IsSelfAdjoint (restrictToRangeClosure D A T h) := by
  apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr
  intro x y
  exact hT.isSymmetric x.val y.val

end HilbertRange

end Problem367.CopyDifference

end

end OAI