import Mathlib
import OAI.MathematicalPhysics.PEPSFilters.LocalOperators
import OAI.MathematicalPhysics.PEPSSubvolume.GeometricLower
import OAI.MathematicalPhysics.PEPSSubvolume.PinnedCosts

namespace OAI

/-! Pinned entropy bounds and geometric upper comparison. -/

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 scoped BigOperators Matrix.Norms.L2Operator
open scoped ComplexOrder BigOperators Matrix.Norms.L2Operator
open Matrix
open Filter Topology
open Set Filter Complex Complex.HadamardThreeLines
open PolynomialPEPS.PinnedEntropy

namespace PolynomialPEPS.Subvolume.Pinning
open Matrix
variable {L q : ℕ}

def coreColumn (C : Finset (Vertex L))
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ))
    (i : RegionConfiguration q C) : EuclideanSpace ℂ (RegionConfiguration q C) :=
  WithLp.toLp 2 (fun x => (U : Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ) x i)

theorem coreColumn_norm (C : Finset (Vertex L))
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ))
    (i : RegionConfiguration q C) : ‖coreColumn C U i‖ = 1 := by
  have hinner : inner ℂ (coreColumn C U i) (coreColumn C U i) = 1 := by
    have h := congrArg (fun A => A i i) (Unitary.coe_star_mul_self U)
    simpa only [PiLp.inner_apply,coreColumn,WithLp.ofLp_toLp,RCLike.inner_apply,
      Matrix.mul_apply,Matrix.star_apply,Matrix.one_apply_eq,starRingEnd_apply,mul_comm] using h
  have hsq : ‖coreColumn C U i‖ ^ 2 = 1 := by
    rw [norm_sq_eq_re_inner (𝕜 := ℂ),hinner]
    rfl
  nlinarith [norm_nonneg (coreColumn C U i)]

theorem sum_coreMatrix (C : Finset (Vertex L))
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ)) :
    ∑ i, coreMatrix C (coreColumn C U i) = 1 := by
  ext x y
  have h := congrArg (fun A => A x y) (Unitary.coe_mul_star_self U)
  simpa [Matrix.sum_apply,coreMatrix,coreColumn,Matrix.mul_apply,Matrix.star_apply] using h

theorem asMap_mul_apply (A B : Operator L q) (ψ : State L q) :
    asMap (A * B) ψ = asMap A (asMap B ψ) := by
  simp only [asMap,map_mul,mul_apply_eq_comp]

theorem asMap_sum_apply {ι : Type*} [Fintype ι] (A : ι → Operator L q) (ψ : State L q) :
    asMap (∑ i, A i) ψ = ∑ i, asMap (A i) ψ := by
  simp only [asMap,map_sum,_root_.sum_apply]

theorem sum_pinnedVector (C : Finset (Vertex L))
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ))
    (ψ : State L q) : ∑ i, pinnedVector C (coreColumn C U i) ψ = ψ := by
  unfold pinnedVector
  rw [← asMap_sum_apply]
  change asMap (∑ i, localLiftHom C (coreMatrix C (coreColumn C U i))) ψ = ψ
  rw [← map_sum, sum_coreMatrix, map_one]
  simp [asMap]

theorem pinned_self_inner (C : Finset (Vertex L))
    (u : EuclideanSpace ℂ (RegionConfiguration q C)) (_hu : ‖u‖ = 1)
    (ψ ζ : State L q) :
    inner ℂ (pinnedVector C u ψ) ζ = inner ℂ ψ (pinnedVector C u ζ) := by
  have h : IsSelfAdjoint (asMap (liftLocal C (coreMatrix C u))) :=
    ((coreMatrix_isHermitian C u).isSelfAdjoint.map (localLiftHom C)).map Matrix.toEuclideanCLM
  exact h.isSymmetric ψ ζ

theorem pinnedVector_idempotent (C : Finset (Vertex L))
    (u : EuclideanSpace ℂ (RegionConfiguration q C)) (hu : ‖u‖ = 1)
    (ψ : State L q) : pinnedVector C u (pinnedVector C u ψ) = pinnedVector C u ψ := by
  unfold pinnedVector
  rw [← asMap_mul_apply,← liftLocal_mul,coreMatrix_idempotent C u hu]

theorem inner_pinned_shell (C X : Finset (Vertex L)) (hCX : C ⊆ X)
    (u : EuclideanSpace ℂ (RegionConfiguration q C)) (hu : ‖u‖ = 1)
    (A : Matrix (RegionConfiguration q (X \ C)) (RegionConfiguration q (X \ C)) ℂ)
    (ψ : State L q) :
    inner ℂ (pinnedVector C u ψ) (asMap (liftLocal (X \ C) A) (pinnedVector C u ψ)) =
      inner ℂ ψ (asMap (liftLocal (X \ C) A) (pinnedVector C u ψ)) := by
  rw [pinned_self_inner C u hu]
  congr 1
  have hc := lift_core_shell_commute C X hCX (coreMatrix C u) A
  change asMap (liftLocal C (coreMatrix C u))
    (asMap (liftLocal (X \ C) A) (pinnedVector C u ψ)) = _
  rw [← asMap_mul_apply,hc.eq,asMap_mul_apply]
  change asMap (liftLocal (X \ C) A) (pinnedVector C u (pinnedVector C u ψ)) = _
  rw [pinnedVector_idempotent C u hu]

theorem sum_pinned_marginals (C X : Finset (Vertex L)) (hCX : C ⊆ X)
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ))
    (ψ : State L q) :
    ∑ i, reducedDensity (pinnedVector C (coreColumn C U i) ψ) (X \ C) =
      reducedDensity ψ (X \ C) := by
  apply Matrix.ext_iff_trace_mul_left.mpr
  intro A
  rw [Matrix.mul_sum,Matrix.trace_sum]
  simp_rw [← inner_liftLocal_trace,inner_pinned_shell C X hCX _ (coreColumn_norm C U _)]
  rw [← inner_sum,← map_sum,sum_pinnedVector]

theorem pinned_norm_sq (C : Finset (Vertex L))
    (u : EuclideanSpace ℂ (RegionConfiguration q C)) (hu : ‖u‖ = 1)
    (ψ : State L q) : ‖pinnedVector C u ψ‖ ^ 2 =
      (Matrix.trace (coreMatrix C u * reducedDensity ψ C)).re := by
  rw [norm_sq_eq_re_inner (𝕜 := ℂ),pinned_self_inner C u hu,pinnedVector_idempotent C u hu]
  exact congrArg Complex.re (inner_liftLocal_trace C (coreMatrix C u) ψ)

theorem trace_coreMatrix (C : Finset (Vertex L))
    (U : unitary (Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ))
    (i : RegionConfiguration q C)
    (A : Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ) :
    Matrix.trace (coreMatrix C (coreColumn C U i) * A) =
      ((U : Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ).conjTranspose * A * (U : Matrix (RegionConfiguration q C) (RegionConfiguration q C) ℂ)) i i := by
  classical
  simp only [Matrix.trace,Matrix.diag,Matrix.mul_apply,coreMatrix,coreColumn,
    Matrix.conjTranspose_apply,Finset.sum_mul]
  apply Finset.sum_congr rfl
  intro x hx
  apply Finset.sum_congr rfl
  intro y hy
  ring

theorem schmidt_weight (C : Finset (Vertex L)) (ψ : State L q)
    (i : RegionConfiguration q C) :
    ‖pinnedVector C (coreColumn C (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ‖ ^ 2 =
      (reducedDensity_isHermitian ψ C).eigenvalues i := by
  rw [pinned_norm_sq C _ (coreColumn_norm C _ i),trace_coreMatrix]
  have h := congrArg (fun A => (A i i).re)
    (reducedDensity_isHermitian ψ C).conjStarAlgAut_star_eigenvectorUnitary
  simpa only [Unitary.conjStarAlgAut_apply,Unitary.coe_star,star_star,Matrix.star_eq_conjTranspose,
    Matrix.conjTranspose_conjTranspose,
    Matrix.diagonal_apply_eq,Function.comp_def,RCLike.ofReal_eq_complex_ofReal,
    Complex.ofReal_re] using h

theorem reducedDensity_smul (S : Finset (Vertex L)) (c : ℂ) (ψ : State L q) :
    reducedDensity (c • ψ) S = (Complex.normSq c : ℂ) • reducedDensity ψ S := by
  have hC : coefficientMatrix (c • ψ) S = c • coefficientMatrix ψ S := by
    ext x y
    rfl
  simp only [reducedDensity,hC,Matrix.conjTranspose_smul,Matrix.smul_mul,Matrix.mul_smul,
    smul_smul]
  rw [mul_comm (star c) c]
  have hn : c * star c = (Complex.normSq c : ℂ) := Complex.mul_conj c
  rw [hn]

theorem reducedDensity_zero (S : Finset (Vertex L)) :
    reducedDensity (0 : State L q) S = 0 := by
  ext x y
  simp [reducedDensity,coefficientMatrix,Matrix.mul_apply]

theorem normalizedPinned_marginal (C S : Finset (Vertex L))
    (u : EuclideanSpace ℂ (RegionConfiguration q C)) (ψ : State L q) :
    ((‖pinnedVector C u ψ‖ ^ 2 : ℝ) : ℂ) • reducedDensity (normalizedPinned C u ψ) S =
      reducedDensity (pinnedVector C u ψ) S := by
  by_cases hz : pinnedVector C u ψ = 0
  · simp [normalizedPinned,hz,reducedDensity_zero]
  · have hc : ‖pinnedVector C u ψ‖ ≠ 0 := norm_ne_zero_iff.mpr hz
    rw [normalizedPinned,reducedDensity_smul,smul_smul]
    have he : ((‖pinnedVector C u ψ‖ ^ 2 : ℝ) : ℂ) *
        (Complex.normSq ((‖pinnedVector C u ψ‖⁻¹ : ℝ) : ℂ) : ℂ) = 1 := by
      rw [Complex.normSq_ofReal,← Complex.ofReal_mul]
      norm_cast
      field_simp
    rw [he,one_smul]

end PolynomialPEPS.Subvolume.Pinning

namespace PolynomialPEPS.Subvolume.Pinning
open Matrix
variable {L q : ℕ}

def schmidtProbability (C : Finset (Vertex L)) (ψ : State L q)
    (i : RegionConfiguration q C) : ℝ :=
  ‖pinnedVector C (coreColumn C (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ‖ ^ 2

def schmidtState (C : Finset (Vertex L)) (ψ : State L q)
    (i : RegionConfiguration q C) : State L q :=
  normalizedPinned C (coreColumn C (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ

theorem schmidtProbability_nonneg (C : Finset (Vertex L)) (ψ : State L q)
    (i : RegionConfiguration q C) : 0 ≤ schmidtProbability C ψ i := sq_nonneg _

theorem schmidtProbability_sum (C : Finset (Vertex L)) (ψ : State L q) (hψ : ‖ψ‖ = 1) :
    ∑ i, schmidtProbability C ψ i = 1 := by
  simp only [schmidtProbability,schmidt_weight]
  exact marginal_eigenvalues_sum ψ hψ C

theorem schmidtProbability_entropy (C : Finset (Vertex L)) (ψ : State L q) :
    ∑ i, Real.negMulLog (schmidtProbability C ψ i) = vonNeumannEntropy ψ C := by
  simp only [schmidtProbability,schmidt_weight,vonNeumannEntropy]

theorem schmidt_shell_mixture (C X : Finset (Vertex L)) (hCX : C ⊆ X) (ψ : State L q) :
    ∑ i, schmidtProbability C ψ i • reducedDensity (schmidtState C ψ i) (X \ C) =
      reducedDensity ψ (X \ C) := by
  have he (i : RegionConfiguration q C) :
      schmidtProbability C ψ i • reducedDensity (schmidtState C ψ i) (X \ C) =
        reducedDensity (pinnedVector C (coreColumn C
          (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ) (X \ C) := by
    simp only [schmidtProbability,schmidtState]
    rw [RCLike.real_smul_eq_coe_smul (K := ℂ)]
    exact
      normalizedPinned_marginal C (X \ C)
        (coreColumn C (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ
  simp_rw [he]
  exact sum_pinned_marginals C X hCX _ ψ

theorem average_schmidt_shell_entropy (C X : Finset (Vertex L)) (hCX : C ⊆ X)
    (ψ : State L q) (hψ : ‖ψ‖ = 1) :
    ∑ i, schmidtProbability C ψ i * vonNeumannEntropy (schmidtState C ψ i) (X \ C) ≤
      vonNeumannEntropy ψ (X \ C) := by
  have h := MatrixEntropy.entropy_concave_mixture (schmidtProbability C ψ)
    (schmidtProbability_nonneg C ψ) (schmidtProbability_sum C ψ hψ)
    (fun i => reducedDensity (schmidtState C ψ i) (X \ C))
    (fun i => reducedDensity_posSemidef (schmidtState C ψ i) (X \ C))
  simpa only [schmidt_shell_mixture C X hCX ψ,MatrixEntropy.entropy,vonNeumannEntropy] using h

end PolynomialPEPS.Subvolume.Pinning

namespace PolynomialPEPS.Subvolume.Pinning
open Matrix
variable {L q : ℕ}

theorem optimizer_cost_le_core_add_shell_entropy (hq : 0 < q)
    (C : Finset (Vertex L)) (X : ℕ → Finset (Vertex L))
    (hX : Monotone X) (hCX : ∀ j, C ⊆ X j)
    (a : ℕ → ℝ) (ha : ∀ j, 0 < a j)
    (ψ : State L q) (hψ : ‖ψ‖ = 1) (n : ℕ) (hn : 0 < n)
    (F : FilterFamily q n (fun j => X j.val))
    (hF : IsFilterOptimizer ψ (fun j => a j.val) F) :
    -Real.log (‖filteredVector F ψ‖ ^ 2) ≤
      vonNeumannEntropy ψ C +
      ∑ j ∈ Finset.range n, a j * vonNeumannEntropy ψ (X j \ C) := by
  let p := schmidtProbability C ψ
  let v := schmidtState C ψ
  let cost := -Real.log (‖filteredVector F ψ‖ ^ 2)
  have hsector (i : RegionConfiguration q C) :
      p i * cost ≤ Real.negMulLog (p i) +
        p i * ∑ j ∈ Finset.range n, a j * vonNeumannEntropy (v i) (X j \ C) := by
    by_cases hz : p i = 0
    · simp only [hz,zero_mul,Real.negMulLog_zero,add_zero,le_refl]
    · have hp : 0 < p i := lt_of_le_of_ne (schmidtProbability_nonneg C ψ i) (Ne.symm hz)
      have hc : 0 < ‖pinnedVector C (coreColumn C
          (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ‖ := by
        have hh : 0 < ‖pinnedVector C (coreColumn C
          (reducedDensity_isHermitian ψ C).eigenvectorUnitary i) ψ‖ ^ 2 := hp
        exact lt_of_le_of_ne (norm_nonneg _) (Ne.symm (sq_pos_iff.mp hh))
      have hb := pinned_sector_cost hq C X hX hCX
        (coreColumn C (reducedDensity_isHermitian ψ C).eigenvectorUnitary i)
        (coreColumn_norm C _ i) a ha ψ n hn F hF hc
      have hw := mul_le_mul_of_nonneg_left hb (le_of_lt hp)
      change p i * cost ≤ p i * (-Real.log (p i) + _) at hw
      simpa only [mul_add,Real.negMulLog_def,mul_neg,neg_mul,v,schmidtState] using hw
  have havg := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (RegionConfiguration q C))) => hsector i)
  rw [← Finset.sum_mul,show ∑ i, p i = 1 from schmidtProbability_sum C ψ hψ,one_mul,
    Finset.sum_add_distrib,show ∑ i, Real.negMulLog (p i) = vonNeumannEntropy ψ C from
      schmidtProbability_entropy C ψ] at havg
  have hsum : (∑ i, p i * ∑ j ∈ Finset.range n, a j * vonNeumannEntropy (v i) (X j \ C)) ≤
      ∑ j ∈ Finset.range n, a j * vonNeumannEntropy ψ (X j \ C) := by
    simp_rw [Finset.mul_sum]
    rw [Finset.sum_comm]
    apply Finset.sum_le_sum
    intro j hj
    have hh := mul_le_mul_of_nonneg_left (average_schmidt_shell_entropy C (X j) (hCX j) ψ hψ)
      (le_of_lt (ha j))
    simpa only [Finset.mul_sum,mul_left_comm,p,v] using hh
  exact havg.trans (by linarith [hsum])

end PolynomialPEPS.Subvolume.Pinning

namespace PolynomialPEPS.Subvolume.GeometricComparison
open scoped BigOperators
open PolynomialPEPS.Subvolume.RectangleContours PolynomialPEPS.Subvolume.HarmonicWeights
open PolynomialPEPS.Subvolume.GeometricLower
variable {L q : ℕ}

theorem rectangle_weighted_conditional_contraction (hq : 0 < q) (J Δ E₀ : ℝ)
    (hJ : 0 ≤ J) (hΔ : 0 < Δ)
    (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) (Ω : State L q)
    (hΩ : ‖Ω‖=1) (hH : IsGridHamiltonian J hv he)
    (hg : asMap (Hamiltonian hv he) Ω=(E₀:ℂ) • Ω)
    (hgap : FullSystemGap (Hamiltonian hv he) Ω E₀ Δ)
    (lo₁ hi₁ lo₂ hi₂ : ℤ) (r : ℕ) (hr : 0 < r)
    (h₁ : hi₁-lo₁+1 ≤ r) (h₂ : hi₂-lo₂+1 ≤ r) :
    let C := rectangle (L:=L) lo₁ hi₁ lo₂ hi₂ 0
    let n := 2^(blocks q J Δ)*r
    let X := fun j => rectangle (L:=L) lo₁ hi₁ lo₂ hi₂ (j+1)
    (∑ j ∈ Finset.range n, weight r n j *
      (vonNeumannEntropy Ω (X j)-vonNeumannEntropy Ω (X j \ C))) ≤
      vonNeumannEntropy Ω C+bufferConstant q J Δ*(r:ℝ) := by
  let C := rectangle (L:=L) lo₁ hi₁ lo₂ hi₂ 0
  let n := 2^(blocks q J Δ)*r
  let X := fun j => rectangle (L:=L) lo₁ hi₁ lo₂ hi₂ (j+1)
  obtain ⟨F,hF,_,hlow⟩ := rectangle_optimizer_entropy_lower hq J Δ E₀ hJ hΔ hv he Ω hΩ hH hg hgap
    lo₁ hi₁ lo₂ hi₂ r hr h₁ h₂
  change (∑ j ∈ Finset.range n, weight r n j*vonNeumannEntropy Ω (X j))-
    bufferConstant q J Δ*(r:ℝ) ≤ -Real.log (‖filteredVector F Ω‖^2) at hlow
  have hn : 0<n := Nat.mul_pos (pow_pos (by omega) _) hr
  have hweights := buffer_weights r (blocks q J Δ) hr (blocks_large q J Δ).1
    (fun j => (boundaryCard (X j):ℝ))
    (fun j _ => rectangle_boundary_weight lo₁ hi₁ lo₂ hi₂ r j hr h₁ h₂)
  have hu := Pinning.optimizer_cost_le_core_add_shell_entropy hq C X
    (fun j k hjk => monotone_rectangle lo₁ hi₁ lo₂ hi₂ (Nat.add_le_add_right hjk 1))
    (fun j => monotone_rectangle lo₁ hi₁ lo₂ hi₂ (Nat.zero_le _))
    (weight r n) (fun j => (hweights.1 j).1) Ω hΩ n hn F hF
  simp only [mul_sub,Finset.sum_sub_distrib]
  linarith only [hlow,hu]

end PolynomialPEPS.Subvolume.GeometricComparison

end

end OAI