| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Probability.Variance |
| import OAI.Combinatorics.MatchingCount.Graphs.EdgeLow |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.Transport |
|
|
| open Finset |
|
|
| variable {V E F : Type*} [Fintype V] [Fintype E] [Fintype F] |
|
|
| variable [DecidableEq V] [DecidableEq E] [DecidableEq F] |
|
|
| variable (inc : E → V → Prop) (inc' : F → V → Prop) (f : E ↪ F) |
| |
| variable (hinc : ∀ e x,inc' (f e) x ↔ inc e x) |
|
|
| include hinc in |
| omit [Fintype V] [Fintype E] [Fintype F] [DecidableEq V] [DecidableEq E] [DecidableEq F] in |
| lemma matching_map_iff [Fintype V] [Fintype E] [Fintype F] |
| [DecidableEq V] [DecidableEq E] [DecidableEq F] (S : Finset E) (U : Finset V) : |
| MatchingOn inc' (S.map f) U ↔ MatchingOn inc S U := by |
| constructor |
| · intro hM |
| refine ⟨fun e he x hx => hM.1 (f e) (Finset.mem_map.mpr ⟨e,he,rfl⟩) x ((hinc e x).mpr hx),?_⟩ |
| intro x hx |
| obtain ⟨q,⟨hq,hqx⟩,hu⟩ := hM.2 x hx |
| obtain ⟨e,he,rfl⟩ := Finset.mem_map.mp hq |
| refine ⟨e,⟨he,(hinc e x).mp hqx⟩,?_⟩ |
| intro e' he' |
| apply f.injective |
| exact hu (f e') ⟨Finset.mem_map.mpr ⟨e',he'.1,rfl⟩,(hinc e' x).mpr he'.2⟩ |
| · intro hM |
| constructor |
| · intro q hq x hx |
| obtain ⟨e,he,rfl⟩ := Finset.mem_map.mp hq |
| exact hM.1 e he x ((hinc e x).mp hx) |
| · intro x hx |
| obtain ⟨e,⟨he,hex⟩,hu⟩ := hM.2 x hx |
| refine ⟨f e,⟨Finset.mem_map.mpr ⟨e,he,rfl⟩,(hinc e x).mpr hex⟩,?_⟩ |
| intro q hq |
| obtain ⟨e',he',rfl⟩ := Finset.mem_map.mp hq.1 |
| exact congrArg f (hu e' ⟨he',(hinc e' x).mp hq.2⟩) |
| |
| noncomputable def matchingMap (U : Finset V) (M : Matchings inc U) : Matchings inc' U := |
| ⟨M.val.map f,(matching_map_iff inc inc' f hinc M.val U).mpr M.property⟩ |
| |
| lemma matchingMap_injective (U : Finset V) : Function.Injective (matchingMap inc inc' f hinc U) := by |
| intro a b h |
| apply Subtype.ext |
| exact Finset.map_injective f (congrArg Subtype.val h) |
|
|
| noncomputable def edgeExtension (w : E → ℝ) (q : F) : ℝ := by |
| classical |
| exact if h : ∃ e,f e=q then w h.choose else 0 |
|
|
| omit [Fintype F] [DecidableEq E] in |
| lemma edgeExtension_on [Fintype F] [DecidableEq E] (w : E → ℝ) (e : E) : edgeExtension f w (f e)=w e := by |
| classical |
| unfold edgeExtension |
| rw [dite_eq_left ⟨e,rfl⟩] |
| exact congrArg w (f.injective (Exists.choose_spec (show ∃ e',f e'=f e from ⟨e,rfl⟩))) |
|
|
| omit [Fintype F] [DecidableEq E] in |
| lemma edgeExtension_off [Fintype F] [DecidableEq E] (w : E → ℝ) (q : F) (hq : ¬∃ e,f e=q) : edgeExtension f w q=0 := by |
| classical |
| simp [edgeExtension,hq] |
|
|
| omit [Fintype F] [DecidableEq E] in |
| lemma edgeExtension_nonneg [Fintype F] [DecidableEq E] (w : E → ℝ) (hw : ∀ e,0≤w e) (q : F) : 0≤edgeExtension f w q := by |
| classical |
| unfold edgeExtension |
| split_ifs <;> first | exact hw _ | norm_num |
|
|
| lemma matchingMap_weight (w : E → ℝ) (U : Finset V) (M : Matchings inc U) : |
| (∏ q∈(matchingMap inc inc' f hinc U M).val,edgeExtension f w q)=∏ e∈M.val,w e := by |
| dsimp [matchingMap] |
| rw [Finset.prod_map] |
| simp_rw [edgeExtension_on] |
| |
| include hinc in |
| |
| theorem partition_embedding (w : E → ℝ) (U : Finset V) : |
| partitionWeight inc' (edgeExtension f w) U=partitionWeight inc w U := by |
| classical |
| unfold partitionWeight |
| symm |
| apply Finset.sum_bij_ne_zero (fun M _ _ => matchingMap inc inc' f hinc U M) |
| · intros; exact Finset.mem_univ _ |
| · intro a _ _ b _ _ h |
| exact matchingMap_injective inc inc' f hinc U h |
| · intro N _ hN |
| have hr : ∀ q∈N.val,∃ e,f e=q := by |
| intro q hq |
| by_contra hn |
| apply hN |
| exact Finset.prod_eq_zero hq (edgeExtension_off f w q hn) |
| let S := univ.filter fun e : E => f e∈N.val |
| have hS : S.map f=N.val := by |
| ext q |
| constructor |
| · intro hq |
| obtain ⟨e,he,rfl⟩ := Finset.mem_map.mp hq |
| exact (Finset.mem_filter.mp he).2 |
| · intro hq |
| obtain ⟨e,rfl⟩ := hr q hq |
| exact Finset.mem_map.mpr ⟨e,by simp [S,hq],rfl⟩ |
| let M : Matchings inc U := ⟨S,(matching_map_iff inc inc' f hinc S U).mp (hS.symm ▸ N.property)⟩ |
| have hM : matchingMap inc inc' f hinc U M=N := Subtype.ext hS |
| refine ⟨M,Finset.mem_univ _,?_,hM⟩ |
| rw [←matchingMap_weight inc inc' f hinc w U M,hM] |
| exact hN |
| · intro M _ _ |
| exact (matchingMap_weight inc inc' f hinc w U M).symm |
|
|
| end MatchingFPRAS.Transport |
|
|
| namespace MatchingFPRAS.Enlargement |
|
|
| open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry |
| open MatchingFPRAS.Hierarchy MatchingFPRAS.Transport Finset |
|
|
| variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V] |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : DecidableEq (SourceLabel w K) := Classical.decEq _ |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _ |
|
|
| noncomputable def sourceRealLabel (w : V → V → ℝ) (K : ℕ) (e : SourceRealEdge V K) : SourceLabel w K := |
| edgeLabel (sourceRealB w K) (sourceRealB_comm w K) (sourceRealB_tri w K) |
| (realLeft K) (realRight K) (sourceLevels w K) e |
|
|
| omit [Nontrivial V] in |
| lemma real_edge_not_diag [Nontrivial V] (K : ℕ) (e : SourceRealEdge V K) : |
| ¬(edge source target (4*(2*K+2)) e.1 e.2).IsDiag := by |
| rw [edge,Sym2.mk_isDiag_iff] |
| intro he |
| have hi := atVertex_injective source target (4*(2*K+2)) e.1 (source_ne_target e.1) he |
| have := congrArg Fin.val hi |
| simp at this |
|
|
| noncomputable def sourceColoredReal (w : V → V → ℝ) (K : ℕ) (e : SourceRealEdge V K) : |
| BagEdge (sourceBags w K) := |
| ⟨⟨(edge source target (4*(2*K+2)) e.1 e.2,sourceRealLabel w K e),real_edge_not_diag K e⟩,by |
| intro x hx |
| apply (mem_memberships _ _ _ (realLeft K) (realRight K) (sourceLevels w K) x _).mpr |
| refine ⟨e,?_,rfl⟩ |
| simpa [ColoredEdge.Incident,Incident,realLeft,realRight,edge] using hx⟩ |
|
|
| lemma sourceColoredReal_injective (w : V → V → ℝ) (K : ℕ) : |
| Function.Injective (sourceColoredReal w K) := by |
| intro e f h |
| apply edge_injective source target (4*(2*K+2)) (by omega) |
| exact congrArg (fun q : BagEdge (sourceBags w K) => q.val.val.1) h |
|
|
| noncomputable def sourceRealEmbedding (w : V → V → ℝ) (K : ℕ) : |
| SourceRealEdge V K ↪ BagEdge (sourceBags w K) := |
| ⟨sourceColoredReal w K,sourceColoredReal_injective w K⟩ |
|
|
| noncomputable def sourceRealActivity (w : V → V → ℝ) (K : ℕ) (e : SourceRealEdge V K) : ℝ := |
| pathActivity (2*K+2) (fun e => bottleneck w (source e) (target e)) |
| (fun e => sourceHeight w (source e)) (fun e => sourceHeight w (target e)) (logicalActivity w) e.1 e.2 |
|
|
| noncomputable def sourceRealPortion (w : V → V → ℝ) (K : ℕ) : BagEdge (sourceBags w K) → ℝ := |
| by classical exact edgeExtension (sourceRealEmbedding w K) (sourceRealActivity w K) |
|
|
| lemma sourceRealPortion_partition (w : V → V → ℝ) (K : ℕ) |
| (R : Finset V) (U : LogicalEdge V → Finset (Fin (4*(2*K+2)))) : |
| partitionWeight BagEdge.Incident (sourceRealPortion w K) (survivors (4*(2*K+2)) R U)= |
| realHolePartition source target (4*(2*K+2)) R U |
| (pathActivity (2*K+2) (fun e => bottleneck w (source e) (target e)) |
| (fun e => sourceHeight w (source e)) (fun e => sourceHeight w (target e)) (logicalActivity w)) := by |
| classical |
| rw [show sourceRealPortion w K=edgeExtension (sourceRealEmbedding w K) (sourceRealActivity w K) from rfl] |
| rw [partition_embedding (fun (q : SourceRealEdge V K) x => x∈edge source target (4*(2*K+2)) q.1 q.2) |
| BagEdge.Incident (sourceRealEmbedding w K) (fun _ _ => Iff.rfl)] |
| exact realMatching_partition source target (4*(2*K+2)) source_ne_target R U _ |
|
|
| noncomputable def holeTerminals (K : ℕ) (H : Finset (SourceVertex V K)) : Finset V := |
| by classical exact univ.filter fun x => Sum.inl x∈H |
|
|
| noncomputable def holeInternals (K : ℕ) (H : Finset (SourceVertex V K)) (e : LogicalEdge V) : |
| Finset (Fin (4*(2*K+2))) := by classical exact univ.filter fun i => Sum.inr (e,i)∈H |
|
|
| omit [Nontrivial V] in |
| lemma hole_decomposition [Nontrivial V] (K : ℕ) (H : Finset (SourceVertex V K)) : |
| enlargedHoles (4*(2*K+2)) (holeTerminals K H) (holeInternals K H)=H := by |
| ext x |
| cases x with |
| | inl x => simp [holeTerminals] |
| | inr ei => rcases ei with ⟨e,i⟩; simp [holeInternals] |
|
|
| omit [Nontrivial V] in |
| lemma survivors_decomposition [Nontrivial V] (K : ℕ) (H : Finset (SourceVertex V K)) : |
| survivors (4*(2*K+2)) (holeTerminals K H) (holeInternals K H)=univ \ H := by |
| ext x |
| cases x with |
| | inl x => simp [holeTerminals] |
| | inr ei => rcases ei with ⟨e,i⟩; simp [holeInternals] |
|
|
| omit [Nontrivial V] in |
| lemma survivors_empty [Nontrivial V] (K : ℕ) : survivors (V := V) (E := LogicalEdge V) (4*(2*K+2)) ∅ (fun _ => ∅)=univ := by |
| ext x |
| cases x with |
| | inl x => simp |
| | inr ei => rcases ei with ⟨e,i⟩; simp |
|
|
| lemma sourceRealActivity_pos (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (K : ℕ) |
| (e : SourceRealEdge V K) : 0<sourceRealActivity w K e := by |
| have hl : 0<logicalActivity w e.1 := by |
| unfold logicalActivity edgeActivity |
| split_ifs <;> exact hw _ _ |
| exact hl.trans_le (profile_lower _ _ _ _ _ |
| (edgeActivity_le_bottleneck w _ _ (source_ne_target e.1)) e.2) |
|
|
| lemma sourceRealPortion_nonneg (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (K : ℕ) |
| (e : BagEdge (sourceBags w K)) : 0 ≤ sourceRealPortion w K e := by |
| classical |
| exact edgeExtension_nonneg _ _ (fun q => (sourceRealActivity_pos w hw K q).le) e |
|
|
| lemma sourceRealPortion_full (w : V → V → ℝ) (hz : 0<partition w ∅) (K : ℕ) : |
| partitionWeight BagEdge.Incident (sourceRealPortion w K) univ = |
| (∏ e, pathConstant (2*K+2) (bottleneck w (source e) (target e)) |
| (sourceHeight w (source e)) (sourceHeight w (target e))) * partition w ∅ := by |
| rw [←survivors_empty (V := V) K,sourceRealPortion_partition] |
| exact intact_partition_identity w hz _ _ _ _ |
|
|
| lemma sourceRealPortion_full_pos (w : V → V → ℝ) (hz : 0<partition w ∅) (K : ℕ) : |
| 0<partitionWeight BagEdge.Incident (sourceRealPortion w K) univ := by |
| rw [sourceRealPortion_full w hz K] |
| apply mul_pos _ hz |
| exact Finset.prod_pos fun e _ => pathConstant_pos _ _ _ _ |
| (zero_lt_one.trans_le (one_le_bottleneck w _ _)) |
|
|
| lemma sourceRealPortion_hole_bound (hn : 2≤Fintype.card V) |
| (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (hz : 0<partition w ∅) |
| (hrlo : ∀ x,(1:ℝ)/4≤rowMax hn w x) (hrhi : ∀ x,rowMax hn w x≤1) |
| (K : ℕ) (H : Finset (SourceVertex V K)) (hH : Even H.card) : |
| partitionWeight BagEdge.Incident (sourceRealPortion w K) (univ \ H) / |
| partitionWeight BagEdge.Incident (sourceRealPortion w K) univ * |
| pairingCapacity (sourceRealB w K) H hH ≤ 2*holeScale V^(H.card/2) := by |
| have heven : Even (enlargedHoles (4*(2*K+2)) (holeTerminals K H) (holeInternals K H)).card := |
| (hole_decomposition K H).symm ▸ hH |
| have ht := lifted_hole_bound hn w hw hz hrlo hrhi (2*K+2) (by omega) |
| (fun e => sourceHeight w (source e)) (fun e => sourceHeight w (target e)) |
| (fun e => sourceHeight_nonneg w _) (fun e => sourceHeight_nonneg w _) |
| (holeTerminals K H) (holeInternals K H) heven |
| rw [←sourceRealPortion_partition w K,←sourceRealPortion_partition w K, |
| survivors_empty,survivors_decomposition] at ht |
| simpa only [hole_decomposition, sourceRealB] using ht |
|
|
| theorem source_bag_inflation (hn : 2≤Fintype.card V) |
| (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (hz : 0<partition w ∅) |
| (hrlo : ∀ x,(1:ℝ)/4≤rowMax hn w x) (hrhi : ∀ x,rowMax hn w x≤1) |
| (K : ℕ) (hK : ∀ x y,x≠y → edgeActivity w x y≤(4:ℝ)^K) : |
| let D := inflationScale (V := SourceVertex V K) (holeScale V) |
| let realZ := partitionWeight BagEdge.Incident (sourceRealPortion w K) univ |
| let bagZ := partitionWeight BagEdge.Incident |
| (fun e => sourceRealPortion w K e+(2:ℝ)^e.val.val.2.1.val/D) univ |
| 1≤bagZ/realZ ∧ bagZ/realZ≤2 := by |
| classical |
| apply bag_inflation_of_hole_estimate (sourceBags w K) (Fintype.card_pos) |
| (sourceBag_card_le_two w K hK) (sourceRealB w K) |
| (fun l => (2:ℝ)^l.1.val) (fun _ => by positivity) |
| · intro e |
| apply sourceBag_height w K (edgeLow_ne_high e.val.val.1 e.val.property) |
| · exact e.property _ (edgeLow_mem _) |
| · exact e.property _ (edgeHigh_mem _) |
| · exact sourceRealPortion_nonneg w hw K |
| · exact sourceRealPortion_full_pos w hz K |
| · exact holeScale_pos |
| · intro H hH |
| convert sourceRealPortion_hole_bound hn w hw hz hrlo hrhi K H hH using 1 |
| congr 3 |
| ext x |
| simp |
|
|
|
|
|
|
| open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry |
| open MatchingFPRAS.Hierarchy MatchingFPRAS.Transport Finset |
|
|
| variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V] |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : DecidableEq (SourceLabel w K) := Classical.decEq _ |
|
|
| noncomputable local instance (w : V → V → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _ |
|
|
| noncomputable def bagHeight (w : V → V → ℝ) (K : ℕ) (l : SourceLabel w K) : ℝ := (2:ℝ)^l.1.val |
|
|
| lemma bagHeight_one (w : V → V → ℝ) (K : ℕ) (l : SourceLabel w K) : 1 ≤ bagHeight w K l := by |
| exact one_le_pow₀ (by norm_num) |
|
|
| lemma bagHeight_pos (w : V → V → ℝ) (K : ℕ) (l : SourceLabel w K) : 0 < bagHeight w K l := |
| zero_lt_one.trans_le (bagHeight_one w K l) |
|
|
| lemma bagHeight_le (w : V → V → ℝ) (K : ℕ) (l : SourceLabel w K) : bagHeight w K l ≤ 4^K := by |
| have hl : l.1.val ≤ 2*K := (Nat.le_of_lt_succ l.1.isLt).trans (sourceLevels_le w K) |
| calc |
| _ ≤ (2:ℝ)^(2*K) := pow_le_pow_right₀ (by norm_num) hl |
| _ = _ := by rw [pow_mul]; norm_num |
|
|
| lemma bagHeight_adjacent (w : V → V → ℝ) (K : ℕ) (a b : SourceLabel w K) |
| (hab : (sourceTree w K).Adj a b) : bagHeight w K a ≤ 2*bagHeight w K b := by |
| change Hierarchy.Parent _ _ _ a b ∨ Hierarchy.Parent _ _ _ b a at hab |
| rcases hab with hab|hab |
| · have he : b.1.val=a.1.val+1 := by have := hab.1; omega |
| change (2:ℝ)^a.1.val ≤ 2*2^b.1.val |
| rw [he,pow_succ] |
| have hz : 0 ≤ (2:ℝ)^a.1.val := by positivity |
| nlinarith |
| · have he : a.1.val=b.1.val+1 := by have := hab.1; omega |
| change (2:ℝ)^a.1.val ≤ 2*2^b.1.val |
| rw [he,pow_succ] |
| nlinarith |
|
|
| lemma sourceRealActivity_le_strength (w : V → V → ℝ) (K : ℕ) (e : SourceRealEdge V K) : |
| sourceRealActivity w K e ≤ sourceRealB w K (realLeft K e) (realRight K e) := by |
| exact edge_activity_le_realBottleneck source target source_ne_target (2*K+2) (by omega) _ _ _ _ e.1 e.2 |
|
|
| lemma sourceRealActivity_le_height (w : V → V → ℝ) (K : ℕ) |
| (hw : ∀ x y,x≠y → edgeActivity w x y ≤ (4:ℝ)^K) (e : SourceRealEdge V K) : |
| sourceRealActivity w K e ≤ 2*bagHeight w K (sourceRealLabel w K e) := by |
| apply (sourceRealActivity_le_strength w K e).trans |
| have hh := dyadic_upper_of_lt (sourceLevels w K) |
| (sourceRealB w K (realLeft K e) (realRight K e)) |
| ((source_strength_le_max w K hw e).trans_lt (maxSourceHeight_lt w K hw)) |
| change _ ≤ 2*(2:ℝ)^(dyadicLevel (sourceLevels w K) (sourceRealB w K (realLeft K e) (realRight K e))).val |
| rw [pow_succ,mul_comm] at hh |
| exact hh.le |
|
|
| lemma sourceRealPortion_le_height (w : V → V → ℝ) (K : ℕ) |
| (hw : ∀ x y,x≠y → edgeActivity w x y ≤ (4:ℝ)^K) (e : BagEdge (sourceBags w K)) : |
| sourceRealPortion w K e ≤ 2*bagHeight w K e.val.val.2 := by |
| classical |
| by_cases he : ∃ q,sourceRealEmbedding w K q=e |
| · obtain ⟨q,rfl⟩ := he |
| rw [sourceRealPortion,edgeExtension_on] |
| exact sourceRealActivity_le_height w K hw q |
| · rw [sourceRealPortion,edgeExtension_off _ _ _ he] |
| exact mul_nonneg (by norm_num) (bagHeight_pos _ _ _).le |
|
|
| noncomputable def sourceBagWeight (w : V → V → ℝ) (K D : ℕ) |
| (e : BagEdge (sourceBags w K)) : ℝ := |
| sourceRealPortion w K e+bagHeight w K e.val.val.2/D |
|
|
| lemma sourceBagWeight_range (w : V → V → ℝ) (K D : ℕ) (hD : 1 ≤ D) |
| (hw : ∀ x y,0 < w x y) (hK : ∀ x y,x≠y → edgeActivity w x y ≤ (4:ℝ)^K) |
| (e : BagEdge (sourceBags w K)) : |
| bagHeight w K e.val.val.2/D ≤ sourceBagWeight w K D e ∧ |
| sourceBagWeight w K D e ≤ 3*bagHeight w K e.val.val.2 := by |
| have hr := sourceRealPortion_nonneg w hw K e |
| have hu := sourceRealPortion_le_height w K hK e |
| have hq : bagHeight w K e.val.val.2/(D:ℝ) ≤ bagHeight w K e.val.val.2 := |
| div_le_self (bagHeight_pos _ _ _).le (by exact_mod_cast hD) |
| dsimp [sourceBagWeight] |
| constructor <;> linarith |
|
|
| lemma sourceBagWeight_global (w : V → V → ℝ) (K D : ℕ) (hD : 1 ≤ D) |
| (hw : ∀ x y,0 < w x y) (hK : ∀ x y,x≠y → edgeActivity w x y ≤ (4:ℝ)^K) |
| (e : BagEdge (sourceBags w K)) : |
| (D:ℝ)⁻¹ ≤ sourceBagWeight w K D e ∧ sourceBagWeight w K D e ≤ 3*4^K := by |
| have hh := sourceBagWeight_range w K D hD hw hK e |
| constructor |
| · calc |
| (D:ℝ)⁻¹ = 1/(D:ℝ) := (one_div _).symm |
| _ ≤ bagHeight w K e.val.val.2/(D:ℝ) := |
| div_le_div_of_nonneg_right (bagHeight_one w K e.val.val.2) (Nat.cast_nonneg D) |
| _ ≤ _ := hh.1 |
| · exact hh.2.trans (mul_le_mul_of_nonneg_left (bagHeight_le w K _) (by norm_num)) |
|
|
| noncomputable def sourceD (K : ℕ) : ℕ := |
| 100*Fintype.card (SourceVertex V K)^2*(100000000*(Fintype.card V+1)^4) |
|
|
| lemma sourceD_one (K : ℕ) : 1 ≤ sourceD (V:=V) K := by |
| have hn : 0 < Fintype.card (SourceVertex V K) := Fintype.card_pos |
| have hp : 0 < sourceD (V:=V) K := by |
| dsimp [sourceD] |
| positivity |
| omega |
|
|
| omit [Nontrivial V] in |
| lemma sourceD_cast [Nontrivial V] (K : ℕ) : |
| (sourceD (V:=V) K:ℝ)=inflationScale (V:=SourceVertex V K) (holeScale V) := by |
| simp only [sourceD,inflationScale,holeScale,Nat.cast_mul,Nat.cast_pow,Nat.cast_add,Nat.cast_one,Nat.cast_ofNat] |
|
|
| end MatchingFPRAS.Enlargement |
|
|
| end OAI |
|
|
