import Mathlib
import OAI.Probability.ParisiFinite.OrdinaryInverseSpecial

namespace OAI

/-! Low Vector. -/

noncomputable section

open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder
open Filter
open scoped BigOperators
open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate
open scoped InnerProductSpace ComplexConjugate
open Filter Topology
namespace SeedInitialization
open CoherentFock RootSpin Complex PointedTree
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]

def lowVector (d : E) : SpinSpace E :=
  SpinOperators.act Y (WZ ((2:ℝ) • d) (vacuum E))

@[simp] theorem norm_lowVector (d : E) : ‖lowVector d‖=1 := by
  rw [lowVector,SpinOperators.norm_act Y_unitary,norm_WZ,norm_vacuum]

theorem ordinary_insertion_eq (γ : ℝ) (v e : E) :
    (ordinaryMap γ (Real.pi/4) v e).symm
      (SpinOperators.act Z (ordinaryMap γ (Real.pi/4) v e (vacuum E)))=
      lowVector (γ • (v-e)) := by
  simp only [ordinaryMap,LinearIsometryEquiv.trans_apply,LinearIsometryEquiv.symm_trans,
    costEquiv_apply,costEquiv_symm_apply,SpinOperators.actEquiv_apply,
    SpinOperators.actEquiv_symm_apply]
  rw [one_layer_insertion,show 2*(Real.pi/4)=Real.pi/2 by ring]
  simp only [Real.cos_pi_div_two,Real.sin_pi_div_two,Complex.ofReal_zero,Complex.ofReal_one,
    zero_smul,one_smul,zero_add,lowVector,two_smul]

theorem inner_lowVector_initial (d : E) :
    ⟪lowVector d,SpinOperators.act Z (vacuum E)⟫_ℂ=
      I*(Real.exp (-2*‖d‖^2):ℂ) := by
  rw [← inner_conj_symm,lowVector,inner_rootZ_vac_rootY_WZ]
  simp only [map_mul,map_neg,Complex.conj_I,neg_neg,Complex.conj_ofReal]
  congr 2
  have hn : ‖(2:ℝ) • d‖^2=4*‖d‖^2 := by
    rw [norm_smul,Real.norm_of_nonneg (by norm_num : (0:ℝ)≤2)]
    ring
  rw [hn]
  ring_nf

theorem tendsto_norm_ordinaryDisplacement (n : ℕ) (b : ℝ) :
    Tendsto (fun t => ‖ordinaryDisplacement n b t‖) atTop (𝓝 (2*|b|)) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  apply squeeze_zero (fun _ => norm_nonneg _) (fun t => ?_)
    (tendsto_ordinaryDisplacement_error n b)
  have h := abs_norm_sub_norm_le (ordinaryDisplacement n b t)
    ((2*b:ℝ) • highDirection n (gamma b t))
  have hn : ‖(2*b:ℝ) • highDirection n (gamma b t)‖=2*|b| := by
    rw [← Complex.coe_smul,norm_smul,highDirection_norm,mul_one,
      Complex.norm_real,Real.norm_eq_abs,abs_mul]
    norm_num
  simpa only [hn,Real.norm_eq_abs] using h

 
def initializedInsertion (n : ℕ) (b t : ℝ) : Mode (n+2) :=
  (ordinary (initializationWord (gamma b t) (delta t) (Real.pi/4)) (n+2)).insertion

@[simp] theorem initializedInsertion_coe (n : ℕ) (b t : ℝ) :
    (initializedInsertion n b t : Level (n+2))=
      (ordinary (initializationWord (gamma b t) (delta t) (Real.pi/4)) (n+2)).op.symm
        (SpinOperators.act Z
          ((ordinary (initializationWord (gamma b t) (delta t) (Real.pi/4)) (n+2)).op
            (vac (n+2)))) := rfl

@[simp] theorem norm_initializedInsertion (n : ℕ) (b t : ℝ) :
    ‖initializedInsertion n b t‖=1 := EvenUnitary.norm_insertion _

theorem initializedInsertion_error (n : ℕ) (b : ℝ) {t : ℝ} (ht : 1 ≤ t) :
    ‖(initializedInsertion n b t:Level (n+2))-lowVector (ordinaryDisplacement n b t)‖≤
      2*(amplitude t^2+amplitude t) := by
  have h := initial_insertion_error (E := Mode (n+1)) (gamma b t) (Real.pi/4) ht
    (actualV n b t) (initialDirection (n+1)) (SpinOperators.act Z)
    (fun x => (SpinOperators.norm_act Z_unitary x).le)
  rw [ordinary_insertion_eq,initialMap_eq_ordinary] at h
  rw [initializedInsertion_coe]
  exact h

theorem tendsto_initializedInsertion_error (n : ℕ) (b : ℝ) :
    Tendsto (fun t => ‖(initializedInsertion n b t:Level (n+2))-
      lowVector (ordinaryDisplacement n b t)‖) atTop (𝓝 0) := by
  apply squeeze_zero' (Filter.Eventually.of_forall fun t => norm_nonneg _) ?_
    (by simpa only [zero_pow (by norm_num : (2:ℕ)≠0),add_zero,mul_zero] using
      ((tendsto_amplitude.pow 2).add tendsto_amplitude).const_mul 2)
  filter_upwards [eventually_ge_atTop (1:ℝ)] with t ht
  exact initializedInsertion_error n b ht

theorem tendsto_lowVector_initial (n : ℕ) (b : ℝ) :
    Tendsto (fun t => ⟪lowVector (ordinaryDisplacement n b t),
      (initialDirection (n+2):Level (n+2))⟫_ℂ) atTop
        (𝓝 (I*(Real.exp (-8*b^2):ℂ))) := by
  have he := Real.continuous_exp.continuousAt.tendsto.comp
    (((tendsto_norm_ordinaryDisplacement n b).pow 2).const_mul (-2))
  have hh := (Complex.continuous_ofReal.continuousAt.tendsto.comp he).const_mul I
  have hpow : -2*(2*|b|)^2= -8*b^2 := by rw [mul_pow,sq_abs]; ring
  rw [hpow] at hh
  have hinit : (initialDirection (n+2):Level (n+2))=
      SpinOperators.act Z (vacuum (Mode (n+1))) := rfl
  simpa only [hinit,inner_lowVector_initial,Function.comp_def] using hh

 

theorem tendsto_initialized_initial (n : ℕ) (b : ℝ) :
    Tendsto (fun t => ⟪(initializedInsertion n b t:Level (n+2)),
      (initialDirection (n+2):Level (n+2))⟫_ℂ) atTop
        (𝓝 (I*(Real.exp (-8*b^2):ℂ))) := by
  have he : Tendsto (fun t =>
      ⟪(initializedInsertion n b t:Level (n+2)),(initialDirection (n+2):Level (n+2))⟫_ℂ-
      ⟪lowVector (ordinaryDisplacement n b t),(initialDirection (n+2):Level (n+2))⟫_ℂ)
      atTop (𝓝 0) := by
    rw [tendsto_zero_iff_norm_tendsto_zero]
    apply squeeze_zero (fun _ => norm_nonneg _) (fun t => ?_)
      (tendsto_initializedInsertion_error n b)
    rw [← inner_sub_left]
    have h := norm_inner_le_norm (𝕜 := ℂ)
      ((initializedInsertion n b t:Level (n+2))-lowVector (ordinaryDisplacement n b t))
      (initialDirection (n+2):Level (n+2))
    have hn : ‖(initialDirection (n+2):Level (n+2))‖=1 := initialDirection_norm (n+2)
    simpa only [hn,mul_one] using h
  simpa only [sub_add_cancel,zero_add] using he.add (tendsto_lowVector_initial n b)

theorem tendsto_initial_visibility (n : ℕ) (b z : ℝ) :
    Tendsto (fun t => -2*(⟪(initializedInsertion n b t:Level (n+2)),
      (-2*b*z:ℝ) • (initialDirection (n+2):Level (n+2))⟫_ℂ).im) atTop
      (𝓝 (4*b*z*Real.exp (-8*b^2))) := by
  have hc := (tendsto_initialized_initial n b).const_mul ((-2*b*z:ℝ):ℂ)
  have hi := Complex.continuous_im.continuousAt.tendsto.comp hc
  have h := hi.const_mul (-2)
  simp only [Complex.mul_im,Complex.ofReal_im,Complex.ofReal_re,zero_mul,zero_add,
    Complex.I_re,Complex.I_im,one_mul,mul_zero,add_zero,Function.comp_def] at h
  convert! h using 1
  · funext t
    rw [← Complex.coe_smul,inner_smul_right]
    simp only [Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,add_zero]
  · congr 1
    ring

theorem initial_visibility_nonzero (n : ℕ) {b : ℝ} (hb : 0 < b) {z : ℝ} (hz : z≠0) :
    ∀ᶠ t : ℝ in atTop, -2*(⟪(initializedInsertion n b t:Level (n+2)),
      (-2*b*z:ℝ) • (initialDirection (n+2):Level (n+2))⟫_ℂ).im≠0 := by
  apply (tendsto_initial_visibility n b z).eventually_ne
  exact mul_ne_zero (mul_ne_zero (mul_ne_zero (by norm_num) hb.ne') hz) (Real.exp_ne_zero _)

end SeedInitialization

namespace SeedInitialization
open CoherentFock RootSpin PointedTree Complex
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]

def preVacuum (E : Type*) [Zero E] : PreSpin E := fun _ => spinCoefficient • basis 0

@[simp] theorem spinCoe_preVacuum : spinCoe (preVacuum E)=vacuum E := by
  ext i
  simp only [spinCoe_apply,preVacuum,UniformSpace.Completion.coe_smul,coe_basis,
    vacuum_apply,spinCoefficient]

omit [InnerProductSpace ℂ E] in
@[simp] theorem spinMass_preVacuum : spinMass (preVacuum E)=2*‖spinCoefficient‖ := by
  simp only [spinMass,preVacuum,mass_smul,mass_basis,mul_one,Fin.sum_univ_two]
  ring

omit [InnerProductSpace ℂ E] in
theorem radius_preVacuum : SpinRadiusLE (preVacuum E) 0 :=
  fun _ => (RadiusLE.basis (0:E) 0 (by simp)).smul _

def preLow (d : E) : PreSpin E := preRoot Y (preWZ ((2:ℝ) • d) (preVacuum E))

@[simp] theorem spinCoe_preLow (d : E) : spinCoe (preLow d)=lowVector d := by
  simp only [preLow,spinCoe_preRoot,spinCoe_preWZ,spinCoe_preVacuum,lowVector]

theorem mass_preLow (d : E) : spinMass (preLow d) ≤ matrixMass Y*(2*‖spinCoefficient‖) := by
  have hM : 0 ≤ matrixMass Y := Finset.sum_nonneg fun i _ =>
    Finset.sum_nonneg fun j _ => norm_nonneg (Y i j)
  exact (spinMass_preRoot _ _).trans (mul_le_mul_of_nonneg_left
    ((spinMass_preWZ _ _).trans_eq spinMass_preVacuum) hM)

theorem radius_preLow (d : E) : SpinRadiusLE (preLow d) (2*‖d‖) := by
  have h := ((radius_preVacuum (E := E)).preWZ ((2:ℝ) • d)).preRoot Y
  simpa only [preLow,norm_smul,Real.norm_of_nonneg (by norm_num : (0:ℝ)≤2),add_zero] using h

theorem bounded_preLow (n : ℕ) (b : ℝ) :
    ∀ᶠ t : ℝ in atTop,
      SpinRadiusLE (preLow (ordinaryDisplacement n b t)) (2*(2*|b|+1)) ∧
      spinMass (preLow (ordinaryDisplacement n b t)) ≤ matrixMass Y*(2*‖spinCoefficient‖) := by
  filter_upwards [ordinaryDisplacement_bounded n b] with t ht
  refine ⟨fun i => (radius_preLow _ i).mono ?_,mass_preLow _⟩
  exact mul_le_mul_of_nonneg_left ht (by norm_num)

theorem tendsto_inner_low_high (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪lowVector (ordinaryDisplacement n b t),
      (highDirection (n+1) (gamma b t):Level (n+2))⟫_ℂ) atTop (𝓝 0) := by
  simpa only [spinCoe_preLow] using tendsto_inner_high_uniform (n+1) b hb
    (fun t => preLow (ordinaryDisplacement n b t)) (2*(2*|b|+1))
    (matrixMass Y*(2*‖spinCoefficient‖)) (by positivity) (bounded_preLow n b)

theorem tendsto_inner_low_address (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪lowVector (ordinaryDisplacement n b t),actualAddress n b t⟫_ℂ)
      atTop (𝓝 0) := by
  simpa only [spinCoe_preLow] using tendsto_inner_address_uniform n b hb
    (fun t => preLow (ordinaryDisplacement n b t)) (2*(2*|b|+1))
    (matrixMass Y*(2*‖spinCoefficient‖)) (by positivity) (bounded_preLow n b)

variable {α : Type*} {l : Filter α}

theorem tendsto_inner_error_unit (x y z : α → E)
    (hxy : Tendsto (fun a => ‖x a-y a‖) l (𝓝 0)) (hz : ∀ a, ‖z a‖=1) :
    Tendsto (fun a => ⟪x a,z a⟫_ℂ-⟪y a,z a⟫_ℂ) l (𝓝 0) := by
  rw [tendsto_zero_iff_norm_tendsto_zero]
  apply squeeze_zero (fun _ => norm_nonneg _) (fun a => ?_) hxy
  rw [← inner_sub_left]
  simpa only [hz a,mul_one] using norm_inner_le_norm (𝕜 := ℂ) (x a-y a) (z a)

 
theorem tendsto_initialized_high (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪(initializedInsertion n b t:Level (n+2)),
      (highDirection (n+1) (gamma b t):Level (n+2))⟫_ℂ) atTop (𝓝 0) := by
  have he := tendsto_inner_error_unit
    (fun t => (initializedInsertion n b t:Level (n+2)))
    (fun t => lowVector (ordinaryDisplacement n b t))
    (fun t => (highDirection (n+1) (gamma b t):Level (n+2)))
    (tendsto_initializedInsertion_error n b) (fun _ => highDirection_norm (n+1) _)
  simpa only [sub_add_cancel,zero_add] using he.add (tendsto_inner_low_high n b hb)

theorem tendsto_initialized_address (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪(initializedInsertion n b t:Level (n+2)),actualAddress n b t⟫_ℂ)
      atTop (𝓝 0) := by
  have he := tendsto_inner_error_unit
    (fun t => (initializedInsertion n b t:Level (n+2)))
    (fun t => lowVector (ordinaryDisplacement n b t)) (actualAddress n b)
    (tendsto_initializedInsertion_error n b) (norm_actualAddress n b)
  simpa only [sub_add_cancel,zero_add] using he.add (tendsto_inner_low_address n b hb)

end SeedInitialization

namespace SeedInitialization
open CoherentFock RootSpin PointedTree Complex
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]

theorem inner_lowVector_creation (d v : E) :
    ⟪lowVector d,plusEmbedding (creationVacuum v)⟫_ℂ=
      (-2*Real.exp (-2*‖d‖^2):ℂ)*⟪d,v⟫_ℂ := by
  rw [lowVector,inner_rootY_WZ_creation]
  have hi : ⟪(2:ℝ) • d,v⟫_ℂ=(2:ℂ)*⟪d,v⟫_ℂ := by
    rw [← Complex.coe_smul,inner_smul_left,Complex.ofReal_ofNat,Complex.conj_ofNat]
  have hn : ‖(2:ℝ) • d‖^2=4*‖d‖^2 := by
    rw [norm_smul,Real.norm_of_nonneg (by norm_num : (0:ℝ)≤2)]
    ring
  rw [hi,hn,show -(4*‖d‖^2)/2= -2*‖d‖^2 by ring]
  ring

theorem tendsto_displacement_initialized (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪ordinaryDisplacement (n+1) b t,initializedInsertion n b t⟫_ℂ)
      atTop (𝓝 0) := by
  have he := tendsto_inner_error_unit
    (fun t => ordinaryDisplacement (n+1) b t)
    (fun t => (2*b:ℝ) • highDirection (n+1) (gamma b t))
    (initializedInsertion n b) (tendsto_ordinaryDisplacement_error (n+1) b)
    (norm_initializedInsertion n b)
  have hh := Complex.continuous_conj.continuousAt.tendsto.comp (tendsto_initialized_high n b hb)
  have hh' : Tendsto (fun t => ⟪(2*b:ℝ) • highDirection (n+1) (gamma b t),
      initializedInsertion n b t⟫_ℂ) atTop (𝓝 0) := by
    have h := hh.const_mul ((2*b:ℝ):ℂ)
    simpa only [Function.comp_def,inner_conj_symm,map_zero,mul_zero,
      ← Complex.coe_smul,inner_smul_left,Complex.conj_ofReal,Submodule.coe_inner] using h
  simpa only [sub_add_cancel,zero_add] using he.add hh'

theorem tendsto_low_rootShift (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪lowVector (ordinaryDisplacement (n+1) b t),
      (rootShift (n+2) (initializedInsertion n b t):Level (n+3))⟫_ℂ)
      atTop (𝓝 0) := by
  have hr := Real.continuous_exp.continuousAt.tendsto.comp
    (((tendsto_norm_ordinaryDisplacement (n+1) b).pow 2).const_mul (-2))
  have hc := (Complex.continuous_ofReal.continuousAt.tendsto.comp hr).const_mul (-2)
  have he (t : ℝ) :
      ⟪lowVector (ordinaryDisplacement (n+1) b t),
        (rootShift (n+2) (initializedInsertion n b t):Level (n+3))⟫_ℂ=
      (-2*Real.exp (-2*‖ordinaryDisplacement (n+1) b t‖^2):ℂ)*
        ⟪ordinaryDisplacement (n+1) b t,initializedInsertion n b t⟫_ℂ :=
    inner_lowVector_creation (ordinaryDisplacement (n+1) b t) (initializedInsertion n b t)
  simp_rw [he]
  simpa only [mul_zero,Function.comp_def] using
    hc.mul (tendsto_displacement_initialized n b hb)

theorem tendsto_initialized_rootShift (n : ℕ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ⟪(initializedInsertion (n+1) b t:Level (n+3)),
      (rootShift (n+2) (initializedInsertion n b t):Level (n+3))⟫_ℂ)
      atTop (𝓝 0) := by
  have he := tendsto_inner_error_unit
    (fun t => (initializedInsertion (n+1) b t:Level (n+3)))
    (fun t => lowVector (ordinaryDisplacement (n+1) b t))
    (fun t => (rootShift (n+2) (initializedInsertion n b t):Level (n+3)))
    (tendsto_initializedInsertion_error (n+1) b)
    (fun t => (rootShift (n+2)).norm_map (initializedInsertion n b t) |>.trans
      (norm_initializedInsertion n b t))
  simpa only [sub_add_cancel,zero_add] using he.add (tendsto_low_rootShift n b hb)

theorem tendsto_initialized_treeEnergy (n : ℕ) (hn : 2 ≤ n) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => treeEnergy (n+2) (initializedInsertion n b t)) atTop (𝓝 0) := by
  have hempty (t : ℝ) : centeredMap (empty (n+2)) (initializedInsertion n b t)=
      initializedInsertion (n+1) b t :=
    ordinary_insertion_empty _ (n+2) (by simp [initializationWord]; omega)
  have hi := Complex.continuous_re.continuousAt.tendsto.comp (tendsto_initialized_rootShift n b hb)
  simpa only [treeEnergy,hempty,Submodule.coe_inner,Function.comp_def,Complex.zero_re] using hi

 

theorem tendsto_initialization_ordinaryValue (b : ℝ) (hb : 0 < b) :
    Tendsto (fun t => ordinaryValue (initializationWord (gamma b t) (delta t) (Real.pi/4)))
      atTop (𝓝 0) := by
  have he (n : ℕ) (hn : 2 ≤ n) (t : ℝ) :
      treeEnergy (n+2) (initializedInsertion n b t)=
      ordinaryValue (initializationWord (gamma b t) (delta t) (Real.pi/4)) :=
    ordinary_energy_stable _ (n+2) (by simp [initializationWord]; omega)
  simpa only [he 2 (by omega)] using tendsto_initialized_treeEnergy 2 (by omega) b hb

end SeedInitialization

namespace ForwardControl
open Complex
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]

 

theorem scaled_residual_bound (r t ε η : ℝ) (hr : 0 < r) (v v' s w : H)
    (hv : ‖v'-v+(2:ℂ) • s‖ ≤ r*ε)
    (hs : ‖r⁻¹ • s-w‖ ≤ η) :
    ‖(t/r) • (v'-v)-(-2*t) • w‖ ≤ |t| *(ε+2*η) := by
  have he : (t/r) • (v'-v)-(-2*t) • w =
      t • (r⁻¹ • (v'-v+(2:ℂ) • s)-(2:ℝ) • (r⁻¹ • s-w)) := by
    simp only [two_smul,smul_add,smul_sub,smul_smul,div_eq_mul_inv]
    module
  rw [he,norm_smul,Real.norm_eq_abs]
  apply mul_le_mul_of_nonneg_left _ (abs_nonneg t)
  have h1 : ‖r⁻¹ • (v'-v+(2:ℂ) • s)‖ ≤ ε := by
    rw [norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hr)]
    calc
      _ ≤ r⁻¹*(r*ε) := mul_le_mul_of_nonneg_left hv (le_of_lt (inv_pos.mpr hr))
      _ = ε := by field_simp
  have h2 : ‖(2:ℝ) • (r⁻¹ • s-w)‖ ≤ 2*η := by
    rw [norm_smul,Real.norm_of_nonneg (by norm_num : (0:ℝ)≤2)]
    gcongr
  exact (norm_sub_le _ _).trans (add_le_add h1 h2)

 

theorem actual_scaled_flip_bound (U V : H ≃ₗᵢ[ℂ] H) (Z F : H →L[ℂ] H)
    (hZ : ∀x, ‖Z x‖ ≤ ‖x‖) (hanti : ∀x, Z (F x)=-F (Z x))
    (Ω o s w : H) (hx : U Ω=o+s) (r t ε η : ℝ) (hr : 0 < r)
    (h1 : ‖V o-o‖ ≤ r*ε) (h2 : ‖V s-F s‖ ≤ r*ε)
    (h3 : ‖V (Z o)-Z o‖ ≤ r*ε) (h4 : ‖V (Z s)-F (Z s)‖ ≤ r*ε)
    (ht : ‖r⁻¹ • U.symm (Z s)-w‖ ≤ η) :
    ‖(t/r) • (U.symm (V.symm (Z (V (U Ω))))-U.symm (Z (U Ω)))-
      (-2*t) • w‖ ≤ |t| *(4*ε+2*η) := by
  apply scaled_residual_bound r t (4*ε) η hr _ _ _ _ _ ht
  have hf := actual_flip_change U V Z F hZ hanti Ω o s hx
  linarith

end ForwardControl

namespace CoherentFock
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]

theorem WZ_difference_le (d e : E) (x : SpinSpace E) :
    ‖WZ d x-WZ e x‖ ≤ ‖WZ (d-e) x-x‖+‖d-e‖*‖e‖*‖x‖ := by
  have he : phase e (d-e) • (WZ d x-WZ e x)=
      WZ e (WZ (d-e) x-x)+(1-phase e (d-e)) • WZ e x := by
    have h := congrArg (fun T : SpinSpace E →L[ℂ] SpinSpace E => T x) (WZ_mul e (d-e))
    simp only [ContinuousLinearMap.comp_apply,smul_apply,show e+(d-e)=d by abel] at h
    rw [map_sub,h]
    module
  calc
    _ = ‖phase e (d-e) • (WZ d x-WZ e x)‖ := by rw [norm_smul,norm_phase,one_mul]
    _ ≤ ‖WZ e (WZ (d-e) x-x)‖+‖(1-phase e (d-e)) • WZ e x‖ := by
      rw [he]; exact norm_add_le _ _
    _ = ‖WZ (d-e) x-x‖+‖phase e (d-e)-1‖*‖x‖ := by
      rw [norm_smul,norm_WZ,norm_WZ,norm_sub_rev (1:ℂ)]
    _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_right (phase_sub_one_le e (d-e)) (norm_nonneg x)]

omit [InnerProductSpace ℂ E] in
theorem tailBound_le_second (x : PreSpace E) : tailBound x ≤ secondTailBound x := by
  classical
  simp only [tailBound,secondTailBound,Finsupp.sum]
  apply Finset.sum_le_sum
  intro d hd
  apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
  nlinarith [sq_nonneg ‖d‖]

theorem WZ_spinCoe_sub_le (h : E) (x : PreSpin E) :
    ‖WZ h (spinCoe x)-spinCoe x‖ ≤ ‖h‖*spinBound x := by
  calc
    _ ≤ ∑ i, ‖(WZ h (spinCoe x)-spinCoe x) i‖ := norm_spin_le_sum _
    _ ≤ ∑ i, ‖h‖*secondTailBound (x i) := by
      apply Finset.sum_le_sum
      intro i hi
      simp only [PiLp.sub_apply,WZ_apply,spinCoe_apply]
      have hb (h : E) := (W_coe_sub_le h (x i)).trans
        (mul_le_mul_of_nonneg_left (tailBound_le_second (x i)) (norm_nonneg h))
      split_ifs
      · exact hb h
      · simpa only [norm_neg] using hb (-h)
    _ = _ := by simp only [spinBound,Finset.mul_sum]

 

theorem WZ_spinCoe_difference (d e : E) (x : PreSpin E) {A B C : ℝ}
    (hx : SpinRadiusLE x B) (hB : 0 ≤ B) (hA : spinMass x ≤ A) (he : ‖e‖ ≤ C) :
    ‖WZ d (spinCoe x)-WZ e (spinCoe x)‖ ≤ ‖d-e‖*(A*(1+2*B+12*B^2)+C*A) := by
  have hM : ‖spinCoe x‖ ≤ A := (norm_spinCoe_le_mass x).trans hA
  have hN : 0 ≤ A := (spinMass_nonneg x).trans hA
  have hC : 0 ≤ C := (norm_nonneg e).trans he
  calc
    _ ≤ ‖WZ (d-e) (spinCoe x)-spinCoe x‖+‖d-e‖*‖e‖*‖spinCoe x‖ := WZ_difference_le _ _ _
    _ ≤ ‖d-e‖*spinBound x+‖d-e‖*C*A := by
      gcongr
      exact WZ_spinCoe_sub_le _ _
    _ ≤ ‖d-e‖*(A*(1+2*B+12*B^2))+‖d-e‖*C*A := by
      gcongr
      exact (spinBound_le_mass x hB hx).trans (by gcongr)
    _ = _ := by ring

end CoherentFock

namespace ForwardControl
open Complex
variable {H α : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] {l : Filter α}

theorem actual_scaled_flip_tendsto (U V : α → H ≃ₗᵢ[ℂ] H) (Z F : H →L[ℂ] H)
    (hZ : ∀x, ‖Z x‖ ≤ ‖x‖) (hanti : ∀x, Z (F x)=-F (Z x))
    (Ω : H) (o s w : α → H) (hx : ∀ a, U a Ω=o a+s a) (r ε η : α → ℝ) (t : ℝ)
    (hr : ∀ᶠ a in l, 0 < r a)
    (he : Tendsto ε l (𝓝 0)) (hh : Tendsto η l (𝓝 0))
    (h1 : ∀ᶠ a in l, ‖V a (o a)-o a‖ ≤ r a*ε a)
    (h2 : ∀ᶠ a in l, ‖V a (s a)-F (s a)‖ ≤ r a*ε a)
    (h3 : ∀ᶠ a in l, ‖V a (Z (o a))-Z (o a)‖ ≤ r a*ε a)
    (h4 : ∀ᶠ a in l, ‖V a (Z (s a))-F (Z (s a))‖ ≤ r a*ε a)
    (ht : ∀ᶠ a in l, ‖(r a)⁻¹ • (U a).symm (Z (s a))-w a‖ ≤ η a) :
    Tendsto (fun a => ‖(t/r a) • ((U a).symm ((V a).symm (Z (V a (U a Ω))))-
      (U a).symm (Z (U a Ω)))-(-2*t) • w a‖) l (𝓝 0) := by
  apply squeeze_zero' (Filter.Eventually.of_forall fun _ => norm_nonneg _) ?_
    (by simpa only [mul_zero,add_zero] using ((he.const_mul 4).add (hh.const_mul 2)).const_mul |t|)
  filter_upwards [hr,h1,h2,h3,h4,ht] with a ha h1 h2 h3 h4 ht
  exact actual_scaled_flip_bound (U a) (V a) Z F hZ hanti Ω (o a) (s a) (w a)
    (hx a) (r a) t (ε a) (η a) ha h1 h2 h3 h4 ht

end ForwardControl

namespace CoherentFock
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]

 

theorem echo_ordinary_error (t r : ℝ) (v v' : E) (V₁ V₂ : SpinSpace E ≃ₗᵢ[ℂ] SpinSpace E)
    (x : SpinSpace E) :
    ‖(phase ((t/r) • v') (-(t/r) • v))⁻¹ •
      V₂ (WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x)))-WZ ((t/r) • (v'-v)) x‖ ≤
      ‖V₁ (WZ (-(t/r) • v) x)-WZ (-(t/r) • v) x‖+
      ‖V₂ (WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x)))-
        WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x))‖ := by
  rw [← corrected_echo t r v v' x,← smul_sub,norm_smul,norm_inv,norm_phase,inv_one,one_mul]
  have he : V₂ (WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x)))-
      WZ ((t/r) • v') (WZ (-(t/r) • v) x) =
      (V₂ (WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x)))-
        WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x)))+
      (WZ ((t/r) • v') (V₁ (WZ (-(t/r) • v) x))-
        WZ ((t/r) • v') (WZ (-(t/r) • v) x)) := by abel
  rw [he]
  exact (norm_add_le _ _).trans (by rw [WZ_error]; exact le_of_eq (add_comm _ _))

 

theorem tendsto_moving_corrected_echo {α : Type*} {l : Filter α}
    (t : ℝ) (r : α → ℝ) (v v' w : α → E) (x : α → PreSpin E) (A B : ℝ)
    (hB : 0 ≤ B) (hx : ∀ᶠ a in l, SpinRadiusLE (x a) B ∧ spinMass (x a)≤A)
    (hw : ∀ a, ‖w a‖=1)
    (hg : Tendsto (fun a => ‖(t/r a) • (v' a-v a)-(-2*t) • w a‖) l (𝓝 0)) :
    Tendsto (fun a => ‖(phase ((t/r a) • v' a) (-(t/r a) • v a))⁻¹ •
      WZ ((t/r a) • v' a) (WZ (-(t/r a) • v a) (spinCoe (x a)))-
      WZ ((-2*t) • w a) (spinCoe (x a))‖) l (𝓝 0) := by
  simp_rw [corrected_echo]
  apply squeeze_zero' (Filter.Eventually.of_forall fun _ => norm_nonneg _) ?_
    (by simpa only [zero_mul] using hg.mul_const (A*(1+2*B+12*B^2)+|(-2*t)| *A))
  filter_upwards [hx] with a ha
  exact WZ_spinCoe_difference _ _ _ ha.1 hB ha.2
    (by rw [norm_smul,hw,mul_one,Real.norm_eq_abs])

end CoherentFock

namespace CoherentFock
open PointedTree Complex
variable {E F : Type*} [SeminormedAddCommGroup E] [InnerProductSpace ℂ E]
  [SeminormedAddCommGroup F] [InnerProductSpace ℂ F]
variable {ι κ α : Type*} [Fintype ι] [Fintype κ] {l : Filter α}

 

def spinPacket (a : ι → Fin 2 → ℂ) (d : ι → E) : SpinSpace E :=
  ∑ i, spinPair (a i 0 • coherent (d i)) (a i 1 • coherent (d i))

theorem inner_spinPacket (a : ι → Fin 2 → ℂ) (b : κ → Fin 2 → ℂ)
    (d : ι → E) (e : κ → E) :
    ⟪spinPacket a d,spinPacket b e⟫_ℂ=
      ∑ i, ∑ j, (conj (a i 0)*b j 0+conj (a i 1)*b j 1)*kernel (d i) (e j) := by
  simp only [spinPacket,sum_inner,inner_sum,inner_spinPair,inner_smul_left,inner_smul_right,
    inner_coherent]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i hi
  apply Finset.sum_congr rfl
  intro j hj
  ring

 

theorem inner_spinPacket_creation (a : ι → Fin 2 → ℂ) (d : ι → E) (h : E) :
    ⟪spinPacket a d,plusEmbedding (creationVacuum h)⟫_ℂ=
      ∑ i, (-I)*(conj (a i 0)+conj (a i 1))*spinCoefficient*
        (Real.exp (-‖d i‖^2/2):ℂ)*⟪d i,h⟫_ℂ := by
  simp only [spinPacket,sum_inner,plusEmbedding_pair,inner_spinPair,creationVacuum,
    inner_smul_left,inner_smul_right,inner_coherent_oneParticle]
  apply Finset.sum_congr rfl
  intro i hi
  ring

 
theorem tendsto_norm_sq_of_inner (d : α → E) (d₀ : F)
    (h : Tendsto (fun t => ⟪d t,d t⟫_ℂ) l (𝓝 ⟪d₀,d₀⟫_ℂ)) :
    Tendsto (fun t => ‖d t‖^2) l (𝓝 (‖d₀‖^2)) := by
  have hn (x : E) : (⟪x,x⟫_ℂ).re=‖x‖^2 := inner_self_eq_norm_sq (𝕜 := ℂ) x
  have hn₀ : (⟪d₀,d₀⟫_ℂ).re=‖d₀‖^2 := inner_self_eq_norm_sq (𝕜 := ℂ) d₀
  simpa only [Function.comp_def,hn,hn₀] using
    Complex.continuous_re.continuousAt.tendsto.comp h

theorem tendsto_kernel_of_gram (d e : α → E) (d₀ e₀ : F)
    (hd : Tendsto (fun t => ⟪d t,d t⟫_ℂ) l (𝓝 ⟪d₀,d₀⟫_ℂ))
    (he : Tendsto (fun t => ⟪e t,e t⟫_ℂ) l (𝓝 ⟪e₀,e₀⟫_ℂ))
    (hde : Tendsto (fun t => ⟪d t,e t⟫_ℂ) l (𝓝 ⟪d₀,e₀⟫_ℂ)) :
    Tendsto (fun t => kernel (d t) (e t)) l (𝓝 (kernel d₀ e₀)) := by
  have hd' := Complex.continuous_ofReal.continuousAt.tendsto.comp
    ((tendsto_norm_sq_of_inner d d₀ hd).neg.div_const 2)
  have he' := Complex.continuous_ofReal.continuousAt.tendsto.comp
    ((tendsto_norm_sq_of_inner e e₀ he).neg.div_const 2)
  exact Complex.continuous_exp.continuousAt.tendsto.comp ((hd'.add hde).add he')

 

theorem tendsto_inner_spinPacket (a : α → ι → Fin 2 → ℂ) (b : α → κ → Fin 2 → ℂ)
    (d : α → ι → E) (e : α → κ → E) (a₀ : ι → Fin 2 → ℂ) (b₀ : κ → Fin 2 → ℂ)
    (d₀ : ι → F) (e₀ : κ → F)
    (ha : ∀ i q, Tendsto (fun t => a t i q) l (𝓝 (a₀ i q)))
    (hb : ∀ j q, Tendsto (fun t => b t j q) l (𝓝 (b₀ j q)))
    (hd : ∀ i, Tendsto (fun t => ⟪d t i,d t i⟫_ℂ) l (𝓝 ⟪d₀ i,d₀ i⟫_ℂ))
    (he : ∀ j, Tendsto (fun t => ⟪e t j,e t j⟫_ℂ) l (𝓝 ⟪e₀ j,e₀ j⟫_ℂ))
    (hde : ∀ i j, Tendsto (fun t => ⟪d t i,e t j⟫_ℂ) l (𝓝 ⟪d₀ i,e₀ j⟫_ℂ)) :
    Tendsto (fun t => ⟪spinPacket (a t) (d t),spinPacket (b t) (e t)⟫_ℂ)
      l (𝓝 ⟪spinPacket a₀ d₀,spinPacket b₀ e₀⟫_ℂ) := by
  simp_rw [inner_spinPacket]
  apply tendsto_finsetSum
  intro i hi
  apply tendsto_finsetSum
  intro j hj
  have hc0 := ((Complex.continuous_conj.continuousAt.tendsto.comp (ha i 0)).mul (hb j 0))
  have hc1 := ((Complex.continuous_conj.continuousAt.tendsto.comp (ha i 1)).mul (hb j 1))
  exact (hc0.add hc1).mul (tendsto_kernel_of_gram _ _ _ _ (hd i) (he j) (hde i j))

 

theorem tendsto_inner_spinPacket_creation (a : α → ι → Fin 2 → ℂ) (d : α → ι → E)
    (h : α → E) (a₀ : ι → Fin 2 → ℂ) (d₀ : ι → F) (h₀ : F)
    (ha : ∀ i q, Tendsto (fun t => a t i q) l (𝓝 (a₀ i q)))
    (hd : ∀ i, Tendsto (fun t => ⟪d t i,d t i⟫_ℂ) l (𝓝 ⟪d₀ i,d₀ i⟫_ℂ))
    (hdh : ∀ i, Tendsto (fun t => ⟪d t i,h t⟫_ℂ) l (𝓝 ⟪d₀ i,h₀⟫_ℂ)) :
    Tendsto (fun t => ⟪spinPacket (a t) (d t),plusEmbedding (creationVacuum (h t))⟫_ℂ)
      l (𝓝 ⟪spinPacket a₀ d₀,plusEmbedding (creationVacuum h₀)⟫_ℂ) := by
  simp_rw [inner_spinPacket_creation]
  apply tendsto_finsetSum
  intro i hi
  have hc := ((Complex.continuous_conj.continuousAt.tendsto.comp (ha i 0)).add
    (Complex.continuous_conj.continuousAt.tendsto.comp (ha i 1))).const_mul (-I)
  have hnorm := Real.continuous_exp.continuousAt.tendsto.comp
    ((tendsto_norm_sq_of_inner _ _ (hd i)).neg.div_const 2)
  exact (((hc.mul_const spinCoefficient).mul
    (Complex.continuous_ofReal.continuousAt.tendsto.comp hnorm)).mul (hdh i))

end CoherentFock

namespace CoherentFock
variable {E X : Type*} [SeminormedAddCommGroup E] [InnerProductSpace ℂ E]
  [NormedAddCommGroup X] [NormedSpace ℝ X] {x : X}

 

theorem analyticAt_norm_sq_of_inner (d : X → E)
    (h : AnalyticAt ℝ (fun t => ⟪d t,d t⟫_ℂ) x) :
    AnalyticAt ℝ (fun t => ‖d t‖^2) x := by
  have hr : AnalyticAt ℝ (fun t => (⟪d t,d t⟫_ℂ).re) x :=
    (Complex.reCLM.analyticAt _).comp h
  convert hr using 1
  ext t
  exact (inner_self_eq_norm_sq (𝕜 := ℂ) (d t)).symm

theorem analyticAt_kernel_of_gram (d e : X → E)
    (hd : AnalyticAt ℝ (fun t => ⟪d t,d t⟫_ℂ) x)
    (he : AnalyticAt ℝ (fun t => ⟪e t,e t⟫_ℂ) x)
    (hde : AnalyticAt ℝ (fun t => ⟪d t,e t⟫_ℂ) x) :
    AnalyticAt ℝ (fun t => kernel (d t) (e t)) x := by
  have hd' : AnalyticAt ℝ (fun t => ((-‖d t‖^2/2:ℝ):ℂ)) x :=
    (Complex.ofRealCLM.analyticAt _).comp (analyticAt_norm_sq_of_inner d hd).neg.div_const
  have he' : AnalyticAt ℝ (fun t => ((-‖e t‖^2/2:ℝ):ℂ)) x :=
    (Complex.ofRealCLM.analyticAt _).comp (analyticAt_norm_sq_of_inner e he).neg.div_const
  exact (analyticAt_cexp.restrictScalars (𝕜 := ℝ)).comp ((hd'.add hde).add he')

theorem analyticAt_phase_of_gram (d e : X → E)
    (hde : AnalyticAt ℝ (fun t => ⟪d t,e t⟫_ℂ) x) :
    AnalyticAt ℝ (fun t => phase (d t) (e t)) x := by
  have him : AnalyticAt ℝ (fun t => (⟪d t,e t⟫_ℂ).im) x :=
    (Complex.imCLM.analyticAt _).comp hde
  have hc : AnalyticAt ℝ (fun t => ((⟪d t,e t⟫_ℂ).im:ℂ)) x :=
    (Complex.ofRealCLM.analyticAt _).comp him
  simpa only [phase,Complex.ofReal_neg,Function.comp_def,Pi.neg_apply,Pi.mul_apply] using
    (analyticAt_cexp.restrictScalars (𝕜 := ℝ)).comp (hc.neg.mul (show AnalyticAt ℝ (fun _ : X => (Complex.I : ℂ)) x from analyticAt_const))

 

theorem analyticAt_inner_spinPacket {ι κ : Type*} [Fintype ι] [Fintype κ]
    (a : X → ι → Fin 2 → ℂ) (b : X → κ → Fin 2 → ℂ)
    (d : X → ι → E) (e : X → κ → E)
    (ha : ∀i q, AnalyticAt ℝ (fun t => a t i q) x)
    (hb : ∀j q, AnalyticAt ℝ (fun t => b t j q) x)
    (hd : ∀i, AnalyticAt ℝ (fun t => ⟪d t i,d t i⟫_ℂ) x)
    (he : ∀j, AnalyticAt ℝ (fun t => ⟪e t j,e t j⟫_ℂ) x)
    (hde : ∀i j, AnalyticAt ℝ (fun t => ⟪d t i,e t j⟫_ℂ) x) :
    AnalyticAt ℝ (fun t => ⟪spinPacket (a t) (d t),spinPacket (b t) (e t)⟫_ℂ) x := by
  simp_rw [inner_spinPacket]
  apply Finset.analyticAt_fun_sum
  intro i hi
  apply Finset.analyticAt_fun_sum
  intro j hj
  have h0 : AnalyticAt ℝ (fun t => conj (a t i 0)) x :=
    (Complex.conjCLE.toContinuousLinearMap.analyticAt _).comp (ha i 0)
  have h1 : AnalyticAt ℝ (fun t => conj (a t i 1)) x :=
    (Complex.conjCLE.toContinuousLinearMap.analyticAt _).comp (ha i 1)
  exact ((h0.mul (hb j 0)).add (h1.mul (hb j 1))).mul
    (analyticAt_kernel_of_gram _ _ (hd i) (he j) (hde i j))

end CoherentFock

namespace CoherentFock
open PointedTree Complex
variable {E : Type*} [SeminormedAddCommGroup E] [InnerProductSpace ℂ E]
  {ι κ : Type*} [Fintype ι] [Fintype κ]

@[simp] theorem spinPacket_apply (a : ι → Fin 2 → ℂ) (d : ι → E) (q : Fin 2) :
    spinPacket a d q=∑i, a i q • coherent (d i) := by
  fin_cases q <;> simp [spinPacket]

theorem spinPacket_smul (z : ℂ) (a : ι → Fin 2 → ℂ) (d : ι → E) :
    z • spinPacket a d=spinPacket (fun i q => z*a i q) d := by
  ext q
  simp [Finset.smul_sum,mul_smul]

theorem spinPacket_sum (a : ι → Fin 2 → ℂ) (b : κ → Fin 2 → ℂ)
    (d : ι → E) (e : κ → E) :
    spinPacket a d+spinPacket b e=spinPacket (Sum.elim a b) (Sum.elim d e) := by
  ext q
  simp [Fintype.sum_sum_type]

theorem act_spinPacket (A : Matrix (Fin 2) (Fin 2) ℂ)
    (a : ι → Fin 2 → ℂ) (d : ι → E) :
    SpinOperators.act A (spinPacket a d)=spinPacket (fun i q => ∑j, A q j*a i j) d := by
  ext q
  simp only [SpinOperators.act_apply,spinPacket_apply,Finset.sum_smul,Finset.smul_sum,mul_smul]
  exact Finset.sum_comm

theorem WZ_spinPacket (h : E) (a : ι → Fin 2 → ℂ) (d : ι → E) :
    WZ h (spinPacket a d)=spinPacket
      (fun p : ι×Fin 2 => fun q => if q=p.2 then
        phase (if p.2=0 then h else -h) (d p.1)*a p.1 q else 0)
      (fun p : ι×Fin 2 => (if p.2=0 then h else -h)+d p.1) := by
  ext q
  fin_cases q <;>
    simp [WZ_apply,spinPacket_apply,Fintype.sum_prod_type,
      map_sum,map_smul,W_coherent,smul_smul,mul_comm]

end CoherentFock

end

end OAI