lean/OAI/Analysis/FreeGroupFactor/MomentFlow.lean

import OAI.Analysis.FreeGroupFactor.Operators

namespace OAI

noncomputable section

universe uA uG uι

open Set Metric Filter
open scoped NNReal Topology BigOperators ContDiff

namespace FreeGroupFactorMain

instance groupVN_normedSpaceReal (G : Type uG) [Group G] :
    NormedSpace ℝ (groupVonNeumann G) :=
  NormedSpace.restrictScalars ℝ ℂ (groupVonNeumann G)

 instance groupHilbert_nontrivial (G : Type uG) [Group G] : Nontrivial (GroupHilbert G) := by
  classical
  apply nontrivial_of_ne (lp.single 2 (1 : G) (1 : ℂ)) 0
  intro he
  have hh := congrArg (fun x : GroupHilbert G => x 1) he
  simp at hh

 instance groupVN_normOneClass (G : Type uG) [Group G] : NormOneClass (groupVonNeumann G) where
  norm_one := by
    change ‖(1 : GroupOperator G)‖ = 1
    exact norm_one

 def groupUnitaryHom (G : Type uG) [Group G] : G →* groupVonNeumann G where
  toFun := groupUnitary
  map_one' := Subtype.ext (leftRegular_one)
  map_mul' g b := Subtype.ext (leftRegular_mul g b)

 def groupAlgebraEvaluation (G : Type uG) [Group G] :
    MonoidAlgebra ℂ G →ₐ[ℂ] groupVonNeumann G :=
  MonoidAlgebra.lift ℂ (groupVonNeumann G) G (groupUnitaryHom G)

 @[simp] theorem groupAlgebraEvaluation_of {G : Type uG} [Group G] (g : G) :
    groupAlgebraEvaluation G (MonoidAlgebra.of ℂ G g) = groupUnitary g := by
  simp [groupAlgebraEvaluation, groupUnitaryHom]

 theorem canonicalTrace_groupAlgebraEvaluation {G : Type uG} [Group G] [DecidableEq G]
    (p : MonoidAlgebra ℂ G) : canonicalTrace (groupAlgebraEvaluation G p) = p.coeff 1 := by
  induction p using MonoidAlgebra.induction_on with
  | of g =>
    rw [groupAlgebraEvaluation_of, canonicalTrace_groupUnitary]
    simp only [MonoidAlgebra.of_apply, MonoidAlgebra.coeff_single, Finsupp.single_apply]
  | add p q hp hq =>
    change canonicalTraceCLM (groupAlgebraEvaluation G (p + q)) = _
    simp only [map_add, canonicalTraceCLM_apply, hp, hq, MonoidAlgebra.coeff_add,
      Finsupp.add_apply]
  | smul c p hp =>
    change canonicalTraceCLM (groupAlgebraEvaluation G (c • p)) = _
    simp only [map_smul, canonicalTraceCLM_apply, hp, MonoidAlgebra.coeff_smul,
      Finsupp.smul_apply]

 theorem canonicalTrace_eval {ι : Type uι} [DecidableEq ι]
    (p : NCPolynomial.Expr (ι × Bool)) :
    canonicalTrace (NCPolynomial.eval (fun ib => groupUnitary (AlgebraPolynomial.signed ib)) p) =
      (NCPolynomial.eval (fun ib => MonoidAlgebra.of ℂ (FreeGroup ι)
        (AlgebraPolynomial.signed ib)) p).coeff 1 := by
  rw [← canonicalTrace_groupAlgebraEvaluation]
  congr 1
  rw [AlgebraPolynomial.map_eval]
  congr 1
  funext ib
  exact (groupAlgebraEvaluation_of _).symm

theorem source_laurent_moments {ι : Type uι} [Fintype ι] [DecidableEq ι]
    (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ)
    (Y : ℝ → (Option ι × Bool) → groupVonNeumann (FreeGroup (Option ι)))
    (hY₀ : ∀ ib, Y 0 ib = groupUnitary (AlgebraPolynomial.signed ib))
    (hsmooth : ∀ ib, ContDiff ℝ ∞ (fun t => Y t ib))
    (hbounded : ∀ t ib, ‖Y t ib‖ ≤ 1)
    (hODE : ∀ t ib, HasDerivAt (fun s => Y s ib)
      (NCPolynomial.eval (Y t)
        (AlgebraPolynomial.encodedField (TraceCocycle.fieldCoefficients h l) ib)) t)
    (p : NCPolynomial.Expr (Option ι × Bool)) (t : ℝ) :
    canonicalTrace (NCPolynomial.eval (Y t) p) =
      canonicalTrace (NCPolynomial.eval (Y 0) p) := by
  classical
  let V := AlgebraPolynomial.encodedField (TraceCocycle.fieldCoefficients h l)
  let J := Finset.univ.sup (fun ib => NCPolynomial.degree (V ib))
  let B := ∑ ib, NCPolynomial.mass (V ib)
  have hB : 0 ≤ B := Finset.sum_nonneg fun _ _ => NCPolynomial.mass_nonneg _
  have hdeg (ib) : NCPolynomial.degree (V ib) ≤ J + 1 := by
    exact (Finset.le_sup (f := fun ib => NCPolynomial.degree (V ib))
      (Finset.mem_univ ib)).trans (Nat.le_succ _)
  have hmass (ib) : NCPolynomial.mass (V ib) ≤ B :=
    Finset.single_le_sum (fun i _ => NCPolynomial.mass_nonneg (V i)) (Finset.mem_univ ib)
  have hinitial (q) : canonicalTrace (NCPolynomial.eval (Y 0) (NCPolynomial.delta V q)) = 0 := by
    have hinit : Y 0 = fun ib => groupUnitary (AlgebraPolynomial.signed ib) := funext hY₀
    rw [hinit, canonicalTrace_eval]
    exact AlgebraPolynomial.encoded_initial_trace h l q
  have hreal (L : ℂ →L[ℝ] ℝ) :
      L (canonicalTrace (NCPolynomial.eval (Y t) p)) =
      L (canonicalTrace (NCPolynomial.eval (Y 0) p)) := by
    let Lt := L.comp ((canonicalTraceCLM (G := FreeGroup (Option ι))).restrictScalars ℝ)
    apply NCPolynomial.polynomial_moments Y V Lt hsmooth hODE 1 le_rfl hbounded
      J B hB hdeg hmass
    intro q
    change L (canonicalTrace (NCPolynomial.eval (Y 0) (NCPolynomial.delta V q))) = 0
    rw [hinitial, map_zero]
  exact Complex.ext (hreal Complex.reCLM) (hreal Complex.imCLM)

end FreeGroupFactorMain

namespace FreeGroupFactorMain.UnitaryEvaluation
open scoped ContDiff
variable {A : Type uA} [CStarAlgebra A] {ι : Type uι}
 theorem norm_signedTrajectory_le_one [Nontrivial A]
    (X : ℝ → ι → A) (hU : ∀ t j, X t j ∈ unitary A)
    (C : unitary A) (t : ℝ) (ib : Option ι × Bool) :
    ‖signedTrajectory X hU C t ib‖ ≤ 1 := by
  change ‖((FreeGroup.lift (extendUnitary (fun j => ⟨X t j, hU t j⟩) C)
    (AlgebraPolynomial.signed ib) : unitary A) : A)‖ ≤ 1
  exact (CStarRing.norm_of_mem_unitary (Subtype.property _)).le

 theorem smooth_signedTrajectory [Fintype ι]
    (X : ℝ → ι → A) (hU : ∀ t j, X t j ∈ unitary A)
    (C : unitary A) (hs : ContDiff ℝ ∞ X) (ib : Option ι × Bool) :
    ContDiff ℝ ∞ (fun t => signedTrajectory X hU C t ib) := by
  rcases ib with ⟨i,b⟩
  cases i with
  | none => cases b <;>
      simp only [signedTrajectory_none_pos, signedTrajectory_none_neg] <;> exact contDiff_const
  | some j => cases b
              · simp only [signedTrajectory_some_neg]
                exact (starL ℝ (A := A)).contDiff.comp ((contDiff_apply ℝ A j).comp hs)
              · simp only [signedTrajectory_some_pos]
                exact (contDiff_apply ℝ A j).comp hs
end FreeGroupFactorMain.UnitaryEvaluation

namespace FreeGroupFactorMain
open scoped ContDiff

 theorem groupUnitary_mem_unitary {G : Type uG} [Group G] (g : G) :
    groupUnitary g ∈ unitary (groupVonNeumann G) := by
  rw [Unitary.mem_iff]
  constructor <;> apply Subtype.ext
  · exact (Unitary.mem_iff.mp (leftRegular_unitary g)).1
  · exact (Unitary.mem_iff.mp (leftRegular_unitary g)).2

 def generatorUnitary {ι : Type uι} (i : ι) : unitary (groupVonNeumann (FreeGroup ι)) :=
  ⟨groupUnitary (FreeGroup.of i), groupUnitary_mem_unitary _⟩

 theorem wordHom_generatorUnitary {ι : Type uι} (g : FreeGroup ι) :
    UnitaryEvaluation.wordHom generatorUnitary g = groupUnitary g := by
  have he : UnitaryEvaluation.wordHom (generatorUnitary (ι := ι)) =
      groupUnitaryHom (FreeGroup ι) := by
    apply FreeGroup.ext_hom
    intro i
    rfl
  exact DFunLike.congr_fun he g

 theorem laurent_flow_moments {ι : Type uι} [Fintype ι] [DecidableEq ι]
    (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ)
    (hS : IsSelfAdjoint (UnitaryEvaluation.laurentValue
      (generatorUnitary (none : Option ι)) l))
    (X : ℝ → ι → groupVonNeumann (FreeGroup (Option ι)))
    (hU : ∀ t j, X t j ∈ unitary (groupVonNeumann (FreeGroup (Option ι))))
    (hX₀ : X 0 = fun j => groupUnitary (FreeGroup.of (some j)))
    (hX : ∀ t, HasDerivAt X (PolynomialFlow.field
      (UnitaryEvaluation.laurentValue (generatorUnitary (none : Option ι)) l) h (X t)) t) :
    ∀ t (g : FreeGroup (Option ι)),
      canonicalTrace (UnitaryEvaluation.wordHom
        (UnitaryEvaluation.extendUnitary (fun j => ⟨X t j, hU t j⟩)
          (generatorUnitary none)) g) = if g = 1 then 1 else 0 := by
  classical
  let C : unitary (groupVonNeumann (FreeGroup (Option ι))) := generatorUnitary none
  let S := UnitaryEvaluation.laurentValue C l
  let Y := UnitaryEvaluation.signedTrajectory X hU C
  have hu0 : UnitaryEvaluation.extendUnitary (fun j => ⟨X 0 j, hU 0 j⟩) C =
      generatorUnitary := by
    funext i
    cases i with
    | none => rfl
    | some j => apply Subtype.ext; exact congrFun hX₀ j
  have hY₀ (ib) : Y 0 ib = groupUnitary (AlgebraPolynomial.signed ib) := by
    dsimp [Y, UnitaryEvaluation.signedTrajectory]
    rw [hu0, wordHom_generatorUnitary]
  have hsmooth (ib) : ContDiff ℝ ∞ (fun t => Y t ib) :=
    UnitaryEvaluation.smooth_signedTrajectory X hU C
      (PolynomialFlow.smooth_solution S h X hX) ib
  have hbounded (t ib) : ‖Y t ib‖ ≤ 1 :=
    UnitaryEvaluation.norm_signedTrajectory_le_one X hU C t ib
  intro t g
  let p := AlgebraPolynomial.encode (MonoidAlgebra.of ℂ (FreeGroup (Option ι)) g)
  have hmoment := source_laurent_moments h l Y hY₀ hsmooth hbounded
    (UnitaryEvaluation.signedTrajectory_ode C h l hS X hU hX) p t
  have he (s) : NCPolynomial.eval (Y s) p =
      UnitaryEvaluation.wordHom
        (UnitaryEvaluation.extendUnitary (fun j => ⟨X s j, hU s j⟩) C) g := by
    change NCPolynomial.eval (fun ib => UnitaryEvaluation.wordHom
      (UnitaryEvaluation.extendUnitary (fun j => ⟨X s j, hU s j⟩) C)
        (AlgebraPolynomial.signed ib)) (AlgebraPolynomial.encode
          (MonoidAlgebra.of ℂ (FreeGroup (Option ι)) g)) = _
    rw [UnitaryEvaluation.eval_encode, UnitaryEvaluation.algebraHom_of]
  rw [he, he, hu0, wordHom_generatorUnitary, canonicalTrace_groupUnitary] at hmoment
  exact hmoment

 theorem actual_laurent_flow_moments {ι : Type uι} [Fintype ι] [DecidableEq ι]
    (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ)
    (hS : IsSelfAdjoint (UnitaryEvaluation.laurentValue
      (generatorUnitary (none : Option ι)) l)) :
    ∃ (X : ℝ → ι → groupVonNeumann (FreeGroup (Option ι)))
      (hU : ∀ t j, X t j ∈ unitary (groupVonNeumann (FreeGroup (Option ι)))),
      X 0 = (fun j => groupUnitary (FreeGroup.of (some j))) ∧
      (∀ t, HasDerivAt X (PolynomialFlow.field
        (UnitaryEvaluation.laurentValue (generatorUnitary (none : Option ι)) l) h (X t)) t) ∧
      ∀ t (g : FreeGroup (Option ι)),
        canonicalTrace (UnitaryEvaluation.wordHom
          (UnitaryEvaluation.extendUnitary (fun j => ⟨X t j, hU t j⟩)
            (generatorUnitary none)) g) = if g = 1 then 1 else 0 := by
  classical
  let C : unitary (groupVonNeumann (FreeGroup (Option ι))) := generatorUnitary none
  let S := UnitaryEvaluation.laurentValue C l
  obtain ⟨X, hX₀, hX, hU⟩ := PolynomialFlow.global_unitary_solution S hS h
    (fun j => groupUnitary (FreeGroup.of (some j))) (fun j => groupUnitary_mem_unitary _)
  refine ⟨X,hU,hX₀,hX,?_⟩
  exact laurent_flow_moments h l hS X hU hX₀ hX

end FreeGroupFactorMain

namespace FreeGroupFactorMain.PolynomialFlow
variable {A : Type uA} [CStarAlgebra A] [Nontrivial A]
variable {ι : Type uι} [Fintype ι] [DecidableEq ι]

omit [Nontrivial A] [Fintype ι] [DecidableEq ι] in
theorem coe_wordList (E : StarSubalgebra ℂ A) [IsClosed (E : Set A)] (w : List (ι × Bool)) (X : ι → E) :
    ((wordList w X : E) : A) = wordList w (fun i => (X i : A)) := by
  induction w with
  | nil => rfl
  | cons a w ih =>
    rcases a with ⟨i, b⟩
    cases b <;> simpa [wordList] using
      congrArg (fun z : A => _ * z) ih

omit [Nontrivial A] [Fintype ι] in
theorem coe_field (E : StarSubalgebra ℂ A) [IsClosed (E : Set A)] (S : E)
    (h : ι → FreeGroup ι →₀ ℝ) (X : ι → E) (j : ι) :
    ((field S h X j : E) : A) = field (S : A) h (fun i => (X i : A)) j := by
  classical
  simp [field, hamiltonian, Finsupp.sum, word, coe_wordList]

theorem solution_mem_subalgebra (E : StarSubalgebra ℂ A) (hE : IsClosed (E : Set A))
    (S : A) (hS : IsSelfAdjoint S) (hSE : S ∈ E) (h : ι → FreeGroup ι →₀ ℝ)
    (X : ℝ → ι → A) (hX : ∀ t, HasDerivAt X (field S h (X t)) t)
    (hU : ∀ t j, X t j ∈ unitary A) (t₀ : ℝ) (h₀ : ∀ j, X t₀ j ∈ E) :
    ∀ t j, X t j ∈ E := by
  let : IsClosed (E : Set A) := hE
  let S' : E := ⟨S, hSE⟩
  let V : ι → E := fun j => ⟨X t₀ j, h₀ j⟩
  have hS' : IsSelfAdjoint S' := Subtype.ext hS
  have hV : ∀ j, V j ∈ unitary E := by
    intro j
    rw [Unitary.mem_iff]
    exact ⟨Subtype.ext (hU t₀ j).1, Subtype.ext (hU t₀ j).2⟩
  obtain ⟨Y, hY₀, hY, hUY⟩ := global_unitary_solution S' hS' h V hV
  let L : (ι → E) →L[ℝ] (ι → A) :=
    ContinuousLinearMap.pi fun j =>
      (E.toSubalgebra.toSubmodule.subtypeL.restrictScalars ℝ).comp
        (ContinuousLinearMap.proj j)
  let Z : ℝ → ι → A := fun t => L (Y (t - t₀))
  have hZ : ∀ t, HasDerivAt Z (field S h (Z t)) t := by
    intro t
    have hd := (hY (t - t₀)).scomp t ((hasDerivAt_id t).sub_const t₀)
    have hm := L.hasFDerivAt.comp_hasDerivAt t hd
    have hm' : HasDerivAt Z (L (field S' h (Y (t - t₀)))) t := by
      simpa only [Function.comp_def, id_eq, one_smul, Z] using hm
    have hf : L (field S' h (Y (t - t₀))) = field S h (Z t) := by
      ext j
      exact coe_field E S' h (Y (t - t₀)) j
    rw [hf] at hm'
    exact hm'
  have hUZ : ∀ t j, Z t j ∈ unitary A := by
    intro t j
    exact ⟨congrArg Subtype.val (hUY (t - t₀) j).1,
      congrArg Subtype.val (hUY (t - t₀) j).2⟩
  have heq : X = Z := unitary_solutions_unique S h X Z hX hZ hU hUZ t₀ (by
    ext j
    change X t₀ j = ((Y (t₀ - t₀) j : E) : A)
    rw [sub_self, hY₀])
  intro t j
  rw [heq]
  exact (Y (t - t₀) j).property

end FreeGroupFactorMain.PolynomialFlow

end

end OAI