import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.PM

namespace OAI

namespace MatchingFPRAS.Transport
variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq E]
variable {inc : E → V → Prop}
namespace DemandEncoding

variable {d : RawDemand inc} (enc : DemandEncoding inc d)

lemma gibbs_bound (w : E → ℝ) (hw : ∀ e, 0 < w e) (A : ℝ) (hA : 1 ≤ A)
    (hcard : enc.dropped.card = enc.added.card)
    (hcompare : ∀ e ∈ enc.dropped, ∀ f ∈ enc.added, w e ≤ A * w f) :
    gibbs w d.first * gibbs w d.second ≤ A^4 * gibbs w enc.first * gibbs w enc.second := by
  have h := four_edge_weight_bound w hw A hA
    (d.first.val.val + d.second.val.val) (enc.first.val.val + enc.second.val.val)
    enc.dropped enc.added enc.conservation hcard enc.dropped_card hcompare
  simp only [Multiset.map_add, Multiset.prod_add, ← Finset.prod_eq_multiset_prod] at h
  have h' : matchingWeight w d.first * matchingWeight w d.second ≤
      A^4 * (matchingWeight w enc.first * matchingWeight w enc.second) := h
  have hp : 0 ≤ partition (inc := inc) w * partition (inc := inc) w := mul_self_nonneg _
  have hh := div_le_div_of_nonneg_right h' hp
  dsimp only [gibbs]
  calc
    _ = (matchingWeight w d.first * matchingWeight w d.second) /
        (partition (inc := inc) w * partition (inc := inc) w) := div_mul_div_comm _ _ _ _
    _ ≤ A^4 * (matchingWeight w enc.first * matchingWeight w enc.second) /
        (partition (inc := inc) w * partition (inc := inc) w) := hh
    _ = _ := by
      field_simp [ne_of_gt (partition_pos w hw d.first)]

end DemandEncoding

end MatchingFPRAS.Transport

namespace MatchingFPRAS.Transport.IndexedCycle

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 (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)

variable (height : L → ℝ) (hheight : ∀ l, 0 < height l)

variable (hstep : ∀ a b, G.Adj a b → height a ≤ 2 * height b)

include hheight hstep

theorem actual_switch_encoding
    (M N : PM (BagEdge.Incident (bags := bags)))
    (hU : ∀ i, c.edgeAt i ∈ M.val ∪ N.val)
    {x p q y : ℕ} (hc : (c.labelCycle hbags).Cell x p q y) (hy : y < c.size)
    (flags : Fin 64) (b : Bool) (D : ℝ) (hD : 1 ≤ D)
    (w : BagEdge bags → ℝ)
    (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3 * height e.color)
    (lo hi : ℝ) (hlo : 0 < lo) (_hlohi : lo ≤ hi) :
    let k := c.cellCorners hbags hc hy
    let emb := k.embeddedPair M N hU (c.cellChords hbags hc hy)
      (c.cellChords_incidence hbags hc hy) flags
    let wt := fun e => max lo (min hi (w e))
    ∃ enc : DemandEncoding BagEdge.Incident (k.rawDemand M N flags),
      enc.first.val = emb.outsideFirst ∪ (c.pathsOfCell hbags hc hy).switched b ∧
      gibbs wt M * gibbs wt N ≤
        (1000*D)^4 * gibbs wt enc.first * gibbs wt enc.second := by
  classical
  dsimp only
  let k := c.cellCorners hbags hc hy
  let emb := k.embeddedPair M N hU (c.cellChords hbags hc hy)
    (c.cellChords_incidence hbags hc hy) flags
  obtain ⟨r, hg⟩ := c.cell_has_good_pair hbags hc hy
  have hr := c.cell_actual_repairs hbags hc hy r hg
  let enc := emb.switchEncoding BagEdge.exists_incident b r (c.leafRepair hbags k) hr
  refine ⟨enc, rfl, ?_⟩
  apply enc.gibbs_bound (fun e => max lo (min hi (w e)))
    (fun e => lt_of_lt_of_le hlo (le_max_left _ _)) (1000*D) (by linarith)
  · exact ((c.pathsOfCell hbags hc hy).modification_cards b r (c.leafRepair hbags k)).1
  · intro e he f hf
    exact c.cell_clamp_comparability hbags height hheight hstep hc hy D hD w hw lo hi
      (le_of_lt hlo) (c.drops_local hbags hc hy r he)
      (c.additions_local hbags hc hy b r hg hf)

theorem actual_error_encodings
    (M N : PM (BagEdge.Incident (bags := bags)))
    (hU : ∀ i, c.edgeAt i ∈ M.val ∪ N.val)
    {x p q y : ℕ} (hc : (c.labelCycle hbags).Cell x p q y) (hy : y < c.size)
    (flags : Fin 64) (b : Bool) (X Y : Fin 4)
    (hX : CellPaths.sideBit X = b) (hY : CellPaths.sideBit Y = b) (hne : X ≠ Y)
    (hl : ∀ i : Fin 4, CellPaths.sideBit i = b → (c.cellCorners hbags hc hy).length i ≠ 1)
    (D : ℝ) (hD : 1 ≤ D) (w : BagEdge bags → ℝ)
    (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3 * height e.color)
    (lo hi : ℝ) (hlo : 0 < lo) (_hlohi : lo ≤ hi) :
    let k := c.cellCorners hbags hc hy
    let emb := k.embeddedPair M N hU (c.cellChords hbags hc hy)
      (c.cellChords_incidence hbags hc hy) flags
    let cp := c.pathsOfCell hbags hc hy
    let wt := fun e => max lo (min hi (w e))
    ∃ enc₀ enc₁ : DemandEncoding BagEdge.Incident (k.rawDemand M N flags),
      enc₀.first.val = emb.outsideFirst ∪ cp.orientation b ∧
      enc₁.first.val = emb.outsideFirst ∪ cp.contextOne b Y ∧
      (cp.side X).closed (cp.chord X) ⊆ enc₀.second.val ∧
      (cp.side X).closed (cp.chord X) ⊆ enc₁.second.val ∧
      gibbs wt M * gibbs wt N ≤ (1000*D)^4 * gibbs wt enc₀.first * gibbs wt enc₀.second ∧
      gibbs wt M * gibbs wt N ≤ (1000*D)^4 * gibbs wt enc₁.first * gibbs wt enc₁.second := by
  classical
  dsimp only
  let k := c.cellCorners hbags hc hy
  let emb := k.embeddedPair M N hU (c.cellChords hbags hc hy)
    (c.cellChords_incidence hbags hc hy) flags
  have hg := c.cell_long_opposite_good hbags hc hy b hl
  have hr := c.cell_actual_repairs hbags hc hy b hg
  let enc₀ := emb.errorZeroEncoding BagEdge.exists_incident b (c.leafRepair hbags k) hr
  let enc₁ := emb.errorOneEncoding BagEdge.exists_incident b (c.leafRepair hbags k) hr Y hY
  refine ⟨enc₀, enc₁, rfl, rfl,
    emb.zero_guide_contains BagEdge.exists_incident b _ hr X hX,
    emb.one_guide_contains BagEdge.exists_incident b _ hr X Y hX hY hne, ?_, ?_⟩
  all_goals
    first
    | apply enc₀.gibbs_bound (fun e => max lo (min hi (w e)))
        (fun e => lt_of_lt_of_le hlo (le_max_left _ _)) (1000*D) (by linarith)
    | apply enc₁.gibbs_bound (fun e => max lo (min hi (w e)))
        (fun e => lt_of_lt_of_le hlo (le_max_left _ _)) (1000*D) (by linarith)
    · exact ((c.pathsOfCell hbags hc hy).modification_cards b b (c.leafRepair hbags k)).1
    · intro e he f hf
      exact c.cell_clamp_comparability hbags height hheight hstep hc hy D hD w hw lo hi
        (le_of_lt hlo) (c.drops_local hbags hc hy b he)
        (c.additions_local hbags hc hy b b hg hf)

end MatchingFPRAS.Transport.IndexedCycle

namespace MatchingFPRAS.Transport

section

variable {V E : Type*}

variable {inc : E → V → Prop}

namespace IndexedCycle

variable (c : IndexedCycle inc)

lemma edgeAt_periodic (i : ℕ) : c.edgeAt (i + c.size) = c.edgeAt i := by
  simp [edgeAt, index]

variable [DecidableEq E]

def intervalPattern (x y a : ℕ) : Finset E :=
  ((Finset.Ico x y).filter (fun i => i % 2 = a)).image c.edgeAt

def parityPattern (a : ℕ) : Finset E := c.intervalPattern 0 c.size a

lemma mem_intervalPattern (e : E) (x y a : ℕ) :
    e ∈ c.intervalPattern x y a ↔ ∃ i, x ≤ i ∧ i < y ∧ i % 2 = a ∧ c.edgeAt i = e := by
  simp only [intervalPattern, Finset.mem_image, Finset.mem_filter, Finset.mem_Ico]
  aesop

lemma intervalPattern_union {x y z : ℕ} (hxy : x ≤ y) (hyz : y ≤ z) (a : ℕ) :
    c.intervalPattern x y a ∪ c.intervalPattern y z a = c.intervalPattern x z a := by
  ext e
  simp only [Finset.mem_union, c.mem_intervalPattern]
  constructor
  · rintro (⟨i,hi,hj,hp,he⟩ | ⟨i,hi,hj,hp,he⟩)
    · exact ⟨i,hi,by omega,hp,he⟩
    · exact ⟨i,by omega,hj,hp,he⟩
  · rintro ⟨i,hi,hj,hp,he⟩
    by_cases h : i < y
    · exact Or.inl ⟨i,hi,h,hp,he⟩
    · exact Or.inr ⟨i,by omega,hj,hp,he⟩

lemma intervalPattern_periodic {x y : ℕ} (a : ℕ) :
    c.intervalPattern (x + c.size) (y + c.size) a = c.intervalPattern x y a := by
  ext e
  simp only [c.mem_intervalPattern]
  constructor
  · rintro ⟨i,hi,hj,hp,he⟩
    have hn : c.size ≤ i := by omega
    refine ⟨i-c.size,by omega,by omega,?_,?_⟩
    · have hh := c.even
      omega
    · have eq : i - c.size + c.size = i := by omega
      rw [← c.edgeAt_periodic, eq]
      exact he
  · rintro ⟨i,hi,hj,hp,he⟩
    refine ⟨i+c.size,by omega,by omega,?_,?_⟩
    · have hh := c.even
      omega
    · rw [c.edgeAt_periodic]; exact he

lemma rotatedPattern {x : ℕ} (hx : x ≤ c.size) (a : ℕ) :
    c.intervalPattern x (x+c.size) a = c.parityPattern a := by
  rw [← c.intervalPattern_union hx (by omega) a]
  have hh : c.intervalPattern c.size (x+c.size) a = c.intervalPattern 0 x a := by
    simpa only [zero_add] using (c.intervalPattern_periodic (x := 0) (y := x) a)
  rw [hh, Finset.union_comm, c.intervalPattern_union (by omega) hx a]
  rfl

lemma arc_through (x l : ℕ) (hx : x < c.size) (hl : 0 < l)
    (hlt : l < c.size) (ho : l % 2 = 1) :
    (c.arc x l hx hl hlt ho).through = c.intervalPattern x (x+l) (x%2) := by
  ext e
  simp only [OddPath.through, pathPattern, Finset.mem_image, Finset.mem_filter,
    Finset.mem_Ico, c.mem_intervalPattern]
  dsimp only [arc]
  constructor
  · rintro ⟨j,⟨⟨_,hj⟩,hp⟩,he⟩
    exact ⟨x+j,by omega,by omega,by omega,he⟩
  · rintro ⟨i,hi,hj,hp,he⟩
    refine ⟨i-x,⟨⟨by omega,by omega⟩,by omega⟩,?_⟩
    simpa only [Nat.add_sub_of_le hi] using he

lemma arc_interior (x l : ℕ) (hx : x < c.size) (hl : 0 < l)
    (hlt : l < c.size) (ho : l % 2 = 1) :
    (c.arc x l hx hl hlt ho).interior = c.intervalPattern x (x+l) (1-x%2) := by
  ext e
  simp only [OddPath.interior, pathPattern, Finset.mem_image, Finset.mem_filter,
    Finset.mem_Ico, c.mem_intervalPattern]
  dsimp only [arc]
  constructor
  · rintro ⟨j,⟨⟨hj₀,hj₁⟩,hp⟩,he⟩
    exact ⟨x+j,by omega,by omega,by omega,he⟩
  · rintro ⟨i,hi,hj,hp,he⟩
    refine ⟨i-x,⟨⟨by omega,by omega⟩,by omega⟩,?_⟩
    simpa only [Nat.add_sub_of_le hi] using he

variable [DecidableEq V]

namespace Corners

variable {c} (k : c.Corners)

lemma cell_piece_interval (chord : Fin 4 → E)
    (hc : ∀ i v, inc (chord i) v ↔
      v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length)
    (b : Bool) (i : Fin 4) :
    (k.cellPaths chord hc).orientationPieces b i =
      c.intervalPattern (k.start i) (k.stop i) (if b then k.a₀%2 else 1-k.a₀%2) := by
  have hs := k.parity_start i
  have hb := k.bounds i
  have he : k.start i + k.length i = k.stop i := by dsimp [length]; omega
  change (if CellPaths.sideBit i = b then (k.side i).through else (k.side i).interior) = _
  by_cases h : CellPaths.sideBit i = b
  · rw [ite_eq_left h]
    rw [show (k.side i).through = _ from c.arc_through _ _ _ _ _ _, he]
    cases b <;> simp_all
  · rw [ite_eq_right h]
    rw [show (k.side i).interior = _ from c.arc_interior _ _ _ _ _ _, he]
    cases b <;> cases hi : CellPaths.sideBit i <;> simp_all
    congr 1
    omega

lemma cell_orientation_parity (chord : Fin 4 → E)
    (hc : ∀ i v, inc (chord i) v ↔
      v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length)
    (b : Bool) :
    (k.cellPaths chord hc).orientation b =
      c.parityPattern (if b then k.a₀%2 else 1-k.a₀%2) := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  have h₃ := k.lt₃
  unfold CellPaths.orientation CellPaths.assemble
  simp only [k.cell_piece_interval, start, stop, Fin.isValue, Matrix.cons_val_zero,
    Matrix.cons_val_one, Matrix.cons_val]
  rw [show c.size + k.a₀ = k.a₀ + c.size by omega]
  have h := c.rotatedPattern (x := k.a₀) (by omega) (if b then k.a₀%2 else 1-k.a₀%2)
  rw [← h]
  ext e
  simp only [Finset.mem_union, c.mem_intervalPattern]
  constructor
  · rintro ((⟨i,hi,hj,hp,he⟩ | ⟨i,hi,hj,hp,he⟩) | (⟨i,hi,hj,hp,he⟩ | ⟨i,hi,hj,hp,he⟩)) <;>
      exact ⟨i,by omega,by omega,hp,he⟩
  · rintro ⟨i,hi,hj,hp,he⟩
    by_cases ha : i < k.a₁
    · exact Or.inl (Or.inl ⟨i,hi,ha,hp,he⟩)
    · by_cases hb : i < k.a₂
      · exact Or.inr (Or.inl ⟨i,by omega,hb,hp,he⟩)
      · by_cases hd : i < k.a₃
        · exact Or.inl (Or.inr ⟨i,by omega,hd,hp,he⟩)
        · exact Or.inr (Or.inr ⟨i,by omega,hj,hp,he⟩)

end Corners

end IndexedCycle

end

open scoped symmDiff

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

variable {inc : E → V → Prop}

def exchange (M N S : Finset E) : Finset E := (M \ S) ∪ (N ∩ S)

lemma mem_exchange (M N S : Finset E) (e : E) :
    e ∈ exchange M N S ↔ (e ∈ M ∧ e ∉ S) ∨ (e ∈ N ∧ e ∈ S) := by
  simp only [exchange, Finset.mem_union, Finset.mem_sdiff, Finset.mem_inter]

lemma exchange_union (M N S : Finset E) :
    exchange M N S ∪ exchange N M S = M ∪ N := by
  ext e
  simp only [Finset.mem_union, mem_exchange]
  tauto

lemma exchange_involution (M N S : Finset E) :
    exchange (exchange M N S) (exchange N M S) S = M := by
  ext e
  simp only [mem_exchange]
  tauto

lemma exchange_composition (M N S T : Finset E) :
    exchange (exchange M N S) (exchange N M S) T = exchange M N (S ∆ T) := by
  ext e
  simp only [mem_exchange, Finset.mem_symmDiff]
  tauto

lemma exchange_multiset (M N S : Finset E) :
    (exchange M N S).val + (exchange N M S).val = M.val + N.val := by
  apply Multiset.ext.mpr
  intro e
  have hc (s : Finset E) : Multiset.count e s.val = if e ∈ s then 1 else 0 :=
    Multiset.count_eq_of_nodup s.nodup
  simp only [Multiset.count_add, hc]
  by_cases hs : e ∈ S <;> by_cases hm : e ∈ M <;> by_cases hn : e ∈ N <;>
    simp [mem_exchange, hs, hm, hn]

lemma exchange_weight {R : Type*} [CommMonoid R] (w : E → R) (M N S : Finset E) :
    (∏ e ∈ exchange M N S, w e) * (∏ e ∈ exchange N M S, w e) =
      (∏ e ∈ M, w e) * (∏ e ∈ N, w e) := by
  have h := congrArg (fun U : Multiset E => (U.map w).prod) (exchange_multiset M N S)
  simpa only [Multiset.map_add, Multiset.prod_add, Finset.prod_eq_multiset_prod] using h

def ExchangeCompatible (M N S : Finset E) : Prop :=
  ∀ e ∈ M, ∀ f ∈ N, ∀ v, inc e v → inc f v → (e ∈ S ↔ f ∈ S)

omit [DecidableEq E] in
lemma ExchangeCompatible.symm {M N S : Finset E} (h : ExchangeCompatible (inc := inc) M N S) :
    ExchangeCompatible (inc := inc) N M S := by
  intro f hf e he v hfv hev
  exact (h e he f hf v hev hfv).symm

lemma exchange_matching [Fintype V] {M N S : Finset E}
    (hM : MatchingOn inc M Finset.univ) (hN : MatchingOn inc N Finset.univ)
    (h : ExchangeCompatible (inc := inc) M N S) :
    MatchingOn inc (exchange M N S) Finset.univ := by
  refine ⟨fun _ _ v _ => Finset.mem_univ v, ?_⟩
  intro v _
  obtain ⟨e,⟨he,hev⟩,hu⟩ := hM.2 v (Finset.mem_univ v)
  obtain ⟨f,⟨hf,hfv⟩,hv⟩ := hN.2 v (Finset.mem_univ v)
  have hs := h e he f hf v hev hfv
  by_cases hse : e ∈ S
  · have hsf := hs.mp hse
    refine ⟨f, ⟨(mem_exchange M N S f).mpr (Or.inr ⟨hf,hsf⟩),hfv⟩, ?_⟩
    rintro g ⟨hg,hgv⟩
    rcases (mem_exchange M N S g).mp hg with ⟨hgm,hgs⟩ | ⟨hgn,_⟩
    · have heq := hu g ⟨hgm,hgv⟩
      exact (hgs (heq ▸ hse)).elim
    · exact hv g ⟨hgn,hgv⟩
  · refine ⟨e, ⟨(mem_exchange M N S e).mpr (Or.inl ⟨he,hse⟩),hev⟩, ?_⟩
    rintro g ⟨hg,hgv⟩
    rcases (mem_exchange M N S g).mp hg with ⟨hgm,_⟩ | ⟨hgn,hgs⟩
    · exact hu g ⟨hgm,hgv⟩
    · have heq := hv g ⟨hgn,hgv⟩
      exact (hse (hs.mpr (heq ▸ hgs))).elim

noncomputable def componentEdges (U : Finset E) (anchor : E) : Finset E := by
  classical
  exact U.filter ((overlayLineGraph inc U).Reachable anchor)

omit [DecidableEq E] in
lemma mem_componentEdges (U : Finset E) (a e : E) :
    e ∈ componentEdges (inc := inc) U a ↔ e ∈ U ∧ (overlayLineGraph inc U).Reachable a e := by
  classical
  simp only [componentEdges, Finset.mem_filter]

lemma shares_reachable {U : Finset E} {e f : E} (he : e ∈ U) (hf : f ∈ U)
    {v : V} (hev : inc e v) (hfv : inc f v) :
    (overlayLineGraph inc U).Reachable e f := by
  by_cases h : e = f
  · subst f; exact SimpleGraph.Reachable.refl e
  · exact (show (overlayLineGraph inc U).Adj e f from ⟨h,he,hf,v,hev,hfv⟩).reachable

lemma component_compatible (M N : Finset E) (anchor : E) :
    ExchangeCompatible (inc := inc) M N (componentEdges (inc := inc) (M ∪ N) anchor) := by
  intro e he f hf v hev hfv
  have heu := Finset.mem_union_left N he
  have hfu := Finset.mem_union_right M hf
  have hr := shares_reachable heu hfu hev hfv
  simp only [mem_componentEdges, heu, hfu, true_and]
  exact ⟨fun h => h.trans hr, fun h => h.trans hr.symm⟩

lemma component_exchange_matching [Fintype V] {M N : Finset E}
    (hM : MatchingOn inc M Finset.univ) (hN : MatchingOn inc N Finset.univ) (anchor : E) :
    MatchingOn inc (exchange M N (componentEdges (inc := inc) (M ∪ N) anchor)) Finset.univ :=
  exchange_matching hM hN (component_compatible M N anchor)

lemma component_exchange_involution (M N : Finset E) (anchor : E) :
    let S := componentEdges (inc := inc) (M ∪ N) anchor
    exchange (exchange M N S) (exchange N M S)
      (componentEdges (inc := inc) (exchange M N S ∪ exchange N M S) anchor) = M := by
  dsimp only
  rw [exchange_union, exchange_involution]

end MatchingFPRAS.Transport

end OAI