import Mathlib
import OAI.Computability.VertexCover.PCP.TableGapReduction
import OAI.Computability.VertexCover.Reduction.SimpleParallel

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

theorem value_le_of_counts (Φ : LabelCover) (σ : ℝ)
    (h : ∀ A : Φ.Labeling, (Φ.satisfiedCount A : ℝ) ≤ σ * Φ.M) : Φ.value ≤ σ := by
  classical
  obtain ⟨A, _, hA⟩ := Finset.exists_mem_eq_sup (Finset.univ : Finset Φ.Labeling)
    ⟨Φ.defaultLabeling, Finset.mem_univ _⟩ Φ.satisfiedCount
  apply (div_le_iff₀ (Nat.cast_pos.mpr Φ.M_pos)).mpr
  change ((Finset.univ.sup Φ.satisfiedCount : ℕ) : ℝ) ≤ _
  rw [hA]
  exact h A

def ParallelCoherent (Φ : LabelCover) : Prop :=
  ∀ e e', Φ.left e = Φ.left e' → Φ.right e = Φ.right e' → Φ.projection e = Φ.projection e'

end VertexCover.LabelCover

namespace VertexCover.ClauseProjection
open UniqueGames.Foundations
open Target

theorem failureCount_eq_sum (F : Formula) (a : Fin F.«variables» → Bool)
    (indices : List (Fin F.clauses.length)) :
    PCP.failureCount F a indices =
      (indices.map (fun i => if (F.clauses.get i).eval a = false then 1 else 0)).sum := by
  induction indices with
  | nil => rfl
  | cons i rest ih =>
      simp only [PCP.failureCount, List.map_cons, List.sum_cons, ih]
      congr 1
      unfold PCP.clauseFailure PCP.clauseAt
      change (if (F.clauses.get i).eval a = true then 0 else 1) = _
      cases (F.clauses.get i).eval a <;> rfl

theorem failureCount_all (F : Formula) (a : Fin F.«variables» → Bool) :
    PCP.failureCount F a (PCP.allIndices F) = (unsatisfiedClauses F a).card := by
  rw [failureCount_eq_sum]
  simp only [PCP.allIndices, List.finRange, List.map_ofFn, List.sum_ofFn, Function.comp_apply]
  exact (Finset.card_filter _ _).symm

theorem simple_value_le (F : Formula) (η : ℚ) (hgap : Hastad.SourceGap.ClauseGap F η) :
    (simpleGame F hgap.1).value ≤ 1 - (η : ℝ) / 3 := by
  classical
  apply LabelCover.value_le_of_counts
  intro A
  have hbad := hgap.2 (assignmentOf F hgap.1 (decodedLabeling F hgap.1 A))
  rw [failureCount_all] at hbad
  have hreject := simple_rejection_count F hgap.1 A
  have hrejectR := Nat.cast_le (α := ℝ) |>.mpr hreject
  have hpart := Finset.card_filter_add_card_filter_not ((simpleGame F hgap.1).Satisfies A)
    (s := Finset.univ)
  have hpartR : ((simpleGame F hgap.1).satisfiedCount A : ℝ) +
      ((Finset.univ.filter (fun e => ¬(simpleGame F hgap.1).Satisfies A e)).card : ℝ) =
      (F.clauses.length : ℝ) * 3 := by
    simp only [Finset.card_univ, Fintype.card_fin] at hpart
    change (simpleGame F hgap.1).satisfiedCount A + _ = F.clauses.length * 3 at hpart
    exact_mod_cast hpart
  change ((simpleGame F hgap.1).satisfiedCount A : ℝ) ≤
    (1 - (η : ℝ) / 3) * ((F.clauses.length * 3 : ℕ) : ℝ)
  push_cast
  nlinarith

noncomputable def fixedBaseTable : PCP.RoundTables.BaseTable :=
  PCP.ExpanderTables.exists_base_table.choose

theorem fixedBaseTable_certificate :
    PCP.SpectralReturn.SpectralCertificate (PCP.ExpanderTables.graph fixedBaseTable) (1/100 : ℝ) :=
  PCP.ExpanderTables.exists_base_table.choose_spec

noncomputable def baseReduction (F : Formula) : LabelCover :=
  simpleGame (PCP.TableIteration.gapMap fixedBaseTable F)
    (PCP.TableIteration.gapMap_nonempty fixedBaseTable F)

theorem baseReduction_complete (F : Formula) (hF : F.Satisfiable) :
    ∃ A : (baseReduction F).Labeling, ∀ e, (baseReduction F).Satisfies A e :=
  simple_perfect_complete _ _ (PCP.TableIteration.gapMap_completeness fixedBaseTable F hF)

theorem baseReduction_sound (F : Formula) (hF : ¬F.Satisfiable) :
    (baseReduction F).value ≤ 1 - (PCP.PCPIteration.finalClauseGap : ℝ) / 3 :=
  simple_value_le _ _ (PCP.TableGapReduction.gapMap_clauseGap fixedBaseTable
    fixedBaseTable_certificate F hF)

theorem baseReduction_coherent (F : Formula) : (baseReduction F).ParallelCoherent :=
  simple_parallel _ _

end VertexCover.ClauseProjection


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