Download data/lean/ComparatorChallenges/FiniteCircle.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/ComparatorChallenges/FiniteCircle.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/ComparatorChallenges/FiniteCircle.lean
-
curl -L -o FiniteCircle.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/ComparatorChallenges/FiniteCircle.lean
10.2 kB
| import Mathlib | |
| namespace OAI | |
| namespace FiniteCircle | |
| open scoped BigOperators List | |
| universe u v | |
| inductive EditStep {Ξ± : Type u} : List Ξ± β List Ξ± β Prop | |
| | insert (u v : List Ξ±) (a : Ξ±) : EditStep (u ++ v) (u ++ a :: v) | |
| | delete (u v : List Ξ±) (a : Ξ±) : EditStep (u ++ a :: v) (u ++ v) | |
| | substitute (u v : List Ξ±) (a b : Ξ±) : EditStep (u ++ a :: v) (u ++ b :: v) | |
| inductive EditScript {Ξ± : Type u} : β β List Ξ± β List Ξ± β Prop | |
| | nil (x : List Ξ±) : EditScript 0 x x | |
| | cons {n : β} {x y z : List Ξ±} : | |
| EditStep x y β EditScript n y z β EditScript (n + 1) x z | |
| noncomputable def editDistance {Ξ± : Type u} (x y : List Ξ±) : β := | |
| sInf {n : β | EditScript n x y} | |
| noncomputable def lcs {Ξ± : Type u} (x y : List Ξ±) : β := | |
| sSup {n : β | β z : List Ξ±, z <+ x β§ z <+ y β§ z.length = n} | |
| noncomputable def deficit {Ξ± : Type u} (x y : List Ξ±) : β := x.length - lcs x y | |
| abbrev Words (Ξ± : Type u) (d : β) := {x : List Ξ± // x.length β€ d} | |
| abbrev RealL1 := lp (fun _ : β => β) 1 | |
| noncomputable def distortion {Ξ± : Type u} {X : Type v} (word : X β List Ξ±) | |
| (f : X β RealL1) : β := | |
| (sSup {r : β | β x y : X, x β y β§ | |
| r = βf x - f yβ / (editDistance (word x) (word y) : β)}) * | |
| (sSup {r : β | β x y : X, x β y β§ | |
| r = (editDistance (word x) (word y) : β) / βf x - f yβ}) | |
| noncomputable def optimalDistortion {Ξ± : Type u} {X : Type v} | |
| (word : X β List Ξ±) : β := | |
| sInf {D | β f : X β RealL1, Function.Injective f β§ D = distortion word f} | |
| noncomputable def E (Ξ± : Type u) (d : β) : β := | |
| optimalDistortion (fun x : Words Ξ± d => x.val) | |
| noncomputable def setDistortion (S : Set (List Bool)) : β := | |
| optimalDistortion (fun x : S => x.val) | |
| noncomputable def alphabetSupremum (d : β) : β := | |
| sSup {r | β A : β, 2 β€ A β§ r = E (Fin A) d} | |
| noncomputable def exponentScale (d : β) : β := | |
| Real.sqrt (Real.log d * Real.log (Real.log d)) | |
| def encode {Ξ± : Type u} {w : β} (c : Ξ± β Fin w β Bool) (x : List Ξ±) : List Bool := | |
| x.flatMap (fun a => List.ofFn (c a)) | |
| def interval {Ξ± : Type u} {w : β} (c : Ξ± β Fin w β Bool) | |
| (a : Ξ±) (s len : β) : List Bool := | |
| ((List.ofFn (c a)).drop s).take len | |
| def OffsetLocal {Ξ± : Type u} {w : β} (Ξ΄ : β) (c : Ξ± β Fin w β Bool) : Prop := | |
| β a b : Ξ±, a β b β β s t : β, | |
| s + w / 8 β€ w β t + w / 8 β€ w β | |
| (lcs (interval c a s (w / 8)) (interval c b t (w / 8)) : β) β€ | |
| (1 - Ξ΄) * (w / 8 : β) | |
| def indexSpan {w : β} (is : List (Fin w)) : β := | |
| match is with | |
| | [] => 0 | |
| | i :: js => (js.getLastD i).val + 1 - i.val | |
| def AnchorLocal {Ξ± : Type u} {w : β} (Ξ΅ : β) (c : Ξ± β Fin w β Bool) : Prop := | |
| β a b : Ξ±, β is js : List (Fin w), | |
| is.Pairwise (fun i j => i.val < j.val) β | |
| js.Pairwise (fun i j => i.val < j.val) β | |
| is.length = js.length β (w : β) / 4 β€ is.length β | |
| (indexSpan is - is.length : β) β€ Ξ΅ * w β | |
| (indexSpan js - js.length : β) β€ Ξ΅ * w β | |
| (β ij β is.zip js, c a ij.1 = c b ij.2) β | |
| a = b β§ β i : Fin w, (i, i) β is.zip js | |
| def SubstitutionBounds {Ξ± : Type u} [Fintype Ξ±] {w : β} | |
| (a C : β) (c : Ξ± β Fin w β Bool) : Prop := | |
| 0 < w β§ (w : β) β€ C * Real.log (2 * Fintype.card Ξ±) β§ | |
| (β L : β, β x y : List Ξ±, x.length = L β y.length = L β | |
| a * w * deficit x y β€ (deficit (encode c x) (encode c y) : β) β§ | |
| deficit (encode c x) (encode c y) β€ w * deficit x y) β§ | |
| (β x y : List Ξ±, editDistance (encode c x) (encode c y) β€ w * editDistance x y) | |
| def TwoCodes (a C Ξ΄ Ξ΅ : β) : Prop := | |
| β (Ξ± : Type) [Fintype Ξ±], 2 β€ Fintype.card Ξ± β | |
| (β (w : β) (c : Ξ± β Fin w β Bool), | |
| SubstitutionBounds a C c β§ OffsetLocal Ξ΄ c) β§ | |
| (β (w : β) (c : Ξ± β Fin w β Bool), | |
| SubstitutionBounds a C c β§ AnchorLocal Ξ΅ c) | |
| def period (h : β) (p : β β β β β) (l : β) : β := β k : Fin h, p l k | |
| def circleSize (h : β) (p : β β β β β) : β := | |
| 2 * β l : Fin h, period h p (l.val + 1) | |
| def MaskPrimes (h : β) (p : β β β β β) : Prop := | |
| (β l k : Fin h, Nat.Prime (p (l.val + 1) k)) β§ | |
| Function.Injective (fun lk : Fin h Γ Fin h => p (lk.1.val + 1) lk.2) β§ | |
| β l k : Fin h, h ^ 3 β€ p (l.val + 1) k β§ p (l.val + 1) k β€ 2 * h ^ 3 | |
| def ExcludedPrimes (m : β) (p : β β β β β) : Prop := | |
| (β l k : Fin m, Nat.Prime (p (l.val + 1) k)) β§ | |
| Function.Injective (fun lk : Fin m Γ Fin m => p (lk.1.val + 1) lk.2) β§ | |
| β l k : Fin m, m ^ 3 < p (l.val + 1) k β§ p (l.val + 1) k β€ m ^ 5 | |
| abbrev MaskTag (h : β) (p : β β β β β) (l : β) := Ξ£ k : Fin h, Fin (p l k) | |
| def maskTags (h : β) (p : β β β β β) (l : β) : List (MaskTag h p l) := | |
| (List.ofFn fun k : Fin h => List.ofFn fun b : Fin (p l k) => Sigma.mk k b).flatten | |
| def MaskAlphabet (h : β) (p : β β β β β) : β β Type | |
| | 0 => Bool | |
| | l + 1 => MaskTag h p (l + 1) Γ MaskAlphabet h p l | |
| instance maskAlphabetFintype (h : β) (p : β β β β β) (l : β) : | |
| Fintype (MaskAlphabet h p l) := by | |
| induction l with | |
| | zero => exact inferInstanceAs (Fintype Bool) | |
| | succ l ih => exact @instFintypeProd _ _ inferInstance ih | |
| def MaskState (h : β) (p : β β β β β) (M : β) : β β Type | |
| | 0 => ZMod M | |
| | l + 1 => MaskTag h p (l + 1) β MaskState h p M l | |
| def shiftMaskState (h : β) (p : β β β β β) (M : β) : | |
| (l : β) β MaskState h p M l β ZMod M β MaskState h p M l | |
| | 0, v, ΞΈ => (show ZMod M from v) + ΞΈ | |
| | l + 1, v, ΞΈ => fun j => shiftMaskState h p M l (v j) ΞΈ | |
| def maskGamma (h : β) (p : β β β β β) (M l a : β) | |
| (j : MaskTag h p l) : ZMod M := | |
| (β k : Fin h, ((M / p l k * (a % p l k) : β) : ZMod M)) + | |
| ((j.2.val * (M / p l j.1) * (a % p l j.1) : β) : ZMod M) | |
| def maskWord (h : β) (p : β β β β β) (R M : β) : | |
| (l : β) β MaskState h p M l β List (MaskAlphabet h p l) | |
| | 0, v => (List.range M).map (fun b => decide (((b : ZMod M) - (show ZMod M from v)).val < M / 2)) | |
| | l + 1, v => (List.range (R * period h p (l + 1))).flatMap fun a => | |
| (maskTags h p (l + 1)).flatMap fun j => | |
| (maskWord h p R M l | |
| (shiftMaskState h p M l (v j) (maskGamma h p M (l + 1) a j))).map | |
| (fun x => (j, x)) | |
| def ExcludedAlphabet (m L : β) : β β Type | |
| | 0 => Fin L Γ Bool | |
| | l + 1 => Fin m Γ ExcludedAlphabet m L l | |
| instance excludedAlphabetFintype (m L l : β) : Fintype (ExcludedAlphabet m L l) := by | |
| induction l with | |
| | zero => exact inferInstanceAs (Fintype (Fin L Γ Bool)) | |
| | succ l ih => exact @instFintypeProd _ _ inferInstance ih | |
| def ExcludedState (m L : β) : β β Type | |
| | 0 => ZMod L | |
| | l + 1 => Fin m β ExcludedState m L l | |
| def shiftExcludedState (m L : β) : | |
| (l : β) β ExcludedState m L l β ZMod L β ExcludedState m L l | |
| | 0, v, ΞΈ => (show ZMod L from v) + ΞΈ | |
| | l + 1, v, ΞΈ => fun i => shiftExcludedState m L l (v i) ΞΈ | |
| def excludedTranslation (m : β) (p : β β β β β) (L l s : β) (i : Fin m) : | |
| ZMod L := β j β Finset.univ.erase i, ((L / p l j * (s % p l j) : β) : ZMod L) | |
| def excludedWord (m : β) (p : β β β β β) (R L : β) : | |
| (l : β) β ExcludedState m L l β List (ExcludedAlphabet m L l) | |
| | 0, v => List.ofFn fun b : Fin L => | |
| (b, decide (((b.val : ZMod L) - (show ZMod L from v)).val < L / 2)) | |
| | l + 1, v => (List.range (R * period m p (l + 1))).flatMap fun s => | |
| (List.ofFn fun i : Fin m => | |
| (excludedWord m p R L l | |
| (shiftExcludedState m L l (v i) (excludedTranslation m p L (l + 1) s i))).map | |
| (fun x => (i, x))).flatten | |
| def MaskWitness (a C Ξ΄ lower : β) (d : β) : Prop := | |
| β h : β, 2 β€ h β§ β p : β β β β β, MaskPrimes h p β§ | |
| β (w : β) (c : MaskAlphabet h p h β Fin w β Bool), | |
| SubstitutionBounds a C c β§ OffsetLocal Ξ΄ c β§ | |
| β n : β, 0 < n β§ n β€ d β§ | |
| (β v : MaskState h p (circleSize h p) h, | |
| (encode c (maskWord h p (h ^ (2 * h)) (circleSize h p) h v)).length = n) β§ | |
| Real.exp (lower * exponentScale d) β€ setDistortion | |
| (Set.range fun v : MaskState h p (circleSize h p) h => | |
| encode c (maskWord h p (h ^ (2 * h)) (circleSize h p) h v)) | |
| def ExcludedWitness (a C Ξ΅ lower : β) (d : β) : Prop := | |
| β m : β, 2 β€ m β§ β p : β β β β β, ExcludedPrimes m p β§ | |
| β (w : β) (c : ExcludedAlphabet m (circleSize m p) m β Fin w β Bool), | |
| SubstitutionBounds a C c β§ AnchorLocal Ξ΅ c β§ | |
| β n : β, 0 < n β§ n β€ d β§ | |
| (β v : ExcludedState m (circleSize m p) m, | |
| (encode c (excludedWord m p (m ^ (2 * m)) (circleSize m p) m v)).length = n) β§ | |
| Real.exp (lower * exponentScale d) β€ setDistortion | |
| (Set.range fun v : ExcludedState m (circleSize m p) m => | |
| encode c (excludedWord m p (m ^ (2 * m)) (circleSize m p) m v)) | |
| def UniformUpper (C : β) (dβ : β) : Prop := | |
| β (Ξ± : Type) [Fintype Ξ±], 2 β€ Fintype.card Ξ± β β d : β, dβ β€ d β | |
| β (M : β) (F : Words Ξ± d β Fin M β β), β x y : Words Ξ± d, | |
| (editDistance x.val y.val : β) β€ β i, |F x i - F y i| β§ | |
| (β i, |F x i - F y i|) β€ | |
| Real.exp (C * exponentScale d) * editDistance x.val y.val | |
| def FullMain : Prop := | |
| β c C a Ccode Ξ΄ Ξ΅ : β, β dβ : β, | |
| 0 < c β§ 0 < C β§ 0 < a β§ 0 < Ccode β§ 0 < Ξ΄ β§ 0 < Ξ΅ β§ | |
| TwoCodes a Ccode Ξ΄ Ξ΅ β§ UniformUpper C dβ β§ | |
| (β (Ξ± : Type) [Fintype Ξ±], 2 β€ Fintype.card Ξ± β β d : β, dβ β€ d β | |
| Real.exp (c * exponentScale d) β€ E Ξ± d β§ | |
| E Ξ± d β€ Real.exp (C * exponentScale d)) β§ | |
| (β d : β, dβ β€ d β | |
| MaskWitness a Ccode Ξ΄ c d β§ ExcludedWitness a Ccode Ξ΅ c d β§ | |
| Real.exp (c * exponentScale d) β€ alphabetSupremum d β§ | |
| alphabetSupremum d β€ Real.exp (C * exponentScale d)) | |
| end FiniteCircle | |
| theorem finiteCircle_fullMain : FiniteCircle.FullMain := by | |
| sorry | |
| end OAI | |