| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.SumLiftMate |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Subdivision |
|
|
| open Finset |
|
|
| lemma valid_step_eq_iff {m : ℕ} {U : Finset (Fin m)} {b c : Selection m} |
| (hb : Valid U b) (hc : Valid U c) (i : Fin m) : |
| b i.castSucc = c i.castSucc ↔ b i.succ = c i.succ := by |
| by_cases hi : i ∈ U |
| · have hb' := hb i |
| have hc' := hc i |
| simp only [hi, ↓reduceIte] at hb' hc' |
| simp [hb'.1,hb'.2,hc'.1,hc'.2] |
| · have hb' : b i.succ = !(b i.castSucc) := by |
| apply (bool_ne_iff_eq_not _ _).mp |
| simpa only [hi, ↓reduceIte] using hb i |
| have hc' : c i.succ = !(c i.castSucc) := by |
| apply (bool_ne_iff_eq_not _ _).mp |
| simpa only [hi, ↓reduceIte] using hc i |
| rw [hb',hc'] |
| simp |
|
|
| lemma valid_eq_iff_zero {m : ℕ} {U : Finset (Fin m)} {b c : Selection m} |
| (hb : Valid U b) (hc : Valid U c) (i : Fin (m+1)) : |
| b i = c i ↔ b 0 = c 0 := by |
| have aux (k : ℕ) (hk : k < m+1) : b ⟨k,hk⟩ = c ⟨k,hk⟩ ↔ b 0 = c 0 := by |
| induction k with |
| | zero => rfl |
| | succ k ih => |
| have hk' : k < m := by omega |
| exact ((valid_step_eq_iff hb hc ⟨k,hk'⟩).symm).trans (ih (by omega)) |
| exact aux i.val i.isLt |
|
|
| theorem broken_unique {m : ℕ} {U : Finset (Fin m)} (hU : U.Nonempty) |
| {b c : Selection m} (hb : Valid U b) (hc : Valid U c) : b = c := by |
| obtain ⟨j,hj⟩ := hU |
| have hb' := hb j |
| have hc' := hc j |
| simp only [hj, ↓reduceIte] at hb' hc' |
| have hzero := (valid_eq_iff_zero hb hc j.castSucc).mp (hb'.1.trans hc'.1.symm) |
| funext i |
| exact (valid_eq_iff_zero hb hc i).mpr hzero |
|
|
| noncomputable def profile (p : ℕ) (B Hu Hv lam : ℝ) : List ℝ := |
| duplicate (List.ofFn fun r : Fin p => max B (Hu / 2^r.val)) ++ [lam] ++ |
| duplicate ((List.ofFn fun r : Fin p => max B (Hv / 2^r.val)).reverse) |
|
|
| @[simp] theorem profile_length (p : ℕ) (B Hu Hv lam : ℝ) : |
| (profile p B Hu Hv lam).length = 4*p+1 := by simp [profile]; omega |
|
|
| noncomputable def profileActivity (p : ℕ) (B Hu Hv lam : ℝ) (i : Fin (4*p+1)) : ℝ := |
| (profile p B Hu Hv lam).get (i.cast (profile_length p B Hu Hv lam).symm) |
|
|
| theorem profileActivity_ofFn (p : ℕ) (B Hu Hv lam : ℝ) : |
| List.ofFn (profileActivity p B Hu Hv lam) = profile p B Hu Hv lam := by |
| apply List.ext_getElem |
| · simp |
| · intro i hi hj |
| simp only [List.getElem_ofFn, profileActivity, List.get_eq_getElem, Fin.val_cast] |
|
|
| theorem exact_profile_weight (p : ℕ) (B Hu Hv lam : ℝ) (a : Bool) : |
| selectedWeight (profileActivity p B Hu Hv lam) |
| (fun i => alternating a i.val) = |
| ((∏ r : Fin p, max B (Hu / 2^r.val)) * |
| (∏ r : Fin p, max B (Hv / 2^r.val))) * (if a then lam else 1) := by |
| rw [intact_weight _ _ (alternating_valid _ _),profileActivity_ofFn] |
| simpa [profile,List.prod_ofFn] using |
| profile_weight a (List.ofFn fun r : Fin p => max B (Hu / 2^r.val)) |
| ((List.ofFn fun r : Fin p => max B (Hv / 2^r.val)).reverse) lam |
|
|
| section Deletion |
|
|
| variable {V E : Type*} [Fintype V] [Fintype E] |
|
|
| def Uses {m : ℕ} (u v : E → V) (b : E → Selection m) (e : E) (x : V) : Prop := |
| (b e 0 = true ∧ u e = x) ∨ (b e (Fin.last m) = true ∧ v e = x) |
|
|
| def FamilyHoles (u v : E → V) (m : ℕ) (R₀ : Finset V) (U : E → Finset (Fin m)) |
| (b : E → Selection m) : Prop := |
| (∀ e, Valid (U e) (b e)) ∧ |
| (∀ x ∈ R₀, ∀ e, ¬ Uses u v b e x) ∧ |
| (∀ x ∉ R₀, ∃! e, Uses u v b e x) |
|
|
| noncomputable def broken {m : ℕ} (U : E → Finset (Fin m)) : Finset E := by |
| classical |
| exact Finset.univ.filter fun e => (U e).Nonempty |
|
|
| @[simp] lemma mem_broken {m : ℕ} (U : E → Finset (Fin m)) (e : E) : |
| e ∈ broken U ↔ (U e).Nonempty := by |
| classical |
| simp [broken] |
|
|
| noncomputable def residualHoles {m : ℕ} (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (b : E → Selection m) : Finset V := by |
| classical |
| exact R₀ ∪ Finset.univ.filter (fun x => ∃ e ∈ broken U, Uses u v b e x) |
|
|
| @[simp] lemma mem_residualHoles {m : ℕ} (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (b : E → Selection m) (x : V) : |
| x ∈ residualHoles u v R₀ U b ↔ x ∈ R₀ ∨ ∃ e ∈ broken U, Uses u v b e x := by |
| classical |
| simp [residualHoles] |
|
|
| theorem residualHoles_independent {m : ℕ} (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) {b c : E → Selection m} |
| (hb : FamilyHoles u v m R₀ U b) (hc : FamilyHoles u v m R₀ U c) : |
| residualHoles u v R₀ U b = residualHoles u v R₀ U c := by |
| classical |
| have he (e) (h : e ∈ broken U) : b e = c e := |
| broken_unique ((mem_broken U e).mp h) (hb.1 e) (hc.1 e) |
| ext x |
| simp only [mem_residualHoles] |
| apply or_congr Iff.rfl |
| apply exists_congr |
| intro e |
| constructor <;> rintro ⟨h,hx⟩ <;> refine ⟨h,?_⟩ |
| · simpa only [Uses,he e h] using hx |
| · simpa only [Uses,he e h] using hx |
|
|
| def LogicalHoles (u v : E → V) (R : Finset V) (forbidden : Finset E) |
| (s : E → Bool) : Prop := |
| (∀ e ∈ forbidden, s e = false) ∧ |
| (∀ x ∈ R, ∀ e, ¬ (s e = true ∧ (u e = x ∨ v e = x))) ∧ |
| (∀ x ∉ R, ∃! e, s e = true ∧ (u e = x ∨ v e = x)) |
|
|
| noncomputable def extract {m : ℕ} (U : E → Finset (Fin m)) |
| (b : E → Selection m) (e : E) : Bool := |
| if (U e).Nonempty then false else b e 0 |
|
|
| omit [Fintype V] [Fintype E] in |
| lemma intact_uses {m : ℕ} (hm : Even m) (u v : E → V) (b : E → Selection m) |
| (e : E) (x : V) (hb : Valid ∅ (b e)) : |
| Uses u v b e x ↔ b e 0 = true ∧ (u e = x ∨ v e = x) := by |
| rw [Uses,intact_terminals hm _ hb] |
| exact and_or_left.symm |
|
|
| theorem extract_legal {m : ℕ} (hm : Even m) (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (b : E → Selection m) |
| (hb : FamilyHoles u v m R₀ U b) : |
| LogicalHoles u v (residualHoles u v R₀ U b) (broken U) (extract U b) := by |
| classical |
| have he (e x) : extract U b e = true ∧ (u e = x ∨ v e = x) ↔ |
| e ∉ broken U ∧ Uses u v b e x := by |
| by_cases h : (U e).Nonempty |
| · simp [extract,h] |
| · have hu : U e = ∅ := Finset.not_nonempty_iff_eq_empty.mp h |
| simp only [extract,h,↓reduceIte,mem_broken,not_false_eq_true,true_and] |
| exact (intact_uses hm u v b e x (by simpa [hu] using hb.1 e)).symm |
| refine ⟨?_,?_,?_⟩ |
| · intro e he' |
| simp [extract,(mem_broken U e).mp he'] |
| · intro x hx e hxe |
| rw [he] at hxe |
| rcases (mem_residualHoles u v R₀ U b x).mp hx with hx | ⟨f,hf,hfx⟩ |
| · exact hb.2.1 x hx e hxe.2 |
| · have hx0 : x ∉ R₀ := by intro hx0; exact hb.2.1 x hx0 f hfx |
| obtain ⟨a,ha,hu⟩ := hb.2.2 x hx0 |
| have hef : e = f := (hu e hxe.2).trans (hu f hfx).symm |
| exact hxe.1 (hef.symm ▸ hf) |
| · intro x hx |
| have hx0 : x ∉ R₀ := by intro h; exact hx ((mem_residualHoles _ _ _ _ _ _).mpr (Or.inl h)) |
| obtain ⟨e,he',hu⟩ := hb.2.2 x hx0 |
| have hn : e ∉ broken U := by |
| intro h |
| exact hx ((mem_residualHoles _ _ _ _ _ _).mpr (Or.inr ⟨e,h,he'⟩)) |
| refine ⟨e,(he e x).mpr ⟨hn,he'⟩,?_⟩ |
| intro f hf |
| exact hu f ((he f x).mp hf).2 |
|
|
| noncomputable def rebuild {m : ℕ} (U : E → Finset (Fin m)) |
| (base : E → Selection m) (s : E → Bool) (e : E) : Selection m := |
| if (U e).Nonempty then base e else fun i => alternating (s e) i.val |
|
|
| omit [Fintype V] in |
| lemma rebuild_uses {m : ℕ} (hm : Even m) (u v : E → V) |
| (U : E → Finset (Fin m)) (base : E → Selection m) (s : E → Bool) (e : E) (x : V) : |
| Uses u v (rebuild U base s) e x ↔ |
| (e ∈ broken U ∧ Uses u v base e x) ∨ |
| (e ∉ broken U ∧ s e = true ∧ (u e = x ∨ v e = x)) := by |
| classical |
| by_cases h : (U e).Nonempty |
| · simp [rebuild,h,Uses] |
| · simp [rebuild,h,Uses,alternating,Nat.even_iff.mp hm,and_or_left] |
|
|
| theorem rebuild_legal {m : ℕ} (hm : Even m) (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (base : E → Selection m) |
| (hb : FamilyHoles u v m R₀ U base) (s : E → Bool) |
| (hs : LogicalHoles u v (residualHoles u v R₀ U base) (broken U) s) : |
| FamilyHoles u v m R₀ U (rebuild U base s) := by |
| classical |
| let R := residualHoles u v R₀ U base |
| have hu (e x) := rebuild_uses hm u v U base s e x |
| refine ⟨?_,?_,?_⟩ |
| · intro e |
| by_cases he : (U e).Nonempty |
| · simpa [rebuild,he] using hb.1 e |
| · have he' : U e = ∅ := Finset.not_nonempty_iff_eq_empty.mp he |
| simpa [rebuild,he,he'] using alternating_valid m (s e) |
| · intro x hx e he |
| have hxR : x ∈ R := (mem_residualHoles _ _ _ _ _ _).mpr (Or.inl hx) |
| rcases (hu e x).mp he with ⟨_,he⟩ | ⟨_,he⟩ |
| · exact hb.2.1 x hx e he |
| · exact hs.2.1 x hxR e he |
| · intro x hx |
| by_cases hxR : x ∈ R |
| · obtain hx0 | ⟨e,he,hxe⟩ := (mem_residualHoles _ _ _ _ _ _).mp hxR |
| · exact (hx hx0).elim |
| obtain ⟨a,ha,hauniq⟩ := hb.2.2 x hx |
| refine ⟨e,(hu e x).mpr (Or.inl ⟨he,hxe⟩),?_⟩ |
| intro f hf |
| rcases (hu f x).mp hf with ⟨_,hf⟩ | ⟨_,hf⟩ |
| · exact (hauniq f hf).trans (hauniq e hxe).symm |
| · exact (hs.2.1 x hxR f hf).elim |
| · obtain ⟨e,he,heuniq⟩ := hs.2.2 x hxR |
| have hen : e ∉ broken U := by |
| intro he' |
| have := hs.1 e he' |
| simp [this] at he |
| refine ⟨e,(hu e x).mpr (Or.inr ⟨hen,he⟩),?_⟩ |
| intro f hf |
| rcases (hu f x).mp hf with ⟨hfb,hf⟩ | ⟨_,hf⟩ |
| · exact (hxR ((mem_residualHoles _ _ _ _ _ _).mpr (Or.inr ⟨f,hfb,hf⟩))).elim |
| · exact heuniq f hf |
|
|
| omit [Fintype V] [Fintype E] in |
| theorem rebuild_extract [Fintype V] [Fintype E] {m : ℕ} (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (base b : E → Selection m) |
| (hb0 : FamilyHoles u v m R₀ U base) (hb : FamilyHoles u v m R₀ U b) : |
| rebuild U base (extract U b) = b := by |
| classical |
| funext e i |
| by_cases he : (U e).Nonempty |
| · have hbe := broken_unique he (hb0.1 e) (hb.1 e) |
| simp [rebuild,he,hbe] |
| · have he' : U e = ∅ := Finset.not_nonempty_iff_eq_empty.mp he |
| have hl := (intact_iff (b e)).mp (by simpa [he'] using hb.1 e) i |
| simpa [rebuild,extract,he] using hl.symm |
|
|
| omit [Fintype V] [Fintype E] in |
| theorem extract_rebuild [Fintype V] [Fintype E] {m : ℕ} (u v : E → V) (R : Finset V) |
| (U : E → Finset (Fin m)) (base : E → Selection m) (s : E → Bool) |
| (hs : LogicalHoles u v R (broken U) s) : |
| extract U (rebuild U base s) = s := by |
| classical |
| funext e |
| by_cases he : (U e).Nonempty |
| · have hs' := hs.1 e ((mem_broken U e).mpr he) |
| simp [extract,he,hs'] |
| · simp [extract,rebuild,he] |
|
|
| noncomputable def deletionEquiv {m : ℕ} (hm : Even m) (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (base : E → Selection m) |
| (hb : FamilyHoles u v m R₀ U base) : |
| {b : E → Selection m // FamilyHoles u v m R₀ U b} ≃ |
| {s : E → Bool // LogicalHoles u v (residualHoles u v R₀ U base) (broken U) s} where |
| toFun b := ⟨extract U b.val, by |
| have h := extract_legal hm u v R₀ U b.val b.property |
| rwa [residualHoles_independent u v R₀ U b.property hb] at h⟩ |
| invFun s := ⟨rebuild U base s.val,rebuild_legal hm u v R₀ U base hb s.val s.property⟩ |
| left_inv b := Subtype.ext (rebuild_extract u v R₀ U base b.val hb b.property) |
| right_inv s := Subtype.ext (extract_rebuild u v _ U base s.val s.property) |
|
|
| noncomputable def realHolePartition (u v : E → V) (m : ℕ) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (w : E → Fin (m+1) → ℝ) : ℝ := by |
| classical |
| letI := Fintype.ofFinite {b : E → Selection m // FamilyHoles u v m R₀ U b} |
| exact ∑ b : {b : E → Selection m // FamilyHoles u v m R₀ U b}, |
| ∏ e, selectedWeight (w e) (b.val e) |
|
|
| noncomputable def logicalHolePartition (u v : E → V) (R : Finset V) |
| (forbidden : Finset E) (lam : E → ℝ) : ℝ := by |
| classical |
| letI := Fintype.ofFinite {s : E → Bool // LogicalHoles u v R forbidden s} |
| exact ∑ s : {s : E → Bool // LogicalHoles u v R forbidden s}, |
| ∏ e, if s.val e then lam e else 1 |
|
|
| noncomputable def deletionConstant {m : ℕ} (U : E → Finset (Fin m)) |
| (base : E → Selection m) (w : E → Fin (m+1) → ℝ) (C : E → ℝ) : ℝ := |
| ∏ e, if (U e).Nonempty then selectedWeight (w e) (base e) else C e |
|
|
| omit [Fintype V] [Fintype E] in |
| theorem deletion_weight [Fintype V] [Fintype E] {m : ℕ} (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (base b : E → Selection m) |
| (hb0 : FamilyHoles u v m R₀ U base) (hb : FamilyHoles u v m R₀ U b) |
| (w : E → Fin (m+1) → ℝ) (left right : E → List ℝ) (lam : E → ℝ) |
| (hw : ∀ e, List.ofFn (w e) = duplicate (left e) ++ [lam e] ++ duplicate (right e)) : |
| (∏ e, selectedWeight (w e) (b e)) = |
| deletionConstant U base w (fun e => (left e).prod * (right e).prod) * |
| ∏ e, if extract U b e then lam e else 1 := by |
| classical |
| unfold deletionConstant |
| rw [← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| intro e _ |
| by_cases he : (U e).Nonempty |
| · have heq := broken_unique he (hb0.1 e) (hb.1 e) |
| simp [extract,he,heq] |
| · have he' : U e = ∅ := Finset.not_nonempty_iff_eq_empty.mp he |
| simp only [extract,he,↓reduceIte] |
| rw [intact_weight _ _ (by simpa [he'] using hb.1 e),hw e,profile_weight] |
|
|
| theorem deletion_partition_identity {m : ℕ} (hm : Even m) (u v : E → V) (R₀ : Finset V) |
| (U : E → Finset (Fin m)) (base : E → Selection m) |
| (hb : FamilyHoles u v m R₀ U base) |
| (w : E → Fin (m+1) → ℝ) (left right : E → List ℝ) (lam : E → ℝ) |
| (hw : ∀ e, List.ofFn (w e) = duplicate (left e) ++ [lam e] ++ duplicate (right e)) : |
| realHolePartition u v m R₀ U w = |
| deletionConstant U base w (fun e => (left e).prod * (right e).prod) * |
| logicalHolePartition u v (residualHoles u v R₀ U base) (broken U) lam := by |
| classical |
| let := Fintype.ofFinite {b : E → Selection m // FamilyHoles u v m R₀ U b} |
| let := Fintype.ofFinite {s : E → Bool // |
| LogicalHoles u v (residualHoles u v R₀ U base) (broken U) s} |
| unfold realHolePartition logicalHolePartition |
| rw [Finset.mul_sum] |
| apply Fintype.sum_equiv (deletionEquiv hm u v R₀ U base hb) |
| intro b |
| exact deletion_weight u v R₀ U base b.val hb b.property w left right lam hw |
|
|
| end Deletion |
|
|
| theorem selectedWeight_vertex_factor {m : ℕ} (U : Finset (Fin m)) |
| (b : Selection m) (hb : Valid U b) (z : Fin (m+2) → ℝ) : |
| selectedWeight (fun i => z i.castSucc * z i.succ) b = |
| (if b 0 then z 0 else 1) * (if b (Fin.last m) then z (Fin.last (m+1)) else 1) * |
| ∏ i : Fin m, if i ∈ U then 1 else z i.succ.castSucc := by |
| classical |
| unfold selectedWeight |
| have hsplit (i : Fin (m+1)) : |
| (if b i then z i.castSucc * z i.succ else 1) = |
| (if b i then z i.castSucc else 1) * (if b i then z i.succ else 1) := by |
| cases b i <;> simp |
| simp_rw [hsplit] |
| rw [Finset.prod_mul_distrib, |
| Fin.prod_univ_succ (fun i : Fin (m+1) => if b i then z i.castSucc else 1), |
| Fin.prod_univ_castSucc (fun i : Fin (m+1) => if b i then z i.succ else 1)] |
| have he : ∀ i : Fin m, |
| (if b i.succ then z i.succ.castSucc else 1) * |
| (if b i.castSucc then z i.castSucc.succ else 1) = |
| if i ∈ U then 1 else z i.succ.castSucc := by |
| intro i |
| have hz : i.castSucc.succ = i.succ.castSucc := rfl |
| rw [hz] |
| have h := hb i |
| by_cases hi : i ∈ U |
| · simp only [hi,↓reduceIte] at h ⊢ |
| simp [h.1,h.2] |
| · simp only [hi,↓reduceIte] at h ⊢ |
| cases h₁ : b i.castSucc <;> cases h₂ : b i.succ <;> simp_all |
| calc |
| _ = (if b 0 then z 0 else 1) * (if b (Fin.last m) then z (Fin.last (m+1)) else 1) * |
| ∏ i : Fin m, ((if b i.succ then z i.succ.castSucc else 1) * |
| (if b i.castSucc then z i.castSucc.succ else 1)) := by |
| rw [Finset.prod_mul_distrib] |
| simp only [Fin.castSucc_zero, Fin.succ_last] |
| ring |
| _ = _ := by simp_rw [he] |
|
|
| theorem valid_interval {m : ℕ} {U : Finset (Fin m)} {b : Selection m} |
| (hb : Valid U b) (a k : ℕ) (hak : a+k ≤ m) |
| (hfree : ∀ i : Fin m, a ≤ i.val → i.val < a+k → i ∉ U) : |
| b ⟨a+k,by omega⟩ = alternating (b ⟨a,by omega⟩) k := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| have hai : a+k < m := by omega |
| have hf := hb ⟨a+k,hai⟩ |
| simp only [hfree ⟨a+k,hai⟩ (by dsimp; omega) (by dsimp; omega),↓reduceIte] at hf |
| have he := (bool_ne_iff_eq_not _ _).mp hf |
| have hi := ih (by omega) (fun i hi hj => hfree i hi (by omega)) |
| simpa only [Fin.succ_mk, Fin.castSucc_mk, Nat.add_assoc, |
| alternating_succ, hi] using he |
|
|
| theorem first_hole_terminal {m : ℕ} {U : Finset (Fin m)} {b : Selection m} |
| (hb : Valid U b) (j : Fin m) (hj : j ∈ U) |
| (hfirst : ∀ i ∈ U, j ≤ i) : |
| b 0 = true ↔ j.val % 2 = 1 := by |
| have hv := valid_interval hb 0 j.val (by omega) (by |
| intro i hi hij him |
| have hh := hfirst i him |
| have : j.val ≤ i.val := hh |
| omega) |
| have hz : b j.castSucc = false := by |
| have h := hb j |
| simp only [hj,↓reduceIte] at h |
| exact h.1 |
| have he : b j.castSucc = alternating (b 0) j.val := by |
| have ez : (⟨0,by omega⟩ : Fin (m+1)) = 0 := Fin.ext rfl |
| have ee : (⟨0+j.val,by omega⟩ : Fin (m+1)) = j.castSucc := by |
| apply Fin.ext; dsimp; omega |
| rw [ee,ez] at hv |
| exact hv |
| rw [hz] at he |
| by_cases h : j.val%2=0 |
| · simp only [alternating,h,↓reduceIte] at he |
| simp [← he,h] |
| · have h1 : j.val%2=1 := by omega |
| simp only [alternating,h,↓reduceIte] at he |
| cases hbool : b 0 |
| · rw [hbool] at he; contradiction |
| · simp only [h1] |
|
|
| end MatchingFPRAS.Subdivision |
|
|
| end OAI |
|
|
