import Mathlib
import OAI.Computability.VertexCover.Reduction.HonestLargeSumIndependent
import OAI.Computability.VertexCover.Machines.Primitives
import OAI.Computability.VertexCover.Machines.ProfileSlot
import OAI.Computability.VertexCover.Machines.ProfileCompat
import OAI.Computability.VertexCover.Machines.NormRepresentation

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
                                   
section

namespace VertexCover.LabelCover
abbrev TracePos (d : ℕ) := Bool × Fin d
abbrev ProfileRep (a b d : ℕ) := TracePos d × Query.Profile a b d
abbrev TraceWeights (a b d : ℕ) := TracePos d → Fin ((max a b)^(d-1)) → Fin (2*d+1)
abbrev Descriptor (a b d : ℕ) :=
  (ProfileRep a b d → Bool) × ((TracePos d × TracePos d → Bool) ×
    ((ProfileRep a b d × ProfileRep a b d → Bool) × TraceWeights a b d))
namespace Descriptor
variable {a b d : ℕ}
abbrev Rep (D : Descriptor a b d) := {r : ProfileRep a b d // D.1 r=true}
noncomputable def slot (D : Descriptor a b d) (r : ProfileRep a b d) : ℕ := by
  classical
  exact (Finset.univ.toList.filter (fun P => D.1 (r.1,P))).idxOf r.2
noncomputable def term (D : Descriptor a b d) (r : ProfileRep a b d) : ℝ :=
  ∑ x : TracePos d, if D.2.1 (x,r.1)=true then
    if h : D.slot r < (max a b)^(d-1) then (gridRational d (D.2.2.2 x ⟨D.slot r,h⟩) : ℝ) else 0
    else 0
def Good (D : Descriptor a b d) (S : Finset D.Rep) : Prop :=
  (∀ r ∈ S, ∀ s ∈ S, D.2.1 (r.val.1,s.val.1)=true → r=s) ∧
  (∀ r ∈ S, ∀ s ∈ S, D.2.2.1 (r.val,s.val)=true)
noncomputable def test (t : ℝ) (D : Descriptor a b d) : Bool := by
  classical
  exact decide (∀ S : Finset D.Rep, D.Good S → |∑ r ∈ S, D.term r.val| ≤ 2*t)
end Descriptor

variable {Φ : LabelCover} {d : ℕ}
def diagram (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d) : Descriptor Φ.qU Φ.qV d :=
  (fun r => decide ((Q r.1).ProfileValid r.2),
    (fun xy => decide (Q xy.1=Q xy.2), (fun rs => decide (Query.ProfilePair (Q rs.1.1) (Q rs.2.1) rs.1.2 rs.2.2),W)))
noncomputable def diagramCoordinate (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d)
    (r : (diagram Q W).Rep) : Φ.Coordinate d :=
  ⟨Q r.val.1,(Q r.val.1).decode r.val.2 (of_decide_eq_true r.property)⟩
noncomputable def diagramSum (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d) : Φ.Coordinate d → ℝ :=
  ∑ x, Φ.increment (Q x) (fun k => (gridRational d (W x ((Q x).slotPermutation k)) : ℝ))
 theorem diagram_coordinate_encode (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d)
    (r : (diagram Q W).Rep) : (Q r.val.1).encode (diagramCoordinate Q W r).2=r.val.2 :=
  (Q r.val.1).encode_decode r.val.2 (of_decide_eq_true r.property)
 theorem diagram_slot (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d)
    (r : (diagram Q W).Rep) : (diagram Q W).slot r.val=((Q r.val.1).profileSlot (diagramCoordinate Q W r).2).val := by
  classical
  simp only [Descriptor.slot,diagram,Query.profileSlot,Query.profileLabels,diagram_coordinate_encode]
 theorem diagram_term (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d)
    (r : (diagram Q W).Rep) : (diagram Q W).term r.val=diagramSum Q W (diagramCoordinate Q W r) := by
  classical
  rw [Descriptor.term]
  simp only [diagramSum,Finset.sum_apply]
  apply Finset.sum_congr rfl
  intro x _
  change (if decide (Q x=Q r.val.1)=true then
    if h : (diagram Q W).slot r.val < Φ.WeightDimension d then
      (gridRational d (W x ⟨_,h⟩) : ℝ) else 0 else 0)=_
  simp only [decide_eq_true_eq]
  by_cases h : Q x=Q r.val.1
  · have hs := diagram_slot Q W r
    have ht : (diagram Q W).slot r.val < Φ.WeightDimension d := hs.symm ▸ ((Q r.val.1).profileSlot _).isLt
    rw [ite_eq_left h,dite_eq_left ht]
    simp only [h,diagramCoordinate,increment_same,Query.slotPermutation_apply]
    exact congrArg (fun k => (gridRational d (W x k) : ℝ)) (Fin.ext hs)
  · rw [ite_eq_right h]
    exact (Φ.increment_other (Q x) _ (diagramCoordinate Q W r) (Ne.symm h)).symm
 theorem diagram_good (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d)
    (S : Finset (diagram Q W).Rep) :
    (diagram Q W).Good S ↔ Set.InjOn (diagramCoordinate Q W) S ∧
      Φ.Compatible (S.image (diagramCoordinate Q W)) := by
  classical
  have pair (r s : (diagram Q W).Rep) :
      (diagram Q W).2.2.1 (r.val,s.val)=true ↔
        Query.LabelPair (diagramCoordinate Q W r).1 (diagramCoordinate Q W s).1
          (diagramCoordinate Q W r).2 (diagramCoordinate Q W s).2 := by
    simp only [diagram,decide_eq_true_eq]
    rw [← diagram_coordinate_encode Q W r,← diagram_coordinate_encode Q W s]
    exact Query.profilePair_iff _ _ _ _
  constructor
  · rintro ⟨hu,hp⟩
    have hi : Set.InjOn (diagramCoordinate Q W) S := by
      intro r hr s hs he
      exact hu r hr s hs (by simp only [diagram,decide_eq_true_eq]; exact congrArg Sigma.fst he)
    refine ⟨hi,(Φ.compatible_pair_iff _).mpr ⟨?_,?_⟩⟩
    · intro p hp' q hq' he
      obtain ⟨r,hr,rfl⟩ := Finset.mem_image.mp hp'
      obtain ⟨s,hs,rfl⟩ := Finset.mem_image.mp hq'
      exact congrArg (diagramCoordinate Q W) (hu r hr s hs (by change Q r.val.1=Q s.val.1 at he; exact decide_eq_true he))
    · intro p hp' q hq'
      obtain ⟨r,hr,rfl⟩ := Finset.mem_image.mp hp'
      obtain ⟨s,hs,rfl⟩ := Finset.mem_image.mp hq'
      exact (pair r s).mp (hp r hr s hs)
  · rintro ⟨hi,hc⟩
    obtain ⟨hu,hp⟩ := (Φ.compatible_pair_iff _).mp hc
    refine ⟨?_,?_⟩
    · intro r hr s hs he
      exact hi hr hs (hu _ (Finset.mem_image.mpr ⟨r,hr,rfl⟩) _ (Finset.mem_image.mpr ⟨s,hs,rfl⟩)
        (by change decide (Q r.val.1=Q s.val.1)=true at he; exact of_decide_eq_true he))
    · intro r hr s hs
      exact (pair r s).mpr (hp _ (Finset.mem_image.mpr ⟨r,hr,rfl⟩) _ (Finset.mem_image.mpr ⟨s,hs,rfl⟩))
 theorem diagram_test (Q : TracePos d → Φ.Query d) (W : TraceWeights Φ.qU Φ.qV d) (t : ℝ) :
    (diagram Q W).test t=true ↔ Φ.compatibilityNorm (diagramSum Q W) ≤ 2*t := by
  classical
  let B := Finset.univ.image Q
  have hz (p : Φ.Coordinate d) (hp : p.1 ∉ B) : diagramSum Q W p=0 := by
    simp only [diagramSum,Finset.sum_apply]
    apply Finset.sum_eq_zero
    intro x _
    exact Φ.increment_other _ _ _ (fun he => hp (Finset.mem_image.mpr ⟨x,Finset.mem_univ _,he.symm⟩))
  have hc (p : Φ.Coordinate d) (hp : p.1 ∈ B) : ∃ r, diagramCoordinate Q W r=p := by
    obtain ⟨x,_,hx⟩ := Finset.mem_image.mp hp
    rcases p with ⟨i,A⟩
    dsimp at hx
    subst i
    let r : (diagram Q W).Rep := ⟨(x,(Q x).encode A),decide_eq_true ((Q x).encode_valid A)⟩
    refine ⟨r,?_⟩
    change (⟨Q x,(Q x).decode ((Q x).encode A) _⟩ : Φ.Coordinate d)=⟨Q x,A⟩
    congr 1
    apply (Q x).encode_injective
    exact (Q x).encode_decode _ _
  rw [Φ.norm_le_representations (diagramCoordinate Q W) _ B hz hc]
  simp only [Descriptor.test,decide_eq_true_eq,diagram_term]
  constructor
  · intro h S hi hs; exact h S ((diagram_good Q W S).mpr ⟨hi,hs⟩)
  · intro h S hs
    obtain ⟨hi,hc'⟩ := (diagram_good Q W S).mp hs
    exact h S hi hc'
end VertexCover.LabelCover
end


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI