Download data/lean/OAI/Computability/RationalHitting/Model.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.23 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/RationalHitting/Model.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/RationalHitting/Model.lean
-
curl -L -o Model.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/RationalHitting/Model.lean
4.23 kB
| import Mathlib | |
| namespace OAI | |
| namespace RationalHitting | |
| universe u | |
| inductive Formula (n : β) where | |
| | var : Fin n β Formula n | |
| | const : β β Formula n | |
| | add : Formula n β Formula n β Formula n | |
| | mul : Formula n β Formula n β Formula n | |
| | inv : Formula n β Formula n | |
| deriving DecidableEq | |
| namespace Formula | |
| def size {n : β} : Formula n β β | |
| | .var _ | .const _ => 1 | |
| | .add f g | .mul f g => f.size + g.size + 1 | |
| | .inv f => f.size + 1 | |
| /-- Evaluation in any rational algebra; a unary inverse requires an actual | |
| two-sided inverse of the evaluated operand, not a totalized inverse. -/ | |
| inductive Eval {n : β} {R : Type u} [Ring R] | |
| (c : β β+* R) (X : Fin n β R) : Formula n β R β Prop where | |
| | var (i) : Eval c X (.var i) (X i) | |
| | const (a) : Eval c X (.const a) (c a) | |
| | add {f g a b} : Eval c X f a β Eval c X g b β Eval c X (.add f g) (a + b) | |
| | mul {f g a b} : Eval c X f a β Eval c X g b β Eval c X (.mul f g) (a * b) | |
| | inv {f a b} : Eval c X f a β a * b = 1 β b * a = 1 β Eval c X (.inv f) b | |
| end Formula | |
| abbrev Mat (d : β) := Matrix (Fin d) (Fin d) β | |
| abbrev Tuple (n d : β) := Fin n β Mat d | |
| def Evaluates {n d : β} (f : Formula n) (X : Tuple n d) (v : Mat d) : Prop := | |
| f.Eval (algebraMap β (Mat d)) X v | |
| def Admissible {n : β} (f : Formula n) : Prop := | |
| β d, 0 < d β§ β (X : Tuple n d), β v, Evaluates f X v | |
| def Nonzero {n : β} (f : Formula n) : Prop := | |
| β d, 0 < d β§ β (X : Tuple n d), β v, Evaluates f X v β§ v β 0 | |
| /-- All output tuples have one common positive dimension. -/ | |
| structure Output (n : β) where | |
| dimension : β | |
| dimension_pos : 0 < dimension | |
| tuples : List (Tuple n dimension) | |
| /-- Little-endian unsigned binary, prefixed by a unary bit-length and a zero | |
| terminator. This is a self-delimiting binary encoding, including zero. -/ | |
| def encodeNat (a : β) : List Bool := | |
| let ds := (Nat.digits 2 a).map (fun b => b != 0) | |
| List.replicate ds.length true ++ [false] ++ ds | |
| /-- Sign bit, binary numerator magnitude, and positive binary denominator. | |
| Rat.num and Rat.den are the canonical reduced numerator and denominator. -/ | |
| def encodeRat (a : β) : List Bool := | |
| [decide (a.num < 0)] ++ encodeNat a.num.natAbs ++ encodeNat a.den | |
| def encodeTuple {n d : β} (X : Tuple n d) : List Bool := | |
| (List.finRange n).flatMap fun i => | |
| (List.finRange d).flatMap fun j => | |
| (List.finRange d).flatMap fun k => encodeRat (X i j k) | |
| def encodeOutput {n : β} (H : Output n) : List Bool := | |
| encodeNat H.dimension ++ encodeNat H.tuples.length ++ H.tuples.flatMap encodeTuple | |
| /-- 0 is blank, 1 and 2 are the two literal binary digits, 3 is work space. | |
| Fixed finite tape alphabet and finite state space; no advice or oracle. -/ | |
| abbrev Alphabet := Fin 4 | |
| abbrev Machine (m : β) := Turing.TM0.Machine Alphabet (Fin (m + 1)) | |
| abbrev Config (m : β) := Turing.TM0.Cfg Alphabet (Fin (m + 1)) | |
| def tapeBit (b : Bool) : Alphabet := if b then 2 else 1 | |
| def unaryInput (n s : β) : List Alphabet := | |
| List.replicate n 2 ++ [1] ++ List.replicate s 2 | |
| /-- Exactly t ordinary deterministic TM0 transitions. -/ | |
| def run {m : β} (G : Machine m) : β β Config m β Option (Config m) | |
| | 0, a => some a | |
| | t + 1, a => (Turing.TM0.step G a).bind (run G t) | |
| def OutputsWithin {m n : β} (G : Machine m) (s bound : β) (H : Output n) : Prop := | |
| β t β€ bound, β a : Config m, | |
| run G t (Turing.TM0.init (unaryInput n s)) = some a β§ | |
| Turing.TM0.step G a = none β§ | |
| a.Tape.rightβ = Turing.ListBlank.mk ((encodeOutput H).map tapeBit) | |
| def Hits {n : β} (s : β) (H : Output n) : Prop := | |
| β f : Formula n, f.size β€ s β Admissible f β Nonzero f β | |
| β X β H.tuples, β v, Evaluates f X v β§ IsUnit v | |
| /-- A fixed polynomial bound on bit time, full binary output length, | |
| and common positive dimension. -/ | |
| def MainStatement : Prop := | |
| β (m : β) (G : Machine m) (C k : β), 0 < C β§ 0 < k β§ | |
| β n s : β, 1 β€ n β 1 β€ s β β H : Output n, | |
| H.dimension β€ C * (n + s + 1) ^ k β§ | |
| (encodeOutput H).length β€ C * (n + s + 1) ^ k β§ | |
| OutputsWithin G s (C * (n + s + 1) ^ k) H β§ Hits s H | |
| end RationalHitting | |
| end OAI | |