import Mathlib
import OAI.MathematicalPhysics.PEPSFilters.LocalOperators
import OAI.MathematicalPhysics.PEPSSubvolume.MixedKernel
import OAI.MathematicalPhysics.PEPSSubvolume.UnitaryVariation
import OAI.MathematicalPhysics.PEPSSubvolume.TraceFunctionals

namespace OAI

/-! Local transition functionals and descending trace stripping. -/

noncomputable section
open scoped BigOperators ComplexOrder
open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator
open scoped BigOperators
open scoped Topology
open Filter
open scoped MatrixOrder
open PolynomialPEPS.PinnedEntropy

namespace PolynomialPEPS.Subvolume.ActualTransition
open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator
open PolynomialPEPS.Subvolume.OptimizerGauge PolynomialPEPS.Subvolume.ActualKernel
open PolynomialPEPS.Subvolume.SpectralCurve PolynomialPEPS.Subvolume.KernelPerturbation
variable {L q : ℕ}

def replacementOutput (A : ℕ → Operator L q) (S : Finset (Vertex L))
    (ψ : State L q) (k n : ℕ) (hk : k<n) :
    Matrix (RegionConfiguration q S) (RegionConfiguration q S) ℂ →ₗ[ℂ] State L q where
  toFun H := asMap (L := L) (q := q)
    (orderedPrefix (Function.update A k (liftLocal S H)) n) ψ
  map_add' H K := by
    rw [liftLocal_add,prefix_update_add A k n hk]
    change Matrix.toEuclideanCLM (𝕜 := ℂ) (_+_) ψ = _
    simp only [map_add,add_apply]
    rfl
  map_smul' c H := by
    rw [liftLocal_smul,prefix_update_smul A k n hk]
    change Matrix.toEuclideanCLM (𝕜 := ℂ) (c • _) ψ = _
    simp only [map_smul,smul_apply]
    rfl

theorem optimizer_moment_commute (hq : 0 < q)
    (X : ℕ → Finset (Vertex L)) (hX : Monotone X)
    (a : ℕ → ℝ) (ψ : State L q) (n : ℕ)
    (F : (j : ℕ) → LocalPositiveFilter q (X j))
    (hF : IsFilterOptimizer ψ (fun j : Fin n => a j.val) (fun j : Fin n => F j.val))
    (k : ℕ) (hk : k < n)
    (H : Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ) :
    let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
    let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ
    inner ℂ v (replacementOutput A (X k) ψ k n hk (H*(F k).matrix)) =
      inner ℂ v (replacementOutput A (X k) ψ k n hk ((F k).matrix*H)) := by
  dsimp only
  let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
  let T := replacementOutput A (X k) ψ k n hk
  let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ
  have ht : T (F k).matrix = v := by
    change asMap (L := L) (q := q) (orderedPrefix (Function.update A k (A k)) n) ψ = v
    rw [Function.update_eq_self]
  have hfv : filteredVector (fun j : Fin n => F j.val) ψ = v := by
    unfold filteredVector
    rw [PhysicalCurve.orderedFilterProduct_eq_prefix]
  have hleft (V : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ)) :
      ‖T ((V : Matrix _ _ ℂ)*(F k).matrix)‖ ≤ ‖T (F k).matrix‖ := by
    rw [ht,← hfv]
    exact one_replacement_bound hq X hX a ψ n F hF k hk V (F k) (hF.1 ⟨k,hk⟩)
  have hright (V : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ)) :
      ‖T ((F k).matrix*(V : Matrix _ _ ℂ))‖ ≤ ‖T (F k).matrix‖ := by
    have hv := one_replacement_bound hq X hX a ψ n F hF k hk V (rightPositive (F k) V)
      (by rw [rightPositive_capacity]; exact hF.1 ⟨k,hk⟩)
    rw [rightPositive_factorization] at hv
    rw [ht,← hfv]
    exact hv
  let l : Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ →ₗ[ℂ] ℂ :=
    (innerSL ℂ (T (F k).matrix)).toLinearMap.comp T
  have hm := HermitianFunctional.moment_commute l (F k).matrix (F k).positive
    (fun K hK => UnitaryStationarity.left_moment_real T (F k).matrix hleft K hK)
    (fun K hK => UnitaryStationarity.right_moment_real T (F k).matrix hright K hK) H
  change inner ℂ (T (F k).matrix) (T (H*(F k).matrix)) =
    inner ℂ (T (F k).matrix) (T ((F k).matrix*H)) at hm
  simpa only [ht] using hm

theorem mixed_kernel_moment_zero (hq : 0 < q)
    (X : ℕ → Finset (Vertex L)) (hX : Monotone X)
    (a : ℕ → ℝ) (ψ : State L q) (n : ℕ)
    (F : (j : ℕ) → LocalPositiveFilter q (X j))
    (hF : IsFilterOptimizer ψ (fun j : Fin n => a j.val) (fun j : Fin n => F j.val))
    (k l : ℕ) (hk : k < n) (hl : l < n) (hkl : k ≠ l) (hp : 2 < 2/a k)
    (U : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ))
    (e : RegionConfiguration q (X k) → ℝ) (he : ∀ i, 0 ≤ e i)
    (hrep : (F k).matrix = spectralHom U (fun i => (e i : ℂ)))
    (hs : ∑ i, (e i)^(2/a k) = 1)
    (H : Matrix (RegionConfiguration q (X l)) (RegionConfiguration q (X l)) ℂ) :
    let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
    let B : Operator L q := liftLocal (X k) (kernel U e)
    inner ℂ (asMap (L := L) (q := q) (orderedPrefix A n) ψ)
      (replacementOutput (Function.update A k B) (X l) ψ l n hl ((F l).matrix*H)) = 0 := by
  dsimp only
  let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
  let B : Operator L q := liftLocal (X k) (kernel U e)
  let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ
  let T := replacementOutput (Function.update A k B) (X l) ψ l n hl
  let f : Matrix (RegionConfiguration q (X l)) (RegionConfiguration q (X l)) ℂ →ₗ[ℂ] ℂ :=
    ((innerSL ℂ v).toLinearMap.comp T).comp (LinearMap.mulLeft ℂ (F l).matrix)
  have hf (W : unitary (Matrix (RegionConfiguration q (X l)) (RegionConfiguration q (X l)) ℂ))
      (hW : star (W : Matrix (RegionConfiguration q (X l)) (RegionConfiguration q (X l)) ℂ)=W) :
      f W = 0 :=
    mixed_transition_zero hq X hX a ψ n F hF k l hk hl hkl hp U e he hrep hs W hW
  exact ReflectionSpan.zero_of_reflection_tests f hf H

end PolynomialPEPS.Subvolume.ActualTransition

namespace PolynomialPEPS.Subvolume.TraceStripping
open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator
open PolynomialPEPS.Subvolume.OptimizerGauge PolynomialPEPS.Subvolume.ActualTransition
variable {L q : ℕ}

theorem orderedPrefix_split (A : ℕ → Operator L q) (k t : ℕ) :
    orderedPrefix A (k+t) =
      orderedPrefix (fun j => A (k+j)) t * orderedPrefix A k := by
  induction t with
  | zero => simp
  | succ t ih =>
    rw [Nat.add_succ,orderedPrefix_succ,orderedPrefix_succ,ih,mul_assoc]

theorem orderedPrefix_shift_head (A : ℕ → Operator L q) (k t : ℕ) :
    orderedPrefix (fun j => A (k+j)) (t+1) =
      orderedPrefix (fun j => A (k+1+j)) t * A k := by
  induction t with
  | zero => simp
  | succ t ih =>
    rw [orderedPrefix_succ,ih,orderedPrefix_succ]
    simpa [Nat.add_assoc,Nat.add_left_comm,Nat.add_comm] using
      (mul_assoc (A (k+(t+1)))
        (orderedPrefix (fun j => A (k+1+j)) t) (A k)).symm

theorem orderedPrefix_replace_split (A : ℕ → Operator L q) (k n : ℕ)
    (hk : k<n) (B : Operator L q) :
    orderedPrefix (Function.update A k B) n =
      orderedPrefix (fun j => A (k+1+j)) (n-(k+1)) * B * orderedPrefix A k := by
  have hn : n = k+1+(n-(k+1)) := by omega
  have hf : (fun j => Function.update A k B (k+1+j)) = (fun j => A (k+1+j)) := by
    funext j
    rw [Function.update_of_ne (by omega)]
  have hb : orderedPrefix (Function.update A k B) (k+1) = B*orderedPrefix A k := by
    rw [orderedPrefix_succ,Function.update_self,prefix_update_outside A k k B le_rfl]
  calc
    orderedPrefix (Function.update A k B) n =
        orderedPrefix (Function.update A k B) (k+1+(n-(k+1))) := by rw [← hn]
    _ = orderedPrefix (fun j => A (k+1+j)) (n-(k+1)) * B * orderedPrefix A k := by
      rw [orderedPrefix_split,hf,hb,mul_assoc]

def insertedProduct (A : ℕ → Operator L q) (H : Operator L q) (k n : ℕ) : Operator L q :=
  orderedPrefix (fun j => A (k+j)) (n-k) * H * orderedPrefix A k

theorem insertedProduct_at_end (A : ℕ → Operator L q) (H : Operator L q) (n : ℕ) :
    insertedProduct A H n n = H*orderedPrefix A n := by simp [insertedProduct]

theorem insertedProduct_right (A : ℕ → Operator L q) (H : Operator L q)
    (k n : ℕ) (hk : k<n) :
    insertedProduct A H k n = orderedPrefix (Function.update A k (A k*H)) n := by
  rw [orderedPrefix_replace_split A k n hk]
  unfold insertedProduct
  rw [show n-k = (n-(k+1))+1 by omega,orderedPrefix_shift_head]
  simp only [mul_assoc]

theorem insertedProduct_left (A : ℕ → Operator L q) (H : Operator L q)
    (k n : ℕ) (hk : k<n) :
    insertedProduct A H (k+1) n = orderedPrefix (Function.update A k (H*A k)) n := by
  rw [orderedPrefix_replace_split A k n hk]
  unfold insertedProduct
  rw [orderedPrefix_succ]
  simp only [mul_assoc]

theorem strip_outer (A : ℕ → Operator L q) (H : Operator L q)
    (f : Operator L q → ℂ) (r n : ℕ) (hr : r≤n)
    (hc : ∀ k, r≤k → k<n →
      f (orderedPrefix (Function.update A k (H*A k)) n) =
        f (orderedPrefix (Function.update A k (A k*H)) n)) :
    f (H*orderedPrefix A n) = f (insertedProduct A H r n) := by
  have heq (k : ℕ) (hrk : r≤k) (hkn : k≤n) :
      f (insertedProduct A H k n) = f (insertedProduct A H r n) := by
    induction k,hrk using Nat.le_induction with
    | base => rfl
    | succ k hrk ih =>
      have hk : k<n := by omega
      rw [insertedProduct_left A H k n hk,hc k hrk hk,
        ← insertedProduct_right A H k n hk]
      exact ih (by omega)
  simpa only [insertedProduct_at_end] using heq n hr le_rfl

theorem optimizer_strip_outer (hq : 0 < q)
    (X : ℕ → Finset (Vertex L)) (hX : Monotone X)
    (a : ℕ → ℝ) (ψ : State L q) (n : ℕ)
    (F : (j : ℕ) → LocalPositiveFilter q (X j))
    (hF : IsFilterOptimizer ψ (fun j : Fin n => a j.val) (fun j : Fin n => F j.val))
    (r : ℕ) (hr : r≤n) (H : Operator L q)
    (hH : ∀ k, r≤k → k<n → SupportedOn H (X k)) :
    let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
    let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ
    inner ℂ v (asMap (L := L) (q := q) H v) =
      inner ℂ v (asMap (L := L) (q := q) (insertedProduct A H r n) ψ) := by
  dsimp only
  let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix
  let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ
  have hc (k : ℕ) (hrk : r≤k) (hkn : k<n) :
      inner ℂ v (asMap (L := L) (q := q) (orderedPrefix (Function.update A k (H*A k)) n) ψ) =
        inner ℂ v (asMap (L := L) (q := q) (orderedPrefix (Function.update A k (A k*H)) n) ψ) := by
    obtain ⟨K,hK⟩ := hH k hrk hkn
    have hc := optimizer_moment_commute hq X hX a ψ n F hF k hkn K
    simpa only [replacementOutput,LinearMap.coe_mk,AddHom.coe_mk,liftLocal_mul,← hK] using hc
  have h := strip_outer A H
    (fun M => inner ℂ v (asMap (L := L) (q := q) M ψ)) r n hr hc
  have heq : asMap (L := L) (q := q) (H*orderedPrefix A n) ψ = asMap H v := by
    change Matrix.toEuclideanCLM (𝕜 := ℂ) (H*orderedPrefix A n) ψ = _
    rw [map_mul]
    rfl
  rw [heq] at h
  exact h

end PolynomialPEPS.Subvolume.TraceStripping

end

end OAI