import Mathlib
import OAI.MathematicalPhysics.PEPSFilters.LocalOperators
import OAI.MathematicalPhysics.PEPSSubvolume.Filters

namespace OAI

/-! Two-factor optimization and Hermitian reflection rotations. -/

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

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

def prefixReplacement (A : ℕ → Operator L q) (k n : ℕ) (hk : k < n) :
    Operator L q →ₗ[ℂ] Operator L q where
  toFun B := orderedPrefix (Function.update A k B) n
  map_add' := prefix_update_add A k n hk
  map_smul' := prefix_update_smul A k n hk

def prefixTwoReplacement (A : ℕ → Operator L q) (k l n : ℕ)
    (hk : k < n) (hl : l < n) (hkl : k ≠ l) :
    Operator L q →ₗ[ℂ] Operator L q →ₗ[ℂ] Operator L q where
  toFun B := prefixReplacement (Function.update A k B) l n hl
  map_add' B C := by
    apply LinearMap.ext
    intro D
    change orderedPrefix (Function.update (Function.update A k (B+C)) l D) n =
      orderedPrefix (Function.update (Function.update A k B) l D) n +
        orderedPrefix (Function.update (Function.update A k C) l D) n
    simp only [Function.update_comm hkl]
    exact prefix_update_add _ k n hk B C
  map_smul' c B := by
    apply LinearMap.ext
    intro D
    change orderedPrefix (Function.update (Function.update A k (c • B)) l D) n =
      c • orderedPrefix (Function.update (Function.update A k B) l D) n
    simp only [Function.update_comm hkl]
    exact prefix_update_smul _ k n hk c B

theorem two_affine_prefix (A : ℕ → Operator L q) (k l n : ℕ)
    (hk : k<n) (hl : l<n) (hkl : k ≠ l) (B C : Operator L q) (s t c d : ℂ) :
    orderedPrefix (Function.update (Function.update A k (c • (A k + s • B)))
      l (d • (A l + t • C))) n =
      (c*d) • (orderedPrefix A n +
        s • orderedPrefix (Function.update A k B) n +
        t • orderedPrefix (Function.update A l C) n +
        (s*t) • orderedPrefix (Function.update (Function.update A k B) l C) n) := by
  let T := prefixTwoReplacement A k l n hk hl hkl
  change T (c • (A k + s • B)) (d • (A l + t • C)) = _
  have h00 : T (A k) (A l) = orderedPrefix A n := by
    simp only [T,prefixTwoReplacement,prefixReplacement,LinearMap.coe_mk,AddHom.coe_mk,
      Function.update_eq_self]
  have h01 : T (A k) C = orderedPrefix (Function.update A l C) n := by
    simp only [T,prefixTwoReplacement,prefixReplacement,LinearMap.coe_mk,AddHom.coe_mk,
      Function.update_eq_self]
  have h10 : T B (A l) = orderedPrefix (Function.update A k B) n := by
    change orderedPrefix (Function.update (Function.update A k B) l (A l)) n = _
    rw [Function.update_comm hkl,Function.update_eq_self]
  have h11 : T B C = orderedPrefix (Function.update (Function.update A k B) l C) n := rfl
  simp only [map_smul,map_add,LinearMap.smul_apply,LinearMap.add_apply,
    h00,h01,h10,h11,smul_add,smul_smul]
  module

end PolynomialPEPS.Subvolume.OptimizerGauge

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

theorem two_replacement_bound (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)
    (V : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ))
    (W : unitary (Matrix (RegionConfiguration q (X l)) (RegionConfiguration q (X l)) ℂ))
    (G : LocalPositiveFilter q (X k)) (hG : filterTracePower G (2/a k) = 1)
    (H : LocalPositiveFilter q (X l)) (hH : filterTracePower H (2/a l) = 1) :
    ‖asMap (L := L) (q := q) (orderedPrefix
      (Function.update (Function.update (fun j => liftLocal (X j) (F j).matrix)
        k (liftLocal (X k) ((V : Matrix _ _ ℂ)*G.matrix)))
        l (liftLocal (X l) ((W : Matrix _ _ ℂ)*H.matrix))) n) ψ‖ ≤
      ‖filteredVector (fun j : Fin n => F j.val) ψ‖ := by
  let U : (j : ℕ) → unitary (Matrix (RegionConfiguration q (X j))
      (RegionConfiguration q (X j)) ℂ) := Function.update (Function.update (fun _ => 1) k V) l W
  let P : (j : ℕ) → LocalPositiveFilter q (X j) := Function.update (Function.update F k G) l H
  have hp : ∀ j < n, filterTracePower (P j) (2/a j) = 1 := by
    intro j hj
    by_cases hjl : j=l
    · subst j
      simpa [P] using hH
    · by_cases hjk : j=k
      · subst j
        simpa [P,Function.update_of_ne hkl] using hG
      · simpa [P,Function.update_of_ne hjk,Function.update_of_ne hjl] using hF.1 ⟨j,hj⟩
  have heq : (fun j => liftLocal (X j) ((U j : Matrix _ _ ℂ)*(P j).matrix)) =
      Function.update (Function.update (fun j => liftLocal (X j) (F j).matrix) k
        (liftLocal (X k) ((V : Matrix _ _ ℂ)*G.matrix))) l
        (liftLocal (X l) ((W : Matrix _ _ ℂ)*H.matrix)) := by
    funext j
    by_cases hjl : j=l
    · subst j
      simp [U,P]
    · by_cases hjk : j=k
      · subst j
        simp [U,P,Function.update_of_ne hkl]
      · simp [U,P,Function.update_of_ne hjk,Function.update_of_ne hjl]
  simpa only [heq] using unitary_positive_family_bound hq X hX a ψ n
    (fun j : Fin n => F j.val) hF U P hp

def rightPositive {X : Finset (Vertex L)} (F : LocalPositiveFilter q X)
    (R : unitary (Matrix (RegionConfiguration q X) (RegionConfiguration q X) ℂ)) :
    LocalPositiveFilter q X :=
  ⟨star (R : Matrix _ _ ℂ)*F.matrix*(R : Matrix _ _ ℂ),
    posSemidef_unitary_conj F.matrix F.positive R⟩

theorem rightPositive_capacity {X : Finset (Vertex L)} (F : LocalPositiveFilter q X)
    (R : unitary (Matrix (RegionConfiguration q X) (RegionConfiguration q X) ℂ)) (p : ℝ) :
    filterTracePower (rightPositive F R) p = filterTracePower F p := by
  unfold filterTracePower NestedFilter.tracePower rightPositive
  rw [eigenvalues_unitary_conj _ F.positive]

theorem rightPositive_factorization {X : Finset (Vertex L)} (F : LocalPositiveFilter q X)
    (R : unitary (Matrix (RegionConfiguration q X) (RegionConfiguration q X) ℂ)) :
    (R : Matrix _ _ ℂ)*(rightPositive F R).matrix = F.matrix*(R : Matrix _ _ ℂ) := by
  change (R : Matrix _ _ ℂ)*(star (R : Matrix _ _ ℂ)*F.matrix*(R : Matrix _ _ ℂ)) = _
  simp only [← mul_assoc,R.property.2,one_mul]

end PolynomialPEPS.Subvolume.OptimizerGauge

open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator
namespace PolynomialPEPS.Subvolume.ReflectionRotation
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def numerator (W : Matrix ι ι ℂ) (t : ℝ) : Matrix ι ι ℂ :=
  1 + ((t : ℂ)*Complex.I) • W

def scale (t : ℝ) : ℝ := (Real.sqrt (1+t^2))⁻¹

theorem scale_pos (t : ℝ) : 0 < scale t := by
  unfold scale
  positivity

theorem scale_sq (t : ℝ) : (scale t)^2*(1+t^2)=1 := by
  have hp : 0 < 1+t^2 := by positivity
  rw [scale, inv_pow, Real.sq_sqrt hp.le, inv_mul_cancel₀ (ne_of_gt hp)]

theorem numerator_star_mul (W : unitary (Matrix ι ι ℂ))
    (hW : star (W : Matrix ι ι ℂ) = (W : Matrix ι ι ℂ)) (t : ℝ) :
    star (numerator (W : Matrix ι ι ℂ) t) * numerator (W : Matrix ι ι ℂ) t =
      ((1+t^2 : ℝ) : ℂ) • (1 : Matrix ι ι ℂ) := by
  have hWW : (W : Matrix ι ι ℂ)*(W : Matrix ι ι ℂ)=1 := by
    simpa only [hW] using W.property.2
  unfold numerator
  simp only [star_add, star_one, star_smul, star_mul, RCLike.star_def,
    Complex.conj_ofReal, Complex.conj_I, hW, add_mul, mul_add, one_mul, mul_one,
    smul_mul_assoc, mul_smul_comm, smul_smul, hWW, smul_add]
  have hc : ((t : ℂ)*Complex.I) * (-Complex.I * (t : ℂ)) = ((t^2 : ℝ) : ℂ) := by
    rw [Complex.ofReal_pow]
    ring_nf
    simp [Complex.I_sq]
  rw [hc, Complex.ofReal_add, Complex.ofReal_one, add_smul, one_smul]
  module

theorem numerator_mul_star (W : unitary (Matrix ι ι ℂ))
    (hW : star (W : Matrix ι ι ℂ) = (W : Matrix ι ι ℂ)) (t : ℝ) :
    numerator (W : Matrix ι ι ℂ) t * star (numerator (W : Matrix ι ι ℂ) t) =
      ((1+t^2 : ℝ) : ℂ) • (1 : Matrix ι ι ℂ) := by
  have hn : star (numerator (W : Matrix ι ι ℂ) (-t)) = numerator (W : Matrix ι ι ℂ) t := by
    simp [numerator, hW, mul_comm]
  have hn' : numerator (W : Matrix ι ι ℂ) (-t) = star (numerator (W : Matrix ι ι ℂ) t) := by
    rw [← hn, star_star]
  simpa only [hn, hn', neg_sq, star_star] using numerator_star_mul W hW (-t)

def rotation (W : unitary (Matrix ι ι ℂ))
    (hW : star (W : Matrix ι ι ℂ) = (W : Matrix ι ι ℂ)) (t : ℝ) :
    unitary (Matrix ι ι ℂ) :=
  ⟨(scale t : ℂ) • numerator (W : Matrix ι ι ℂ) t, by
    have hc : (scale t : ℂ)*(scale t : ℂ)*((1+t^2 : ℝ) : ℂ) = 1 := by
      rw [← Complex.ofReal_mul, ← Complex.ofReal_mul, ← sq, scale_sq, Complex.ofReal_one]
    constructor
    · simp only [star_smul, RCLike.star_def, Complex.conj_ofReal,
        smul_mul_assoc, mul_smul_comm, smul_smul, numerator_star_mul W hW,
        ← mul_assoc, hc, one_smul]
    · simp only [star_smul, RCLike.star_def, Complex.conj_ofReal,
        smul_mul_assoc, mul_smul_comm, smul_smul, numerator_mul_star W hW,
        ← mul_assoc, hc, one_smul]⟩

end PolynomialPEPS.Subvolume.ReflectionRotation

end

end OAI