| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Graphs.EnlargementRun |
| import OAI.Combinatorics.MatchingCount.Sampling.PairStep |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Variation |
|
|
| open Finset |
|
|
| variable {Ω Ψ : Type*} [Fintype Ω] [Fintype Ψ] |
|
|
| lemma bind_perturbation_on (p : Ω → ℝ) (k l : Ω → Ψ → ℝ) |
| (hp : ∀ x,0 ≤ p x) (hs : ∑ x,p x=1) (ε : ℝ) |
| (he : ∀ x,p x≠0 → tv (k x) (l x) ≤ ε) : |
| tv (bind p k) (bind p l) ≤ ε := by |
| unfold tv bind |
| have h : ∑ y,|∑ x,p x*k x y-∑ x,p x*l x y| ≤ 2*ε := by |
| calc |
| _ = ∑ y,|∑ x,p x*(k x y-l x y)| := by simp only [mul_sub,sum_sub_distrib] |
| _ ≤ ∑ y,∑ x,|p x*(k x y-l x y)| := sum_le_sum (fun y _ => abs_sum_le_sum_abs _ _) |
| _ = ∑ x,p x*(∑ y,|k x y-l x y|) := by |
| rw [sum_comm]; simp_rw [abs_mul,abs_of_nonneg (hp _),←mul_sum] |
| _ ≤ ∑ x,p x*(2*ε) := by |
| apply sum_le_sum |
| intro x _ |
| by_cases hx : p x=0 |
| · simp [hx] |
| · apply mul_le_mul_of_nonneg_left _ (hp x) |
| have hh:=he x hx |
| unfold tv at hh |
| linarith |
| _ = _ := by rw [←sum_mul,hs,one_mul] |
| linarith |
|
|
| end MatchingFPRAS.Variation |
|
|
| namespace MatchingFPRAS.WeightedOptions |
|
|
| open Finset Variation |
|
|
| variable {J Ω B : Type*} [Fintype J] [DecidableEq J] [Fintype Ω] [DecidableEq Ω] |
|
|
| variable [Fintype B] [Nonempty B] |
|
|
| theorem drawThen_tv_on (c : WeightedOptions J) (g : J → B → Ω) (k : ℕ) |
| (P : J → Ω → ℝ) (e : ℝ) (he : ∀ j,c.law j≠0 → tv (imageLaw (g j)) (P j)≤e) : |
| tv (imageLaw (c.drawThen g k)) (bind (fun j=>(c.law j:ℝ)) P)≤ |
| 2*c.size/(2:ℝ)^k+e := by |
| rw [drawThen_law] |
| calc |
| _ ≤ tv (bind (imageLaw (c.draw k)) (fun j=>imageLaw (g j))) |
| (bind (fun j=>(c.law j:ℝ)) (fun j=>imageLaw (g j)))+ |
| tv (bind (fun j=>(c.law j:ℝ)) (fun j=>imageLaw (g j))) |
| (bind (fun j=>(c.law j:ℝ)) P) := tv_triangle _ _ _ |
| _ ≤ 2*c.size/(2:ℝ)^k+e := add_le_add |
| ((bind_contraction _ _ _ (fun _=>imageLaw_nonneg _) (fun _=>imageLaw_sum _)).trans (c.draw_tv k)) |
| (bind_perturbation_on _ _ _ (fun j=>by exact_mod_cast c.law_nonneg j) |
| (c.real_law_sum) e (fun j hj=>he j (by exact_mod_cast hj))) |
|
|
| end MatchingFPRAS.WeightedOptions |
|
|
| namespace MatchingFPRAS.Replica |
|
|
| open Finset Variation |
|
|
| variable {I Ω B : Type*} [Fintype I] [DecidableEq I] [Fintype Ω] [DecidableEq Ω] |
|
|
| variable [Fintype B] [Nonempty B] [LinearOrder (Update I)] |
|
|
| def admissible (guides : I → Finset I) (base : Finset I) : Option (Update I) → Prop |
| | none => True |
| | some (.inl ij) => ij.2∈guides ij.1 |
| | some (.inr i) => i∈base |
|
|
| lemma scanChoice_support (guides : I → Finset I) (base : Finset I) (hb : base.Nonempty) |
| (u : Option (Update I)) (hu : (scanChoice guides base hb).law u≠0) : |
| admissible guides base u := by |
| cases u with |
| | none => trivial |
| | some u => |
| by_contra h |
| apply hu |
| simp only [scanChoice,WeightedOptions.mix_law,WeightedOptions.pure_law, |
| WeightedOptions.map_law] |
| simp only [reduceCtorEq,ite_false,Option.some.injEq,sum_ite_eq',mem_univ,ite_true] |
| rw [WeightedOptions.uniform_law] |
| have hn : u∉updates guides base := by |
| cases u <;> simpa [updates,admissible] using h |
| simp [hn] |
| |
| omit [LinearOrder (Update I)] in |
| lemma localSampler_tv_on [LinearOrder (Update I)] (p : I → Ω → ℝ) (Q : ∀ x y,PairCapacity p x y) |
| (guides : I → Finset I) (base : Finset I) |
| (pair : I → I → (Ω×Ω) → B → Ω×Ω) (refresh : I → B → Ω) (e : ℝ) (he : 0≤e) |
| (hp : ∀ x y,y∈guides x → ∀ a,tv (imageLaw (pair x y a)) |
| (fun b=>(Q x y).q a b/(p x a.1*p y a.2))≤e) |
| (hr : ∀ i,i∈base → tv (imageLaw (refresh i)) (p i)≤e) |
| (s : I → Ω) (u : Option (Update I)) (hu : admissible guides base u) : |
| tv (imageLaw (localSampler pair refresh s u)) (updateKernel p Q s u)≤e := by |
| cases u with |
| | none => |
| have h : imageLaw (localSampler pair refresh s none)=updateKernel p Q s none := by |
| funext t |
| simp only [imageLaw,push,localSampler,updateKernel] |
| by_cases hst : s=t |
| · subst t |
| simpa using uniform_sum (A:=B) |
| · simp [hst] |
| rw [h,tv_self] |
| exact he |
| | some u => cases u with |
| | inl ij => |
| have hk : updateKernel p Q s (some (.inl ij))= |
| push (fun b=>(Q ij.1 ij.2).q (s ij.1,s ij.2) b/(p ij.1 (s ij.1)*p ij.2 (s ij.2))) |
| (replacePair ij.1 ij.2 s) := by |
| funext t |
| simp only [updateKernel,pairStep,push] |
| rw [hk] |
| change tv (imageLaw ((replacePair ij.1 ij.2 s) ∘ pair ij.1 ij.2 (s ij.1,s ij.2))) |
| (push (fun b=>(Q ij.1 ij.2).q (s ij.1,s ij.2) b/(p ij.1 (s ij.1)*p ij.2 (s ij.2))) |
| (replacePair ij.1 ij.2 s))≤e |
| rw [imageLaw_comp] |
| exact (push_contraction _ _ _).trans (hp _ _ hu _) |
| | inr i => |
| have hk : updateKernel p Q s (some (.inr i))=push (p i) (Function.update s i) := by |
| funext t |
| simp only [updateKernel,baseStep,push] |
| apply sum_congr rfl |
| intro a _ |
| congr 1 |
| rw [hk] |
| change tv (imageLaw ((Function.update s i) ∘ refresh i)) (push (p i) (Function.update s i))≤e |
| rw [imageLaw_comp] |
| exact (push_contraction _ _ _).trans (hr i hu) |
| |
| theorem sampleScan_tv_on (p : I → Ω → ℝ) (hp : ∀ i a,0<p i a) (hs : ∀ i,∑ a,p i a=1) |
| (guides : I → Finset I) (hself : ∀ x y,y∈guides x → x≠y) |
| (base : Finset I) (hb : base.Nonempty) (Q : ∀ x y,PairCapacity p x y) |
| (pair : I → I → (Ω×Ω) → B → Ω×Ω) (refresh : I → B → Ω) (e : ℝ) (he : 0≤e) |
| (hpr : ∀ x y,y∈guides x → ∀ a,tv (imageLaw (pair x y a)) |
| (fun b=>(Q x y).q a b/(p x a.1*p y a.2))≤e) |
| (hr : ∀ i,i∈base → tv (imageLaw (refresh i)) (p i)≤e) (k : ℕ) (s : I → Ω) : |
| tv (imageLaw (sampleScan guides base hb pair refresh k s)) |
| (FiniteChain.kernel (density p) (scanFlow p guides base Q) s)≤ |
| 2*(1+updateCount guides base)/(2:ℝ)^k+e := by |
| have ht := WeightedOptions.drawThen_tv_on (scanChoice guides base hb) (localSampler pair refresh s) |
| k (updateKernel p Q s) e (fun u hu=> |
| localSampler_tv_on p Q guides base pair refresh e he hpr hr s u (scanChoice_support guides base hb u hu)) |
| have hl : Variation.bind (fun u=>((scanChoice guides base hb).law u:ℝ)) (updateKernel p Q s)= |
| FiniteChain.kernel (density p) (scanFlow p guides base Q) s := by |
| funext t |
| rw [scanChoice_law,localScan_kernel p hp hs guides hself base Q] |
| rw [hl,scanChoice_size] at ht |
| simpa only [Nat.cast_add,Nat.cast_one,sampleScan] using ht |
| |
| |
| |
| open Finset |
| |
| variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω] |
| |
| lemma metropolis_normalize (P : SymmetricProposal Ω) (u : Ω → ℝ) (hu : ∀ a,0<u a) |
| (c : ℝ) (hc : 0<c) (a b : Ω) : |
| metropolis P (fun x=>u x/c) a b=metropolis P u a b := by |
| have huc : ∀ x,0<u x/c:=fun x=>div_pos (hu x) hc |
| have hf := WeightedOptions.row_eq_of_off _ _ (metropolis_row P _ huc a) |
| (metropolis_row P _ hu a) a (fun b hab=>?_) |
| · exact congrFun hf b |
| rw [metropolis_acceptance _ _ huc _ _ hab,metropolis_acceptance _ _ hu _ _ hab] |
| congr 2 |
| field_simp |
| |
| end MatchingFPRAS.Replica |
| |
| namespace MatchingFPRAS.Transport.Sparse |
| |
| open Finset Replica Variation |
| |
| variable {V E : Type*} [Fintype V] [DecidableEq V] [Fintype E] [LinearOrder E] |
| |
| variable (ends : E → Sym2 V) |
| |
| attribute [local instance] finsetOrder pmOrder |
| |
| def rationalWeight (w : E → ℚ) (A : PM (fun e v=>v∈ends e)) : ℚ := ∏ e∈A.val,w e |
| |
| omit [DecidableEq V] [Fintype E] [LinearOrder E] in |
| lemma rationalWeight_pos [DecidableEq V] [Fintype E] [LinearOrder E] |
| (w : E → ℚ) (hw : ∀ e,0<w e) (A : PM (fun e v=>v∈ends e)) : |
| 0<rationalWeight ends w A := prod_pos (fun e _=>hw e) |
| |
| omit [DecidableEq V] [Fintype E] [LinearOrder E] in |
| lemma rationalWeight_cast [DecidableEq V] [Fintype E] [LinearOrder E] |
| (w : E → ℚ) (A : PM (fun e v=>v∈ends e)) : |
| (rationalWeight ends w A:ℝ)=matchingWeight (fun e=>(w e:ℝ)) A := by |
| simp [rationalWeight,matchingWeight] |
| |
| def rationalPairWeight (w z : E → ℚ) (a : PM (fun e v=>v∈ends e) × PM (fun e v=>v∈ends e)) : ℚ := |
| rationalWeight ends w a.1*rationalWeight ends z a.2 |
| |
| lemma rationalPairWeight_pos (w z : E → ℚ) (hw : ∀ e,0<w e) (hz : ∀ e,0<z e) |
| (a : PM (fun e v=>v∈ends e) × PM (fun e v=>v∈ends e)) : 0<rationalPairWeight ends w z a := |
| mul_pos (rationalWeight_pos ends w hw a.1) (rationalWeight_pos ends z hz a.2) |
| |
| def pairStepTable (hloop : ∀ e,¬(ends e).IsDiag) |
| (hpar : ∀ e,(univ.filter (fun f=>ends f=ends e)).card≤2) |
| (w z : E → ℚ) (hw : ∀ e,0<w e) (hz : ∀ e,0<z e) |
| (a : PM (fun e v=>v∈ends e) × PM (fun e v=>v∈ends e)) := |
| (pairTable ends hloop hpar a).metropolisChoice (rationalPairWeight ends w z) |
| (rationalPairWeight_pos ends w z hw hz) a |
| |
| theorem pairStepTable_law (hloop : ∀ e,¬(ends e).IsDiag) |
| (hpar : ∀ e,(univ.filter (fun f=>ends f=ends e)).card≤2) |
| (w z : E → ℚ) (hw : ∀ e,0<w e) (hz : ∀ e,0<z e) |
| (a b : PM (fun e v=>v∈ends e) × PM (fun e v=>v∈ends e)) : |
| ((pairStepTable ends hloop hpar w z hw hz a).law b:ℝ)= |
| metropolis (pairProposal ends hloop hpar) (pairLaw ends (fun e=>(w e:ℝ)) (fun e=>(z e:ℝ))) a b := by |
| rw [pairStepTable,WeightedOptions.metropolisChoice_law (pairProposal ends hloop hpar) |
| (pairTable ends hloop hpar) (pairTable_law ends hloop hpar)] |
| have hw' : ∀ e,(0:ℝ)<w e:=fun e=>by exact_mod_cast hw e |
| have hz' : ∀ e,(0:ℝ)<z e:=fun e=>by exact_mod_cast hz e |
| let c:=partition (inc:=fun e v=>v∈ends e) (fun e=>(w e:ℝ))* |
| partition (inc:=fun e v=>v∈ends e) (fun e=>(z e:ℝ)) |
| have hc : 0<c:=mul_pos (partition_pos _ hw' a.1) (partition_pos _ hz' a.2) |
| have he : pairLaw ends (fun e=>(w e:ℝ)) (fun e=>(z e:ℝ))= |
| (fun x=>(rationalPairWeight ends w z x:ℝ)/c) := by |
| funext x |
| simp only [pairLaw,gibbs,rationalPairWeight,Rat.cast_mul,rationalWeight_cast,c] |
| exact div_mul_div_comm _ _ _ _ |
| rw [he,metropolis_normalize _ _ (fun x=>by exact_mod_cast rationalPairWeight_pos ends w z hw hz x) c hc] |
| |
| theorem pairStepTable_tv (hloop : ∀ e,¬(ends e).IsDiag) |
| (hpar : ∀ e,(univ.filter (fun f=>ends f=ends e)).card≤2) |
| (w z : E → ℚ) (hw : ∀ e,0<w e) (hz : ∀ e,0<z e) |
| (a : PM (fun e v=>v∈ends e) × PM (fun e v=>v∈ends e)) (k : ℕ) : |
| tv (imageLaw ((pairStepTable ends hloop hpar w z hw hz a).draw k)) |
| (metropolis (pairProposal ends hloop hpar) (pairLaw ends (fun e=>(w e:ℝ)) (fun e=>(z e:ℝ))) a) ≤ |
| 4*(8*a.1.val.card.choose 2+2*a.1.val.card+(a.1.val.card+a.2.val.card)+3)/(2:ℝ)^k := by |
| have ht := (pairStepTable ends hloop hpar w z hw hz a).draw_tv k |
| have hl : (fun b=>((pairStepTable ends hloop hpar w z hw hz a).law b:ℝ))= |
| metropolis (pairProposal ends hloop hpar) (pairLaw ends (fun e=>(w e:ℝ)) (fun e=>(z e:ℝ))) a := |
| funext (pairStepTable_law ends hloop hpar w z hw hz a) |
| rw [hl] at ht |
| apply ht.trans |
| rw [pairStepTable,WeightedOptions.metropolisChoice_size] |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| have hs := pairTable_size ends hloop hpar a |
| have hs' : ((pairTable ends hloop hpar a).size:ℝ)≤ |
| 8*a.1.val.card.choose 2+2*a.1.val.card+(a.1.val.card+a.2.val.card)+3 := by exact_mod_cast hs |
| push_cast |
| nlinarith |
|
|
| end MatchingFPRAS.Transport.Sparse |
|
|
| namespace MatchingFPRAS.FiniteChoice |
|
|
| lemma choose_pos {r K : ℕ} (p : Fin r → ℚ) (hs : ∑ i,p i=1) |
| (hK : 0<K) (J : Fin K) : 0<p (choose p hs hK J) := by |
| have hl := choose_lower p hs hK J |
| have hu := choose_upper p hs hK J |
| have hd := cumulative_step p (choose p hs hK J) |
| linarith |
|
|
| lemma chooseBits_pos {r : ℕ} (p : Fin r → ℚ) (hs : ∑ i,p i=1) |
| (k : ℕ) (bits : Fin k → Bool) : 0<p (chooseBits p hs k bits) := |
| choose_pos p hs _ _ |
|
|
| end MatchingFPRAS.FiniteChoice |
|
|
| namespace MatchingFPRAS.UnitRefresh |
|
|
| instance {α : Type*} [Finite α] : Finite (Pairing α) := by |
| apply Finite.of_injective Pairing.mate |
| intro p q h |
| cases p; cases q |
| simp only [Pairing.mk.injEq] at * |
| exact h |
|
|
| noncomputable instance {α : Type*} [Fintype α] : Fintype (Pairing α) := Fintype.ofFinite _ |
|
|
| variable {α β : Type*} |
|
|
| variable [DecidableEq α] |
|
|
| universe u |
|
|
|
|
|
|
| open Finset Polynomial |
|
|
| def completionSum (a : ℕ) : ℕ[X] →+ ℕ where |
| toFun p := p.sum (fun k c => c * pairingCount (a+k)) |
| map_zero' := Polynomial.sum_zero_index _ |
| map_add' p q := Polynomial.sum_add_index p q _ (by simp) (by intros; exact Nat.add_mul ..) |
|
|
| @[simp] lemma completion_monomial (a k c : ℕ) : |
| completionSum a (monomial k c)=c*pairingCount (a+k) := by |
| change (monomial k c : ℕ[X]).sum (fun j d => d * pairingCount (a+j)) = _ |
| exact Polynomial.sum_monomial_index c _ (Nat.zero_mul _) |
|
|
| noncomputable def interfacePolynomial (s : ℕ) (F : Fin (s+1) → ℕ) : ℕ[X] := |
| ∑ l : Fin (s+1), monomial (s-l.val) (s.choose l.val * F l) |
|
|
| variable {I : Type*} [Fintype I] [DecidableEq I] |
|
|
| noncomputable def convolution (s : I → ℕ) (F : ∀ i, Fin (s i+1) → ℕ) : ℕ[X] := |
| ∏ i, interfacePolynomial (s i) (F i) |
|
|
| omit [Fintype I] in |
| lemma prod_monomials (t : Finset I) (n c : I → ℕ) : |
| (∏ i ∈ t, monomial (n i) (c i) : ℕ[X]) = monomial (∑ i ∈ t,n i) (∏ i ∈ t,c i) := by |
| induction t using Finset.induction_on with |
| | empty => simp |
| | @insert i t hi ih => simp [hi,ih,Polynomial.monomial_mul_monomial] |
|
|
| theorem convolution_recurrence (s : I → ℕ) (F : ∀ i, Fin (s i+1) → ℕ) (u k : ℕ) : |
| completionSum (u+k) (convolution s F) = |
| ∑ l : ∀ i, Fin (s i+1), |
| pairingCount (u+k+(∑ i, (s i - (l i).val))) * (∏ i, ((s i).choose (l i).val * F i (l i))) := by |
| classical |
| unfold convolution interfacePolynomial |
| rw [Fintype.prod_sum,map_sum] |
| apply Finset.sum_congr rfl |
| intro l hl |
| rw [prod_monomials,completion_monomial,Nat.mul_comm] |
|
|
|
|
|
|
| open Finset Polynomial |
|
|
| lemma interface_natDegree (s : ℕ) (F : Fin (s+1) → ℕ) : |
| (interfacePolynomial s F).natDegree ≤ s := by |
| apply Polynomial.natDegree_sum_le_of_forall_le |
| intro l hl |
| exact (Polynomial.natDegree_monomial_le _).trans (Nat.sub_le _ _) |
|
|
| variable {I : Type*} [Fintype I] [DecidableEq I] |
|
|
| omit [DecidableEq I] in |
| lemma convolution_natDegree (s : I → ℕ) (F : ∀ i, Fin (s i+1) → ℕ) : |
| (convolution s F).natDegree ≤ ∑ i,s i := by |
| apply (Polynomial.natDegree_prod_le _ _).trans |
| exact Finset.sum_le_sum fun i _ => interface_natDegree (s i) (F i) |
|
|
| omit [DecidableEq I] in |
| theorem convolution_finite_evaluation (s : I → ℕ) (F : ∀ i, Fin (s i+1) → ℕ) |
| (N u k : ℕ) (hN : (∑ i,s i) ≤ N) : |
| completionSum (u+k) (convolution s F) = |
| ∑ a ∈ Finset.range (N+1), (convolution s F).coeff a * pairingCount (u+k+a) := by |
| change (convolution s F).sum (fun a c => c * pairingCount (u+k+a)) = _ |
| apply Polynomial.sum_eq_of_subset |
| · simp |
| · intro a ha |
| apply Finset.mem_range.mpr |
| by_contra hn |
| have hz := Polynomial.coeff_eq_zero_of_natDegree_lt |
| (lt_of_le_of_lt (convolution_natDegree s F |>.trans hN) (by omega : N<a)) |
| exact Polynomial.mem_support_iff.mp ha hz |
|
|
|
|
|
|
| def Pairing.sigma {L : Type*} {A : L → Type*} (p : ∀ l, Pairing (A l)) : Pairing (Sigma A) where |
| mate x := ⟨x.1,(p x.1).mate x.2⟩ |
| involutive x := by |
| cases x with |
| | mk l x => exact congrArg (Sigma.mk l) ((p l).involutive x) |
| no_fixed x h := by |
| have he : (p x.1).mate x.2=x.2 := eq_of_heq (Sigma.mk.inj_iff.mp h).2 |
| exact (p x.1).no_fixed x.2 he |
|
|
| variable {V L : Type*} [Fintype V] [Fintype L] [DecidableEq V] [DecidableEq L] |
|
|
| structure ColoredPairing (bags : V → Finset L) where |
| pair : Pairing V |
| color : V → L |
| allowed : ∀ x, color x ∈ bags x |
| same_color : ∀ x, color (pair.mate x)=color x |
|
|
| omit [Fintype V] [Fintype L] [DecidableEq V] [DecidableEq L] in |
| @[ext] lemma ColoredPairing.ext {bags : V → Finset L} {p q : ColoredPairing bags} |
| (hp : p.pair=q.pair) (hc : p.color=q.color) : p=q := by |
| cases p; cases q; simp_all |
|
|
| instance (bags : V → Finset L) : Finite (ColoredPairing bags) := |
| Finite.of_injective (fun p : ColoredPairing bags => (p.pair,p.color)) (by |
| intro p q h |
| exact ColoredPairing.ext (congrArg Prod.fst h) (congrArg Prod.snd h)) |
|
|
| noncomputable instance (bags : V → Finset L) : Fintype (ColoredPairing bags) := Fintype.ofFinite _ |
|
|
| abbrev Assignment (bags : V → Finset L) := {f : V → L |
|
|
| def ColoredPairing.fiber {bags : V → Finset L} (p : ColoredPairing bags) (l : L) : |
| Pairing {x : V |
| mate x := ⟨p.pair.mate x,(p.same_color x).trans x.property⟩ |
| involutive x := Subtype.ext (p.pair.involutive x) |
| no_fixed x h := p.pair.no_fixed x (congrArg Subtype.val h) |
|
|
| def ColoredPairing.glue (bags : V → Finset L) (f : Assignment bags) |
| (p : ∀ l,Pairing {x : V |
| pair := (Pairing.sigma p).map (Equiv.sigmaFiberEquiv f.val) |
| color := f.val |
| allowed := f.property |
| same_color x := (p (f.val x)).mate ⟨x,rfl⟩ |>.property |
|
|
| def assignmentPairingEquiv (bags : V → Finset L) : |
| ColoredPairing bags ≃ Σ f : Assignment bags, ∀ l, Pairing {x : V |
| toFun p := ⟨⟨p.color,p.allowed⟩,p.fiber⟩ |
| invFun q := ColoredPairing.glue bags q.1 q.2 |
| left_inv p := by |
| apply ColoredPairing.ext |
| · ext x; rfl |
| · rfl |
| right_inv q := by |
| rcases q with ⟨f,p⟩ |
| change (⟨f,(ColoredPairing.glue bags f p).fiber⟩ : |
| Σ f : Assignment bags, ∀ l, Pairing {x : V |
| apply congrArg (fun q : ∀ l, Pairing {x : V // f.val x=l} => |
| (⟨f,q⟩ : Σ f : Assignment bags, ∀ l, Pairing {x : V |
| funext l |
| ext x |
| change ((p (f.val x)).mate ⟨x,rfl⟩).val = ((p l).mate x).val |
| obtain ⟨x,hx⟩ := x |
| dsimp at hx ⊢ |
| subst l |
| rfl |
|
|
| theorem coloredPairing_card (bags : V → Finset L) : |
| Fintype.card (ColoredPairing bags) = |
| ∑ f : Assignment bags, ∏ l : L, pairingCount (Fintype.card {x : V |
| classical |
| rw [Fintype.card_congr (assignmentPairingEquiv bags),Fintype.card_sigma] |
| apply Finset.sum_congr rfl |
| intro f hf |
| rw [Fintype.card_pi] |
| apply Finset.prod_congr rfl |
| intro l hl |
| exact pairing_card |
|
|
| end MatchingFPRAS.UnitRefresh |
|
|
| end OAI |
|
|
