lean/OAI/Combinatorics/MatchingCount/Sampling/ChosenChord.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.Components
import OAI.Combinatorics.MatchingCount.Sampling.Sewn

namespace OAI

namespace MatchingFPRAS.Transport.IndexedCycle

variable {V L : Type*} [Fintype V] [DecidableEq V] [DecidableEq L] [Fintype L]

variable {bags : V → Finset L} (c : IndexedCycle (BagEdge.Incident (bags := bags)))

variable {G : SimpleGraph L}

variable (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)

noncomputable def chosenChord (x y : ℕ) : BagEdge bags := by
  classical
  exact if h : x < y ∧ y < c.size ∧ (c.labelCycle hbags).Admissible x y then
    c.chord hbags x y h.1 h.2.1 h.2.2 else c.edgeAt 0

omit [Fintype V] [DecidableEq V] [Fintype L] in
lemma chosenChord_eq (x y : ℕ) (hxy : x < y) (hy : y < c.size)
    (ha : (c.labelCycle hbags).Admissible x y) :
    c.chosenChord hbags x y = c.chord hbags x y hxy hy ha := by
  unfold chosenChord
  rw [dite_eq_left (show x < y ∧ y < c.size ∧ (c.labelCycle hbags).Admissible x y from ⟨hxy,hy,ha⟩)]

noncomputable def diagramGain (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (x y : ℕ) : ℝ := c.signedGain R f x y (c.chosenChord hbags x y)

noncomputable def diagramTerm (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (x p q y : ℕ) : ℝ := by
  classical
  exact if h : (c.labelCycle hbags).Cell x p q y ∧ y < c.size then
    (c.cellCorners hbags h.1 h.2).signedLocalTerm (c.cellChords hbags h.1 h.2)
      (c.cellChords_incidence hbags h.1 h.2) R f else 0

omit [Fintype V] [Fintype L] in
lemma diagramGain_short (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (x : ℕ) (hx : x + 1 < c.size) : c.diagramGain hbags R f x (x+1)=0 := by
  have ha : (c.labelCycle hbags).Admissible x (x+1) := by
    refine ⟨(c.edgeAt x).color, (c.edge_color_fixed hbags x).1, ?_⟩
    simpa only [Nat.cast_add, Nat.cast_one] using (c.edge_color_fixed hbags x).2
  unfold diagramGain
  rw [c.chosenChord_eq hbags x (x+1) (by omega) hx ha,
    c.chord_short hbags _ _ _ _ _ rfl]
  exact c.signedGain_short R f x hx

omit [Fintype V] [Fintype L] in
lemma diagramGain_root (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ) :
    c.diagramGain hbags R f 0 (c.size-1) =
      f (R ∪ c.parityPattern 0) - f (R ∪ c.parityPattern 1) := by
  have hm := c.four_le
  have ha : (c.labelCycle hbags).Admissible 0 (c.size-1) := by
    refine ⟨(c.edgeAt (c.size-1)).color, ?_, (c.edge_color_fixed hbags (c.size-1)).1⟩
    have hh := (c.edge_color_fixed hbags (c.size-1)).2
    have he : ((c.size-1 : ℕ) : ℤ)+1 = (0 : ℤ)+c.size := by omega
    rw [he, c.labelSets_periodic hbags] at hh
    simpa only [Nat.cast_zero] using hh
  unfold diagramGain
  rw [c.chosenChord_eq hbags 0 (c.size-1) (by omega) (by omega) ha,
    c.chord_wrap hbags _ _ _ _ _ ⟨rfl,by omega⟩]
  exact c.signedGain_root R f

omit [Fintype V] [Fintype L] in
lemma diagram_cell_recurrence (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (x p q y : ℕ) (hc : (c.labelCycle hbags).Cell x p q y) (hy : y < c.size) :
    c.diagramGain hbags R f x y = c.diagramTerm hbags R f x p q y +
      c.diagramGain hbags R f x p + c.diagramGain hbags R f p q +
      c.diagramGain hbags R f q y := by
  have hxp := hc.first_pos
  have hpq := hc.middle_pos
  have hqy := hc.third_pos
  have he : (c.labelCycle hbags).Admissible x y := by
    obtain ⟨l,hl₁,hl₂⟩ := hc.exterior
    exact ⟨l,hl₂,hl₁⟩
  unfold diagramGain diagramTerm
  rw [dite_eq_left ⟨hc,hy⟩,
    c.chosenChord_eq hbags x y (by omega) hy he,
    c.chosenChord_eq hbags x p hxp (by omega) hc.first,
    c.chosenChord_eq hbags p q hpq (by omega) hc.middle,
    c.chosenChord_eq hbags q y hqy hy hc.third]
  exact (c.cellCorners hbags hc hy).signed_cell_recurrence
    (c.cellChords hbags hc hy) (c.cellChords_incidence hbags hc hy) R f
    BagEdge.exists_incident

omit [Fintype V] [Fintype L] in
theorem sum_cells_identity (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (Q : MatchingFPRAS.Cells.CycleData.Subdivision (c.labelCycle hbags) 0 (c.size-1)) :
    f (R ∪ c.parityPattern 0) - f (R ∪ c.parityPattern 1) =
      Q.sumCells (c.diagramTerm hbags R f) := by
  rw [← c.diagramGain_root hbags R f]
  exact Q.signed_cancellation_bounded (c.diagramGain hbags R f) (c.diagramTerm hbags R f)
    (c.diagramGain_short hbags R f) (c.diagram_cell_recurrence hbags R f)
    (by have := c.four_le; omega)

end MatchingFPRAS.Transport.IndexedCycle

namespace MatchingFPRAS.Cells.CycleData

variable {L : Type*} [DecidableEq L] {G : SimpleGraph L} {m : ℕ} {C : CycleData G m}

@[ext] structure CellIndex where
  x : ℕ
  p : ℕ
  q : ℕ
  y : ℕ
  deriving DecidableEq

namespace Subdivision

variable {x y : ℕ}

def cellList : {x y : ℕ} → Subdivision C x y → List CellIndex
  | _, _, .edge _ => []
  | x, y, .node (p := p) (q := q) _ Q₁ Q₂ Q₃ =>
      ⟨x,p,q,y⟩ :: (Q₁.cellList ++ Q₂.cellList ++ Q₃.cellList)

lemma mem_cellList {Q : Subdivision C x y} {a : CellIndex} (ha : a ∈ Q.cellList) :
    x ≤ a.x ∧ a.y ≤ y ∧ C.Cell a.x a.p a.q a.y := by
  induction Q with
  | edge h => simp [cellList] at ha
  | @node x p q y h Q₁ Q₂ Q₃ ih₁ ih₂ ih₃ =>
    simp only [cellList, List.mem_cons, List.mem_append] at ha
    rcases ha with rfl | (ha | ha) | ha
    · exact ⟨le_rfl, le_rfl, h⟩
    · obtain ⟨hx,hy,hc⟩ := ih₁ ha
      exact ⟨hx, by have := h.middle_pos; have := h.third_pos; omega, hc⟩
    · obtain ⟨hx,hy,hc⟩ := ih₂ ha
      exact ⟨by have := h.first_pos; omega, by have := h.third_pos; omega, hc⟩
    · obtain ⟨hx,hy,hc⟩ := ih₃ ha
      exact ⟨by have := h.first_pos; have := h.middle_pos; omega, hy, hc⟩

lemma cellList_length (Q : Subdivision C x y) : Q.cellList.length = Q.cells := by
  induction Q with
  | edge h => rfl
  | node h _ _ _ ih₁ ih₂ ih₃ => simp only [cellList, List.length_cons,
      List.length_append, cells, ih₁, ih₂, ih₃]; omega

lemma cellList_separated {x₁ y₁ x₂ y₂ : ℕ} (Q₁ : Subdivision C x₁ y₁)
    (Q₂ : Subdivision C x₂ y₂) (h : y₁ ≤ x₂) :
    ∀ a ∈ Q₁.cellList, ∀ b ∈ Q₂.cellList, a ≠ b := by
  intro a ha b hb hab
  subst b
  obtain ⟨_,hy,hc⟩ := mem_cellList ha
  obtain ⟨hx,_,_⟩ := mem_cellList hb
  have := hc.first_pos
  have := hc.middle_pos
  have := hc.third_pos
  omega

lemma cellList_nodup (Q : Subdivision C x y) : Q.cellList.Nodup := by
  induction Q with
  | edge h => simp [cellList]
  | @node x p q y h Q₁ Q₂ Q₃ ih₁ ih₂ ih₃ =>
    rw [cellList, List.nodup_cons]
    refine ⟨?_, List.nodup_append.mpr ⟨List.nodup_append.mpr ⟨ih₁, ih₂,
      cellList_separated Q₁ Q₂ le_rfl⟩, ih₃, ?_⟩⟩
    · intro ha
      simp only [List.mem_append] at ha
      rcases ha with (ha | ha) | ha
      · have hh := (mem_cellList ha).2.1
        have := h.middle_pos
        have := h.third_pos
        simp only at hh
        omega
      · have hh := (mem_cellList ha).1
        have := h.first_pos
        simp only at hh
        omega
      · have hh := (mem_cellList ha).1
        have := h.first_pos
        have := h.middle_pos
        simp only at hh
        omega
    · intro a ha b hb
      rcases List.mem_append.mp ha with ha | ha
      · exact cellList_separated Q₁ Q₃ (le_of_lt h.middle_pos) a ha b hb
      · exact cellList_separated Q₂ Q₃ le_rfl a ha b hb

def cellSet (Q : Subdivision C x y) : Finset CellIndex := Q.cellList.toFinset

lemma cellSet_card (Q : Subdivision C x y) : Q.cellSet.card = Q.cells := by
  rw [cellSet, List.toFinset_card_of_nodup Q.cellList_nodup, Q.cellList_length]

lemma sumCells_eq_sum (Q : Subdivision C x y) (f : ℕ → ℕ → ℕ → ℕ → ℝ) :
    Q.sumCells f = ∑ a ∈ Q.cellSet, f a.x a.p a.q a.y := by
  rw [cellSet, List.sum_toFinset _ Q.cellList_nodup]
  induction Q with
  | edge h => rfl
  | node h _ _ _ ih₁ ih₂ ih₃ =>
    simp only [sumCells, cellList, List.map_cons, List.map_append, List.sum_cons,
      List.sum_append, ih₁, ih₂, ih₃]
    ring

end Subdivision

end MatchingFPRAS.Cells.CycleData

namespace MatchingFPRAS.Transport.IndexedCycle

section

variable {V L : Type*} [Fintype V] [DecidableEq V] [DecidableEq L] [Fintype L]

variable {bags : V → Finset L} (c : IndexedCycle (BagEdge.Incident (bags := bags)))

variable {G : SimpleGraph L}

variable (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)

noncomputable def diagramEnergy (R : Finset (BagEdge bags)) (f : Finset (BagEdge bags) → ℝ)
    (x p q y : ℕ) : ℝ := by
  classical
  exact if h : (c.labelCycle hbags).Cell x p q y ∧ y < c.size then
    let P := c.pathsOfCell hbags h.1 h.2
    (f (R ∪ P.switched true) - f (R ∪ P.switched false))^2 +
      (P.contextError R f true 2 0)^2 + (P.contextError R f false 3 1)^2
    else 0

omit [Fintype V] [Fintype L] in
lemma diagramEnergy_nonneg (R : Finset (BagEdge bags))
    (f : Finset (BagEdge bags) → ℝ) (x p q y : ℕ) :
    0 ≤ c.diagramEnergy hbags R f x p q y := by
  unfold diagramEnergy
  split_ifs <;> positivity

omit [Fintype V] [Fintype L] in
lemma diagramTerm_sq_le (R : Finset (BagEdge bags))
    (f : Finset (BagEdge bags) → ℝ) (x p q y : ℕ) :
    (c.diagramTerm hbags R f x p q y)^2 ≤ 3 * c.diagramEnergy hbags R f x p q y := by
  classical
  by_cases h : (c.labelCycle hbags).Cell x p q y ∧ y < c.size
  · simp only [diagramTerm, diagramEnergy, dite_eq_left h]
    let P := c.pathsOfCell hbags h.1 h.2
    let a := f (R ∪ P.switched true) - f (R ∪ P.switched false)
    let b := P.contextError R f true 2 0
    let d := P.contextError R f false 3 1
    change (if x%2=0 then a+b-d else -(a+b-d))^2 ≤ 3*(a^2+b^2+d^2)
    split_ifs <;> nlinarith [sq_nonneg (a-b), sq_nonneg (a+d), sq_nonneg (b+d)]
  · simp only [diagramTerm, diagramEnergy, dite_eq_right h, zero_pow (by decide : 2≠0), mul_zero,
      le_refl]

omit [Fintype L] in
theorem cycle_cell_square_bound (R : Finset (BagEdge bags))
    (f : Finset (BagEdge bags) → ℝ)
    (Q : MatchingFPRAS.Cells.CycleData.Subdivision (c.labelCycle hbags) 0 (c.size-1)) :
    (f (R ∪ c.parityPattern 0) - f (R ∪ c.parityPattern 1))^2 ≤
      3 * (Fintype.card V : ℝ) *
        ∑ a ∈ Q.cellSet, c.diagramEnergy hbags R f a.x a.p a.q a.y := by
  classical
  let t := fun a : MatchingFPRAS.Cells.CycleData.CellIndex =>
    c.diagramTerm hbags R f a.x a.p a.q a.y
  let e := fun a : MatchingFPRAS.Cells.CycleData.CellIndex =>
    c.diagramEnergy hbags R f a.x a.p a.q a.y
  have hsum : 0 ≤ ∑ a ∈ Q.cellSet, e a :=
    Finset.sum_nonneg (fun a _ => c.diagramEnergy_nonneg hbags R f a.x a.p a.q a.y)
  have hsize : c.size ≤ Fintype.card V := by
    simpa only [Fintype.card_fin] using Fintype.card_le_of_injective c.vertex c.simple
  have hcells : (Q.cellSet.card : ℝ) ≤ (Fintype.card V : ℝ) := by
    apply Nat.cast_le.mpr
    rw [Q.cellSet_card]
    have := Q.cells_length
    omega
  have hcs := Finset.sum_mul_sq_le_sq_mul_sq Q.cellSet t (fun _ => (1:ℝ))
  simp only [mul_one, one_pow, Finset.sum_const, nsmul_eq_mul, mul_one] at hcs
  have he : ∑ a ∈ Q.cellSet, (t a)^2 ≤ 3 * ∑ a ∈ Q.cellSet, e a := by
    rw [Finset.mul_sum]
    exact Finset.sum_le_sum (fun a _ => c.diagramTerm_sq_le hbags R f a.x a.p a.q a.y)
  rw [c.sum_cells_identity hbags R f Q, Q.sumCells_eq_sum]
  change (∑ a ∈ Q.cellSet, t a)^2 ≤ 3 * (Fintype.card V : ℝ) * ∑ a ∈ Q.cellSet, e a
  calc
    _ ≤ (∑ a ∈ Q.cellSet, t a^2) * (Q.cellSet.card : ℝ) := hcs
    _ ≤ (3 * ∑ a ∈ Q.cellSet, e a) * (Q.cellSet.card : ℝ) :=
      mul_le_mul_of_nonneg_right he (Nat.cast_nonneg _)
    _ ≤ (3 * ∑ a ∈ Q.cellSet, e a) * (Fintype.card V : ℝ) :=
      mul_le_mul_of_nonneg_left hcells (mul_nonneg (by norm_num) hsum)
    _ = _ := by ring

end

variable {V L : Type*} [Fintype V] [DecidableEq V] [DecidableEq L] [Fintype L]

variable {bags : V → Finset L} (c : IndexedCycle (BagEdge.Incident (bags := bags)))

variable {G : SimpleGraph L}

variable (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)

noncomputable def subdivision (hG : G.IsAcyclic) :
    MatchingFPRAS.Cells.CycleData.Subdivision (c.labelCycle hbags) 0 (c.size-1) :=
  Classical.choice ((c.labelCycle hbags).quadrangulate hG c.four_le c.even)

omit [Fintype L] in
theorem exchange_cell_square_bound {M N : Finset (BagEdge bags)}
    (hM : MatchingOn BagEdge.Incident M Finset.univ)
    (hN : MatchingOn BagEdge.Incident N Finset.univ)
    (hU : ∀ i, c.edgeAt i ∈ M ∪ N) (hG : G.IsAcyclic)
    (f : Finset (BagEdge bags) → ℝ) :
    (f M - f (exchange M N c.edgeSet))^2 ≤
      3 * (Fintype.card V : ℝ) *
        ∑ a ∈ (c.subdivision hbags hG).cellSet,
          c.diagramEnergy hbags (M \ c.edgeSet) f a.x a.p a.q a.y := by
  classical
  have hU' : ∀ i, c.edgeAt i ∈ N ∪ M := by simpa only [Finset.union_comm] using hU
  have hpat := c.inter_edgeSet_parity hM hN hU
  have hpat' := c.inter_edgeSet_parity hN hM hU'
  have hcomp := c.cycle_edge_mem_complement hM hN hU 0
  have hMsplit : M = (M \ c.edgeSet) ∪ M ∩ c.edgeSet := by
    ext e
    simp only [Finset.mem_union,Finset.mem_sdiff,Finset.mem_inter]
    tauto
  have hX : exchange M N c.edgeSet = (M \ c.edgeSet) ∪ N ∩ c.edgeSet := rfl
  rw [hpat] at hMsplit
  rw [hpat'] at hX
  have hb := c.cycle_cell_square_bound hbags (M \ c.edgeSet) f (c.subdivision hbags hG)
  by_cases he : c.edgeAt 0 ∈ M
  · have hn : c.edgeAt 0 ∉ N := fun hn => (hcomp.mp hn) he
    simp only [ite_eq_left he,ite_eq_right hn] at hMsplit hX
    calc
      _ = (f ((M \ c.edgeSet) ∪ c.parityPattern 0) -
          f ((M \ c.edgeSet) ∪ c.parityPattern 1))^2 := by rw [← hMsplit,← hX]
      _ ≤ _ := hb
  · have hn : c.edgeAt 0 ∈ N := by tauto
    simp only [ite_eq_right he,ite_eq_left hn] at hMsplit hX
    calc
      _ = (f ((M \ c.edgeSet) ∪ c.parityPattern 1) -
          f ((M \ c.edgeSet) ∪ c.parityPattern 0))^2 := by rw [← hMsplit,← hX]
      _ = (f ((M \ c.edgeSet) ∪ c.parityPattern 0) -
          f ((M \ c.edgeSet) ∪ c.parityPattern 1))^2 := by ring
      _ ≤ _ := hb

end MatchingFPRAS.Transport.IndexedCycle

namespace MatchingFPRAS.Transport

variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E]

variable {inc : E → V → Prop}

abbrev LongComponent (p : PM inc × PM inc) :=
  {S : Finset E // ∃ c : IndexedCycle inc, c.edgeSet = S ∧ ∀ i, c.edgeAt i ∈ p.1.val ∪ p.2.val}

namespace LongComponent

variable {p : PM inc × PM inc} (S : LongComponent p)

noncomputable instance : Fintype (LongComponent p) := Fintype.ofFinite _

noncomputable def cycle : IndexedCycle inc := S.property.choose

omit [DecidableEq V] [Fintype E] in
lemma cycle_set : S.cycle.edgeSet = S.val := S.property.choose_spec.1

omit [DecidableEq V] [Fintype E] in
lemma cycle_union : ∀ i, S.cycle.edgeAt i ∈ p.1.val ∪ p.2.val := S.property.choose_spec.2

omit [DecidableEq V] [Fintype E] in
lemma mem_components : S.val ∈ components (inc := inc) (p.1.val ∪ p.2.val) :=
  S.cycle_set ▸ S.cycle.edgeSet_mem_components p.1.property p.2.property S.cycle_union

omit [DecidableEq V] [Fintype E] in
lemma anchor_recovers {T : LongComponent p} (h : S.cycle.edgeAt 0 = T.cycle.edgeAt 0) : S = T := by
  apply Subtype.ext
  rw [← S.cycle_set,← T.cycle_set,S.cycle.edgeSet_eq_component p.1.property p.2.property S.cycle_union,
    T.cycle.edgeSet_eq_component p.1.property p.2.property T.cycle_union,h]

end LongComponent

end MatchingFPRAS.Transport

namespace MatchingFPRAS.Transport.CellDemands

variable {V L : Type*} [Fintype V] [DecidableEq V] [Fintype L] [DecidableEq L]

variable {bags : V → Finset L}

noncomputable local instance : Fintype (BagEdge bags) := Fintype.ofFinite _

variable {G : SimpleGraph L}

variable (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)

variable (hG : G.IsAcyclic)

abbrev Demand := Σ p : PM (BagEdge.Incident (bags := bags)) × PM BagEdge.Incident,
  Σ S : LongComponent p, ↥(S.cycle.subdivision hbags hG).cellSet

end MatchingFPRAS.Transport.CellDemands

end OAI