| import Mathlib | |
| import OAI.Algebra.GroupRing.PatternTotalCoding | |
| namespace OAI | |
| noncomputable section | |
| namespace TorsionFreeZeroDivisors.ChainUsage | |
| open scoped Classical BigOperators | |
| open PortSubdivision DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths | |
| open ChainIsomorphism ChainChunkTransport ChainMultiplicity | |
| variable {V D P : Type} [Fintype D] [Fintype P] (Γ : PortGraph V D) | |
| (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2) | |
| local notation "B" => {d : D // turn Γ.origin mark h2 d=d} | |
| local notation "S" => suppressed Γ mark h2 | |
| local notation "R" => Rep Γ mark h2 | |
| local notation "w" => word Γ mark h2 | |
| variable (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) | |
| local notation "col" => color Γ mark h2 paths | |
| local notation "m" => ChunkComparisons.multiplicity col | |
| def Used : Prop := ∀ d,∃ p,d∈(paths p).flatMap w ∨ Γ.reverse d∈(paths p).flatMap w | |
| omit [Fintype P] in | |
| lemma representative_used (hu : Used Γ mark h2 paths) (c : R) : | |
| ∃ p b,b∈paths p ∧ representative Γ mark h2 b=c := by | |
| obtain ⟨p,hp⟩ := hu c.val.val | |
| rcases hp with hp|hp | |
| · obtain ⟨b,hb,he⟩ := List.mem_flatMap.mp hp | |
| have heq := same_word Γ mark h2 he (start_mem_word Γ mark h2 c.val) | |
| exact ⟨p,b,hb,heq ▸ representative_val Γ mark h2 c⟩ | |
| · obtain ⟨b,hb,he⟩ := List.mem_flatMap.mp hp | |
| have heq := same_word Γ mark h2 he | |
| (reverse_mem_word Γ mark h2 c.val c.val.val (start_mem_word Γ mark h2 c.val)) | |
| exact ⟨p,b,hb,by rw [heq,representative_reverse,representative_val]⟩ | |
| lemma multiplicity_pos (hu : Used Γ mark h2 paths) (c : R) : 1 ≤ m c := by | |
| simp only [ChunkComparisons.multiplicity,Fintype.card_eq_nat_card] | |
| obtain ⟨p,b,hb,he⟩ := representative_used Γ mark h2 paths hu c | |
| obtain ⟨i,hi⟩ := List.mem_iff_get.mp hb | |
| have hn : Nonempty {t // col t=c} := by | |
| refine ⟨⟨⟨p,i⟩,?_⟩⟩ | |
| change representative Γ mark h2 ((paths p).get i)=c | |
| rw [hi,he] | |
| exact Nat.card_pos | |
| lemma traversal_card : Fintype.card (RepeatedBlocks.Traversal m)=∑p,(paths p).length := by | |
| rw [Fintype.card_congr (ChunkComparisons.enumeration col)] | |
| simp only [FiniteChunking.Traversal,chunks] | |
| exact (Fintype.card_sigma (α:=fun p : P => Fin (paths p).length)).trans (Finset.sum_congr rfl (fun p _ => Fintype.card_fin _)) | |
| lemma multiplicity_le (c : R) : m c≤∑p,(paths p).length := by | |
| simp only [ChunkComparisons.multiplicity,Fintype.card_eq_nat_card] | |
| have h := Nat.card_le_card_of_injective (Subtype.val : {t // col t=c} → _) | |
| Subtype.val_injective | |
| simpa only [FiniteChunking.Traversal,chunks,Nat.card_sigma,Nat.card_fin] using h | |
| omit [Fintype D] [Fintype P] in | |
| lemma flatMap_length_le {A Z : Type*} (f : A → List Z) (l : List A) {a : A} (ha : a∈l) : | |
| (f a).length≤(l.flatMap f).length := by | |
| induction l with | |
| | nil => simp at ha | |
| | cons b l ih => | |
| rcases List.mem_cons.mp ha with rfl|ha | |
| · simp only [List.flatMap_cons,List.length_append] | |
| omega | |
| · have h := ih ha | |
| simp only [List.flatMap_cons,List.length_append] | |
| omega | |
| lemma length_le_total_of_mem (p : P) (b : B) (hb : b∈paths p) : | |
| chainLength Γ mark h2 b≤∑p,((paths p).flatMap w).length := by | |
| rw [←word_length] | |
| exact (flatMap_length_le w _ hb).trans | |
| (Finset.single_le_sum (f:=fun p => ((paths p).flatMap w).length) | |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ p)) | |
| lemma chain_length_le (hu : Used Γ mark h2 paths) (b : B) : | |
| chainLength Γ mark h2 b≤∑p,((paths p).flatMap w).length := by | |
| obtain ⟨p,a,ha,he⟩ := representative_used Γ mark h2 paths hu (representative Γ mark h2 b) | |
| have h := length_le_total_of_mem Γ mark h2 paths p a ha | |
| rw [oriented_length Γ mark h2 a,he,←oriented_length Γ mark h2 b] at h | |
| exact h | |
| lemma rep_card_le : Fintype.card R≤Fintype.card B := Fintype.card_subtype_le _ | |
| end TorsionFreeZeroDivisors.ChainUsage | |
| namespace TorsionFreeZeroDivisors.SourcePattern | |
| open scoped Classical BigOperators | |
| open PortSubdivision MarkedChainBound DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths | |
| open ChainIsomorphism ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks | |
| open ActualComplexity CoreStripping ImageComplexity GirthAsymptotics TypedGraphs | |
| /-- The uniformly bounded number of marked darts is derived, not required of an | |
| original pattern. Extra marks are just the prescribed path endpoints. -/ | |
| theorem marked_bound (B K : ℕ) : ∃ R : ℕ,0<R ∧ | |
| ∀ {V D P : Type} [Fintype V] [Fintype D] [Fintype P] | |
| (Γ : PortGraph V D) (M : Finset V) (_hM : M.card≤2*K) | |
| (paths : P → List D) (_hp : ∀ p,paths p≠[]) | |
| (_ : Fintype.card P≤K) (_ : Function.Surjective Γ.origin) | |
| (_ : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse)) | |
| (_ : ∀ d,∃ p,d∈paths p ∨ Γ.reverse d∈paths p) | |
| (L : ℝ) (_ : 0<L) (_ : (∑ p,(paths p).length:ℕ)≤(B:ℝ)*L) | |
| (_ : ∀ a (c : Γ.subdivision.Walk a a),c.IsCycle → | |
| L≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c), | |
| Fintype.card {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}≤R ∧ | |
| Fintype.card (Mark (marks Γ M))≤R := by | |
| obtain ⟨R,hR⟩ := bounded_image_branches (B:ℝ) (Nat.cast_nonneg _) (2*K) | |
| refine ⟨R+6*K+1,by omega,?_⟩ | |
| intro V D P _ _ _ Γ M hM paths hp hP hv hc hi L hL hH hg | |
| have hleaf := leaf_bound Γ paths hp hc hi | |
| have hdc := dart_count Γ paths hi | |
| have hdc' : (Fintype.card D:ℝ)≤2*(B:ℝ)*L := by | |
| have hdc' : (Fintype.card D:ℝ)≤2*(∑ p,(paths p).length:ℕ) := by exact_mod_cast hdc | |
| nlinarith | |
| have hleaf' : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card≤2*K := | |
| hleaf.trans (Nat.mul_le_mul_left _ hP) | |
| have hb := hR Γ L hL hdc' hg hleaf' | |
| have hd := marked_dart_bound Γ M | |
| have hseed : Fintype.card {d : D // | |
| turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}≤R+6*K+1 := by | |
| rw [chain_dart_card] | |
| omega | |
| exact ⟨hseed,(marked_vertices_le Γ _ _ hv).trans hseed⟩ | |
| abbrev Seeds {V D : Type} [Fintype D] (Γ : PortGraph V D) (M : Finset V) := | |
| {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d} | |
| def R (B K : ℕ) : ℕ := (marked_bound B K).choose | |
| lemma R_pos (B K : ℕ) : 0<R B K := (marked_bound B K).choose_spec.1 | |
| def T (B K : ℕ) : ℕ := R B K*(B+K) | |
| /-- The actual suppressed form of source paths. No bound on the resulting | |
| skeleton, chain lengths, multiplicities or number of traversals is assumed. -/ | |
| structure Data (B K I rep : ℕ) where | |
| V : Type | |
| D : Type | |
| P : Type | |
| E : Type | |
| [fV : Fintype V] | |
| [fD : Fintype D] | |
| [fP : Fintype P] | |
| [fE : Fintype E] | |
| graph : PortGraph V D | |
| vertices : Finset V | |
| vertices_bound : vertices.card≤2*K | |
| no_isolated : Function.Surjective graph.origin | |
| side : V → Bool | |
| side_edge : ∀ d,side (graph.origin (graph.reverse d))=side (graph.origin d) | |
| paths : P → List (Seeds graph vertices) | |
| nonempty : ∀ p,paths p≠[] | |
| root : Option P | |
| path_bound : Fintype.card P≤K | |
| comparison_bound : Fintype.card E≤I | |
| image : ChainUsage.Used graph (marks graph vertices) (marks_degree_two graph vertices) paths | |
| path_chain : ∀ p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).IsChain | |
| (WeightedMoore.PortWalk.step graph.origin graph.reverse) | |
| cyclic_chain : ∀ p,StageRoot.cyclic root p=true → | |
| ∀ᵉ (x∈((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).getLast?) | |
| (y∈((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).head?), | |
| WeightedMoore.PortWalk.step graph.origin graph.reverse x y | |
| girth : ∀ a (c : graph.subdivision.Walk a a),c.IsCycle → | |
| (L (size rep):ℝ)≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c | |
| length_le : (∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ)≤B*L (size rep) | |
| length_ge : L (size rep)≤(∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ) | |
| comparisons : Comparisons (E:=E) (pathLength (chunks graph (marks graph vertices) (marks_degree_two graph vertices) paths) | |
| (chunkLength graph (marks graph vertices) (marks_degree_two graph vertices) paths)) | |
| 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≤pathLength (chunks graph (marks graph vertices) (marks_degree_two graph vertices) paths) | |
| (chunkLength graph (marks graph vertices) (marks_degree_two graph vertices) paths) (comparisons.source e) | |
| reduced : ∀ x e,comparisons.side x=some e → | |
| originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths x≠ | |
| originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths (comparisons.pairing.partner x) ∧ | |
| originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths x≠graph.reverse | |
| (originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths (comparisons.pairing.partner x)) | |
| unpaired_le : ((Finset.univ.filter (fun x => comparisons.pairing.partner x=x)).card:ℝ)≤ | |
| StageFusion.epsilon (1/600) 256* | |
| (∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ) | |
| attribute [instance] Data.fV Data.fD Data.fP Data.fE | |
| namespace Data | |
| variable {B K I rep : ℕ} (a : Data B K I rep) | |
| abbrev mark := marks a.graph a.vertices | |
| abbrev degree_two := marks_degree_two a.graph a.vertices | |
| abbrev words (p : a.P) := (a.paths p).flatMap (word a.graph a.mark a.degree_two) | |
| abbrev totalLength : ℕ := ∑p,(a.words p).length | |
| abbrev lengths : a.P → ℕ := pathLength (chunks a.graph a.mark a.degree_two a.paths) | |
| (chunkLength a.graph a.mark a.degree_two a.paths) | |
| lemma words_nonempty (p : a.P) : a.words p≠[] := by | |
| intro he | |
| obtain ⟨b,hb⟩ := List.exists_mem_of_ne_nil (a.paths p) (a.nonempty p) | |
| have hm : b.val∈a.words p := by | |
| apply List.mem_flatMap.mpr | |
| exact ⟨b,hb,start_mem_word a.graph a.mark a.degree_two b⟩ | |
| simp [he] at hm | |
| lemma lengths_le (p : a.P) : a.lengths p≤B*L (size rep) := by | |
| rw [lengths,pathLength_eq] | |
| apply le_trans (b:=a.totalLength) _ a.length_le | |
| exact Finset.single_le_sum (f:=fun p => (a.words p).length) | |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ p) | |
| lemma upper_bound (e : a.E) : a.upper e≤B*L (size rep) := | |
| (a.upper_le e).trans (a.lengths_le _) | |
| lemma lower_bound (e : a.E) : a.lower e≤B*L (size rep) := | |
| (a.lower_le e).trans (a.upper_bound e) | |
| lemma covered : ∀ d,ChainCoverage.Covered a.graph.reverse (turn a.graph.origin a.mark a.degree_two) | |
| a.graph.reverse_reverse (turn_involutive a.graph.origin a.mark a.degree_two) d := by | |
| apply ActualMarkedChains.actual_image_covered a.graph a.mark a.degree_two a.words a.path_chain _ a.image | |
| intro p d hd | |
| rw [words,ChainPathTransport.flatMap_head] at hd | |
| obtain ⟨b,_hb,hbd⟩ := Option.mem_map.mp hd | |
| subst d | |
| exact (turn_fixed_iff a.graph.origin a.mark a.degree_two b.val).mp b.property | |
| lemma mark_bounds (hL : 0<L (size rep)) : | |
| Fintype.card (Seeds a.graph a.vertices)≤R B K ∧ Fintype.card (Mark a.mark)≤R B K := by | |
| apply (marked_bound B K).choose_spec.2 a.graph a.vertices a.vertices_bound a.words | |
| a.words_nonempty a.path_bound a.no_isolated a.path_chain a.image (L (size rep)) | |
| (by exact_mod_cast hL) _ a.girth | |
| exact_mod_cast a.length_le | |
| lemma total_traversals_le (hL : 0<L (size rep)) : ∑p,(a.paths p).length≤T B K := by | |
| have h := ChainPaths.bounded_chain_traversals a.graph a.mark a.degree_two | |
| (B:ℝ) (Nat.cast_nonneg _) K (R B K) a.path_bound (a.mark_bounds hL).1 | |
| (L (size rep)) (by exact_mod_cast hL) a.girth a.paths a.path_chain | |
| (by exact_mod_cast a.length_le) | |
| have he : (R B K:ℝ)*((B:ℝ)+K)=(T B K:ℝ) := by simp only [T,Nat.cast_mul,Nat.cast_add] | |
| rw [he,Nat.ceil_natCast] at h | |
| exact h | |
| lemma traversal_le (hL : 0<L (size rep)) (p : a.P) : (a.paths p).length≤T B K := | |
| (Finset.single_le_sum (f:=fun p => (a.paths p).length) | |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ p)).trans (a.total_traversals_le hL) | |
| lemma offset_bounds (e : a.E) : | |
| -(2*(B*L (size rep):ℕ):ℤ)≤a.comparisons.offset e ∧ | |
| a.comparisons.offset e≤(2*(B*L (size rep):ℕ):ℤ) := by | |
| have hlo : (0:ℝ)≤a.comparisons.lo e := by rw [a.lower_eq]; positivity | |
| have hhi : (0:ℝ)≤a.comparisons.hi e := by rw [a.upper_eq]; positivity | |
| have hlb : a.comparisons.lo e≤(B*L (size rep):ℕ) := by | |
| rw [a.lower_eq]; exact_mod_cast a.lower_bound e | |
| have hub : a.comparisons.hi e≤(B*L (size rep):ℕ) := by | |
| rw [a.upper_eq]; exact_mod_cast a.upper_bound e | |
| have hlen : (a.lengths (a.comparisons.source (a.comparisons.flip e)):ℝ)≤(B*L (size rep):ℕ) := | |
| by exact_mod_cast a.lengths_le _ | |
| have hr := a.comparisons.target_range e | |
| have he : -2*((B*L (size rep):ℕ):ℝ)≤(a.comparisons.offset e:ℝ) ∧ | |
| (a.comparisons.offset e:ℝ)≤2*((B*L (size rep):ℕ):ℝ) := by | |
| cases hh : a.comparisons.reverse e <;> simp only [hh,Bool.false_eq_true,↓reduceIte] at hr | |
| · constructor <;> linarith | |
| · constructor <;> linarith | |
| exact_mod_cast he | |
| def bounded (hL : 0<L (size rep)) : BoundedPattern.Data (R B K) K (T B K) I (B*L (size rep)) where | |
| V := a.V | |
| D := a.D | |
| P := a.P | |
| E := a.E | |
| graph := a.graph | |
| mark := a.mark | |
| degree_two := a.degree_two | |
| covered := a.covered | |
| side := a.side | |
| side_edge := a.side_edge | |
| paths := a.paths | |
| nonempty := a.nonempty | |
| root := a.root | |
| comparisons := a.comparisons | |
| lower e := ⟨a.lower e,by have := a.lower_bound e; omega⟩ | |
| upper e := ⟨a.upper e,by have := a.upper_bound e; omega⟩ | |
| offset e := ⟨(a.comparisons.offset e+2*(B*L (size rep):ℕ)).toNat,by | |
| obtain ⟨hl,hu⟩ := a.offset_bounds e | |
| omega⟩ | |
| lower_eq := a.lower_eq | |
| upper_eq := a.upper_eq | |
| offset_eq e := by | |
| obtain ⟨hl,hu⟩ := a.offset_bounds e | |
| dsimp | |
| omega | |
| dart_bound := (a.mark_bounds hL).1 | |
| vertex_bound := (a.mark_bounds hL).2 | |
| path_bound := a.path_bound | |
| comparison_bound := a.comparison_bound | |
| chain_length_bound d := (ChainUsage.chain_length_le a.graph a.mark a.degree_two a.paths a.image d).trans a.length_le | |
| traversal_bound := a.traversal_le hL | |
| lemma bounded_good (hL : 0<L (size rep)) : | |
| (a.bounded hL).Good B (R B K) (T B K) (I*(T B K)^2) rep where | |
| multiplicity_le c := (ChainUsage.multiplicity_le a.graph a.mark a.degree_two a.paths c).trans | |
| (a.total_traversals_le hL) | |
| multiplicity_pos := ChainUsage.multiplicity_pos a.graph a.mark a.degree_two a.paths a.image | |
| path_chain p := ChainPathTransport.isChain a.graph a.mark a.degree_two (a.paths p) (a.path_chain p) | |
| cyclic_chain p hp := ChainPathTransport.closing a.graph a.mark a.degree_two (a.paths p) (a.cyclic_chain p hp) | |
| reduced := a.reduced | |
| chains_le := (ChainUsage.rep_card_le a.graph a.mark a.degree_two).trans (a.mark_bounds hL).1 | |
| cut_comparisons_le := by | |
| change Fintype.card a.E*(Fintype.card (RepeatedBlocks.Traversal | |
| (ChunkComparisons.multiplicity (color a.graph a.mark a.degree_two a.paths))))^2≤_ | |
| rw [ChainUsage.traversal_card] | |
| exact Nat.mul_le_mul a.comparison_bound (Nat.pow_le_pow_left (a.total_traversals_le hL) 2) | |
| length_le := by | |
| change (∑p,(a.words p).length:ℝ)≤_ | |
| exact_mod_cast a.length_le | |
| length_ge := by | |
| change _≤(∑p,(a.words p).length:ℝ) | |
| exact_mod_cast a.length_ge | |
| unpaired_le := by | |
| change _≤StageFusion.epsilon (1/600) 256*(∑p,(a.words p).length:ℝ) | |
| exact_mod_cast a.unpaired_le | |
| end Data | |
| end TorsionFreeZeroDivisors.SourcePattern | |
| namespace TorsionFreeZeroDivisors.BoundedPattern | |
| open scoped Classical Topology | |
| open Filter GirthAsymptotics TypedGraphs ActualPatternEvent | |
| lemma polynomial_exp_tendsto (c B d M : ℕ) (hM : 0<M) : | |
| Tendsto (fun rep => (c:ℝ)*(B*L (size rep)+1:ℕ)^d* | |
| Real.exp (-(L (size rep):ℝ)/(4800*M))) atTop (𝓝 0) := by | |
| have hL : Tendsto (fun rep => (L (size rep):ℝ)) atTop atTop := | |
| tendsto_natCast_atTop_atTop.comp (L_tendsto.comp size_tendsto) | |
| have ht := (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (d:ℝ) | |
| (1/(4800*M)) (by positivity)).comp hL | |
| simp only [Function.comp_def,Real.rpow_natCast] at ht | |
| have ht' := ht.const_mul ((c:ℝ)*(B+1:ℝ)^d) | |
| simp only [mul_zero] at ht' | |
| apply squeeze_zero' (Eventually.of_forall (fun _ => by positivity)) _ ht' | |
| filter_upwards [hL.eventually (eventually_ge_atTop (1:ℝ))] with rep hr | |
| have hp : ((B*L (size rep)+1:ℕ):ℝ)^d≤((B+1:ℝ)*(L (size rep):ℝ))^d := by | |
| gcongr | |
| push_cast | |
| nlinarith | |
| calc | |
| _ ≤ (c:ℝ)*((B+1:ℝ)*(L (size rep):ℝ))^d* | |
| Real.exp (-(L (size rep):ℝ)/(4800*M)) := by gcongr | |
| _ = (c:ℝ)*(B+1:ℝ)^d*((L (size rep):ℝ)^d* | |
| Real.exp (-(1/(4800*M:ℝ))*(L (size rep):ℝ))) := by | |
| have he : -(L (size rep):ℝ)/(4800*M)=-(1/(4800*M:ℝ))*(L (size rep):ℝ) := by ring | |
| rw [he,mul_pow] | |
| ring | |
| lemma mem_samples (rep : ℕ) (r : Match rep) : r∈samples rep ↔ | |
| (r.1.Contains ∅ ∧ ((3*L (size rep):ℕ):ℕ∞)≤(r.1.graph (PatternEmbeddings.origin (@Types.outgoingA rep))).subdivision.egirth) ∧ | |
| (r.2.Contains ∅ ∧ ((3*L (size rep):ℕ):ℕ∞)≤(r.2.graph (PatternEmbeddings.origin (@Types.outgoingB rep))).subdivision.egirth) := by | |
| simp only [samples,ConditionedMatchings.Matching.conditioned,Finset.mem_product, | |
| Finset.mem_filter,Finset.mem_univ,true_and] | |
| lemma samples_eventually_nonempty : ∀ᶠ rep in atTop,(samples rep).Nonempty := by | |
| filter_upwards [TypedGraphs.eventual_nonempty] with rep hr | |
| obtain ⟨a,ha⟩ := hr.1 | |
| obtain ⟨b,hb⟩ := hr.2 | |
| simp only [ConditionedMatchings.Matching.conditioned, Finset.mem_filter, | |
| Finset.mem_univ, true_and] at ha hb | |
| refine ⟨(a,b),(mem_samples rep (a,b)).mpr ?_⟩ | |
| exact ⟨ha,hb⟩ | |
| /-- With the bounds fixed beforehand, for every sufficiently large admissible | |
| size there is an actual pair of conditioned matchings avoiding every bounded | |
| pattern. The roots are universally quantified after the size threshold. -/ | |
| theorem eventually_avoids (R K T I B Q M J : ℕ) | |
| (hR : 0<R) (hK : 0<K) (hI : 0<I) (hM : 0<M) : | |
| ∀ᶠ rep in atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep), | |
| ∃ r∈samples rep,∀ a : Data R K T I (B*L (size rep)), | |
| a.Good B Q M J rep → ¬a.event rep x y r := by | |
| have hsmall := (polynomial_exp_tendsto (PatternTotalCoding.coefficient R K T I) | |
| B (R+3*I) M hM).eventually_lt_const (by norm_num : (0:ℝ)<1) | |
| filter_upwards [hsmall, samples_eventually_nonempty,PatternUniform.eventually_ready B M Q J hM] | |
| with rep hb hs hr | |
| intro x y | |
| have hprob := (probability_union R K T I (B*L (size rep)) B Q M J rep hR hK hI hM hs hr x y).trans_lt hb | |
| by_contra hn | |
| have hall : ∀ r∈samples rep,∃ a : Data R K T I (B*L (size rep)), | |
| a.Good B Q M J rep ∧ a.event rep x y r := by | |
| push Not at hn | |
| exact hn | |
| have he : (samples rep).filter (fun r => ∃ a : Data R K T I (B*L (size rep)), | |
| a.Good B Q M J rep ∧ a.event rep x y r)=samples rep := by | |
| apply Finset.filter_eq_self.mpr | |
| exact hall | |
| rw [he,div_self (by exact_mod_cast (Finset.card_pos.mpr hs).ne')] at hprob | |
| exact (lt_irrefl (1:ℝ)) hprob | |
| end TorsionFreeZeroDivisors.BoundedPattern | |
| end | |
| end OAI | |