math / data /lean /OAI /Computability /WLIdentification /PolynomialArithmetic.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
14 kB
import OAI.Computability.WLIdentification.WordArithmetic
namespace OAI
namespace WLIdentification
namespace WordExpressions
namespace Poly
variable {n : β„•}
theorem replicate {c : (Fin n β†’ Word) β†’ β„•} (hc : NatPoly c) (b : Bool) :
Poly (fun S => List.replicate (c S) b) := by
apply (tabulate hc (BoolPoly.const b)).congr
intro S
simp
theorem mapBits {w : (Fin n β†’ Word) β†’ Word} {p : (Fin (n+1) β†’ Word) β†’ Bool}
(hw : Poly w) (hp : BoolPoly p) :
Poly (fun S => (List.range (w S).length).map (fun i => p (Fin.snoc S (unary i)))) :=
tabulate (NatPoly.length hw) hp
theorem append {u v : (Fin n β†’ Word) β†’ Word} (hu : Poly u) (hv : Poly v) :
Poly (fun S => u S ++ v S) := by
let p : (Fin (n+1) β†’ Word) β†’ Bool := fun T =>
if (T (Fin.last n)).length < (u (T ∘ Fin.castSucc)).length then
(u (T ∘ Fin.castSucc))[(T (Fin.last n)).length]?.getD false
else (v (T ∘ Fin.castSucc))[(T (Fin.last n)).length-(u (T ∘ Fin.castSucc)).length]?.getD false
have hp : BoolPoly p := by
apply (branches
(NatPoly.lt (NatPoly.var (Fin.last n)) (NatPoly.length (rename hu Fin.castSucc)))
(nth (rename hu Fin.castSucc) (NatPoly.var (Fin.last n)))
(nth (rename hv Fin.castSucc) (NatPoly.sub (NatPoly.var (Fin.last n))
(NatPoly.length (rename hu Fin.castSucc))))).congr
intro T
dsimp only [p]
by_cases hh : (T (Fin.last n)).length < (u (T ∘ Fin.castSucc)).length <;> simp [hh]
have h := tabulate (NatPoly.add (NatPoly.length hu) (NatPoly.length hv)) hp
apply h.congr
intro S
apply List.ext_getElem (by simp)
intro i hi hj
simp only [List.getElem_map, List.getElem_range, p, Fin.snoc_last, unary,
List.length_replicate, snoc_prefix, List.getElem_append]
split
Β· rename_i hh
rw [List.getElem?_eq_getElem hh]
rfl
Β· rename_i hh
have hv' : i-(u S).length < (v S).length := by simp only [List.length_append] at hj; omega
rw [List.getElem?_eq_getElem hv']
rfl
theorem reverse {w : (Fin n β†’ Word) β†’ Word} (hw : Poly w) : Poly (fun S => (w S).reverse) := by
have hp := nth (rename hw Fin.castSucc)
(NatPoly.sub (NatPoly.length (rename hw Fin.castSucc)) (NatPoly.succ (NatPoly.var (Fin.last n))))
apply (tabulate (NatPoly.length hw) hp).congr
intro S
apply List.ext_getElem (by simp)
intro i hi hj
simp only [List.getElem_map, List.getElem_range, Fin.snoc_last, unary, List.length_replicate,
snoc_prefix]
have hi' : i < (w S).length := by simpa using hj
rw [List.getElem?_eq_getElem (by omega)]
simp only [Option.getD_some, List.getElem_reverse, Nat.sub_sub, Nat.add_comm]
theorem take {w : (Fin n β†’ Word) β†’ Word} {c : (Fin n β†’ Word) β†’ β„•}
(hw : Poly w) (hc : NatPoly c) : Poly (fun S => (w S).take (c S)) := by
apply (cutOf hw (NatPoly.sub (NatPoly.length hw) hc)).congr
intro S
simp only [unary, List.length_replicate]
by_cases h : c S ≀ (w S).length
Β· rw [Nat.sub_sub_self h]
Β· rw [show (w S).length-c S = 0 by omega, Nat.sub_zero, List.take_length,
List.take_of_length_le (by omega)]
theorem dropPrefix {w : (Fin n β†’ Word) β†’ Word} {c : (Fin n β†’ Word) β†’ β„•}
(hw : Poly w) (hc : NatPoly c) : Poly (fun S => (w S).drop (c S)) := by
have hp := nth (rename hw Fin.castSucc)
(NatPoly.add (NatPoly.rename hc Fin.castSucc) (NatPoly.var (Fin.last n)))
apply (tabulate (NatPoly.sub (NatPoly.length hw) hc) hp).congr
intro S
apply List.ext_getElem (by simp)
intro i hi hj
simp only [List.getElem_map, List.getElem_range, Fin.snoc_last, unary, List.length_replicate,
snoc_prefix, List.getElem_drop]
rw [List.getElem?_eq_getElem (by simpa only [List.length_drop] using (show c S+i < (w S).length from by
simp only [List.length_drop] at hj; omega))]
rfl
end Poly
end WordExpressions
namespace WordExpressions.NatPoly
variable {n : β„•}
theorem sum {c : (Fin n β†’ Word) β†’ β„•} {f : (Fin (n+1) β†’ Word) β†’ β„•}
(hc : NatPoly c) (hf : NatPoly f) :
NatPoly (fun S => ((List.range (c S)).map (fun i => f (Fin.snoc S (unary i)))).sum) := by
let step : (Fin (n+2) β†’ Word) β†’ β„• := fun T => (T (accum n)).length+f (T ∘ Fin.castSucc)
have hstep : NatPoly step := add (var _) (rename hf _)
have hs (S : Fin n β†’ Word) (k : β„•) : stages step S 0 k =
((List.range k).map (fun i => f (Fin.snoc S (unary i)))).sum := by
induction k with
| zero => rfl
| succ k ih => simp [stages, step, ih, List.sum_range_succ]
obtain ⟨C,hC,hcb⟩ := bound hc
obtain ⟨F,hF,hfb⟩ := bound hf
let H := fun N => C N*F (N+C N)
have hH : ComputationBounds.Polynomial H :=
ComputationBounds.mul hC (ComputationBounds.compose hF (ComputationBounds.add ComputationBounds.identity hC))
have hstage (S : Fin n β†’ Word) (N : β„•) (hS : βˆ€ j, (S j).length ≀ N) :
βˆ€ k ≀ c S, stages step S 0 k ≀ H N := by
have heval (k : β„•) (hk : k ≀ c S) : f (Fin.snoc S (unary k)) ≀ F (N+C N) := by
apply hfb
intro j
refine Fin.lastCases ?_ (fun i => ?_) j
Β· simp only [Fin.snoc_last, unary, List.length_replicate]
exact (hk.trans (hcb S N hS)).trans (Nat.le_add_left _ _)
Β· simpa only [Fin.snoc_castSucc] using (hS i).trans (Nat.le_add_right _ _)
have haux (k : β„•) (hk : k ≀ c S) : stages step S 0 k ≀ k*F (N+C N) := by
induction k with
| zero => simp [stages]
| succ k ih =>
simp only [stages, step, extend_accum, unary, List.length_replicate, extend_prefix]
have hi := ih (by omega)
have he := heval k (by omega)
change stages step S 0 k+f (Fin.snoc S (unary k)) ≀ _
simpa only [Nat.succ_mul] using Nat.add_le_add hi he
intro k hk
exact (haux k hk).trans (Nat.mul_le_mul_right _ (hk.trans (hcb S N hS)))
apply (loop hc (const 0) hstep H hH hstage).congr
intro S
dsimp only
rw [hs]
end WordExpressions.NatPoly
namespace WordExpressions.NatPoly
variable {n : β„•}
theorem pair {f g : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) (hg : NatPoly g) :
NatPoly (fun S => Nat.pair (f S) (g S)) := by
apply (ite (lt hf hg) (add (mul hg hg) hf) (add (add (mul hf hf) hf) hg)).congr
intro S
simp only [Nat.pair]
by_cases h : f S < g S <;> simp [h]
theorem sqrt {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) : NatPoly (fun S => (f S).sqrt) := by
have hp : BoolPoly (fun T : Fin (n+1) β†’ Word =>
decide ((T (Fin.last n)).length*(T (Fin.last n)).length ≀ f (T ∘ Fin.castSucc))) :=
le (mul (var _) (var _)) (rename hf _)
apply (findGreatest hf hp).congr
intro S
dsimp only
apply congrArg unary
simp only [Fin.snoc_last, unary, List.length_replicate, snoc_prefix, decide_eq_true_eq]
apply Nat.findGreatest_eq_iff.mpr
refine ⟨Nat.sqrt_le_self _, fun _ => Nat.sqrt_le _, ?_⟩
intro i hi _ hsq
have := Nat.le_sqrt.mpr hsq
omega
theorem unpair_fst {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) :
NatPoly (fun S => (Nat.unpair (f S)).1) := by
have hs := sqrt hf
have hr := sub hf (mul hs hs)
apply (ite (lt hr hs) hr hs).congr
intro S
by_cases h : f S-(f S).sqrt*(f S).sqrt < (f S).sqrt <;> simp [Nat.unpair, h]
theorem unpair_snd {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) :
NatPoly (fun S => (Nat.unpair (f S)).2) := by
have hs := sqrt hf
have hr := sub hf (mul hs hs)
apply (ite (lt hr hs) hs (sub hr hs)).congr
intro S
by_cases h : f S-(f S).sqrt*(f S).sqrt < (f S).sqrt <;> simp [Nat.unpair, h]
end WordExpressions.NatPoly
namespace WordExpressions.NatPoly
variable {n : β„•}
theorem cap_mul (b x c : β„•) : Min.min (Min.min x c*b) c = Min.min (x*b) c := by
by_cases hb : b = 0
Β· simp [hb]
have hb : 1 ≀ b := by omega
by_cases hx : x ≀ c
Β· rw [min_eq_left hx]
Β· have hxc : c ≀ x := by omega
rw [min_eq_right hxc, min_eq_right (by nlinarith), min_eq_right (by nlinarith)]
theorem cappedPow {b e c : (Fin n β†’ Word) β†’ β„•} (hb : NatPoly b) (he : NatPoly e) (hc : NatPoly c) :
NatPoly (fun S => Min.min ((b S)^(e S)) (c S)) := by
let f : (Fin (n+2) β†’ Word) β†’ β„• := fun T => Min.min ((T (accum n)).length*b (T ∘ old)) (c (T ∘ old))
have hf : NatPoly f := min (mul (var _) (rename hb _)) (rename hc _)
have hs (S : Fin n β†’ Word) (k : β„•) : stages f S (Min.min 1 (c S)) k = Min.min ((b S)^k) (c S) := by
induction k with
| zero => simp [stages]
| succ k ih => simp only [stages, f, extend_accum, unary, List.length_replicate, extend_base, ih,
cap_mul, pow_succ]
obtain ⟨C,hC,hcb⟩ := bound hc
apply (loop he (min (const 1) hc) hf C hC (by
intro S N hS k _
rw [hs]
exact (min_le_right _ _).trans (hcb S N hS))).congr
intro S
dsimp only
rw [hs]
end WordExpressions.NatPoly
namespace WordExpressions.NatPoly
variable {n : β„•}
theorem bitsSize {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) : NatPoly (fun S => (f S).size) := by
have hp : BoolPoly (fun T : Fin (n+1) β†’ Word =>
decide (Min.min (2^(T (Fin.last n)).length) (f (T ∘ Fin.castSucc)+1) ≀ f (T ∘ Fin.castSucc))) :=
le (cappedPow (const 2) (var _) (succ (rename hf _))) (rename hf _)
have hmax := findGreatest hf hp
apply (ite (eqtest hf (const 0)) (const 0) (succ hmax)).congr
intro S
simp only [Fin.snoc_last, unary, List.length_replicate, snoc_prefix, decide_eq_true_eq]
by_cases hz : f S = 0
Β· simp [hz]
Β· simp only [hz, ↓reduceIte]
have hpos : 0 < (f S).size := by
by_contra hh
have := Nat.size_le.mp (show (f S).size ≀ 0 from by omega)
simp only [pow_zero] at this
omega
have hsize : (f S).size ≀ f S := Nat.size_le.mpr Nat.lt_two_pow_self
have hmaxeq : Nat.findGreatest (fun i => Min.min (2^i) (f S+1) ≀ f S) (f S) = (f S).size-1 := by
apply Nat.findGreatest_eq_iff.mpr
refine ⟨by omega, ?_, ?_⟩
Β· intro _
apply (min_le_left _ _).trans
have hn : Β¬ f S < 2^((f S).size-1) := by
intro hn
have := Nat.size_le.mpr hn
omega
omega
Β· intro i hi _ hle
have hpow : f S < 2^i := Nat.size_le.mp (by omega)
omega
rw [hmaxeq]
congr 1
omega
theorem div_cap (x y : β„•) : x / Min.min y (x+1) = x/y := by
by_cases hy : y ≀ x+1
Β· rw [min_eq_left hy]
Β· rw [min_eq_right (by omega), Nat.div_eq_of_lt (by omega), Nat.div_eq_of_lt (by omega)]
theorem testBit {f i : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) (hi : NatPoly i) :
BoolPoly (fun S => (f S).testBit (i S)) := by
apply (eqtest (mod (div hf (cappedPow (const 2) hi (succ hf))) (const 2)) (const 1)).congr
intro S
simp only [div_cap, Nat.testBit_eq_decide_div_mod_eq]
end WordExpressions.NatPoly
namespace WordExpressions.Poly
variable {n : β„•}
theorem bits {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) : Poly (fun S => (f S).bits) := by
apply (tabulate (NatPoly.bitsSize hf)
(NatPoly.testBit (NatPoly.rename hf Fin.castSucc) (NatPoly.var (Fin.last n)))).congr
intro S
apply List.ext_getElem (by simp [Nat.size_eq_bits_len])
intro i hi hj
simp only [List.getElem_map, List.getElem_range, Fin.snoc_last, unary,
List.length_replicate, snoc_prefix, Nat.testBit_eq_inth, List.getI_eq_getElem?_getD]
rw [List.getElem?_eq_getElem hj]
rfl
theorem binary {f : (Fin n β†’ Word) β†’ β„•} (hf : NatPoly f) : Poly (fun S => (f S).bits.reverse) :=
reverse (bits hf)
end WordExpressions.Poly
namespace WordExpressions
namespace NatPoly
variable {n : β„•}
/-- Saturated, genuine left-to-right binary decoding. It stays unary-bounded by c. -/
def decodeCap (w : Word) (c : β„•) : β„• := w.foldl (fun x b => Min.min (2*x+if b then 1 else 0) c) 0
theorem decodeCap_aux (w : Word) (c x : β„•) :
w.foldl (fun x b => Min.min (2*x+if b then 1 else 0) c) (Min.min x c) =
Min.min (w.foldl (fun x b => 2*x+if b then 1 else 0) x) c := by
induction w generalizing x with
| nil => rfl
| cons b w ih =>
simp only [List.foldl_cons]
have hm : Min.min (2*Min.min x c+if b then 1 else 0) c =
Min.min (2*x+if b then 1 else 0) c := by
cases b
Β· simpa only [Bool.false_eq_true, ↓reduceIte, add_zero, Nat.mul_comm] using cap_mul 2 x c
Β· simp only [↓reduceIte]
by_cases hx : x ≀ c
Β· rw [min_eq_left hx]
Β· rw [min_eq_right (by omega : c ≀ x), min_eq_right (by omega : c ≀ 2*c+1),
min_eq_right (by omega : c ≀ 2*x+1)]
rw [hm, ih]
theorem decodeCap_correct (w : Word) (c : β„•) : decodeCap w c = Min.min (binaryValue w) c := by
simpa only [decodeCap, binaryValue, zero_min] using decodeCap_aux w c 0
theorem decode {w : (Fin n β†’ Word) β†’ Word} {c : (Fin n β†’ Word) β†’ β„•}
(hw : Poly w) (hc : NatPoly c) : NatPoly (fun S => Min.min (binaryValue (w S)) (c S)) := by
let f : (Fin (n+2) β†’ Word) β†’ β„• := fun T =>
Min.min (2*(T (accum n)).length+if (w (T ∘ old))[(T (index n)).length]?.getD false then 1 else 0) (c (T ∘ old))
have hf : NatPoly f := min
(add (mul (const 2) (var _)) (ite (Poly.nth (Poly.rename hw old) (var _)) (const 1) (const 0)))
(rename hc old)
have hs (S : Fin n β†’ Word) (k : β„•) (hk : k ≀ (w S).length) :
stages f S 0 k = decodeCap ((w S).take k) (c S) := by
induction k with
| zero => rfl
| succ k ih =>
have hk' : k < (w S).length := by omega
simp only [stages, f, extend_accum, unary, List.length_replicate, extend_base, extend_index,
List.getElem?_eq_getElem hk', Option.getD_some, ih (by omega)]
rw [List.take_succ_eq_append_getElem hk']
simp only [decodeCap, List.foldl_append, List.foldl_cons, List.foldl_nil]
obtain ⟨C,hC,hcb⟩ := bound hc
apply (loop (length hw) (const 0) hf C hC (by
intro S N hS k hk
rw [hs S k hk, decodeCap_correct]
exact (min_le_right _ _).trans (hcb S N hS))).congr
intro S
dsimp only
rw [hs S _ (le_refl _), List.take_length, decodeCap_correct]
end NatPoly
end WordExpressions
end WLIdentification
end OAI