| import Mathlib |
| import OAI.Algebra.GroupRing.FiniteClusters |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace TorsionFreeZeroDivisors.ClusterLocalization |
|
|
| section |
| open scoped Classical BigOperators |
| open ComparedBlocks |
| variable {T E : Type} [Fintype T] {len : T → ℕ} |
| (C : Comparisons (E:=E) len) (keep : T → Prop) |
| local instance clusterFintype : Fintype (Cluster C keep) := Fintype.ofFinite _ |
|
|
| def pathEquiv (c : Cluster C keep) : {t // belongs C keep c t} ≃ |
| {v : {t // keep t} // (graph C keep).connectedComponentMk v=c} where |
| toFun t := by |
| have hk : keep t.val := (cluster_exists C keep).mp ⟨c,t.property⟩ |
| refine ⟨⟨t.val,hk⟩,?_⟩ |
| have he := PairingClusters.cluster_some (fun x : Position len => x.1) |
| C.pairing.partner C.pairing.involutive keep hk |
| exact Option.some.inj (he.symm.trans t.property) |
| invFun v := ⟨v.val.val,by |
| change PairingClusters.cluster _ _ _ _ v.val.val=some c |
| rw [PairingClusters.cluster_some _ _ _ _ v.val.property] |
| exact congrArg some v.property⟩ |
| left_inv t := Subtype.ext rfl |
| right_inv v := Subtype.ext (Subtype.ext rfl) |
|
|
| lemma paths_card (c : Cluster C keep) : (paths C keep c).card=(FiniteClusters.block (graph C keep) c).card := by |
| simpa only [Fintype.card_subtype,paths,FiniteClusters.block] using Fintype.card_congr (pathEquiv C keep c) |
| lemma member_exists (c : Cluster C keep) : ∃ t,belongs C keep c t := by |
| obtain ⟨v,hv⟩ := FiniteClusters.block_nonempty (graph C keep) c |
| let t := (pathEquiv C keep c).symm ⟨v,(FiniteClusters.mem_block _).mp hv⟩ |
| exact ⟨t.val,t.property⟩ |
|
|
| /-- A closed retained subset supplied by recursive separation bounds the |
| actual connected component, even when the pairing has loops or parallel arcs. -/ |
| lemma paths_card_le {K : ℕ} |
| (hs : ∀ t,keep t → ∃ B : Finset T,t∈B ∧ B.card≤K ∧ |
| ∀ x∈B,∀ y,keep y → PairingClusters.Rel (fun x : Position len=>x.1) C.pairing.partner x y → y∈B) |
| (c : Cluster C keep) : (paths C keep c).card≤K := by |
| rw [paths_card] |
| apply FiniteClusters.block_card |
| intro t |
| obtain ⟨B,hB,hBK,hcl⟩ := hs t.val t.property |
| refine ⟨B.subtype keep,?_,?_,?_⟩ |
| · simpa only [Finset.mem_subtype] using hB |
| · exact (by rw [Finset.card_subtype]; exact Finset.card_filter_le _ _ : (B.subtype keep).card≤B.card).trans hBK |
| · intro x hx y hxy |
| have hx' : x.val∈B := by simpa only [Finset.mem_subtype] using hx |
| have hy := hcl x.val hx' y.val y.property hxy.2 |
| simpa only [Finset.mem_subtype] using hy |
|
|
| lemma mass_upper {K cap : ℕ} (hK : ∀ c : Cluster C keep,(paths C keep c).card≤K) |
| (hcap : ∀ t,len t≤cap) (c : Cluster C keep) : mass C keep c≤K*cap := by |
| calc |
| _ ≤ ∑ _t∈paths C keep c,cap := Finset.sum_le_sum fun t _=>hcap t |
| _ = (paths C keep c).card*cap := by simp |
| _ ≤ K*cap := Nat.mul_le_mul_right _ (hK c) |
|
|
| lemma mass_lower {L : ℕ} (hL : ∀ t,L≤len t) (c : Cluster C keep) : L ≤ mass C keep c := by |
| obtain ⟨t,ht⟩ := member_exists C keep c |
| apply (hL t).trans |
| exact Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht⟩) |
|
|
| lemma short_mass_refined {L : ℕ} (root : Option T) |
| (ho : ∀ t,root≠some t → L≤len t) : |
| (∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c)≤ |
| ∑ t∈Finset.univ.filter (fun t=>root=some t ∧ len t<L),len t := by |
| cases root with |
| | none => simpa using short_mass C keep none ho |
| | some r => |
| by_cases h : len r<L |
| · have he : Finset.univ.filter (fun t=>some r=some t ∧ len t<L)= |
| Finset.univ.filter (fun t=>some r=some t) := by |
| ext t |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,Option.some.injEq] |
| constructor |
| · exact And.left |
| · intro ht; exact ⟨ht,ht ▸ h⟩ |
| rw [he] |
| exact short_mass C keep (some r) ho |
| · have hall : ∀ t,L≤len t := by |
| intro t |
| by_cases ht : r=t |
| · subst t; omega |
| · exact ho t (fun he=>ht (Option.some.inj he)) |
| have hn : ∀ c : Cluster C keep,¬mass C keep c<L := |
| fun c=>not_lt_of_ge (mass_lower C keep hall c) |
| simp only [Finset.filter_false_of_mem (fun c _=>hn c),Finset.sum_empty,Nat.zero_le] |
|
|
| lemma short_mass_half {L : ℕ} (root : Option T) (H₀ : ℝ) (hH₀ : 0≤H₀) |
| (ho : ∀ t,root≠some t → L≤len t) |
| (hr : ∀ t,root=some t → len t<L → (len t:ℝ)≤H₀/2) : |
| ((∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c):ℝ)≤H₀/2 := by |
| have hh : ((∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c):ℝ)≤ |
| ((∑ t∈Finset.univ.filter (fun t=>root=some t ∧ len t<L),len t):ℝ) := by |
| exact_mod_cast short_mass_refined C keep root ho |
| apply hh.trans |
| cases root with |
| | none => simp only [reduceCtorEq,false_and]; simp; positivity |
| | some r => |
| by_cases h : len r<L |
| · have he : (Finset.univ.filter (fun t=>some r=some t ∧ len t<L))={r} := by ext t; simp; aesop |
| rw [he,Finset.sum_singleton] |
| exact hr r rfl h |
| · have he : (Finset.univ.filter (fun t=>some r=some t ∧ len t<L))=∅ := by ext t; simp; aesop |
| rw [he,Finset.sum_empty] |
| positivity |
| end |
| |
| open scoped Classical BigOperators |
| open ComparedBlocks |
| variable {T E : Type} [Fintype T] [Fintype E] {len : T → ℕ} |
| (C : Comparisons (E:=E) len) (keep : T → Prop) |
| local instance selectedClusterFintype : Fintype (Cluster C keep) := Fintype.ofFinite _ |
|
|
| omit [Fintype E] in |
| /-- Retained closures are nonnegative; only deleted original positions are |
| charged in the lower bound for retained mass. -/ |
| lemma retained_original (old : T → ℕ) (ho : ∀ t,old t≤len t) : |
| (∑t,old t)≤(∑c,mass C keep c)+∑t∈Finset.univ.filter (fun t=>¬keep t),old t := by |
| rw [mass_sum] |
| calc |
| _ = (∑t∈Finset.univ.filter keep,old t)+∑t∈Finset.univ.filter (fun t=>¬keep t),old t := |
| (Finset.sum_filter_add_sum_filter_not _ _ _).symm |
| _ ≤ _ := Nat.add_le_add_right (Finset.sum_le_sum fun t _=>ho t) _ |
|
|
| /-- An averaging argument on the actual connected components of the |
| retained pairing graph. E counts oriented interval sides, hence its factor 2. -/ |
| theorem exists_selected (old : T → ℕ) (ho : ∀ t,old t≤len t) |
| (root : Option T) (L K cap : ℕ) (H₀ ε C₂ : ℝ) |
| (hH₀ : 0<H₀) (hL : 0<L) (hε : 0<ε) (hC₂ : 0<C₂) |
| (hsize : ∀ c : Cluster C keep,(paths C keep c).card≤K) |
| (hcap : ∀ t,len t≤cap*L) |
| (hbase : H₀≤∑t,(old t:ℝ)) |
| (hdelete : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤H₀/16) |
| (hbad : ((Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card:ℝ)+ |
| ((Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card:ℝ)≤ε/16*H₀) |
| (hcompare : (Fintype.card E:ℝ)/2≤C₂/(16*L)*H₀) |
| (hlong : ∀ t,root≠some t → L≤len t) |
| (hroot : ∀ t,root=some t → len t<L → (len t:ℝ)≤H₀/2) : |
| ∃ c : Cluster C keep,L ≤ mass C keep c ∧ mass C keep c≤K*cap*L ∧ |
| (bad C keep c:ℝ)≤ε*mass C keep c ∧ |
| (comparisons C keep c:ℝ)/2≤C₂*mass C keep c/L := by |
| have hret : 15/16*H₀≤∑c,(mass C keep c:ℝ) := by |
| have hh : (∑t,(old t:ℝ))≤(∑c,(mass C keep c:ℝ))+ |
| ∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ) := by |
| exact_mod_cast retained_original C keep old ho |
| linarith |
| have hb : (∑c,(bad C keep c:ℝ))≤ε/16*H₀ := by |
| have hh : (∑c,(bad C keep c:ℝ))≤ |
| ((Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card:ℝ)+ |
| ((Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card:ℝ) := by |
| exact_mod_cast bad_sum C keep |
| exact hh.trans hbad |
| have hi : (∑c,(comparisons C keep c:ℝ)/2)≤C₂/(16*L)*H₀ := by |
| rw [←Finset.sum_div] |
| apply le_trans _ hcompare |
| apply div_le_div_of_nonneg_right _ (by norm_num) |
| exact_mod_cast comparisons_sum C keep |
| have hu : ∀ c : Cluster C keep,(mass C keep c:ℝ)≤(K*cap:ℝ)*L := by |
| intro c |
| have h := mass_upper C keep hsize hcap c |
| rw [←Nat.mul_assoc] at h |
| exact_mod_cast h |
| have hs : (∑c∈Finset.univ.filter (fun c=>(mass C keep c:ℝ)<L),(mass C keep c:ℝ))≤H₀/2 := by |
| have h := short_mass_half C keep root H₀ hH₀.le hlong hroot |
| simpa only [Nat.cast_sum,Nat.cast_lt] using h |
| obtain ⟨c,hcl,hcu,hcb,hci⟩ := PlanarLocalization.exists_good_cluster |
| (fun c=>(mass C keep c:ℝ)) (fun c=>(bad C keep c:ℝ)) |
| (fun c=>(comparisons C keep c:ℝ)/2) H₀ L ε (K*cap) C₂ hH₀ |
| (by exact_mod_cast hL) hε hC₂ (fun _=>Nat.cast_nonneg _) (fun _=>Nat.cast_nonneg _) |
| (fun _=>by positivity) hu hret hb hi hs |
| refine ⟨c,?_,?_,hcb,hci⟩ |
| · exact_mod_cast hcl |
| · exact_mod_cast hcu |
| end TorsionFreeZeroDivisors.ClusterLocalization |
| namespace TorsionFreeZeroDivisors.RestrictComparisons |
| open scoped Classical |
| variable {T : Type} (root : Option T) (keep : T → Prop) |
| def rootPath : Option {t // keep t} := root.bind fun t=>if h : keep t then some ⟨t,h⟩ else none |
| lemma rootPath_some (t : {t // keep t}) : rootPath root keep=some t ↔ root=some t.val := by |
| cases root with |
| | none => simp [rootPath] |
| | some r => |
| by_cases hr : keep r |
| · simp only [rootPath,Option.bind_some,dite_eq_left hr,Option.some.injEq,Subtype.ext_iff] |
| · simp only [rootPath,Option.bind_some,dite_eq_right hr,reduceCtorEq,false_iff,Option.some.injEq] |
| intro h; subst r; exact hr t.property |
| lemma rootPath_cyclic (t : {t // keep t}) : StageRoot.cyclic (rootPath root keep) t=StageRoot.cyclic root t.val := by |
| simp only [StageRoot.cyclic,ne_eq,rootPath_some] |
| lemma rootPath_map {Z : Type} (f : T → Z) {z : Z} |
| (h : (rootPath root keep).map (f ∘ Subtype.val)=some z) : root.map f=some z := by |
| cases root with |
| | none => simp [rootPath] at h |
| | some r => |
| by_cases hr : keep r |
| · simpa only [rootPath,Option.bind_some,dite_eq_left hr,Option.map_some,Function.comp_apply] using h |
| · simp only [rootPath,Option.bind_some,dite_eq_right hr,Option.map_none,reduceCtorEq] at h |
| end TorsionFreeZeroDivisors.RestrictComparisons |
|
|
| namespace TorsionFreeZeroDivisors.SampleGraph |
| open scoped Classical BigOperators |
| open PortSubdivision ComparedBlocks ComparisonGeometry GirthAsymptotics TypedGraphs ActualPatternEvent |
| /-- Literal path/comparison data before the separator and averaging step. |
| Unlike BoundedSystem it makes no quantitative smallness or pairing assumption. -/ |
| structure PathSystem (rep : ℕ) (r : Match rep) (x : VA rep) (y : VB rep) where |
| P : Type |
| E : Type |
| [fP : Fintype P] |
| [fE : Fintype E] |
| paths : P → List (DA rep⊕DB rep) |
| nonempty : ∀ p,paths p≠[] |
| root : Option P |
| path_chain : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse) |
| cyclic_chain : ∀ p,StageRoot.cyclic root p=true → |
| ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?), |
| WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse x y |
| comparisons : Comparisons (E:=E) (fun p => (paths p).length) |
| lower : E → ℕ |
| upper : E → ℕ |
| lower_eq : ∀ e,comparisons.lo e=lower e |
| upper_eq : ∀ e,comparisons.hi e=upper e |
| lower_le : ∀ e,lower e≤upper e |
| upper_le : ∀ e,upper e≤(paths (comparisons.source e)).length |
| reduced : ∀ x e,comparisons.side x=some e → |
| RawDecomposition.dart paths x≠RawDecomposition.dart paths (comparisons.pairing.partner x) ∧ |
| RawDecomposition.dart paths x≠(graph rep r).reverse (RawDecomposition.dart paths (comparisons.pairing.partner x)) |
| rootA : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inl z) → z=x |
| rootB : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inr z) → z=y |
| compatible : ∀ p e,comparisons.side p=some e → label rep (RawDecomposition.dart paths p)= |
| if comparisons.reverse e then Types.inverse (label rep (RawDecomposition.dart paths (comparisons.pairing.partner p))) |
| else label rep (RawDecomposition.dart paths (comparisons.pairing.partner p)) |
| attribute [instance] PathSystem.fP PathSystem.fE |
| namespace PathSystem |
| variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep} |
| (s : PathSystem rep r x y) (keep : s.P → Prop) |
| lemma dart_embed (p : Position (fun t : {t // keep t}=>(s.paths t.val).length)) : |
| RawDecomposition.dart (fun t : {t // keep t}=>s.paths t.val) p= |
| RawDecomposition.dart s.paths (RestrictComparisons.embed keep p) := rfl |
|
|
| abbrev restrict : PathSystem rep r x y where |
| P := {p // keep p} |
| E := {e // RestrictComparisons.Active s.comparisons keep e} |
| fP := inferInstance |
| fE := inferInstance |
| paths := fun p=>s.paths p.val |
| nonempty := fun p=>s.nonempty p.val |
| root := RestrictComparisons.rootPath s.root keep |
| path_chain := fun p=>s.path_chain p.val |
| cyclic_chain := by |
| intro p hp |
| exact s.cyclic_chain p.val ((RestrictComparisons.rootPath_cyclic s.root keep p) ▸ hp) |
| comparisons := RestrictComparisons.comparisons s.comparisons keep |
| lower := fun e=>s.lower e.val |
| upper := fun e=>s.upper e.val |
| lower_eq := fun e=>s.lower_eq e.val |
| upper_eq := fun e=>s.upper_eq e.val |
| lower_le := fun e=>s.lower_le e.val |
| upper_le := fun e=>s.upper_le e.val |
| reduced := by |
| intro p e he |
| have hh := s.reduced (RestrictComparisons.embed keep p) e.val |
| ((RestrictComparisons.side_some s.comparisons keep p e).mp he) |
| rw [←RestrictComparisons.partner_image_of_side s.comparisons keep he] at hh |
| exact hh |
| rootA := fun z hz=>s.rootA z (RestrictComparisons.rootPath_map s.root keep |
| (fun p=>(graph rep r).origin ((s.paths p).head (s.nonempty p))) hz) |
| rootB := fun z hz=>s.rootB z (RestrictComparisons.rootPath_map s.root keep |
| (fun p=>(graph rep r).origin ((s.paths p).head (s.nonempty p))) hz) |
| compatible := by |
| intro p e he |
| have hh := s.compatible (RestrictComparisons.embed keep p) e.val |
| ((RestrictComparisons.side_some s.comparisons keep p e).mp he) |
| rw [←RestrictComparisons.partner_image_of_side s.comparisons keep he] at hh |
| exact hh |
|
|
| /-- Bounding a literal system adds no realizability or word constraints. -/ |
| def bounded {Bnd K I : ℕ} |
| (hP : Fintype.card s.P≤K) (hE : Fintype.card s.E≤I) |
| (hlo : L (size rep)≤∑p,(s.paths p).length) |
| (hhi : (∑p,(s.paths p).length)≤Bnd*L (size rep)) |
| (hbad : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)≤ |
| StageFusion.epsilon (1/600) 256*(∑p,(s.paths p).length:ℕ)) : BoundedSystem Bnd K I rep r x y where |
| P := s.P |
| E := s.E |
| paths := s.paths |
| nonempty := s.nonempty |
| root := s.root |
| path_bound := hP |
| comparison_bound := hE |
| path_chain := s.path_chain |
| cyclic_chain := s.cyclic_chain |
| length_le := hhi |
| length_ge := hlo |
| comparisons := s.comparisons |
| lower := s.lower |
| upper := s.upper |
| lower_eq := s.lower_eq |
| upper_eq := s.upper_eq |
| lower_le := s.lower_le |
| upper_le := s.upper_le |
| reduced := s.reduced |
| unpaired_le := hbad |
| rootA := s.rootA |
| rootB := s.rootB |
| compatible := s.compatible |
| end PathSystem |
| end TorsionFreeZeroDivisors.SampleGraph |
| namespace TorsionFreeZeroDivisors.SampleGraph.PathSystem |
| open scoped Classical BigOperators |
| open ComparedBlocks ClusterLocalization GirthAsymptotics TypedGraphs ActualPatternEvent |
| variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep} |
| (s : PathSystem rep r x y) (keep : s.P → Prop) |
| local instance : Fintype (Cluster s.comparisons keep) := Fintype.ofFinite _ |
|
|
| /-- Realizes the selected component by exactly its literal retained paths and |
| interval sides, with the same signs, noncoincident lifts, and prescribed root. -/ |
| def selected_bounded {Bnd K I : ℕ} (c : Cluster s.comparisons keep) |
| (hP : (ClusterLocalization.paths s.comparisons keep c).card≤K) |
| (hE : ClusterLocalization.comparisons s.comparisons keep c≤I) |
| (hlo : L (size rep) ≤ mass s.comparisons keep c) |
| (hhi : mass s.comparisons keep c≤Bnd*L (size rep)) |
| (hbad : (bad s.comparisons keep c:ℝ)≤ |
| StageFusion.epsilon (1/600) 256*mass s.comparisons keep c) : |
| BoundedSystem Bnd K I rep r x y := by |
| let sc := s.restrict (belongs s.comparisons keep c) |
| refine { |
| P := {p // belongs s.comparisons keep c p} |
| E := {e // RestrictComparisons.Active s.comparisons (belongs s.comparisons keep c) e} |
| fP := inferInstance |
| fE := inferInstance |
| paths := fun p=>s.paths p.val |
| nonempty := fun p=>s.nonempty p.val |
| root := sc.root |
| path_bound := ?_ |
| comparison_bound := hE |
| path_chain := sc.path_chain |
| cyclic_chain := sc.cyclic_chain |
| length_le := ?_ |
| length_ge := ?_ |
| comparisons := localC s.comparisons keep c |
| lower := sc.lower |
| upper := sc.upper |
| lower_eq := sc.lower_eq |
| upper_eq := sc.upper_eq |
| lower_le := sc.lower_le |
| upper_le := sc.upper_le |
| reduced := sc.reduced |
| unpaired_le := ?_ |
| rootA := sc.rootA |
| rootB := sc.rootB |
| compatible := sc.compatible } |
| · simpa only [Fintype.card_subtype,ClusterLocalization.paths] using hP |
| · rw [local_mass]; exact hhi |
| · rw [local_mass]; exact hlo |
| · rw [←fixed_card s.comparisons keep c,←local_mass s.comparisons keep c] at hbad |
| convert hbad using 2 |
| congr 1 |
| ext p |
| simp |
| |
| /-- The analytic union bound excludes the localized system using the sharp |
| mass and interval estimates. -/ |
| theorem excluded_of_local_totals (K cap : ℕ) (C₂ H₀ : ℝ) (old : s.P → ℕ) |
| (ho : ∀ t,old t≤(s.paths t).length) |
| (hH₀ : 0<H₀) (hL : 0<L (size rep)) (hC₂ : 0<C₂) |
| (hsize : ∀ c : Cluster s.comparisons keep,(ClusterLocalization.paths s.comparisons keep c).card≤K) |
| (hcap : ∀ t,(s.paths t).length≤cap*L (size rep)) |
| (hbase : H₀≤∑t,(old t:ℝ)) |
| (hdelete : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤H₀/16) |
| (hbad : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)+ |
| ((Finset.univ.filter (fun p=>¬keep p.1 ∧ s.comparisons.pairing.partner p≠p)).card:ℝ)≤ |
| StageFusion.epsilon (1/600) 256/16*H₀) |
| (hcompare : (Fintype.card s.E:ℝ)/2≤C₂/(16*L (size rep))*H₀) |
| (hlong : ∀ t,s.root≠some t → L (size rep)≤(s.paths t).length) |
| (hroot : ∀ t,s.root=some t → (s.paths t).length<L (size rep) → ((s.paths t).length:ℝ)≤H₀/2) |
| (havoid : IsEmpty (BoundedSystem (K*cap) K ⌈2*C₂*(K*cap:ℝ)⌉₊ rep r x y)) : False := by |
| have hε : 0<StageFusion.epsilon (1/600) 256 := StageFusion.epsilon_pos (by norm_num) (by norm_num) |
| obtain ⟨c,hlo,hhi,hb,hi⟩ := exists_selected s.comparisons keep old ho s.root |
| (L (size rep)) K cap H₀ (StageFusion.epsilon (1/600) 256) C₂ hH₀ hL hε hC₂ |
| hsize hcap hbase hdelete hbad hcompare hlong hroot |
| have he : ClusterLocalization.comparisons s.comparisons keep c≤⌈2*C₂*(K*cap:ℝ)⌉₊ := by |
| suffices (ClusterLocalization.comparisons s.comparisons keep c:ℝ)≤(⌈2*C₂*(K*cap:ℝ)⌉₊:ℝ) by exact_mod_cast this |
| apply le_trans _ (Nat.le_ceil _) |
| have hLr : (0:ℝ)<L (size rep) := by exact_mod_cast hL |
| have hi' := (le_div_iff₀ hLr).mp hi |
| have hh : (mass s.comparisons keep c:ℝ)≤(K*cap:ℝ)*L (size rep) := by exact_mod_cast hhi |
| have hm := mul_le_mul_of_nonneg_left hh hC₂.le |
| nlinarith |
| exact havoid.false (s.selected_bounded keep c (hsize c) he hlo hhi hb) |
| end TorsionFreeZeroDivisors.SampleGraph.PathSystem |
|
|
| end |
|
|
| end OAI |
|
|
