import Mathlib.Data.Rat.Cast.Order
import Mathlib.Basic.Real.Basic
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.NormNum
import OAI.Computability.BinPacking.Configurations.K4Soundness
import OAI.Computability.BinPacking.Configurations.ReductionCompleteness
import OAI.Computability.BinPacking.Machines.GraphPackingOutput
import OAI.Computability.BinPacking.PCP.PCPSourceHardness
import OAI.Computability.BinPacking.Packing.LiteralSlotGap

namespace OAI

noncomputable section

namespace BinPackingGap.PCPFoundation

section

open BinPackingGames.Foundations
open Target
open BinPackingCompleteness

def gap : ℚ := PCPSource.sourceGap

def rho : ℝ := (gap : ℝ) / 6

theorem gap_pos : 0 < gap := PCPSource.sourceGap_pos

theorem gap_cast_pos : (0 : ℝ) < gap := by exact_mod_cast gap_pos

theorem rho_pos : 0 < rho := div_pos gap_cast_pos (by norm_num)

theorem rho_lt_gap_third : rho < (gap : ℝ) / 3 := by
  unfold rho
  nlinarith [gap_cast_pos]

def formula (F : Formula) : Formula := PCPSource.normalizedFormula F

def graph (F : Formula) : GraphInput := LiteralSlotGraph.graph (formula F)

def target (F : Formula) : ℕ := 2 * (formula F).clauses.length

theorem formula_nonempty (F : Formula) : (formula F).clauses ≠ [] :=
  PCPSource.normalizedFormula_nonempty F

theorem clause_count_pos (F : Formula) : 0 < (formula F).clauses.length :=
  List.length_pos_iff.mpr (formula_nonempty F)

theorem edges_nonempty (F : Formula) : (graph F).edges ≠ [] :=
  LiteralSlotGraph.graph_edges_nonempty (formula F) (formula_nonempty F)

theorem target_le_vertices (F : Formula) : target F ≤ (graph F).n := by
  change 2 * (formula F).clauses.length ≤ 3 * (formula F).clauses.length
  omega

theorem cover_complete (F : Formula) (hF : F.Satisfiable) :
    (graph F).CoverAtMost (target F) :=
  LiteralSlotGraph.coverAtMost_of_satisfiable (formula F)
    ((PCPSource.normalizedFormula_satisfiable_iff F).mpr hF)

theorem failedCount_eq_card (F : Formula) (A : Fin F.variables → Bool) :
    PCP.NameCompaction.failedCount F A = (LiteralSlotGraph.failedClauses F A).card := by
  rw [PCPSource.failedCount_eq_fin_sum]
  simpa only [PCP.clauseAt, Fin.getElem_fin] using! (LiteralSlotGraph.failedClauses_card_sum F A).symm

private theorem realGapOfRatGap (q : ℚ) (m n : ℕ)
    (h : q * (m : ℚ) ≤ (n : ℚ)) : (q : ℝ) * (m : ℝ) ≤ (n : ℝ) := by
  exact_mod_cast h

private theorem realCountBound (a b c : ℕ) (h : a + b ≤ c) :
    (a : ℝ) + (b : ℝ) ≤ (c : ℝ) := by
  exact_mod_cast h

theorem normalized_failed_gap (F : Formula) (hF : ¬ F.Satisfiable)
    (A : Fin (PCPSource.normalizedFormula F).variables → Bool) :
    PCPSource.sourceGap * ((PCPSource.normalizedFormula F).clauses.length : ℚ) ≤
      ((LiteralSlotGraph.failedClauses (PCPSource.normalizedFormula F) A).card : ℚ) := by
  have bound := PCPSource.clauseGap F hF A
  rw [PCPSource.violatedCount_eq_failedCount F A, failedCount_eq_card] at bound
  exact bound

private theorem cover_bound_from_failed_gap (G : Formula) (q : ℚ)
    (bound : ∀ A : Fin G.variables → Bool,
      q * (G.clauses.length : ℚ) ≤ ((LiteralSlotGraph.failedClauses G A).card : ℚ))
    (C : Finset (LiteralSlotGraph.graph G).Vertex)
    (hC : (LiteralSlotGraph.graph G).IsCover C) :
    ((2 * G.clauses.length : ℕ) : ℝ) + (q : ℝ) * (G.clauses.length : ℝ) ≤
      (C.card : ℝ) := by
  obtain ⟨A, hA⟩ := LiteralSlotGraph.assignment_count_of_cover G C hC
  have hgap := realGapOfRatGap q G.clauses.length _ (bound A)
  have hcount := realCountBound (2 * G.clauses.length)
    (LiteralSlotGraph.failedClauses G A).card C.card hA
  linarith only [hgap, hcount]

theorem cover_sound (F : Formula) (hF : ¬ F.Satisfiable)
    (C : Finset (graph F).Vertex) (hC : (graph F).IsCover C) :
    (target F : ℝ) + (gap : ℝ) * ((formula F).clauses.length : ℝ) ≤ (C.card : ℝ) :=
  cover_bound_from_failed_gap (formula F) gap (normalized_failed_gap F hF) C hC

theorem no_small_cover (F : Formula) (hF : ¬ F.Satisfiable)
    (C : Finset (graph F).Vertex) (hC : (graph F).IsCover C) :
    ¬ (C.card : ℝ) ≤ (target F : ℝ) + rho * ((graph F).n : ℝ) := by
  intro hsmall
  have hlarge := cover_sound F hF C hC
  have hm : (0 : ℝ) < (formula F).clauses.length := by
    exact_mod_cast clause_count_pos F
  have hn : ((graph F).n : ℝ) = 3 * ((formula F).clauses.length : ℝ) := by
    norm_num [graph, LiteralSlotGraph.graph_n]
  rw [hn] at hsmall
  unfold rho at hsmall
  nlinarith [mul_pos gap_cast_pos hm]

theorem normalizedSource (language : List Bool → Prop)
    (membership : Complexity.CookLevin.InNP language) :
    ∃ source : Complexity.CookLevin.PolynomialThreeSATReduction language,
    ∃ runtime : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
        Complexity.formulaBits (PCPSourceHardness.formula source),
      Complexity.MachineFiniteAlphabet.FiniteAlphabet runtime.tm ∧
      ∀ input : List Bool,
        ((PCPSourceHardness.formula source input).Satisfiable ↔ language input) ∧
        (PCPSourceHardness.formula source input).clauses ≠ [] ∧
        (∀ (clause : Clause (PCPSourceHardness.formula source input).variables),
          clause ∈ (PCPSourceHardness.formula source input).clauses →
          ∀ i j : Fin 3, clause[i].variableIndex = clause[j].variableIndex → i = j) ∧
        (¬ language input →
          SourceAmplification.ClauseGap (PCPSource.clauseFamily (source.reduce input))
            PCPSource.sourceGap) :=
  PCPSourceHardness.normalizedSource language membership

end

open BinPackingGames.Foundations.Target

def graphInput (F : Formula) : GraphReductionInput where
  graph := graph F
  k := target F
  k_le := target_le_vertices F
  nonempty := edges_nonempty F

def packingOutput (c : Nat) (F : Formula) : RawReductionOutput :=
  graphPackingOutput c rho (graphInput F)

theorem packingOutput_valid (c : Nat) (F : Formula) :
    (packingOutput c F).2.Valid :=
  graphPackingOutput_valid c rho (graphInput F)

theorem packingOutput_count (c : Nat) (F : Formula) :
    (packingOutput c F).2.length = 5 * (packingOutput c F).1 :=
  graphPackingOutput_length c rho (graphInput F)

theorem packingOutput_size_lower (c : Nat) (F : Formula)
    (i : ((packingOutput c F).2.toInstance (packingOutput_valid c F)).Item) :
    (1 / 6 : ℚ) < ((packingOutput c F).2.toInstance (packingOutput_valid c F)).size i :=
  (graphPackingOutput_size_bounds c rho (graphInput F) i).1

theorem packingOutput_complete (c : Nat) (F : Formula) (hF : F.Satisfiable) :
    HasPacking ((packingOutput c F).2.toInstance (packingOutput_valid c F))
      (packingOutput c F).1 := by
  apply (graphPackingOutput_hasPacking_iff c rho (graphInput F) _).mpr
  exact cover_hasPacking_reduction c rho (graph F) (target F)
    (target_le_vertices F) (cover_complete F hF)

theorem packingOutput_sound (c : Nat) (F : Formula) (hF : ¬ F.Satisfiable) :
    ¬ HasPacking ((packingOutput c F).2.toInstance (packingOutput_valid c F))
      ((packingOutput c F).1 + c) := by
  intro hp
  obtain ⟨p⟩ := (graphPackingOutput_hasPacking_iff c rho (graphInput F) _).mp hp
  obtain ⟨C, hcover, hsmall⟩ := packing_extracts_cover c rho rho_pos
    (graph F) (target F) (target_le_vertices F) p (Nat.le_refl _)
  exact no_small_cover F hF C hcover hsmall

end BinPackingGap.PCPFoundation

end

end OAI