| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.Sym2Order |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| open Finset Replica Replica.Ladder Variation |
|
|
| def discreteLadderSteps (N D K T m : ℕ) : ℕ := |
| 20*ladderL N D*ladderM N D T*(ladderLambda N D K T+Nat.clog 2 m+1) |
|
|
| lemma discreteLadderSteps_eq (N D K T m : ℕ) : |
| discreteLadderSteps N D K T m=ladderSteps N D K T ((m:ℝ)⁻¹) := by |
| simp only [discreteLadderSteps,ladderSteps,inv_inv] |
| rw [show (2:ℝ)=(2:ℕ) by norm_cast,Real.natCeil_logb_natCast] |
| |
| variable {V L : Type*} [Fintype V] [LinearOrder V] [Fintype L] [LinearOrder L] |
|
|
| variable {bags : V → Finset L} {G : SimpleGraph L} |
|
|
| attribute [local instance] sym2Order bagEdgeOrder bagEdgeFintype UnitRefresh.Computable.allowedDec |
|
|
| noncomputable local instance : DecidableEq (BagPM bags) := Classical.decEq _ |
|
|
| attribute [local instance] prodOrder sumOrder |
|
|
| variable (hbags : ∀ v,∀ a∈bags v,∀ b∈bags v,a=b ∨ G.Adj a b) (hG : G.IsAcyclic) |
|
|
| variable (rank : L → ℕ) (parent : L → Option L) |
|
|
| variable (hb : UnitRefresh.RankedBags bags rank parent) (hne : ∀ v,(bags v).Nonempty) |
|
|
| variable (hp : ∀ l p,parent l=some p → rank p<rank l) |
|
|
| def finiteLadder (D K T m : ℕ) (hq : 0<ladderQ (Fintype.card V) D) |
| (w : BagEdge bags → ℚ) (M : BagPM bags) (η : ℚ) |
| (s : Slot T (ladderQ (Fintype.card V) D) → BagPM bags) : |
| (Fin (discreteLadderSteps (Fintype.card V) D K T m * scanBitCount (Fintype.card V) |
| (bitPrecision (discreteLadderSteps (Fintype.card V) D K T m * |
| scanErrorNumerator V L bags T (ladderQ (Fintype.card V) D)) η)) → Bool) → |
| Slot T (ladderQ (Fintype.card V) D) → BagPM bags := |
| ladderBitRun hbags hG rank parent hb hne hp hq w M |
| (bitPrecision (discreteLadderSteps (Fintype.card V) D K T m * |
| scanErrorNumerator V L bags T (ladderQ (Fintype.card V) D)) η) |
| (discreteLadderSteps (Fintype.card V) D K T m) s |
|
|
| lemma finiteLadder_tv (height : L → ℝ) (hheight : ∀ l,0<height l) |
| (hstep : ∀ a b,G.Adj a b → height a≤2*height b) |
| (D K : ℕ) (hD : 1≤D) (hN : 2≤Fintype.card V) (w : BagEdge bags → ℚ) |
| (hw : ∀ e,height e.color / D ≤ (w e:ℝ) ∧ (w e:ℝ)≤3*height e.color) |
| (hglobal : ∀ e,(D:ℝ)⁻¹≤(w e:ℝ) ∧ (w e:ℝ)≤3*4^K) |
| (M : BagPM bags) (T m : ℕ) (hm : 1 < m) (η : ℚ) (hη : 0<η) |
| (hq : 0<ladderQ (Fintype.card V) D) |
| (s : Slot T (ladderQ (Fintype.card V) D) → BagPM bags) : |
| tv (imageLaw (finiteLadder hbags hG rank parent hb hne hp D K T m hq w M η s)) |
| (ladderLaw (fun e=>(w e:ℝ)) T (ladderQ (Fintype.card V) D)) ≤ (η:ℝ)+(m:ℝ)⁻¹ := by |
| have hm' : (1:ℝ)<(m:ℝ) := by exact_mod_cast hm |
| have hi:=ideal_ladder_sampling hbags hG height hheight hstep D K hD hN |
| (fun e=>(w e:ℝ)) hw hglobal M T s ((m:ℝ)⁻¹) (by positivity) (by exact inv_lt_one_of_one_lt₀ hm') |
| rw [←discreteLadderSteps_eq] at hi |
| have hb:=ladderBitRun_walk_tv hbags hG rank parent hb hne hp hq w M |
| (discreteLadderSteps (Fintype.card V) D K T m) η hη s |
| exact (tv_triangle _ _ _).trans (add_le_add hb hi) |
|
|
| end MatchingFPRAS.Transport |
|
|
| namespace MatchingFPRAS.BottleneckAlgorithm |
| |
| open Finset MatchingFPRAS.Switching |
| |
| variable {V : Type*} [Fintype V] [LinearOrder V] |
|
|
| variable {α : Type*} [LinearOrder α] [OfNat α 1] |
|
|
| def edge (w : V → V → α) (a b : V) : α := if a<b then w a b else w b a |
|
|
| def seed (w : V → V → α) (a b : V) : α := if a=b then 1 else max 1 (edge w a b) |
| |
| def advance (w : V → V → α) (a b : V) : α := |
| if a=b then 1 else max (w a b) |
| (univ.sup' ⟨a,mem_univ a⟩ fun c => min (w a c) (w c b)) |
| |
| def close (w : V → V → α) : ℕ → V → V → α |
| | 0 => seed w |
| | k+1 => advance (close w k) |
| |
| @[simp] lemma close_diag (w : V → V → α) (k : ℕ) (a : V) : close w k a a=1 := by |
| cases k <;> simp [close,seed,advance] |
| |
| lemma close_one (w : V → V → α) (k : ℕ) (a b : V) : 1≤close w k a b := by |
| induction k with |
| | zero => |
| by_cases hab : a=b |
| · simp [close,seed,hab] |
| · simp [close,seed,hab] |
| | succ k ih => |
| by_cases h : a=b |
| · subst b; simp |
| · exact ih.trans (by simp [close,advance,h]) |
| |
| lemma close_mono_step (w : V → V → α) (k : ℕ) (a b : V) : |
| close w k a b≤close w (k+1) a b := by |
| by_cases h : a=b |
| · subst b; simp |
| · simp [close,advance,h] |
| |
| lemma close_mono (w : V → V → α) (a b : V) : Monotone (fun k=>close w k a b) := |
| monotone_nat_of_le_succ (fun k=>close_mono_step w k a b) |
| |
| lemma edge_le_close (w : V → V → α) (k : ℕ) (a b : V) (hab : a≠b) : |
| edge w a b≤close w k a b := by |
| have h : edge w a b≤close w 0 a b := by |
| simp [close,seed,hab] |
| exact h.trans (close_mono w a b (Nat.zero_le k)) |
| |
| lemma via_le_close (w : V → V → α) (k : ℕ) (a b c : V) (hab : a≠b) : |
| min (close w k a c) (close w k c b)≤close w (k+1) a b := by |
| exact (le_sup' (fun c=>min (close w k a c) (close w k c b)) (mem_univ c)).trans |
| (by simp [close,advance,hab]) |
| |
| lemma chain_le_close (w : V → V → α) (t : α) (a b : V) (L : List V) |
| (hab : a≠b) (hc : List.IsChain (fun x y=>t≤edge w x y) (a::L)) |
| (hn : (a::L).Nodup) (hb : b∈L) : t≤close w L.length a b := by |
| induction L generalizing a with |
| | nil => simp at hb |
| | cons c cs ih => |
| rcases List.isChain_cons_cons.mp hc with ⟨hac,hc⟩ |
| have han := List.nodup_cons.mp hn |
| have hne : a≠c := by intro h |
| rcases List.mem_cons.mp hb with rfl|hb |
| · exact hac.trans (edge_le_close w _ _ _ hne) |
| · have hcb : c≠b := by |
| intro he |
| exact (List.nodup_cons.mp han.2).1 (he ▸ hb) |
| have hh := ih c hcb hc han.2 hb |
| change t≤close w (cs.length+1) a b |
| exact (le_min (hac.trans (edge_le_close w cs.length a c hne)) hh).trans |
| (via_le_close w cs.length a b c hab) |
| |
| lemma close_le (w B : V → V → α) (_hdiag : ∀ a,B a a=1) (hone : ∀ a b,1≤B a b) |
| (hedge : ∀ a b,a≠b → edge w a b≤B a b) |
| (htri : ∀ a b c,a≠b → a≠c → b≠c → min (B a c) (B c b)≤B a b) |
| (k : ℕ) (a b : V) : close w k a b≤B a b := by |
| induction k generalizing a b with |
| | zero => |
| by_cases hab : a=b |
| · subst b; simpa [close,seed] using hone a a |
| · simpa [close,seed,hab] using max_le (hone a b) (hedge a b hab) |
| | succ k ih => |
| by_cases hab : a=b |
| · subst b; simpa using hone a a |
| · change (if a=b then 1 else _)≤_ |
| rw [ite_eq_right hab] |
| apply max_le (ih a b) |
| apply sup'_le |
| intro c _ |
| by_cases hac : a=c |
| · subst c |
| rw [close_diag] |
| exact (min_le_left _ _).trans (hone a b) |
| by_cases hbc : b=c |
| · subst c |
| rw [close_diag] |
| exact (min_le_right _ _).trans (hone a b) |
| exact (min_le_min (ih a c) (ih c b)).trans (htri a b c hab hac hbc) |
| |
| theorem real_close_eq (w : V → V → ℝ) (a b : V) : |
| close w (Fintype.card V) a b=bottleneck w a b := by |
| apply le_antisymm |
| · exact close_le w (bottleneck w) (by intro a; simp [bottleneck]) |
| (one_le_bottleneck w) (edgeActivity_le_bottleneck w) (bottleneck_ultrametric w) _ _ _ |
| · by_cases hab : a=b |
| · subst b; simp [bottleneck] |
| by_cases ht : 1<bottleneck w a b |
| · obtain ⟨L,hL,hnd,hb⟩ := bottleneck_path w a b hab ht |
| have hlen := hnd.length_le_card |
| have h := chain_le_close w (bottleneck w a b) a b L hab hL hnd hb |
| exact h.trans (close_mono w a b (by simpa using (show L.length≤Fintype.card V from by simpa using (Nat.le_of_succ_le hlen)))) |
| · exact (le_of_not_gt ht).trans (close_one w _ _ _) |
| |
| lemma cast_close (w : V → V → ℚ) (k : ℕ) (a b : V) : |
| ((close w k a b : ℚ) : ℝ)=close (fun x y => (w x y : ℝ)) k a b := by |
| induction k generalizing a b with |
| | zero => |
| unfold close seed edge |
| split_ifs < |
| | succ k ih => |
| simp only [close,advance] |
| split_ifs with hab |
| · simp |
| · have hh := Finset.apply_sup'_eq_sup'_comp (s:=(univ:Finset V)) |
| (f:=fun c=>min (close w k a c) (close w k c b)) ⟨a,mem_univ a⟩ |
| (fun x : ℚ => (x : ℝ)) (by intro x y; exact Rat.cast_max x y) |
| rw [Rat.cast_max] |
| apply congrArg₂ max (ih a b) |
| calc |
| _ = _ := hh |
| _ = _ := by |
| apply Finset.sup'_congr _ rfl |
| intro c _ |
| simp [Rat.cast_min,ih] |
| |
| theorem rational_close_eq (w : V → V → ℚ) (a b : V) : |
| ((close w (Fintype.card V) a b : ℚ) : ℝ)=bottleneck (fun x y=>(w x y:ℝ)) a b := by |
| rw [cast_close,real_close_eq] |
| |
| end MatchingFPRAS.BottleneckAlgorithm |
| |
| end OAI |
| |
