| import OAI.Computability.WeisfeilerLeman.GraphFormula |
|
|
| namespace OAI |
|
|
| universe uD uV uJ uK uL uT |
|
|
| namespace WLTime.Marking |
| variable {D : Type uD} {V : Type uV} {p : D → Prop} {count : V → ℕ} |
|
|
| def rectangleAdj (R : D → D → Prop) (c : D → ℕ) (d e : D) (i j : ℕ) : Prop := |
| p d ∧ p e ∧ i ≤ c d ∧ j ≤ c e ∧ |
| ((i=0 ∧ j=0 ∧ R d e) ∨ (i=0 ∧ j≠0 ∧ d=e) ∨ (i≠0 ∧ j=0 ∧ d=e)) |
|
|
| theorem decodeSlots_adj (e : {d // p d} ≃ V) (G : SimpleGraph V) |
| (R : D → D → Prop) (c : D → ℕ) |
| (hc : ∀d : {d // p d},count (e d)=c d.val) |
| (hR : ∀d f : {d // p d},G.Adj (e d) (e f) ↔ R d.val f.val) |
| (L q : ℕ) (d f : D) (i j : Fin L) : |
| (rawGraph G (decodeSlots (count:=count) e L q)).Adj (some (.inl (d,i))) (some (.inl (f,j))) ↔ |
| rectangleAdj (p:=p) R c d f i.val j.val := by |
| classical |
| by_cases hd : p d |
| · by_cases hf : p f |
| · have heq : e ⟨d,hd⟩=e ⟨f,hf⟩ ↔ d=f := by |
| rw [e.injective.eq_iff,Subtype.mk.injEq] |
| have hadj := hR ⟨d,hd⟩ ⟨f,hf⟩ |
| have hcd := hc ⟨d,hd⟩ |
| have hcf := hc ⟨f,hf⟩ |
| by_cases hi : i.val=0 <;> by_cases hj : j.val=0 |
| · simpa [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,slotAdj,rectangleAdj] using hadj |
| · by_cases hle : j.val-1<c f |
| · have h : j.val≤c f := by omega |
| simp [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,hcf,hle,slotAdj,rectangleAdj,h,heq] |
| · have h : ¬j.val≤c f := by omega |
| simp [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,hcf,hle,rectangleAdj,h] |
| · by_cases hle : i.val-1<c d |
| · have h : i.val≤c d := by omega |
| simp [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,hcd,hle,slotAdj,rectangleAdj,h,heq] |
| · have h : ¬i.val≤c d := by omega |
| simp [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,hcd,hle,rectangleAdj,h] |
| · by_cases hli : i.val-1<c d <;> by_cases hlj : j.val-1<c f <;> |
| simp [rawGraph,rawAdj,decodeSlots,hd,hf,hi,hj,hcd,hcf,hli,hlj,rectangleAdj,slotAdj] |
| · simp [rawGraph,rawAdj,decodeSlots,hd,hf,rectangleAdj] |
| · simp [rawGraph,rawAdj,decodeSlots,hd,rectangleAdj] |
| end WLTime.Marking |
|
|
| namespace WLTime.NatCode |
| namespace Expr |
| variable {J : Type uJ} |
| def add (a b : Expr J) : Expr J := .binary .add a b |
| def mul (a b : Expr J) : Expr J := .binary .mul a b |
| @[simp] theorem add_eval (a b : Expr J) (σ : J → ℕ) (w : List Bool) : |
| (a.add b).eval σ w=a.eval σ w+b.eval σ w := rfl |
| @[simp] theorem mul_eval (a b : Expr J) (σ : J → ℕ) (w : List Bool) : |
| (a.mul b).eval σ w=a.eval σ w*b.eval σ w := rfl |
| end Expr |
| namespace Predicate |
| variable {J : Type uJ} |
| def le (a b : Expr J) : Predicate J := (Predicate.lt b a).neg |
| @[simp] theorem le_holds (a b : Expr J) (σ : J → ℕ) (w : List Bool) : |
| (le a b).Holds σ w ↔ a.eval σ w≤b.eval σ w := by |
| exact Nat.not_lt |
|
|
| def rectangular (p q R same : Predicate J) (a b i j : Expr J) : Predicate J := |
| p.conj (q.conj ((le i a).conj ((le j b).conj |
| (((Predicate.eq i (Expr.const 0)).conj ((Predicate.eq j (Expr.const 0)).conj R)).disj |
| (((Predicate.eq i (Expr.const 0)).conj ((Predicate.eq j (Expr.const 0)).neg.conj same)).disj |
| ((Predicate.eq i (Expr.const 0)).neg.conj ((Predicate.eq j (Expr.const 0)).conj same))))))) |
| theorem rectangular_holds (p q R same : Predicate J) (a b i j : Expr J) |
| (σ : J → ℕ) (w : List Bool) : |
| (rectangular p q R same a b i j).Holds σ w ↔ |
| p.Holds σ w ∧ q.Holds σ w ∧ i.eval σ w≤a.eval σ w ∧ j.eval σ w≤b.eval σ w ∧ |
| ((i.eval σ w=0 ∧ j.eval σ w=0 ∧ R.Holds σ w) ∨ |
| (i.eval σ w=0 ∧ j.eval σ w≠0 ∧ same.Holds σ w) ∨ |
| (i.eval σ w≠0 ∧ j.eval σ w=0 ∧ same.Holds σ w)) := by |
| simp only [rectangular,Holds,disj,Expr.eval,le,not_and_or,not_not,Nat.not_lt] |
| tauto |
| end Predicate |
| end WLTime.NatCode |
|
|
| namespace WLTime.OneTape.Symbolic |
| open CircuitEncoding NatCode Compression |
| variable (M : OneTape) (d q K : ℕ) |
| open scoped Classical |
| noncomputable def coefficient : ℕ := (instanceData M d q []).rectCoefficient K |
|
|
| variable {J : Type uJ} |
| noncomputable def countExpr (N : Expr J) (t : BlockTag M d q K) (a b : Expr J) : Expr J := |
| ((b.add (N.mul (a.add (N.mul (Expr.const (Fintype.equivFin _ t).val))))).add (Expr.const 1)).mul |
| (((Expr.const (coefficient M d q K)).mul (N.mul N)).add (Expr.const 1)) |
|
|
| theorem countExpr_correct (N : Expr J) (σ : J → ℕ) (w : List Bool) |
| (hN : N.eval σ w=w.length) (t : BlockTag M d q K) (a b : Expr J) |
| (x y : Fin w.length) (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) : |
| (countExpr M d q K N t a b).eval σ w= |
| ConsistencyData.mixedCode K t x y*((instanceData M d q w).rectCoefficient K*w.length^2+1) := by |
| simp only [countExpr,Expr.mul_eval,Expr.add_eval,Expr.eval,hN,ha,hb, |
| ConsistencyData.mixedCode,coefficient,pow_two] |
| rfl |
|
|
| noncomputable def sameRect (t u : BlockTag M d q K) (v z : Values M d q K) |
| (a b c e : Expr J) : Predicate J := |
| (Predicate.truth (decide (t=u ∧ v=z))).conj ((Predicate.eq a c).conj (Predicate.eq b e)) |
|
|
| theorem sameRect_correct (t u : BlockTag M d q K) (v z : Values M d q K) |
| (a b c e : Expr J) (σ : J → ℕ) (w : List Bool) (x y l h : Fin w.length) |
| (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) |
| (hc : c.eval σ w=l.val) (he : e.eval σ w=h.val) : |
| (sameRect M d q K t u v z a b c e).Holds σ w ↔ |
| (t,v,x,y)=(u,z,l,h) := by |
| simp only [sameRect,Predicate.Holds,decide_eq_true_eq,ha,hb,hc,he,Fin.val_inj,Prod.mk.injEq] |
| tauto |
|
|
| noncomputable def slotPredicate (N : Expr J) (ε : F₂) (t u : BlockTag M d q K) |
| (v z : Values M d q K) (a b i c e j : Expr J) : Predicate J := |
| Predicate.rectangular (validity M d q N K ε t v a b) (validity M d q N K ε u z c e) |
| (adjacent M d q N K t u v z a b c e) (sameRect M d q K t u v z a b c e) |
| (countExpr M d q K N t a b) (countExpr M d q K N u c e) i j |
|
|
| theorem slotPredicate_correct (N : Expr J) (hK : 0<K) (hr : 1≤d+q) |
| (ε : F₂) (σ : J → ℕ) (w : List Bool) (hN : N.eval σ w=w.length) |
| (t u : BlockTag M d q K) (v z : Values M d q K) (a b i c e j : Expr J) |
| (x y l h : Fin w.length) (s t' : Fin ((instanceData M d q w).slotLimit K)) (pad : ℕ) |
| (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) (hi : i.eval σ w=s.val) |
| (hc : c.eval σ w=l.val) (he : e.eval σ w=h.val) (hj : j.eval σ w=t'.val) : |
| (slotPredicate M d q K N ε t u v z a b i c e j).Holds σ w ↔ |
| ((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj |
| (some (.inl ((t,v,x,y),s))) (some (.inl ((u,z,l,h),t'))) := by |
| let I := instanceData M d q w |
| have hn (f : {f : I.Rect K // I.RectValid K ε f}) : |
| I.spacedCount K (I.rectVertexEquiv K hK hr ε f).1= |
| ConsistencyData.mixedCode K f.val.1 f.val.2.2.1 f.val.2.2.2*(I.rectCoefficient K*w.length^2+1) := by |
| change ConsistencyData.rawCode K (ConsistencyData.makeBlock K f.val.1 f.val.2.2.1 f.val.2.2.2)*_= _ |
| rw [ConsistencyData.rawCode_make] |
| have hR (f g : {f : I.Rect K // I.RectValid K ε f}) : |
| (I.valuationGraph K ε).Adj (I.rectVertexEquiv K hK hr ε f) (I.rectVertexEquiv K hK hr ε g) ↔ |
| I.RawAdjacent K (I.rectEquiv K f.val) (I.rectEquiv K g.val) := |
| I.descriptor_adjacent K hK hr ε _ _ |
| unfold ConsistencyData.rectangularGraph ConsistencyData.slots |
| erw [Marking.decodeSlots_adj (I.rectVertexEquiv K hK hr ε) (I.valuationGraph K ε) |
| (fun f g => I.RawAdjacent K (I.rectEquiv K f) (I.rectEquiv K g)) |
| (fun f => ConsistencyData.mixedCode K f.1 f.2.2.1 f.2.2.2*(I.rectCoefficient K*w.length^2+1)) |
| hn hR] |
| simp only [slotPredicate,Predicate.rectangular_holds,Marking.rectangleAdj, |
| validity_correct M d q N K ε σ w hN _ _ _ _ _ _ ha hb, |
| validity_correct M d q N K ε σ w hN _ _ _ _ _ _ hc he, |
| sameRect_correct M d q K _ _ _ _ _ _ _ _ σ w _ _ _ _ ha hb hc he, |
| countExpr_correct M d q K N σ w hN _ _ _ _ _ ha hb, |
| countExpr_correct M d q K N σ w hN _ _ _ _ _ hc he,hi,hj] |
| dsimp only [ConsistencyData.RectValid,ConsistencyData.rectEquiv,I] |
| apply and_congr_right |
| intro ht |
| apply and_congr_right |
| intro hu |
| rw [adjacent_correct M d q N K σ w hN t u v z a b c e x y l h ha hb hc he ht.1 hu.1] |
| rfl |
| end WLTime.OneTape.Symbolic |
|
|
| namespace WLTime.UnaryPrograms |
| open TypedStack |
| variable {K : Type uK} [DecidableEq K] |
| theorem countdown_indexed (c : Code K Bool) (s : ℕ → Stacks K Bool) (B n i : ℕ) |
| (hc : ∀j<n,∃t≤B,c.Exec (s (i+j)) t (s (i+j+1))) : |
| ∃t≤n*(B+3)+1, |
| (Code.loop (Code.nonempty (.inl 0)) (.seq (c.relabel Sum.inr) (.pop (.inl 0))) : |
| Code (Fin 2 ⊕ K) Bool).Exec (Sum.elim (extra n) (s i)) t (Sum.elim (extra 0) (s (i+n))) := by |
| induction n generalizing i with |
| | zero => exact ⟨1,by omega,.loop_false (by simp [Code.nonempty,tops,extra,numeral])⟩ |
| | succ n ih => |
| obtain ⟨u,hu,he⟩ := hc 0 (by omega) |
| simp only [Nat.add_zero] at he |
| have hb := Code.Exec.seq (Code.relabel_inr_exec he (extra (n+1))) (Code.Exec.pop _ (.inl 0)) |
| rw [extra_succ_update] at hb |
| obtain ⟨v,hv,hr⟩ := ih (i+1) (fun j hj => by simpa only [Nat.add_assoc,Nat.add_comm 1] using hc (j+1) (by omega)) |
| have hh := Code.Exec.loop_true (p:=Code.nonempty (.inl 0)) |
| (by simp [Code.nonempty,tops,extra,numeral]) hb hr |
| refine ⟨u+2+v+1,by nlinarith,?_⟩ |
| convert hh using 1 |
| congr 2 |
| omega |
|
|
| theorem repeat_indexed (base : K) (c : Code K Bool) (s : ℕ → Stacks K Bool) (B n : ℕ) |
| (hc : ∀j<n,∃t≤B,c.Exec (s j) t (s (j+1))) (hb : s 0 base=numeral n) : |
| ∃t≤n*(B+15)+3,(repeatN base c).Exec (Sum.elim (extra 0) (s 0)) t (Sum.elim (extra 0) (s n)) := by |
| have hf := Code.copy_exec (.inr base : Fin 2 ⊕ K) (.inl 0) (.inl 1) |
| (by simp) (by simp) (by simp) false (Sum.elim (extra 0) (s 0)) (by simp [extra]) |
| have he : Function.update (Sum.elim (extra 0) (s 0)) (.inl 0) |
| (Sum.elim (extra 0) (s 0) (.inr base)++Sum.elim (extra 0) (s 0) (.inl 0))=Sum.elim (extra n) (s 0) := by |
| funext i; cases i with |
| | inl j => fin_cases j <;> simp [extra,numeral,hb] |
| | inr j => simp |
| rw [he] at hf |
| obtain ⟨t,ht,hr⟩ := countdown_indexed c s B n 0 (by simpa only [Nat.zero_add]) |
| simp only [Nat.zero_add] at hr |
| refine ⟨_,?_,Code.Exec.seq hf hr⟩ |
| simp only [Sum.elim_inr,hb,numeral_length] |
| nlinarith |
| end WLTime.UnaryPrograms |
|
|
| namespace WLTime.TypedStack.Program |
| variable {K : Type uK} [DecidableEq K] |
| theorem repeat_indexed (base : K) (p : Program K) (s : ℕ → Stacks K Bool) (B n : ℕ) |
| (hc : ∀j<n,∃t≤B,p.Exec (s j) t (s (j+1))) (hb : s 0 base=UnaryPrograms.numeral n) : |
| ∃t≤n*(B+15)+3,(repeatN base p).Exec (s 0) t (s n) := by |
| obtain ⟨t,ht,he⟩ := UnaryPrograms.repeat_indexed (.inr base : Fin p.scratch ⊕ K) p.code |
| (fun i => p.ambient (s i)) B n hc hb |
| refine ⟨t,ht,?_⟩ |
| apply Code.relabel_exec_of_maps _ (Equiv.injective _) he |
| · intro k; cases k with |
| | inl i => fin_cases i <;> rfl |
| | inr i => cases i <;> rfl |
| · intro k; cases k with |
| | inl i => fin_cases i <;> rfl |
| | inr i => cases i <;> rfl |
| · intro l hl; exact False.elim (hl ((merge 2 p.scratch).symm l) (Equiv.apply_symm_apply _ l)) |
| end WLTime.TypedStack.Program |
|
|
| namespace WLTime.NatCode |
| open TypedStack UnaryPrograms |
| universe u |
|
|
| inductive Writer : Type u → Type (u+1) where |
| | emit {K : Type u} (p : Predicate K) : Writer K |
| | seq {K : Type u} (a b : Writer K) : Writer K |
| | loop {K : Type u} (n : Expr K) (body : Writer (Option K)) : Writer K |
|
|
| namespace Writer |
| variable {K : Type u} |
|
|
| def eval {K : Type u} : Writer K → (K → ℕ) → List Bool → List Bool |
| | .emit p,σ,w => [decide (p.Holds σ w)] |
| | .seq a b,σ,w => a.eval σ w++b.eval σ w |
| | .loop n body,σ,w => (List.range (n.eval σ w)).flatMap (fun i => body.eval (Option.elim' i σ) w) |
|
|
| def depth {K : Type u} : Writer K → ℕ |
| | .emit _ => 0 |
| | .seq a b => max a.depth b.depth |
| | .loop _ body => body.depth+1 |
|
|
| def charge {K : Type u} : Writer K → ℕ |
| | .emit p => 4*p.code.charge+20 |
| | .seq a b => a.charge+b.charge |
| | .loop n body => n.charge+body.charge+100 |
|
|
| def Safe {K : Type u} : Writer K → (K → ℕ) → List Bool → ℕ → Prop |
| | .emit p,σ,w,B => p.Bounded σ w B |
| | .seq a b,σ,w,B => a.Safe σ w B ∧ b.Safe σ w B |
| | .loop n body,σ,w,B => n.Bounded σ w B ∧ ∀i<n.eval σ w,body.Safe (Option.elim' i σ) w B |
|
|
| def compile {K : Type u} : Writer K → {L : Type uL} → [DecidableEq L] → (K → L) → L → L → Program L |
| | .emit p,_,_,ρ,word,out => Program.allocate |
| (Program.seq (p.code.compile (Sum.inr ∘ ρ) (.inr word) (.inl (0 : Fin 1))) |
| (Program.seq (Program.ofCode (.pushDyn (.inr out) (fun z => z (.inl 0)==some true))) |
| (Program.clear (.inl 0)))) |
| | .seq a b,_,_,ρ,word,out => Program.seq (a.compile ρ word out) (b.compile ρ word out) |
| | .loop n body,_,_,ρ,word,out => Program.allocate |
| (Program.seq (n.compile (Sum.inr ∘ ρ) (.inr word) (.inl (1 : Fin 2))) |
| (Program.seq (Program.repeatN (.inl 1) |
| (Program.seq (body.compile (Option.elim' (.inl 0) (Sum.inr ∘ ρ)) (.inr word) (.inr out)) |
| (Program.push (.inl 0) true))) |
| (Program.seq (Program.clear (.inl 0)) (Program.clear (.inl 1))))) |
|
|
| theorem numeral_bool_head (p : Prop) [Decidable p] : |
| ((numeral (if p then 1 else 0)).head?==some true)=decide p := by by_cases hp:p <;> simp [hp,numeral] |
|
|
| theorem emit_exec {L : Type uL} [DecidableEq L] (p : Predicate K) (ρ : K → L) (word out : L) |
| (_how : out≠word) (_hor : ∀k,out≠ρ k) (σ : K → ℕ) (w : List Bool) (B : ℕ) |
| (hp : p.Bounded σ w B) (hwB : w.length≤B) (s : Stacks L Bool) |
| (hs : ∀k,s (ρ k)=numeral (σ k)) (hw : s word=w) : |
| ∃t≤(4*p.code.charge+20)*(B+1)^2, |
| ((Writer.emit p).compile ρ word out).Exec s t |
| (Function.update s out (decide (p.Holds σ w)::s out)) := by |
| let z : Stacks (Fin 1 ⊕ L) Bool := Sum.elim (fun _ => []) s |
| obtain ⟨t,ht,he⟩ := p.code.compile_exec (Sum.inr ∘ ρ) (.inr word) (.inl (0 : Fin 1)) |
| (by simp) (fun _ => by simp) σ w (2*B+1) (p.code_bounded σ w B hp) (by omega) z |
| (fun k => hs k) hw (by simp [z]) |
| let mid := Function.update z (.inl (0 : Fin 1)) (numeral (p.code.eval σ w)) |
| have hb := Program.ofCode_exec (Code.Exec.pushDyn mid (.inr out) (fun v => v (.inl 0)==some true)) |
| have hc := Program.clear_exec (.inl (0 : Fin 1)) |
| (Function.update mid (.inr out) ((tops mid (.inl 0)==some true)::mid (.inr out))) |
| have hh := Program.seq_exec he (Program.seq_exec hb hc) |
| have hout : Function.update |
| (Function.update mid (.inr out) ((tops mid (.inl 0)==some true)::mid (.inr out))) (.inl 0) []= |
| Sum.elim (fun _ : Fin 1 => []) (Function.update s out (decide (p.Holds σ w)::s out)) := by |
| funext j; cases j with |
| | inl i => have hi:i=0 := Subsingleton.elim _ _; subst i; simp |
| | inr j => simp only [mid,z,tops,p.code_eval,numeral_bool_head, |
| Function.update_of_ne Sum.inr_ne_inl,Function.update_apply,Sum.inr.injEq, |
| Sum.elim_inr,ite_true] |
| rw [hout] at hh |
| refine ⟨_,?_,Program.local_exec hh⟩ |
| simp only [mid,Function.update_of_ne Sum.inl_ne_inr,Function.update_self,numeral_length] |
| have hv := p.code_le_one σ w |
| nlinarith [Nat.zero_le (B*B)] |
|
|
| theorem compile_exec (p : Writer K) {L : Type uL} [DecidableEq L] (ρ : K → L) (word out : L) |
| (how : out≠word) (hor : ∀k,out≠ρ k) (σ : K → ℕ) (w : List Bool) (B : ℕ) |
| (hp : p.Safe σ w B) (hwB : w.length≤B) (s : Stacks L Bool) |
| (hs : ∀k,s (ρ k)=numeral (σ k)) (hw : s word=w) : |
| ∃t≤p.charge*(B+1)^(p.depth+2),(p.compile ρ word out).Exec s t |
| (Function.update s out ((p.eval σ w).reverse++s out)) := by |
| induction p generalizing L with |
| | emit p => simpa only [compile,depth,charge,eval,List.reverse_singleton,List.singleton_append] using |
| emit_exec p ρ word out how hor σ w B hp hwB s hs hw |
| | seq a b iha ihb => |
| obtain ⟨t,ht,h1⟩ := iha ρ word out how hor σ hp.1 s hs hw |
| obtain ⟨v,hv,h2⟩ := ihb ρ word out how hor σ hp.2 |
| (Function.update s out ((a.eval σ w).reverse++s out)) |
| (fun k => by simpa only [Function.update_of_ne (hor k).symm] using hs k) |
| (by simpa only [Function.update_of_ne how.symm] using hw) |
| have hh := Program.seq_exec h1 h2 |
| refine ⟨t+v,?_,?_⟩ |
| · have hpa := Nat.pow_le_pow_right (by omega : 1≤B+1) (Nat.add_le_add_right (Nat.le_max_left a.depth b.depth) 2) |
| have hpb := Nat.pow_le_pow_right (by omega : 1≤B+1) (Nat.add_le_add_right (Nat.le_max_right a.depth b.depth) 2) |
| calc |
| t+v ≤ a.charge*(B+1)^(a.depth+2)+b.charge*(B+1)^(b.depth+2) := Nat.add_le_add ht hv |
| _ ≤ (a.charge+b.charge)*(B+1)^(max a.depth b.depth+2) := by nlinarith |
| · simpa only [compile,eval,List.reverse_append,List.append_assoc,Function.update_self,Function.update_idem] using hh |
| | loop n body ih => |
| let z : Stacks (Fin 2 ⊕ L) Bool := Sum.elim (fun _ => []) s |
| let N := n.eval σ w |
| let words (i : ℕ) := (List.range i).flatMap (fun j => body.eval (Option.elim' j σ) w) |
| let st (i : ℕ) : Stacks (Fin 2 ⊕ L) Bool := |
| Function.update (Function.update (Function.update z (.inl 1) (numeral N)) (.inl 0) (numeral i)) |
| (.inr out) ((words i).reverse++s out) |
| have hn := n.eval_le σ w B hp.1 |
| obtain ⟨t,ht,h0⟩ := n.compile_exec (Sum.inr ∘ ρ) (.inr word) (.inl (1 : Fin 2)) |
| (by simp) (fun _ => by simp) σ w B hp.1 hwB z (fun k => hs k) hw (by simp [z]) |
| have hs0 : st 0=Function.update z (.inl 1) (numeral N) := by |
| funext j; cases j with |
| | inl j => |
| by_cases hj : j=0 |
| · subst j |
| simp only [st,Function.update_of_ne Sum.inl_ne_inr,Function.update_self,numeral, |
| List.replicate_zero,Function.update_of_ne (by simp : (Sum.inl (0 : Fin 2) : Fin 2 ⊕ L)≠.inl 1), |
| z,Sum.elim_inl] |
| · have hj' : j=1 := by omega |
| subst j |
| simp only [st,Function.update_of_ne Sum.inl_ne_inr, |
| Function.update_of_ne (by simp : (Sum.inl (1 : Fin 2) : Fin 2 ⊕ L)≠.inl 0),Function.update_self] |
| | inr j => |
| simp only [st,z,words,List.range_zero,List.flatMap_nil,List.reverse_nil, |
| List.nil_append,Function.update_of_ne Sum.inr_ne_inl,Function.update_apply, |
| Sum.inr.injEq,Sum.elim_inr] |
| split_ifs with h |
| · subst j; rfl |
| · rfl |
| rw [← hs0] at h0 |
| let step := Program.seq |
| (body.compile (Option.elim' (.inl (0 : Fin 2)) (Sum.inr ∘ ρ)) (.inr word) (.inr out)) |
| (Program.push (.inl 0) true) |
| have hρ (k) : (Sum.inr (ρ k) : Fin 2 ⊕ L)≠.inr out := by |
| intro h; exact hor k (Sum.inr.inj h).symm |
| have hword : (Sum.inr word : Fin 2 ⊕ L)≠.inr out := by |
| intro h; exact how (Sum.inr.inj h).symm |
| have steps : ∀j<N,∃v≤body.charge*(B+1)^(body.depth+2)+2,step.Exec (st j) v (st (j+1)) := by |
| intro j hj |
| obtain ⟨v,hv,he⟩ := ih (Option.elim' (.inl (0 : Fin 2)) (Sum.inr ∘ ρ)) (.inr word) (.inr out) |
| (by simpa using how) (fun k => by cases k <;> simp [hor]) (Option.elim' j σ) (hp.2 j hj) (st j) |
| (fun k => by cases k with |
| | none => simp only [Option.elim',st,Function.update_of_ne Sum.inl_ne_inr,Function.update_self] |
| | some k => simpa only [Option.elim',st,Function.comp_apply,Function.update_of_ne (hρ k), |
| Function.update_of_ne Sum.inr_ne_inl,z,Sum.elim_inr] using hs k) |
| (by simpa only [st,Function.update_of_ne hword,Function.update_of_ne Sum.inr_ne_inl,z,Sum.elim_inr] using hw) |
| have hi := Program.push_exec (.inl (0 : Fin 2)) true |
| (Function.update (st j) (.inr out) ((body.eval (Option.elim' j σ) w).reverse++st j (.inr out))) |
| have hh := Program.seq_exec he hi |
| refine ⟨v+2,by omega,?_⟩ |
| convert hh using 1 |
| funext k; cases k with |
| | inl k => fin_cases k <;> simp [st,numeral,List.replicate_succ] |
| | inr k => simp [st,words,List.range_succ,List.flatMap_append,List.reverse_append,List.append_assoc] |
| obtain ⟨v,hv,h1⟩ := Program.repeat_indexed (.inl (1 : Fin 2)) step st |
| (body.charge*(B+1)^(body.depth+2)+2) N steps (by simp [st]) |
| have h2 := Program.clear_exec (.inl (0 : Fin 2)) (st N) |
| have h3 := Program.clear_exec (.inl (1 : Fin 2)) (Function.update (st N) (.inl 0) []) |
| have hh := Program.seq_exec h0 (Program.seq_exec h1 (Program.seq_exec h2 h3)) |
| have hout : Function.update (Function.update (st N) (.inl 0) []) (.inl 1) []= |
| Sum.elim (fun _ : Fin 2 => []) (Function.update s out (((Writer.loop n body).eval σ w).reverse++s out)) := by |
| funext j; cases j with |
| | inl j => fin_cases j <;> simp |
| | inr j => simp only [st,z,eval,words,N,Function.update_of_ne Sum.inr_ne_inl, |
| Function.update_apply,Sum.inr.injEq,Sum.elim_inr] |
| rw [hout] at hh |
| refine ⟨_,?_,Program.local_exec hh⟩ |
| simp only [st,Function.update_of_ne Sum.inl_ne_inr,Function.update_self,numeral_length, |
| Function.update_of_ne (by simp : (Sum.inl (1 : Fin 2) : Fin 2 ⊕ L)≠.inl 0)] |
| change t+(v+(3*N+1+(3*N+1)))≤(n.charge+body.charge+100)*(B+1)^(body.depth+1+2) |
| have hexp : body.depth+1+2=(body.depth+2)+1 := by omega |
| rw [hexp,pow_succ] |
| have hpow : (B+1)^2≤(B+1)^(body.depth+2) := Nat.pow_le_pow_right (by omega) (by omega) |
| have hone : 1≤(B+1)^(body.depth+2) := Nat.one_le_pow _ _ (by omega) |
| dsimp [N] at hv ⊢ |
| nlinarith [Nat.mul_le_mul_left n.charge hpow, |
| Nat.mul_le_mul_right (body.charge*(B+1)^(body.depth+2)+17) hn, |
| Nat.mul_le_mul_left B hone] |
| end Writer |
| end WLTime.NatCode |
|
|
| namespace WLTime.NatCode |
| namespace Expr |
| variable {K : Type uK} {J : Type uJ} |
| def rename (f : K → J) (e : Expr K) : Expr J := e.bind (Expr.var ∘ f) |
| @[simp] theorem rename_eval (f : K → J) (e : Expr K) (σ : J → ℕ) (w : List Bool) : |
| (e.rename f).eval σ w=e.eval (σ ∘ f) w := by simp only [rename,bind_eval,eval,Function.comp_def] |
| theorem rename_bounded (f : K → J) (e : Expr K) (σ : J → ℕ) (w : List Bool) (B : ℕ) : |
| (e.rename f).Bounded σ w B ↔ e.Bounded (σ ∘ f) w B := by |
| induction e with |
| | const | var => rfl |
| | binary op a b ha hb => |
| change ((a.rename f).Bounded σ w B ∧ (b.rename f).Bounded σ w B ∧ |
| op.eval ((a.rename f).eval σ w) ((b.rename f).eval σ w)≤B) ↔ _ |
| rw [ha,hb,rename_eval,rename_eval] |
| rfl |
| | bit a ha => |
| exact and_congr ha Iff.rfl |
|
|
| end Expr |
| namespace Writer |
| variable {K : Type uK} |
| def empty : Writer K := .loop (.const 0) (.emit (.truth false)) |
| @[simp] theorem empty_eval (σ : K → ℕ) (w : List Bool) : (empty : Writer K).eval σ w=[] := rfl |
| @[simp] theorem empty_depth : (empty : Writer K).depth=1 := rfl |
| theorem empty_safe (σ : K → ℕ) (w : List Bool) (B : ℕ) : (empty : Writer K).Safe σ w B := by |
| exact ⟨Nat.zero_le _,fun i hi => (Nat.not_lt_zero i hi).elim⟩ |
| def each {T : Type uT} (l : List T) (f : T → Writer K) : Writer K := l.foldr (fun t p => .seq (f t) p) empty |
| @[simp] theorem each_eval {T : Type uT} (l : List T) (f : T → Writer K) (σ : K → ℕ) (w : List Bool) : |
| (each l f).eval σ w=l.flatMap (fun t => (f t).eval σ w) := by |
| induction l with |
| | nil => rfl |
| | cons t l ih => |
| change (f t).eval σ w++(each l f).eval σ w=_ |
| rw [ih,List.flatMap_cons] |
| theorem each_safe {T : Type uT} (l : List T) (f : T → Writer K) (σ : K → ℕ) (w : List Bool) (B : ℕ) |
| (h : ∀t∈l,(f t).Safe σ w B) : (each l f).Safe σ w B := by |
| induction l with |
| | nil => exact empty_safe σ w B |
| | cons t l ih => exact ⟨h t (by simp),ih (fun t ht => h t (by simp [ht]))⟩ |
| theorem each_depth_le {T : Type uT} (l : List T) (f : T → Writer K) (b : ℕ) (hb : 1≤b) |
| (h : ∀t∈l,(f t).depth≤b) : (each l f).depth≤b := by |
| induction l with |
| | nil => exact hb |
| | cons t l ih => exact max_le (h t (by simp)) (ih (fun t ht => h t (by simp [ht]))) |
|
|
| def grid (N L : Expr K) (body : Writer (Option (Option (Option K)))) : Writer K := |
| .loop N (.loop (N.rename some) (.loop (L.rename (some ∘ some)) body)) |
| theorem grid_eval (N L : Expr K) (body : Writer (Option (Option (Option K)))) |
| (σ : K → ℕ) (w : List Bool) : |
| (grid N L body).eval σ w=(List.range (N.eval σ w)).flatMap (fun a => |
| (List.range (N.eval σ w)).flatMap (fun b => |
| (List.range (L.eval σ w)).flatMap (fun i => body.eval |
| (Option.elim' i (Option.elim' b (Option.elim' a σ))) w))) := by |
| simp only [grid,eval,Expr.rename_eval,Function.comp_def,Option.elim'_some] |
| theorem grid_safe (N L : Expr K) (body : Writer (Option (Option (Option K)))) |
| (σ : K → ℕ) (w : List Bool) (B : ℕ) (hN : N.Bounded σ w B) (hL : L.Bounded σ w B) |
| (hb : ∀a<N.eval σ w,∀b<N.eval σ w,∀i<L.eval σ w, |
| body.Safe (Option.elim' i (Option.elim' b (Option.elim' a σ))) w B) : |
| (grid N L body).Safe σ w B := by |
| refine ⟨hN,fun a ha => ⟨?_,fun b hb' => ⟨?_,fun i hi => ?_⟩⟩⟩ |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hL |
| · simp only [Expr.rename_eval,Function.comp_def,Option.elim'_some] at hb' hi |
| exact hb a ha b hb' i hi |
| @[simp] theorem grid_depth (N L : Expr K) (body : Writer (Option (Option (Option K)))) : |
| (grid N L body).depth=body.depth+3 := by simp only [grid,depth] |
| end Writer |
| end WLTime.NatCode |
|
|
| end OAI |
|
|
