import Mathlib
import OAI.Computability.VertexCover.Reduction.IncrementNorm
import OAI.Computability.VertexCover.Reduction.ListHitMaximum
import OAI.Computability.VertexCover.Reduction.PairEventMean

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

noncomputable def incidence (Φ : LabelCover) {d : ℕ} (seed : Φ.Seeds d)
    (I : Finset (Φ.Coordinate d)) :
    Fin d → Fin (Φ.WeightDimension d) → ℝ := fun j k =>
  truthValue (∃ a : (Φ.query seed j).LocalLabel,
    (⟨Φ.query seed j, a⟩ : Φ.Coordinate d) ∈ I ∧ (Φ.query seed j).slot a = k)

theorem incidence_at_label (Φ : LabelCover) {d : ℕ} (seed : Φ.Seeds d)
    (I : Finset (Φ.Coordinate d)) (j : Fin d) (a : (Φ.query seed j).LocalLabel) :
    Φ.incidence seed I j ((Φ.query seed j).slot a) =
      truthValue ((⟨Φ.query seed j, a⟩ : Φ.Coordinate d) ∈ I) := by
  unfold incidence
  congr 1
  apply propext
  constructor
  · rintro ⟨b, hb, heq⟩
    have : b = a := (Φ.query seed j).slot_injective heq
    simpa [this] using hb
  · intro ha; exact ⟨a, ha, rfl⟩

theorem incidence_eq_single (Φ : LabelCover) {d : ℕ} (seed : Φ.Seeds d)
    {I : Finset (Φ.Coordinate d)} (hI : Φ.Compatible I) (j : Fin d)
    (a : (Φ.query seed j).LocalLabel)
    (ha : (⟨Φ.query seed j, a⟩ : Φ.Coordinate d) ∈ I) (k : Fin (Φ.WeightDimension d)) :
    Φ.incidence seed I j k = truthValue ((Φ.query seed j).slot a = k) := by
  unfold incidence
  congr 1
  apply propext
  constructor
  · rintro ⟨b, hb, hbk⟩
    have hab : b = a := by
      have := hI.1 ⟨_, b⟩ hb ⟨_, a⟩ ha rfl
      exact Sigma.mk.inj_iff.mp this |>.2 |> eq_of_heq
    simpa [hab] using hbk
  · intro h; exact ⟨a, ha, h⟩

theorem incidence_block_bound (Φ : LabelCover) {d : ℕ} (seed : Φ.Seeds d)
    {I : Finset (Φ.Coordinate d)} (hI : Φ.Compatible I) (j : Fin d) :
    ∑ k, |Φ.incidence seed I j k| ≤ 1 := by
  classical
  by_cases h : ∃ a : (Φ.query seed j).LocalLabel,
      (⟨Φ.query seed j, a⟩ : Φ.Coordinate d) ∈ I
  · obtain ⟨a, ha⟩ := h
    simp_rw [Φ.incidence_eq_single seed hI j a ha]
    have ht : ∀ P, |truthValue P| = truthValue P := by
      intro P; by_cases hP : P <;> simp [truthValue, hP]
    simp_rw [ht]
    simp [truthValue, eq_comm]
  · have hz : ∀ k, Φ.incidence seed I j k = 0 := by
      intro k
      simp only [incidence, truthValue]
      rw [ite_eq_right (fun ⟨label, hlabel, _⟩ => h ⟨label, hlabel⟩)]
    simp [hz]

noncomputable def incidenceHull (Φ : LabelCover) {d : ℕ} (seed : Φ.Seeds d) :
    Set (Fin d → Fin (Φ.WeightDimension d) → ℝ) :=
  convexHull ℝ {g | ∃ I, Φ.Compatible I ∧
    (g = Φ.incidence seed I ∨ g = -Φ.incidence seed I)}

noncomputable def listMass (Φ : LabelCover) {d : ℕ} (L : Φ.PrivateLists d)
    (seed : Φ.Seeds d) (J : Finset (Fin d))
    (g : Fin d → Fin (Φ.WeightDimension d) → ℝ) : ℝ :=
  ∑ j ∈ J, ∑ a ∈ (L (Φ.query seed j)).toFinset, |g j ((Φ.query seed j).slot a)|

theorem listMass_convex_sublevel (Φ : LabelCover) {d : ℕ} (L : Φ.PrivateLists d)
    (seed : Φ.Seeds d) (J : Finset (Fin d)) (C : ℝ) :
    Convex ℝ {g | Φ.listMass L seed J g ≤ C} := by
  classical
  intro x hx y hy a b ha hb hab
  change Φ.listMass L seed J (a • x + b • y) ≤ C
  calc
    _ ≤ ∑ j ∈ J, ∑ z ∈ (L (Φ.query seed j)).toFinset,
        (a * |x j ((Φ.query seed j).slot z)| + b * |y j ((Φ.query seed j).slot z)|) := by
      apply Finset.sum_le_sum; intro j hj
      apply Finset.sum_le_sum; intro z hz
      simpa only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, abs_mul,
        abs_of_nonneg ha, abs_of_nonneg hb] using
        abs_add_le (a*x j ((Φ.query seed j).slot z)) (b*y j ((Φ.query seed j).slot z))
    _ = a * Φ.listMass L seed J x + b * Φ.listMass L seed J y := by
      simp [listMass, Finset.sum_add_distrib, Finset.mul_sum]
    _ ≤ a*C + b*C := add_le_add (mul_le_mul_of_nonneg_left hx ha)
      (mul_le_mul_of_nonneg_left hy hb)
    _ = C := by rw [← add_mul, hab, one_mul]

theorem listMass_incidence (Φ : LabelCover) {d : ℕ} (L : Φ.PrivateLists d)
    (seed : Φ.Seeds d) (J : Finset (Fin d))
    {I : Finset (Φ.Coordinate d)} (hI : Φ.Compatible I) :
    Φ.listMass L seed J (Φ.incidence seed I) = (Φ.hitPositions L seed I J).card := by
  classical
  have hblock : ∀ j, (∑ a ∈ (L (Φ.query seed j)).toFinset,
      |Φ.incidence seed I j ((Φ.query seed j).slot a)|) =
      truthValue (Φ.ListHit L seed I j) := by
    intro j
    by_cases h : Φ.ListHit L seed I j
    · obtain ⟨a, haL, haI⟩ := h
      have honly : ∀ b : (Φ.query seed j).LocalLabel,
          (⟨Φ.query seed j, b⟩ : Φ.Coordinate d) ∈ I ↔ b = a := by
        intro b
        constructor
        · intro hb
          have := hI.1 ⟨_, b⟩ hb ⟨_, a⟩ haI rfl
          exact Sigma.mk.inj_iff.mp this |>.2 |> eq_of_heq
        · rintro rfl; exact haI
      simp_rw [Φ.incidence_at_label, honly]
      have ht : ∀ P, |truthValue P| = truthValue P := by
        intro P; by_cases hP : P <;> simp [truthValue, hP]
      simp_rw [ht]
      rw [show truthValue (Φ.ListHit L seed I j) = 1 by
        simp [truthValue, show Φ.ListHit L seed I j from ⟨a, haL, haI⟩]]
      rw [Finset.sum_eq_single a]
      · simp [truthValue]
      · intro b hb hba; simp [truthValue, hba]
      · intro ha; exact (ha (List.mem_toFinset.mpr haL)).elim
    · have hz : ∀ a ∈ (L (Φ.query seed j)).toFinset,
          (⟨Φ.query seed j, a⟩ : Φ.Coordinate d) ∉ I := by
        intro a ha haI
        exact h ⟨a, List.mem_toFinset.mp ha, haI⟩
      rw [show truthValue (Φ.ListHit L seed I j) = 0 by simp [truthValue, h]]
      apply Finset.sum_eq_zero
      intro a ha
      rw [Φ.incidence_at_label]
      simp [truthValue, hz a ha]
  simp only [listMass, hblock]
  rw [hitPositions, Finset.card_filter]
  push_cast
  apply Finset.sum_congr rfl
  intro j hj
  by_cases h : Φ.ListHit L seed I j <;> simp [truthValue, h]

theorem listMass_le_hitMaximum (Φ : LabelCover) {d : ℕ} (L : Φ.PrivateLists d)
    (seed : Φ.Seeds d) (J : Finset (Fin d))
    {g : Fin d → Fin (Φ.WeightDimension d) → ℝ}
    (hg : g ∈ Φ.incidenceHull seed) :
    Φ.listMass L seed J g ≤ Φ.listHitMaximum L seed J := by
  classical
  apply convexHull_min (t := {g | Φ.listMass L seed J g ≤
    (Φ.listHitMaximum L seed J : ℝ)}) ?_ (Φ.listMass_convex_sublevel L seed J _) hg
  rintro z ⟨I, hI, rfl | rfl⟩
  · change Φ.listMass L seed J (Φ.incidence seed I) ≤ _
    rw [Φ.listMass_incidence L seed J hI]
    exact_mod_cast (Finset.le_sup (f := fun I => (Φ.hitPositions L seed I J).card)
      (show I ∈ Φ.compatibleSelections d from by
      simp [compatibleSelections, hI]))
  · change Φ.listMass L seed J (-Φ.incidence seed I) ≤ _
    have hn : Φ.listMass L seed J (-Φ.incidence seed I) =
        Φ.listMass L seed J (Φ.incidence seed I) := by simp [listMass]
    rw [hn, Φ.listMass_incidence L seed J hI]
    exact_mod_cast (Finset.le_sup (f := fun I => (Φ.hitPositions L seed I J).card)
      (show I ∈ Φ.compatibleSelections d from by
      simp [compatibleSelections, hI]))

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