| import OAI.Computability.MatchingCount.TerminalMincut |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.OddCutParity |
| open Finset UnitFlow CutAlgebra TerminalMincut |
| variable {n : ℕ} |
|
|
| def OddSide (U S : Finset (Fin n)) : Prop := Odd (S∩U).card |
| instance oddSideDecidable (U S : Finset (Fin n)) : Decidable (OddSide U S) := |
| inferInstanceAs (Decidable (Odd _)) |
| |
| lemma terminal_partition (U A : Finset (Fin n)) : |
| (A∩U).card + (Aᶜ∩U).card=U.card := by |
| simpa only [sdiff_eq_inter_compl,inter_comm] using card_inter_add_card_sdiff U A |
| |
| lemma even_other (U A : Finset (Fin n)) (hU : Even U.card) (hA : Even (A∩U).card) : |
| Even (Aᶜ∩U).card := by |
| have hh := terminal_partition U A |
| rw [Nat.even_iff] at hU hA ⊢ |
| omega |
| |
| lemma odd_other (U A : Finset (Fin n)) (hU : Even U.card) (hA : OddSide U A) : |
| OddSide U Aᶜ := by |
| have hh := terminal_partition U A |
| rw [Nat.even_iff] at hU |
| change Odd (A∩U).card at hA |
| change Odd (Aᶜ∩U).card |
| rw [Nat.odd_iff] at hA ⊢ |
| omega |
| |
| lemma odd_separates (U S : Finset (Fin n)) (hU : Even U.card) (hS : OddSide U S) : |
| Separates U S := by |
| have hc := odd_other U S hU hS |
| have hp : 0<(S∩U).card := by have := Nat.odd_iff.mp hS; omega |
| have hpc : 0<(Sᶜ∩U).card := by have := Nat.odd_iff.mp hc; omega |
| obtain ⟨a,ha⟩ := card_pos.mp hp |
| obtain ⟨z,hz⟩ := card_pos.mp hpc |
| exact ⟨a,(mem_inter.mp ha).2,z,(mem_inter.mp hz).2, |
| (mem_inter.mp ha).1,mem_compl.mp (mem_inter.mp hz).1⟩ |
| |
| lemma separate_cards (U A : Finset (Fin n)) (hA : Separates U A) : |
| 0<(A∩U).card ∧ 0<(Aᶜ∩U).card := by |
| obtain ⟨a,ha,z,hz,haa,hza⟩ := hA |
| exact ⟨card_pos.mpr ⟨a,mem_inter.mpr ⟨haa,ha⟩⟩, |
| card_pos.mpr ⟨z,mem_inter.mpr ⟨mem_compl.mpr hza,hz⟩⟩⟩ |
| |
| lemma split_odd (U S A : Finset (Fin n)) (hS : OddSide U S) |
| (hnot : ¬OddSide (A∩U) S) : OddSide (Aᶜ∩U) S := by |
| have hh := terminal_partition (S∩U) A |
| have h₁ : A∩(S∩U)=S∩(A∩U) := by ext v; simp; tauto |
| have h₂ : Aᶜ∩(S∩U)=S∩(Aᶜ∩U) := by ext v; simp; tauto |
| rw [h₁,h₂] at hh |
| simp only [OddSide,Nat.odd_iff] at hS hnot ⊢ |
| omega |
| |
| def contractMap (A : Finset (Fin n)) (r : Fin n) (v : Fin n) : Fin n := |
| if v∈A then v else r |
| |
| lemma lift_contract (A T : Finset (Fin n)) (r : Fin n) : |
| lift (contractMap A r) T = if r∈T then (T∩A)∪Aᶜ else T∩A := by |
| ext v |
| by_cases hv : v∈A <;> by_cases hr : r∈T <;> |
| simp [mem_lift,contractMap,hv,hr] |
| |
| lemma lift_card (U A T : Finset (Fin n)) (r : Fin n) : |
| (lift (contractMap A r) T∩U).card = |
| (T∩(A∩U)).card + if r∈T then (Aᶜ∩U).card else 0 := by |
| rw [lift_contract] |
| split_ifs with hr |
| · have hd : Disjoint ((T∩A)∩U) (Aᶜ∩U) := by |
| apply disjoint_left.mpr |
| intro v hv hw |
| exact (mem_compl.mp (mem_inter.mp hw).1) (mem_inter.mp (mem_inter.mp hv).1).2 |
| rw [union_inter_distrib_right,card_union_of_disjoint hd] |
| rw [inter_assoc] |
| · simp only [inter_assoc,add_zero] |
| |
| lemma odd_lift_iff (U A T : Finset (Fin n)) (r : Fin n) |
| (he : Even (Aᶜ∩U).card) : |
| OddSide U (lift (contractMap A r) T) ↔ OddSide (A∩U) T := by |
| simp only [OddSide,lift_card,Nat.odd_iff] |
| rw [Nat.even_iff] at he |
| split_ifs <;> omega |
| |
| lemma lift_of_subset (A T : Finset (Fin n)) (r : Fin n) (hr : r∉A) (hT : T⊆A) : |
| lift (contractMap A r) T=T := by |
| have hrt : r∉T := fun h => hr (hT h) |
| rw [lift_contract,ite_eq_right hrt,inter_eq_left.mpr hT] |
| |
| lemma cut_contract_subset (c : Fin n → Fin n → ℕ) (A T : Finset (Fin n)) |
| (r : Fin n) (hr : r∉A) (hT : T⊆A) : |
| cutCapacity (push c (contractMap A r)) T=cutCapacity c T := by |
| rw [cut_push,lift_of_subset A T r hr hT] |
| |
| lemma odd_subset_iff (U A T : Finset (Fin n)) (hT : T⊆A) : |
| OddSide (A∩U) T ↔ OddSide U T := by |
| have hh : T∩(A∩U)=T∩U := by rw [←inter_assoc,inter_eq_left.mpr hT] |
| rw [OddSide,OddSide,hh] |
| |
| end BinaryMatching.OddCutParity |
| end |
| |
| end OAI |
| |
