import OAI.Combinatorics.CliqueFree.Projection

namespace OAI

noncomputable section

open scoped BigOperators
open Finset

attribute [local instance] Classical.propDecidable

namespace CliqueFreeIndependence.WeightedGraph

universe u v

variable {V : Type u} [Fintype V]

attribute [local instance 10000] edgeStateDecEq

namespace Splitting
variable {G : SimpleGraph V}

noncomputable def graph (F : EdgeState G → EdgeState G)
    (hF : ∀ e, (F e).src = e.src) (good : EdgeState G → Prop) : SimpleGraph (EdgeState G) where
  Adj a b := ∃ e, good e ∧ good e.rev ∧ F e = a ∧ F e.rev = b
  symm := ⟨by
    rintro a b ⟨e, he, hr, ha, hb⟩
    exact ⟨e.rev, hr, by simpa using he, hb, by simpa using ha⟩⟩
  loopless := ⟨by
    rintro a ⟨e, he, hr, ha, hb⟩
    have heq : e.src = e.dst := by
      calc
        e.src = (F e).src := (hF e).symm
        _ = (F e.rev).src := congrArg EdgeState.src (ha.trans hb.symm)
        _ = e.dst := hF e.rev
    exact e.adj.ne heq⟩

omit [Fintype V] in
lemma projection (F : EdgeState G → EdgeState G)
    (hF : ∀ e, (F e).src = e.src) (good : EdgeState G → Prop) :
    EdgeProjection (graph F hF good) G EdgeState.src := by
  have endpoints {a b : EdgeState G} {e : EdgeState G} (ha : F e = a) (hb : F e.rev = b) :
      a.src = e.src ∧ b.src = e.dst :=
    ⟨by rw [← ha, hF], by rw [← hb, hF]; rfl⟩
  constructor
  · rintro a b ⟨e, _, _, ha, hb⟩
    obtain ⟨hs, ht⟩ := endpoints ha hb
    rw [hs, ht]
    exact e.adj
  · rintro a b c d ⟨e, _, _, ha, hb⟩ ⟨f, _, _, hc, hd⟩ hac hbd
    obtain ⟨he1, he2⟩ := endpoints ha hb
    obtain ⟨hf1, hf2⟩ := endpoints hc hd
    have hef : e = f := Subtype.ext (Prod.ext (he1.symm.trans (hac.trans hf1))
      (he2.symm.trans (hbd.trans hf2)))
    subst f
    exact ⟨ha.symm.trans hc, hb.symm.trans hd⟩

lemma neighborMass_le (w : V → ℝ) (F : EdgeState G → EdgeState G)
    (hF : ∀ e, (F e).src = e.src) (good : EdgeState G → Prop)
    (K : EdgeState G → EdgeState G → ℝ) (hK0 : ∀ a e, 0 ≤ K a e)
    (hK1 : ∀ a, ∑ e, K a e = 1) {L : ℝ} (hL : 0 ≤ L)
    (hadm : ∀ e, good e → w e.dst ≤ L * K (F e) e) (a : EdgeState G) :
    neighborMass (graph F hF good) (w ∘ EdgeState.src) a ≤ L := by
  classical
  let H := graph F hF good
  let N := ↑(neighbors H a)
  have hproj := projection F hF good
  let f : N → EdgeState G := fun b ↦
    ⟨(a.src, b.val.src), hproj.map_adj _ _ ((mem_neighbors _ _ _).1 b.property)⟩
  have hf : Function.Injective f := by
    intro b c heq
    apply Subtype.ext
    apply hproj.neighbor_injective a b.property c.property
    exact congrArg (fun e : EdgeState G ↦ e.dst) heq
  have hle (b : N) : w b.val.src ≤ L * K a (f b) := by
    obtain ⟨e, he, _, ha, hb⟩ := (mem_neighbors H a b.val).1 b.property
    have hef : f b = e := by
      apply Subtype.ext
      apply Prod.ext
      · exact (congrArg EdgeState.src ha).symm.trans (hF e)
      · exact (congrArg EdgeState.src hb).symm.trans (hF e.rev)
    rw [hef, ← ha]
    have hd : b.val.src = e.dst := (congrArg EdgeState.src hb).symm.trans (hF e.rev)
    simpa only [hd] using hadm e he
  calc
    _ = ∑ b : N, w b.val.src := (sum_coe_sort (neighbors H a) (fun b ↦ w b.src)).symm
    _ ≤ ∑ b : N, L * K a (f b) := sum_le_sum (fun b _ ↦ hle b)
    _ = L * ∑ b : N, K a (f b) := (mul_sum _ _ _).symm
    _ ≤ L * ∑ e, K a e := mul_le_mul_of_nonneg_left (sum_injective_le f hf (K a) (hK0 a)) hL
    _ = L := by rw [hK1, mul_one]

/-- All three corner agreements and all six admissible incidences. -/
def Survives (F : EdgeState G → EdgeState G) (good : EdgeState G → Prop)
    (t : TriangleState G) : Prop :=
  F t.edge12 = F t.edge13 ∧
  F t.edge12.rev = F t.edge23 ∧
  F t.edge13.rev = F t.edge23.rev ∧
  good t.edge12 ∧ good t.edge12.rev ∧ good t.edge13 ∧ good t.edge13.rev ∧
  good t.edge23 ∧ good t.edge23.rev

lemma triangleMass_surviving_le {w : V → ℝ} (hw : ∀ v, 0 ≤ w v)
    (F : EdgeState G → EdgeState G) (hF : ∀ e, (F e).src = e.src)
    (good : EdgeState G → Prop) :
    (∑ t : TriangleState G, if Survives F good t then TriangleState.weight w t else 0) ≤
      6 * triangleMass (graph F hF good) (w ∘ EdgeState.src) := by
  classical
  let H := graph F hF good
  let S := {t : TriangleState G // Survives F good t}
  let f : S → TriangleState H := fun t ↦
    ⟨(F t.val.edge12, F t.val.edge12.rev, F t.val.edge13.rev),
      ⟨t.val.edge12, t.property.2.2.2.1, t.property.2.2.2.2.1, rfl, rfl⟩,
      ⟨t.val.edge13, t.property.2.2.2.2.2.1, t.property.2.2.2.2.2.2.1, t.property.1.symm, rfl⟩,
      ⟨t.val.edge23, t.property.2.2.2.2.2.2.2.1, t.property.2.2.2.2.2.2.2.2,
        t.property.2.1.symm, t.property.2.2.1.symm⟩⟩
  have coords (t : S) :
      (f t).first.src = t.val.first ∧ (f t).second.src = t.val.second ∧
        (f t).third.src = t.val.third := by
    change (F t.val.edge12).src = _ ∧ (F t.val.edge12.rev).src = _ ∧ (F t.val.edge13.rev).src = _
    simp only [hF]
    exact ⟨rfl, rfl, rfl⟩
  have hf : Function.Injective f := by
    intro t s hts
    apply Subtype.ext
    apply Subtype.ext
    apply Prod.ext
    · exact (coords t).1.symm.trans ((congrArg (fun a : TriangleState H ↦ a.first.src) hts).trans (coords s).1)
    · apply Prod.ext
      · exact (coords t).2.1.symm.trans ((congrArg (fun a : TriangleState H ↦ a.second.src) hts).trans (coords s).2.1)
      · exact (coords t).2.2.symm.trans ((congrArg (fun a : TriangleState H ↦ a.third.src) hts).trans (coords s).2.2)
  calc
    _ = ∑ t : S, TriangleState.weight w t.val := by
      rw [← sum_filter]
      exact Finset.sum_subtype _ (by simp) _
    _ = ∑ t : S, TriangleState.weight (w ∘ EdgeState.src) (f t) := by
      apply sum_congr rfl
      intro t _
      simp only [TriangleState.weight, Function.comp_apply, (coords t).1, (coords t).2.1, (coords t).2.2]
    _ ≤ ∑ t : TriangleState H, TriangleState.weight (w ∘ EdgeState.src) t :=
      sum_injective_le f hf _ (fun t ↦ mul_nonneg (mul_nonneg (hw _) (hw _)) (hw _))
    _ = _ := TriangleState.sum_weight _

end Splitting

end CliqueFreeIndependence.WeightedGraph

end

end OAI