import Mathlib

namespace OAI

noncomputable section
open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator MatrixOrder
open Matrix

noncomputable section
open scoped BigOperators ComplexOrder
namespace PolynomialPEPS.PhysicalMove

abbrev Vertex (L : ℕ) := Fin L × Fin L

def ForwardAdjacent {L : ℕ} (v w : Vertex L) : Prop :=
  (v.1.val + 1 = w.1.val ∧ v.2 = w.2) ∨
  (v.1 = w.1 ∧ v.2.val + 1 = w.2.val)

abbrev Edge (L : ℕ) := {e : Vertex L × Vertex L // ForwardAdjacent e.1 e.2}

instance edgeFintype (L : ℕ) : Fintype (Edge L) := Fintype.ofFinite _

def Incident {L : ℕ} (v : Vertex L) (e : Edge L) : Prop :=
  v = e.val.1 ∨ v = e.val.2

abbrev IncidentEdge {L : ℕ} (v : Vertex L) := {e : Edge L // Incident v e}
instance incidentFintype {L : ℕ} (v : Vertex L) : Fintype (IncidentEdge v) :=
  Fintype.ofFinite _

abbrev Configuration (L q : ℕ) := Vertex L → Fin q
abbrev State (L q : ℕ) := EuclideanSpace ℂ (Configuration L q)
abbrev Operator (L q : ℕ) := Matrix (Configuration L q) (Configuration L q) ℂ
abbrev RegionConfiguration {L : ℕ} (q : ℕ) (S : Finset (Vertex L)) :=
  {v : Vertex L // v ∈ S} → Fin q

                                                                                
def liftLocal {L q : ℕ} (S : Finset (Vertex L))
    (a : Matrix (RegionConfiguration q S) (RegionConfiguration q S) ℂ) :
    Operator L q := fun x y =>
  if ∀ v, v ∉ S → x v = y v then
    a (fun v => x v.val) (fun v => y v.val)
  else 0

def SupportedOn {L q : ℕ} (a : Operator L q) (S : Finset (Vertex L)) : Prop :=
  ∃ aS : Matrix (RegionConfiguration q S) (RegionConfiguration q S) ℂ,
    a = liftLocal S aS

def EdgeSites {L : ℕ} (e : Edge L) : Finset (Vertex L) := {e.val.1, e.val.2}

def Hamiltonian {L q : ℕ} (hv : Vertex L → Operator L q)
    (he : Edge L → Operator L q) : Operator L q :=
  (∑ v, hv v) + ∑ e, he e

def asMap {L q : ℕ} (a : Operator L q) : State L q →L[ℂ] State L q :=
  Matrix.toEuclideanCLM (n := Configuration L q) (𝕜 := ℂ) a

def opNorm {L q : ℕ} (a : Operator L q) : ℝ := ‖asMap a‖

                                                                            
def IsGridHamiltonian {L q : ℕ} (J : ℝ)
    (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) : Prop :=
  (∀ v, SupportedOn (hv v) {v} ∧ opNorm (hv v) ≤ J) ∧
  (∀ e, SupportedOn (he e) (EdgeSites e) ∧ opNorm (he e) ≤ J) ∧
  (Hamiltonian hv he).IsHermitian

def phase (θ : ℝ) : ℂ := Complex.exp ((θ : ℂ) * Complex.I)

                                                                                
def UniqueGround {L q : ℕ} (H : Operator L q) (Ω : State L q) (E₀ : ℝ) : Prop :=
  ‖Ω‖ = 1 ∧
  asMap H Ω = (E₀ : ℂ) • Ω ∧
  (∀ ψ : State L q,
    E₀ * ‖ψ‖ ^ 2 ≤ (inner ℂ ψ (asMap H ψ)).re) ∧
  (∀ ψ : State L q, ‖ψ‖ = 1 →
    asMap H ψ = (E₀ : ℂ) • ψ →
    ∃ θ : ℝ, ψ = phase θ • Ω)

                                                                         
def FullSystemGap {L q : ℕ} (H : Operator L q) (Ω : State L q)
    (E₀ Δ : ℝ) : Prop :=
  ∀ ψ : State L q,
    Δ * (‖ψ‖ ^ 2 - ‖inner ℂ Ω ψ‖ ^ 2) ≤
      (inner ℂ ψ (asMap H ψ)).re - E₀ * ‖ψ‖ ^ 2

                                                                             
abbrev LocalTensor {L : ℕ} (q : ℕ) (D : Edge L → ℕ) (v : Vertex L) :=
  Fin q → ((e : IncidentEdge v) → Fin (D e.val)) → ℂ

                                                                         
                                              
def contractPEPS {L q : ℕ} (D : Edge L → ℕ)
    (A : (v : Vertex L) → LocalTensor q D v) : State L q :=
  WithLp.toLp 2 (fun x => ∑ a : (e : Edge L) → Fin (D e),
    ∏ v : Vertex L, A v (x v) (fun e => a e.val))

def HasPEPSApproximation {L q : ℕ} (Ω : State L q) (C c : ℝ) : Prop :=
  ∃ (D : Edge L → ℕ) (A : (v : Vertex L) → LocalTensor q D v),
    (∀ e, 0 < D e) ∧
    (∀ e, (D e : ℝ) ≤ C * Real.rpow (L : ℝ) c) ∧
    contractPEPS D A ≠ 0 ∧
    ∃ θ : ℝ,
      ‖((‖contractPEPS D A‖⁻¹ : ℝ) : ℂ) • contractPEPS D A - phase θ • Ω‖ ≤
        (L : ℝ)⁻¹

                                                                           
                                                                    
def MainStatement : Prop :=
  ∀ (q : ℕ), 2 ≤ q → ∀ (J Δ : ℝ), 0 < J → 0 < Δ →
    ∃ C c : ℝ, 0 < C ∧ 0 < c ∧
      ∀ (L : ℕ), 2 ≤ L →
      ∀ (hv : Vertex L → Operator L q) (he : Edge L → Operator L q)
        (Ω : State L q) (E₀ : ℝ),
        IsGridHamiltonian J hv he →
        UniqueGround (Hamiltonian hv he) Ω E₀ →
        FullSystemGap (Hamiltonian hv he) Ω E₀ Δ →
        HasPEPSApproximation Ω C c

end PolynomialPEPS.PhysicalMove

   
                                                                          
                                                                         
                                                                            
                                                                             
  
namespace PolynomialPEPS.PhysicalMove

                                                                               
def joinConfigurations {L q : ℕ} (A : Finset (Vertex L))
    (x : RegionConfiguration q A) (z : RegionConfiguration q Aᶜ) :
    Configuration L q := by
  classical
  exact fun v => if h : v ∈ A then x ⟨v, h⟩ else z ⟨v, Finset.mem_compl.mpr h⟩

                                                                            
                               
def coefficientMatrix {L q : ℕ} (Ω : State L q) (A : Finset (Vertex L)) :
    Matrix (RegionConfiguration q A) (RegionConfiguration q Aᶜ) ℂ :=
  fun x z => Ω (joinConfigurations A x z)

                                                                            
                                                              
def reducedDensity {L q : ℕ} (Ω : State L q) (A : Finset (Vertex L)) :
    Matrix (RegionConfiguration q A) (RegionConfiguration q A) ℂ :=
  coefficientMatrix Ω A * (coefficientMatrix Ω A).conjTranspose

theorem reducedDensity_isHermitian {L q : ℕ} (Ω : State L q)
    (A : Finset (Vertex L)) : (reducedDensity Ω A).IsHermitian := by
  exact Matrix.isHermitian_mul_conjTranspose_self _

                                                                    
                                                                    
def vonNeumannEntropy {L q : ℕ} (Ω : State L q) (A : Finset (Vertex L)) : ℝ :=
  ∑ i, Real.negMulLog ((reducedDensity_isHermitian Ω A).eigenvalues i)

                                                                               
                                                                          
def boundaryCard {L : ℕ} (A : Finset (Vertex L)) : ℕ := by
  classical
  exact Fintype.card {e : Edge L //
    (e.val.1 ∈ A ∧ e.val.2 ∉ A) ∨ (e.val.1 ∉ A ∧ e.val.2 ∈ A)}

                                                                             
                                                                           
                                                                           
def UniformAreaLaw : Prop :=
  ∀ (q : ℕ), 2 ≤ q → ∀ (J Δ : ℝ), 0 < J → 0 < Δ →
    ∃ C_A : ℝ, 0 < C_A ∧
      ∀ (L : ℕ), 2 ≤ L →
      ∀ (hv : Vertex L → Operator L q) (he : Edge L → Operator L q)
        (Ω : State L q) (E₀ : ℝ),
        IsGridHamiltonian J hv he →
        UniqueGround (Hamiltonian hv he) Ω E₀ →
        FullSystemGap (Hamiltonian hv he) Ω E₀ Δ →
        ∀ A : Finset (Vertex L),
          vonNeumannEntropy Ω A ≤ C_A * (boundaryCard A : ℝ)

end PolynomialPEPS.PhysicalMove

end
end

end OAI