import OAI.InformationTheory.PhotonNumber.Basic
import OAI.Analysis.QuantumTrace.Basic

namespace OAI

noncomputable section

section
open scoped BigOperators ComplexConjugate ENNReal Topology
open MeasureTheory
open scoped ComplexConjugate

namespace WeightedShift
variable {I J : Type*}
abbrev H (I : Type*) := lp (fun _ : I => ℂ) 2

theorem hasSum_square (x : H I) : HasSum (fun i => ‖x i‖^2) (‖x‖^2) := by
  simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using lp.hasSum_norm (p := 2) (by norm_num) x

theorem pull_mem (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (_hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H J) :
    Memℓp (fun i => c i*x (f i)) 2 := by
  apply (memℓp_gen_iff (by norm_num : 0 < (2 : ENNReal).toReal)).mpr
  simp only [ENNReal.toReal_ofNat, Real.rpow_two]
  apply (((hasSum_square x).summable.comp_injective hf).mul_left (C^2)).of_nonneg_of_le
    (fun _ => sq_nonneg _)
  intro i
  rw [norm_mul, mul_pow]
  exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (norm_nonneg _) (hc i) 2) (sq_nonneg _)

def pull (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H J) : H I :=
  ⟨_, pull_mem f hf c C hC hc x⟩
@[simp] theorem pull_apply (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H J) (i : I) :
    pull f hf c C hC hc x i = c i*x (f i) := rfl

theorem pull_bound (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H J) :
    ‖pull f hf c C hC hc x‖ ≤ C*‖x‖ := by
  have h₁ : ‖pull f hf c C hC hc x‖^2 ≤ C^2*∑' i, ‖x (f i)‖^2 := by
    rw [← (hasSum_square (pull f hf c C hC hc x)).tsum_eq, ← tsum_mul_left]
    apply Summable.tsum_le_tsum (fun i => ?_) (hasSum_square _).summable
      (((hasSum_square x).summable.comp_injective hf).mul_left _)
    simp only [pull_apply, norm_mul, mul_pow]
    exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (norm_nonneg _) (hc i) 2) (sq_nonneg _)
  have h₂ : (∑' i, ‖x (f i)‖^2) ≤ ‖x‖^2 := by
    rw [← (hasSum_square x).tsum_eq]
    exact tsum_comp_le_tsum_of_inj (hasSum_square x).summable (fun _ => sq_nonneg _) hf
  have h₃ := mul_le_mul_of_nonneg_left h₂ (sq_nonneg C)
  nlinarith [norm_nonneg (pull f hf c C hC hc x), mul_nonneg hC (norm_nonneg x)]

def pullCLM (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) : H J →L[ℂ] H I :=
  LinearMap.mkContinuous
    { toFun := pull f hf c C hC hc
      map_add' := fun x y => by
        apply lp.ext
        funext i
        change c i*(x (f i)+y (f i)) = c i*x (f i)+c i*y (f i)
        ring
      map_smul' := fun z x => by
        apply lp.ext
        funext i
        change c i*(z*x (f i)) = z*(c i*x (f i))
        ring }
    C (pull_bound f hf c C hC hc)
@[simp] theorem pullCLM_apply (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H J) (i : I) :
    pullCLM f hf c C hC hc x i = c i*x (f i) := rfl

variable [DecidableEq I] [DecidableEq J]

theorem pullCLM_single (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (i : I) (z : ℂ) :
    pullCLM f hf c C hC hc (lp.single 2 (f i) z) = lp.single 2 i (c i*z) := by
  apply lp.ext
  funext k
  simp only [pullCLM_apply, lp.coeFn_single, Pi.single_apply]
  by_cases he : k = i
  · subst k; simp
  · have hh : f k ≠ f i := fun h => he (hf h)
    simp [he, hh]

omit [DecidableEq I] in
 theorem pullCLM_single_outside (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (j : J) (hj : ∀ i, f i ≠ j) (z : ℂ) :
    pullCLM f hf c C hC hc (lp.single 2 j z) = 0 := by
  apply lp.ext
  funext i
  simp [hj i]

 theorem adjoint_apply_image (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H I) (i : I) :
    (pullCLM f hf c C hC hc).adjoint x (f i) = conj (c i)*x i := by
  have hh := ContinuousLinearMap.adjoint_inner_right (pullCLM f hf c C hC hc)
    (lp.single 2 (f i) 1) x
  simpa only [pullCLM_single, mul_one, lp.inner_single_left, RCLike.inner_apply,
    map_one, one_mul, mul_comm] using hh

omit [DecidableEq I] in
 theorem adjoint_apply_outside (f : I → J) (hf : Function.Injective f) (c : I → ℂ)
    (C : ℝ) (hC : 0 ≤ C) (hc : ∀ i, ‖c i‖ ≤ C) (x : H I) (j : J) (hj : ∀ i, f i ≠ j) :
    (pullCLM f hf c C hC hc).adjoint x j = 0 := by
  have hh := ContinuousLinearMap.adjoint_inner_right (pullCLM f hf c C hC hc)
    (lp.single 2 j 1) x
  rw [pullCLM_single_outside f hf c C hC hc j hj, inner_zero_left] at hh
  simpa only [lp.inner_single_left, RCLike.inner_apply, map_one, mul_one] using hh

end WeightedShift

namespace Annihilation
open EntropyPhotonNumber QuantumTrace
variable {n : ℕ}

def up (j : Fin n) (k : NumberIndex n) : NumberIndex n := k + Pi.single j 1
@[simp] theorem up_same (j : Fin n) (k : NumberIndex n) : up j k j = k j+1 := by simp [up]
@[simp] theorem up_other (j l : Fin n) (hl : l ≠ j) (k : NumberIndex n) : up j k l = k l := by simp [up, Pi.single_eq_of_ne hl]
theorem up_injective (j : Fin n) : Function.Injective (up j) := by
  intro k l h
  exact add_right_cancel h
@[simp] theorem weight_up (j : Fin n) (k : NumberIndex n) : numberWeight (up j k) = numberWeight k+1 := by
  simp only [numberWeight, up, Pi.add_apply, Nat.cast_add, Finset.sum_add_distrib]
  have h : (∑ i : Fin n, (((Pi.single j 1 : Fin n → ℕ) i): ℝ)) = 1 := by
    simp only [Pi.single_apply]
    simp
  rw [h]
  ring

theorem coordinate_le_weight (j : Fin n) (k : NumberIndex n) : (k j:ℝ)+1 ≤ numberWeight k := by
  have h : (k j:ℝ) ≤ ∑ i : Fin n, (k i:ℝ) :=
    Finset.single_le_sum (fun i _ => Nat.cast_nonneg (k i)) (Finset.mem_univ j)
  dsimp [numberWeight]
  linarith

theorem sqrt_step_le_weight (j : Fin n) (k : NumberIndex n) : Real.sqrt ((k j:ℝ)+1) ≤ numberWeight (up j k) := by
  have h₁ := coordinate_le_weight j k
  have h₂ := numberWeight_one_le k
  have hs := Real.sq_sqrt (show 0 ≤ (k j:ℝ)+1 by positivity)
  have hp := Real.sqrt_nonneg ((k j:ℝ)+1)
  rw [weight_up]
  nlinarith

def coefficient (a b : ℕ) (j : Fin n) (k : NumberIndex n) : ℂ :=
  ((numberWeight k)^a*Real.sqrt ((k j:ℝ)+1)/(numberWeight (up j k))^b : ℝ)

theorem coefficient_bound (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) (k : NumberIndex n) : ‖coefficient a b j k‖ ≤ 1 := by
  have hk := numberWeight_one_le k
  have hu := numberWeight_one_le (up j k)
  have hkpos : 0 < numberWeight k := by linarith
  have hupos : 0 < numberWeight (up j k) := by linarith
  have hm : numberWeight k ≤ numberWeight (up j k) := by rw [weight_up]; linarith
  have hp : numberWeight k^a*Real.sqrt ((k j:ℝ)+1) ≤ numberWeight (up j k)^(a+1) := by
    rw [pow_succ]
    exact mul_le_mul (pow_le_pow_left₀ hkpos.le hm a) (sqrt_step_le_weight j k)
      (Real.sqrt_nonneg _) (pow_nonneg hupos.le _)
  have hpow : numberWeight (up j k)^(a+1) ≤ numberWeight (up j k)^b :=
    pow_le_pow_right₀ hu hab
  rw [coefficient, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
  exact (div_le_one (pow_pos hupos b)).mpr (hp.trans hpow)


def sandwich (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) : Fock n →L[ℂ] Fock n :=
  WeightedShift.pullCLM (up j) (up_injective j) (coefficient a b j) 1 (by norm_num)
    (coefficient_bound a b hab j)
@[simp] theorem sandwich_apply (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    sandwich a b hab j x k = coefficient a b j k*x (up j k) := rfl

theorem sandwich_norm_le (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) : ‖sandwich a b hab j‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ (by norm_num)
  intro x
  exact WeightedShift.pull_bound (up j) (up_injective j) _ 1 (by norm_num) (coefficient_bound a b hab j) x

end Annihilation

namespace Annihilation
open EntropyPhotonNumber QuantumTrace
open scoped ComplexConjugate
variable {n : ℕ}

theorem sqrt_step_le_base (j : Fin n) (k : NumberIndex n) : Real.sqrt ((k j:ℝ)+1) ≤ numberWeight k := by
  have h₁ := coordinate_le_weight j k
  have h₂ := numberWeight_one_le k
  have hs := Real.sq_sqrt (show 0 ≤ (k j:ℝ)+1 by positivity)
  nlinarith [Real.sqrt_nonneg ((k j:ℝ)+1)]

def creationCoefficient (a b : ℕ) (j : Fin n) (k : NumberIndex n) : ℂ :=
  ((numberWeight (up j k))^a*Real.sqrt ((k j:ℝ)+1)/(numberWeight k)^b : ℝ)

theorem creationCoefficient_bound (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) (k : NumberIndex n) :
    ‖creationCoefficient a b j k‖ ≤ 2^a := by
  have hk := numberWeight_one_le k
  have hkpos : 0 < numberWeight k := by linarith
  have hu : 0 < numberWeight (up j k) := by linarith [numberWeight_one_le (up j k)]
  have hup : numberWeight (up j k) ≤ 2*numberWeight k := by rw [weight_up]; linarith
  have hp : numberWeight (up j k)^a*Real.sqrt ((k j:ℝ)+1) ≤ 2^a*numberWeight k^(a+1) := by
    calc
      _ ≤ (2*numberWeight k)^a*numberWeight k := mul_le_mul
        (pow_le_pow_left₀ (by linarith [numberWeight_one_le (up j k)]) hup a)
        (sqrt_step_le_base j k) (Real.sqrt_nonneg _) (by positivity)
      _ = _ := by rw [mul_pow, pow_succ]; ring
  have hpow := mul_le_mul_of_nonneg_left (pow_le_pow_right₀ hk hab) (show (0:ℝ) ≤ 2^a by positivity)
  rw [creationCoefficient, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
  exact (div_le_iff₀ (pow_pos hkpos b)).mpr (hp.trans hpow)


def creationSandwich (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) : Fock n →L[ℂ] Fock n :=
  (WeightedShift.pullCLM (up j) (up_injective j) (creationCoefficient a b j) (2^a)
    (by positivity) (creationCoefficient_bound a b hab j)).adjoint

theorem creationSandwich_norm_le (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) :
    ‖creationSandwich a b hab j‖ ≤ 2^a := by
  rw [creationSandwich, LinearIsometryEquiv.norm_map]
  apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
  intro x
  exact WeightedShift.pull_bound (up j) (up_injective j) _ _ (by positivity) (creationCoefficient_bound a b hab j) x

@[simp] theorem creationSandwich_up (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    creationSandwich a b hab j x (up j k) = creationCoefficient a b j k*x k := by
  rw [creationSandwich, WeightedShift.adjoint_apply_image]
  simp only [creationCoefficient, Complex.conj_ofReal]

@[simp] theorem creationSandwich_zero (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) (x : Fock n)
    (k : NumberIndex n) (hk : k j = 0) : creationSandwich a b hab j x k = 0 := by
  rw [creationSandwich]
  apply WeightedShift.adjoint_apply_outside
  intro l hl
  have hh := congrFun hl j
  rw [up_same, hk] at hh
  omega

def down (j : Fin n) (k : NumberIndex n) : NumberIndex n := Function.update k j (k j-1)
@[simp] theorem up_down (j : Fin n) (k : NumberIndex n) (hk : 0 < k j) : up j (down j k) = k := by
  funext i
  by_cases he : i = j
  · subst i; simp [down, Nat.sub_add_cancel hk]
  · simp [down, he]
@[simp] theorem down_up (j : Fin n) (k : NumberIndex n) : down j (up j k) = k := by
  funext i
  by_cases he : i = j
  · subst i; simp [down]
  · simp [down, he]

 theorem index_cases (j : Fin n) (k : NumberIndex n) : k j = 0 ∨ ∃ l, k = up j l := by
  by_cases hk : k j = 0
  · exact Or.inl hk
  · exact Or.inr ⟨down j k, (up_down j k (Nat.pos_of_ne_zero hk)).symm⟩

 theorem coefficient_inverse_bound (m : ℕ) (k : NumberIndex n) : ‖((numberWeight k^m)⁻¹ : ℂ)‖ ≤ 1 := by
  rw [norm_inv, norm_pow, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (by linarith [numberWeight_one_le k])]
  exact inv_le_one_of_one_le₀ (one_le_pow₀ (numberWeight_one_le k))

def inverseWeight (m : ℕ) : Fock n →L[ℂ] Fock n :=
  WeightedShift.pullCLM id Function.injective_id (fun k => ((numberWeight k^m)⁻¹ : ℂ)) 1 (by norm_num)
    (coefficient_inverse_bound m)
@[simp] theorem inverseWeight_apply (m : ℕ) (x : Fock n) (k : NumberIndex n) :
    inverseWeight m x k = ((numberWeight k^m)⁻¹ : ℂ)*x k := rfl

theorem inverseWeight_injective (m : ℕ) : Function.Injective (inverseWeight (n := n) m) := by
  intro x y h
  apply lp.ext
  funext k
  have hh := congrArg (fun z : Fock n => z k) h
  simp only [inverseWeight_apply] at hh
  exact mul_left_cancel₀ (by exact inv_ne_zero (pow_ne_zero m (by exact_mod_cast (show numberWeight k ≠ 0 by linarith [numberWeight_one_le k])))) hh

theorem inverseWeight_add (a b : ℕ) : inverseWeight (n := n) (a+b) = inverseWeight a ∘L inverseWeight b := by
  ext x k
  simp only [inverseWeight_apply, ContinuousLinearMap.comp_apply, pow_add, mul_inv_rev]
  ring

 theorem sandwich_factor (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) :
    sandwich 0 b (by omega) j = inverseWeight a ∘L sandwich a b hab j := by
  ext x k
  have hn : (numberWeight k : ℂ) ≠ 0 := by exact_mod_cast (show numberWeight k ≠ 0 by linarith [numberWeight_one_le k])
  simp only [ContinuousLinearMap.comp_apply, inverseWeight_apply, sandwich_apply, coefficient,
    pow_zero, one_mul, Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_pow]
  field_simp

 theorem creationSandwich_factor (a b : ℕ) (hab : a+1 ≤ b) (j : Fin n) :
    creationSandwich 0 b (by omega) j = inverseWeight a ∘L creationSandwich a b hab j := by
  apply ContinuousLinearMap.ext
  intro x
  apply lp.ext
  funext k
  rcases index_cases j k with hk | ⟨l,rfl⟩
  · simp [creationSandwich_zero _ _ _ _ _ k hk]
  · have hn : (numberWeight (up j l) : ℂ) ≠ 0 := by exact_mod_cast (show numberWeight (up j l) ≠ 0 by linarith [numberWeight_one_le (up j l)])
    simp only [ContinuousLinearMap.comp_apply, inverseWeight_apply, creationSandwich_up, creationCoefficient,
      pow_zero, one_mul, Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_pow]
    field_simp

end Annihilation

namespace Annihilation
open EntropyPhotonNumber QuantumTrace
variable {n : ℕ}

def lowering (j : Fin n) : Fock n →L[ℂ] Fock n := sandwich 0 1 (by omega) j
def raising (j : Fin n) : Fock n →L[ℂ] Fock n := creationSandwich 0 1 (by omega) j

@[simp] theorem lowering_apply (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    lowering j x k = (Real.sqrt ((k j:ℝ)+1) : ℂ)*inverseWeight 1 x (up j k) := by
  simp only [lowering, sandwich_apply, coefficient, pow_zero, one_mul, pow_one,
    Complex.ofReal_div, inverseWeight_apply]
  ring

@[simp] theorem raising_up (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    raising j x (up j k) = (Real.sqrt ((k j:ℝ)+1) : ℂ)*inverseWeight 1 x k := by
  simp only [raising, creationSandwich_up, creationCoefficient, pow_zero, one_mul,
    pow_one, Complex.ofReal_div, inverseWeight_apply]
  ring

@[simp] theorem raising_zero (j : Fin n) (x : Fock n) (k : NumberIndex n) (hk : k j = 0) :
    raising j x k = 0 := creationSandwich_zero _ _ _ _ _ _ hk

 theorem lowering_sq (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    ‖lowering j x k‖^2 = ((k j:ℝ)+1)*‖inverseWeight 1 x (up j k)‖^2 := by
  rw [lowering_apply, norm_mul, mul_pow, Complex.norm_real, Real.norm_eq_abs, sq_abs,
    Real.sq_sqrt (by positivity)]

 theorem raising_sq (j : Fin n) (x : Fock n) (k : NumberIndex n) :
    ‖raising j x (up j k)‖^2 = ((k j:ℝ)+1)*‖inverseWeight 1 x k‖^2 := by
  rw [raising_up, norm_mul, mul_pow, Complex.norm_real, Real.norm_eq_abs, sq_abs,
    Real.sq_sqrt (by positivity)]

 theorem lowering_norm_sum (j : Fin n) (x : Fock n) :
    HasSum (fun k : NumberIndex n => (k j:ℝ)*‖inverseWeight 1 x k‖^2) (‖lowering j x‖^2) := by
  have hh := WeightedShift.hasSum_square (lowering j x)
  simp only [lowering_sq] at hh
  have hz (k : NumberIndex n) (hk : k ∉ Set.range (up j)) :
      (k j:ℝ)*‖inverseWeight 1 x k‖^2 = 0 := by
    rcases index_cases j k with he | ⟨l,rfl⟩
    · simp [he]
    · exact (hk ⟨l,rfl⟩).elim
  apply (up_injective j).hasSum_iff hz |>.mp
  simpa only [Function.comp_def, up_same, Nat.cast_add, Nat.cast_one] using hh

 theorem raising_norm_sum (j : Fin n) (x : Fock n) :
    HasSum (fun k : NumberIndex n => ((k j:ℝ)+1)*‖inverseWeight 1 x k‖^2) (‖raising j x‖^2) := by
  have hz (k : NumberIndex n) (hk : k ∉ Set.range (up j)) : ‖raising j x k‖^2 = 0 := by
    rcases index_cases j k with he | ⟨l,rfl⟩
    · simp [raising_zero _ _ _ he]
    · exact (hk ⟨l,rfl⟩).elim
  have hh := (up_injective j).hasSum_iff hz |>.mpr (WeightedShift.hasSum_square (raising j x))
  simpa only [Function.comp_def, raising_sq] using hh


 theorem canonical_norm_identity (j : Fin n) (x : Fock n) :
    ‖raising j x‖^2 = ‖lowering j x‖^2+‖inverseWeight 1 x‖^2 := by
  have hh := (lowering_norm_sum j x).add (WeightedShift.hasSum_square (inverseWeight 1 x))
  have he : HasSum (fun k : NumberIndex n => ((k j:ℝ)+1)*‖inverseWeight 1 x k‖^2)
      (‖lowering j x‖^2+‖inverseWeight 1 x‖^2) := by
    convert! hh using 1
    ext k
    ring
  exact (raising_norm_sum j x).unique he

 theorem inverseWeight_selfAdjoint (m : ℕ) : IsSelfAdjoint (inverseWeight (n := n) m) := by
  apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr
  intro x y
  apply HasSum.unique (lp.hasSum_inner (𝕜 := ℂ) (inverseWeight m x) y)
  convert! lp.hasSum_inner (𝕜 := ℂ) x (inverseWeight m y) using 1
  ext k
  simp only [inverseWeight_apply, RCLike.inner_apply, map_mul, map_inv₀, map_pow,
    Complex.conj_ofReal]
  ring

 theorem lowering_adjoint_inverse (j : Fin n) :
    (lowering j).adjoint ∘L inverseWeight 1 = inverseWeight 1 ∘L raising j := by
  apply ContinuousLinearMap.ext
  intro x
  apply lp.ext
  funext k
  rcases index_cases j k with hk | ⟨l,rfl⟩
  · have hn : ∀ l, up j l ≠ k := by intro l he; have hh := congrFun he j; rw [up_same, hk] at hh; omega
    change (lowering j).adjoint (inverseWeight 1 x) k = inverseWeight 1 (raising j x) k
    have hh := WeightedShift.adjoint_apply_outside (up j) (up_injective j) (coefficient 0 1 j) 1 (by norm_num) (coefficient_bound 0 1 (by omega) j) (inverseWeight 1 x) k hn
    change (lowering j).adjoint (inverseWeight 1 x) k = 0 at hh
    rw [hh]
    simp [inverseWeight_apply, raising_zero _ _ _ hk]
  · change (lowering j).adjoint (inverseWeight 1 x) (up j l) = inverseWeight 1 (raising j x) (up j l)
    have hh := WeightedShift.adjoint_apply_image (up j) (up_injective j) (coefficient 0 1 j) 1 (by norm_num) (coefficient_bound 0 1 (by omega) j) (inverseWeight 1 x) l
    change (lowering j).adjoint (inverseWeight 1 x) (up j l) = _ at hh
    rw [hh]
    have hc : (starRingEnd ℂ) (coefficient 0 1 j l) = coefficient 0 1 j l :=
      Complex.conj_ofReal _
    rw [hc]
    simp only [coefficient, pow_zero, one_mul, pow_one,
      raising_up, inverseWeight_apply, Complex.ofReal_div]
    ring

 theorem ladder_adjoint_pairing (j : Fin n) (x y : Fock n) :
    inner ℂ (lowering j x) (inverseWeight 1 y) = inner ℂ (inverseWeight 1 x) (raising j y) := by
  rw [← ContinuousLinearMap.adjoint_inner_right]
  have hh := congrArg (fun T : Fock n →L[ℂ] Fock n => T y) (lowering_adjoint_inverse j)
  change (lowering j).adjoint (inverseWeight 1 y) = inverseWeight 1 (raising j y) at hh
  rw [hh]
  exact (ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mp (inverseWeight_selfAdjoint 1) x (raising j y)).symm

end Annihilation

namespace CrossEnsemble
variable {I J E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]

def operator (u v : I → E) : E →L[ℂ] E := ∑' i, InnerProductSpace.rankOne ℂ (u i) (v i)

omit [InnerProductSpace ℂ E] [CompleteSpace E] in
theorem norm_product_summable {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) : Summable (fun i => ‖u i‖*‖v i‖) := by
  apply Summable.of_nonneg_of_le (fun i => mul_nonneg (norm_nonneg _) (norm_nonneg _)) _ (hu.add hv)
  intro i
  nlinarith [sq_nonneg (‖u i‖-‖v i‖)]

theorem hasSum_operator {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) :
    HasSum (fun i => InnerProductSpace.rankOne ℂ (u i) (v i)) (operator u v) := by
  apply Summable.hasSum
  apply Summable.of_norm
  simpa only [InnerProductSpace.norm_rankOne] using norm_product_summable hu hv

theorem entry_hasSum {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) (x y : E) :
    HasSum (fun i => inner ℂ x (u i)*inner ℂ (v i) y) (inner ℂ x (operator u v y)) := by
  convert! ((hasSum_operator hu hv).mapL (ContinuousLinearMap.apply ℂ E y)).mapL (innerSL ℂ x) using 1
  ext i
  simp [InnerProductSpace.rankOne_apply, mul_comm]

omit [CompleteSpace E] in
theorem square_coordinates_summable (b : HilbertBasis J ℂ E) {u : I → E}
    (hu : Summable (fun i => ‖u i‖^2)) :
    Summable (fun ij : I × J => ‖inner ℂ (b ij.2) (u ij.1)‖^2) := by
  apply (summable_prod_of_nonneg (fun _ => sq_nonneg _)).mpr
  have hh (i : I) : HasSum (fun j => ‖inner ℂ (b j) (u i)‖^2) (‖u i‖^2) := by
    have ht := (b.hasSum_inner_mul_inner (u i) (u i)).mapL Complex.reCLM
    convert! ht using 1
    · ext j
      rw [← inner_conj_symm (u i) (b j), mul_comm, Complex.mul_conj]
      simp only [Complex.reCLM_apply, Complex.normSq_eq_norm_sq, Complex.ofReal_re]
    · simp [← Complex.ofReal_pow]
  refine ⟨fun i => (hh i).summable, ?_⟩
  simpa only [(hh _).tsum_eq] using hu

omit [CompleteSpace E] in
theorem trace_norm_summable (b : HilbertBasis J ℂ E) {u v : I → E}
    (hu : Summable (fun i => ‖u i‖^2)) (hv : Summable (fun i => ‖v i‖^2)) :
    Summable (fun ij : I × J => ‖inner ℂ (b ij.2) (u ij.1)*inner ℂ (v ij.1) (b ij.2)‖) := by
  apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _
    ((square_coordinates_summable b hu).add (square_coordinates_summable b hv))
  intro ij
  rw [norm_mul, norm_inner_symm (v ij.1)]
  nlinarith [sq_nonneg (‖inner ℂ (b ij.2) (u ij.1)‖-‖inner ℂ (b ij.2) (v ij.1)‖)]

def pairing (u v : I → E) (Z : E →L[ℂ] E) : ℂ := ∑' i, inner ℂ (v i) (Z (u i))

omit [CompleteSpace E] in
theorem applied_summable {u : I → E} (hu : Summable (fun i => ‖u i‖^2)) (Z : E →L[ℂ] E) :
    Summable (fun i => ‖Z (u i)‖^2) := by
  apply Summable.of_nonneg_of_le (fun _ => sq_nonneg _) _ (hu.mul_left (‖Z‖^2))
  intro i
  calc
    _ ≤ (‖Z‖*‖u i‖)^2 := pow_le_pow_left₀ (norm_nonneg _) (Z.le_opNorm _) _
    _ = _ := mul_pow _ _ _

omit [CompleteSpace E] in
theorem pairing_summable {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) (Z : E →L[ℂ] E) :
    Summable (fun i => inner ℂ (v i) (Z (u i))) :=
  (norm_product_summable hv (applied_summable hu Z)).of_norm_bounded
    (fun _i => norm_inner_le_norm _ _)

theorem trace_hasSum (b : HilbertBasis J ℂ E) {u v : I → E}
    (hu : Summable (fun i => ‖u i‖^2)) (hv : Summable (fun i => ‖v i‖^2)) :
    HasSum (fun j => inner ℂ (b j) (operator u v (b j)))
      (∑' i, inner ℂ (v i) (u i)) := by
  have hh := (trace_norm_summable b hu hv).of_norm
  have hi (i : I) : HasSum (fun j => inner ℂ (b j) (u i)*inner ℂ (v i) (b j)) (inner ℂ (v i) (u i)) := by
    simpa only [mul_comm] using b.hasSum_inner_mul_inner (v i) (u i)
  have he (j : J) := entry_hasSum hu hv (b j) (b j)
  have hf := hh.hasSum.prod_fiberwise (f := fun ij : I × J => inner ℂ (b ij.2) (u ij.1)*inner ℂ (v ij.1) (b ij.2)) hi
  have hg := hh.prod_symm.hasSum.prod_fiberwise (f := fun ji : J × I => inner ℂ (b ji.1) (u ji.2)*inner ℂ (v ji.2) (b ji.1)) he
  have ht : (∑' j, inner ℂ (b j) (operator u v (b j)))=∑' i, inner ℂ (v i) (u i) := by
    rw [hg.tsum_eq, hf.tsum_eq]
    exact (Equiv.prodComm J I).tsum_eq (fun ij : I × J => inner ℂ (b ij.2) (u ij.1)*inner ℂ (v ij.1) (b ij.2))
  exact ht ▸ hg.summable.hasSum

theorem operator_comp_left {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) (Z : E →L[ℂ] E) :
    Z ∘L operator u v=operator (fun i => Z (u i)) v := by
  apply ContinuousLinearMap.ext
  intro y
  apply ext_inner_left ℂ
  intro x
  have hh := ((hasSum_operator hu hv).mapL (ContinuousLinearMap.apply ℂ E y)).mapL Z
  have ht := hh.mapL (innerSL ℂ x)
  have ht' : HasSum (fun i => inner ℂ x (Z (u i))*inner ℂ (v i) y)
      (inner ℂ x (Z (operator u v y))) := by
    convert! ht using 1
    ext i
    simp [InnerProductSpace.rankOne_apply, mul_comm]
  exact ht'.unique (entry_hasSum (applied_summable hu Z) hv x y)

theorem pairing_trace (b : HilbertBasis J ℂ E) {u v : I → E}
    (hu : Summable (fun i => ‖u i‖^2)) (hv : Summable (fun i => ‖v i‖^2)) (Z : E →L[ℂ] E) :
    HasSum (fun j => inner ℂ (b j) (Z (operator u v (b j)))) (pairing u v Z) := by
  have hh := trace_hasSum b (applied_summable hu Z) hv
  rw [← operator_comp_left hu hv Z] at hh
  exact hh

 theorem pairing_eq_of_operator_eq {K : Type*} (b : HilbertBasis J ℂ E)
    {u v : I → E} {x y : K → E}
    (hu : Summable (fun i => ‖u i‖^2)) (hv : Summable (fun i => ‖v i‖^2))
    (hx : Summable (fun i => ‖x i‖^2)) (hy : Summable (fun i => ‖y i‖^2))
    (he : operator u v=operator x y) (Z : E →L[ℂ] E) : pairing u v Z=pairing x y Z := by
  apply HasSum.unique (pairing_trace b hu hv Z)
  rw [he]
  exact pairing_trace b hx hy Z
end CrossEnsemble

namespace CrossEnsemble
open scoped BigOperators ComplexConjugate
variable {I J E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]

theorem operator_adjoint {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) : (operator u v).adjoint=operator v u := by
  apply ContinuousLinearMap.ext
  intro y
  apply ext_inner_left ℂ
  intro x
  rw [ContinuousLinearMap.adjoint_inner_right]
  have hh := (entry_hasSum hu hv y x).mapL Complex.conjCLE.toContinuousLinearMap
  change HasSum (fun i => conj (inner ℂ y (u i)*inner ℂ (v i) x))
    (conj (inner ℂ y (operator u v x))) at hh
  simp only [map_mul, inner_conj_symm] at hh
  have hh' : HasSum (fun i => inner ℂ x (v i)*inner ℂ (u i) y)
      (inner ℂ (operator u v x) y) := by
    convert! hh using 1
    ext i
    ring
  exact hh'.unique (entry_hasSum hv hu x y)

theorem operator_sandwich {u v : I → E} (hu : Summable (fun i => ‖u i‖^2))
    (hv : Summable (fun i => ‖v i‖^2)) (Z : E →L[ℂ] E) :
    Z ∘L operator u v ∘L Z.adjoint=operator (fun i => Z (u i)) (fun i => Z (v i)) := by
  have hr : operator u v ∘L Z.adjoint=operator u (fun i => Z (v i)) := by
    have hh := congrArg ContinuousLinearMap.adjoint (operator_comp_left hv hu Z)
    simpa only [ContinuousLinearMap.adjoint_comp, operator_adjoint hv hu,
      operator_adjoint (applied_summable hv Z) hu] using hh
  rw [hr, operator_comp_left hu (applied_summable hv Z) Z]
end CrossEnsemble

namespace Annihilation
open EntropyPhotonNumber QuantumTrace
open scoped BigOperators ComplexConjugate
variable {n : ℕ}

def modeBound (j : Fin n) (upward : Bool) : Fock n →L[ℂ] Fock n :=
  WeightedShift.pullCLM id Function.injective_id
    (fun k => (((k j:ℝ)+(if upward then 1 else 0))/numberWeight k : ℝ)) 1 (by norm_num) (by
    intro k
    have hk := numberWeight_one_le k
    have hc := coordinate_le_weight j k
    have hp : 0 < numberWeight k := by linarith
    rw [Complex.norm_real, Real.norm_of_nonneg (by positivity)]
    apply (div_le_iff₀ hp).mpr
    cases upward <;> norm_num at * <;> linarith)

@[simp] theorem modeBound_apply (j : Fin n) (upward : Bool) (x : Fock n) (k : NumberIndex n) :
    modeBound j upward x k =
      ((((k j:ℝ)+(if upward then 1 else 0))/numberWeight k : ℝ):ℂ)*x k := rfl

theorem modeBound_selfAdjoint (j : Fin n) (upward : Bool) : IsSelfAdjoint (modeBound j upward) := by
  apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr
  intro x y
  apply HasSum.unique (lp.hasSum_inner (𝕜 := ℂ) (modeBound j upward x) y)
  convert! lp.hasSum_inner (𝕜 := ℂ) x (modeBound j upward y) using 1
  ext k
  simp only [modeBound_apply, RCLike.inner_apply, map_mul, Complex.conj_ofReal]
  ring

theorem modeBound_inverse_commute (j : Fin n) (upward : Bool) (m : ℕ) :
    modeBound j upward ∘L inverseWeight m=inverseWeight m ∘L modeBound j upward := by
  ext x k
  simp only [ContinuousLinearMap.comp_apply, modeBound_apply, inverseWeight_apply]
  ring

theorem sandwich_right_inverse (a b t : ℕ) (hab : a+1 ≤ b) (j : Fin n) :
    sandwich a (b+t) (by omega) j = sandwich a b hab j ∘L inverseWeight t := by
  ext x k
  simp only [sandwich_apply, coefficient, inverseWeight_apply, ContinuousLinearMap.comp_apply,
    Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_pow, pow_add]
  ring

theorem creationSandwich_right_inverse (a b t : ℕ) (hab : a+1 ≤ b) (j : Fin n) :
    creationSandwich a (b+t) (by omega) j = creationSandwich a b hab j ∘L inverseWeight t := by
  apply ContinuousLinearMap.ext
  intro x
  apply lp.ext
  funext k
  rcases index_cases j k with hk | ⟨l,rfl⟩
  · simp [creationSandwich_zero _ _ _ _ _ k hk]
  · simp only [creationSandwich_up, creationCoefficient, inverseWeight_apply, ContinuousLinearMap.comp_apply,
      Complex.ofReal_div, Complex.ofReal_mul, Complex.ofReal_pow, pow_add]
    ring

def gain (j : Fin n) (upward : Bool) : Fock n →L[ℂ] Fock n :=
  if upward then creationSandwich 2 3 (by omega) j else sandwich 2 3 (by omega) j

def unweightedGain (j : Fin n) (upward : Bool) : Fock n →L[ℂ] Fock n :=
  if upward then raising j else lowering j

theorem gain_factor (j : Fin n) (upward : Bool) :
    inverseWeight 2 ∘L gain j upward=unweightedGain j upward ∘L inverseWeight 2 := by
  cases upward
  · exact (sandwich_factor 2 3 (by omega) j).symm.trans (sandwich_right_inverse 0 1 2 (by omega) j)
  · exact (creationSandwich_factor 2 3 (by omega) j).symm.trans (creationSandwich_right_inverse 0 1 2 (by omega) j)

theorem quadratic_coordinate (w t : ℝ) (hw : 0 < w) (z : ℂ) :
    ((w:ℂ)^2)⁻¹ * ((t:ℂ)/(w:ℂ)*z) * (((w:ℂ)^3)⁻¹*conj z)=
      (t:ℂ)*((((|w|:ℝ):ℂ)^3)⁻¹*(‖z‖:ℂ))^2 := by
  rw [abs_of_pos hw]
  calc
    _ = (t:ℂ)*(w:ℂ)⁻¹^6*(z*conj z) := by ring
    _ = _ := by
      rw [Complex.mul_conj, Complex.normSq_eq_norm_sq, Complex.ofReal_pow]
      ring

theorem mode_quadratic (j : Fin n) (upward : Bool) (x : Fock n) :
    inner ℂ (inverseWeight 3 x) (inverseWeight 2 (modeBound j upward x))=
      (‖unweightedGain j upward (inverseWeight 2 x)‖^2:ℝ) := by
  have hh : HasSum (fun k : NumberIndex n =>
      ((k j:ℝ)+(if upward then 1 else 0))*‖inverseWeight 3 x k‖^2)
      (‖unweightedGain j upward (inverseWeight 2 x)‖^2) := by
    have hi : inverseWeight 1 (inverseWeight 2 x)=inverseWeight 3 x := by
      exact congrArg (fun T : Fock n →L[ℂ] Fock n => T x) (inverseWeight_add 1 2).symm
    cases upward
    · simpa only [Bool.false_eq_true, ↓reduceIte, add_zero, unweightedGain, hi] using lowering_norm_sum j (inverseWeight 2 x)
    · simpa only [↓reduceIte, unweightedGain, hi] using raising_norm_sum j (inverseWeight 2 x)
  apply HasSum.unique (lp.hasSum_inner (𝕜 := ℂ) (inverseWeight 3 x) (inverseWeight 2 (modeBound j upward x)))
  convert! hh.mapL Complex.ofRealCLM using 1
  ext k
  simp only [RCLike.inner_apply, inverseWeight_apply, modeBound_apply, Complex.ofRealCLM_apply,
    map_mul, map_inv₀, map_pow, Complex.conj_ofReal, norm_mul, norm_inv, norm_pow,
    Complex.norm_real, Real.norm_eq_abs, Complex.ofReal_mul, Complex.ofReal_pow,
    Complex.ofReal_inv, Complex.ofReal_div]
  exact quadratic_coordinate _ _ (by have := numberWeight_one_le k; linarith) (x k)
end Annihilation

namespace WeightedGenerator
open EntropyPhotonNumber Annihilation
open scoped BigOperators
variable {n : ℕ} {I J : Type*}


def dissipator (x : I → Fock n) (j : Fin n) (upward : Bool) : Fock n →L[ℂ] Fock n :=
  CrossEnsemble.operator (fun i => gain j upward (x i)) (fun i => gain j upward (x i))-
    (2:ℂ)⁻¹ • (CrossEnsemble.operator (fun i => modeBound j upward (x i)) (fun i => inverseWeight 1 (x i))+
      CrossEnsemble.operator (fun i => inverseWeight 1 (x i)) (fun i => modeBound j upward (x i)))

def generator (r : ℝ) (x : I → Fock n) : Fock n →L[ℂ] Fock n :=
  ∑ j, (((r+1:ℝ):ℂ) • dissipator x j false+(r:ℂ) • dissipator x j true)

def pairing (r : ℝ) (x : I → Fock n) (Z : Fock n →L[ℂ] Fock n) : ℂ :=
  ∑ j, (((r+1:ℝ):ℂ)*(CrossEnsemble.pairing (fun i => gain j false (x i)) (fun i => gain j false (x i)) Z-
      (2:ℂ)⁻¹*(CrossEnsemble.pairing (fun i => modeBound j false (x i)) (fun i => inverseWeight 1 (x i)) Z+
        CrossEnsemble.pairing (fun i => inverseWeight 1 (x i)) (fun i => modeBound j false (x i)) Z))+
    (r:ℂ)*(CrossEnsemble.pairing (fun i => gain j true (x i)) (fun i => gain j true (x i)) Z-
      (2:ℂ)⁻¹*(CrossEnsemble.pairing (fun i => modeBound j true (x i)) (fun i => inverseWeight 1 (x i)) Z+
        CrossEnsemble.pairing (fun i => inverseWeight 1 (x i)) (fun i => modeBound j true (x i)) Z)))

theorem pairing_hasSum (b : HilbertBasis J ℂ (Fock n)) (r : ℝ) (x : I → Fock n)
    (hx : Summable (fun i => ‖x i‖^2)) (Z : Fock n →L[ℂ] Fock n) :
    HasSum (fun k => inner ℂ (b k) (Z (generator r x (b k)))) (pairing r x Z) := by
  have ha (j : Fin n) (u : Bool) := CrossEnsemble.applied_summable hx (gain j u)
  have hb (j : Fin n) (u : Bool) := CrossEnsemble.applied_summable hx (modeBound j u)
  have hc := CrossEnsemble.applied_summable hx (inverseWeight 1)
  have h (j : Fin n) (u : Bool) :=
    (CrossEnsemble.pairing_trace b (ha j u) (ha j u) Z).sub
      (((CrossEnsemble.pairing_trace b (hb j u) hc Z).add
        (CrossEnsemble.pairing_trace b hc (hb j u) Z)).mul_left (2:ℂ)⁻¹)
  have hh := hasSum_sum fun j (_hj : j ∈ (Finset.univ : Finset (Fin n))) =>
    ((h j false).mul_left ((r+1:ℝ):ℂ)).add ((h j true).mul_left (r:ℂ))
  convert! hh using 1
  ext k
  simp only [generator, dissipator, sum_apply, add_apply,
    sub_apply, smul_apply, map_sum, map_add, map_sub, map_smul,
    inner_sum, inner_sub_right, inner_add_right, inner_smul_right]

end WeightedGenerator

end

end

end OAI