| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! |
| Newman normalization, block coding, canonical representatives, and static tests. |
| -/ |
|
|
| /- Rewriting layer for the self-reference construction. No assumptions on |
| either main theorem are introduced here. -/ |
| namespace FiniteAlgebraicEnvelopes.Bootstrap |
|
|
| section |
| open Relation |
|
|
| section Newman |
| variable {α : Type*} (R : α → α → Prop) |
|
|
| def Irreducible (a : α) : Prop := ∀ b, ¬ R a b |
|
|
| theorem exists_irreducible (wf : WellFounded (flip R)) (a : α) : |
| ∃ b, ReflTransGen R a b ∧ Irreducible R b := by |
| classical |
| induction a using wf.induction with |
| | h a ih => |
| by_cases ha : Irreducible R a |
| · exact ⟨a, .refl, ha⟩ |
| · obtain ⟨b, hab⟩ := not_forall.mp ha |
| have hab : R a b := Classical.not_not.mp hab |
| obtain ⟨c, hbc, hc⟩ := ih b hab |
| exact ⟨c, (ReflTransGen.single hab).trans hbc, hc⟩ |
|
|
| theorem irreducible_reaches {a b : α} (ha : Irreducible R a) |
| (hab : ReflTransGen R a b) : a = b := by |
| rcases hab.cases_head with hab | ⟨c,hac,_⟩ |
| · exact hab |
| · exact False.elim (ha c hac) |
|
|
| /-- Newman's induction, with the terminal-descendant existence made explicit. -/ |
| theorem normal_unique (wf : WellFounded (flip R)) |
| (localJoin : ∀ a b c, R a b → R a c → Join (ReflTransGen R) b c) |
| (a : α) : ∀ b c, ReflTransGen R a b → ReflTransGen R a c → |
| Irreducible R b → Irreducible R c → b = c := by |
| induction a using wf.induction with |
| | h a ih => |
| intro b c hab hac hb hc |
| rcases hab.cases_head with rfl | ⟨b₁,hab₁,hb₁b⟩ |
| · exact irreducible_reaches R hb hac |
| rcases hac.cases_head with rfl | ⟨c₁,hac₁,hc₁c⟩ |
| · exact (irreducible_reaches R hc (.head hab₁ hb₁b)).symm |
| obtain ⟨d,hb₁d,hc₁d⟩ := localJoin a b₁ c₁ hab₁ hac₁ |
| obtain ⟨e,hde,he⟩ := exists_irreducible R wf d |
| exact (ih b₁ hab₁ b e hb₁b (hb₁d.trans hde) hb he).trans |
| (ih c₁ hac₁ c e hc₁c (hc₁d.trans hde) hc he).symm |
|
|
| theorem newman (wf : WellFounded (flip R)) |
| (localJoin : ∀ a b c, R a b → R a c → Join (ReflTransGen R) b c) |
| {a b c : α} (hab : ReflTransGen R a b) (hac : ReflTransGen R a c) : |
| Join (ReflTransGen R) b c := by |
| obtain ⟨u,hbu,hu⟩ := exists_irreducible R wf b |
| obtain ⟨v,hcv,hv⟩ := exists_irreducible R wf c |
| have h := normal_unique R wf localJoin a u v (hab.trans hbu) (hac.trans hcv) hu hv |
| exact ⟨u,hbu,h ▸ hcv⟩ |
| end Newman |
|
|
| variable {S : Type*} |
|
|
| /-- One directed rule in an arbitrary two-sided context. -/ |
| inductive Step (rules : List (List S × List S)) : List S → List S → Prop |
| | apply {u v} (h : (u,v) ∈ rules) (x y) : Step rules (x++u++y) (x++v++y) |
|
|
| abbrev Steps (rules : List (List S × List S)) := ReflTransGen (Step rules) |
|
|
| theorem step_context {rules : List (List S × List S)} {u v : List S} |
| (h : Step rules u v) (x y : List S) : Step rules (x++u++y) (x++v++y) := by |
| cases h with |
| | apply h a b => simpa only [List.append_assoc] using Step.apply h (x++a) (b++y) |
|
|
| theorem steps_context {rules : List (List S × List S)} {u v : List S} |
| (h : Steps rules u v) (x y : List S) : Steps rules (x++u++y) (x++v++y) := |
| h.lift (fun w => x++w++y) (fun _ _ h => step_context h x y) |
|
|
| theorem lex_append_suffix {r : S → S → Prop} {u v : List S} |
| (h : List.Lex r u v) (hlen : u.length = v.length) (y : List S) : |
| List.Lex r (u++y) (v++y) := by |
| induction h with |
| | nil => simp at hlen |
| | rel h => exact .rel h |
| | cons h ih => exact .cons (ih (by simpa using hlen)) |
|
|
| theorem shortlex_context {r : S → S → Prop} {u v : List S} |
| (h : List.Shortlex r u v) (x y : List S) : |
| List.Shortlex r (x++u++y) (x++v++y) := by |
| simp only [List.append_assoc] |
| apply List.Shortlex.append_left (s := x) |
| rcases List.shortlex_def.mp h with h | ⟨hl,h⟩ |
| · apply List.Shortlex.of_length_lt |
| simpa using h |
| · exact List.Shortlex.of_lex (by simp [hl]) (lex_append_suffix h hl y) |
|
|
| theorem step_shortlex {r : S → S → Prop} {rules : List (List S × List S)} |
| (dec : ∀ p ∈ rules, List.Shortlex r p.2 p.1) {u v : List S} |
| (h : Step rules u v) : List.Shortlex r v u := by |
| cases h with |
| | apply hm x y => exact shortlex_context (dec _ hm) x y |
|
|
| theorem steps_length {r : S → S → Prop} {rules : List (List S × List S)} |
| (dec : ∀ p ∈ rules, List.Shortlex r p.2 p.1) {u v : List S} |
| (h : Steps rules u v) : v.length ≤ u.length := by |
| induction h with |
| | refl => rfl |
| | tail huv hvw ih => |
| have hh := List.shortlex_def.mp (step_shortlex dec hvw) |
| omega |
|
|
| theorem steps_wellFounded {r : S → S → Prop} {rules : List (List S × List S)} |
| (wf : WellFounded r) (dec : ∀ p ∈ rules, List.Shortlex r p.2 p.1) : |
| WellFounded (flip (Step rules)) := |
| (List.Shortlex.wf wf).mono (fun _ _ h => step_shortlex dec h) |
|
|
| /-- A bounded table sees precisely those rules whose left sides fit the bound. -/ |
| theorem step_stable {rs rt : List (List S × List S)} {k : ℕ} |
| (stable : ∀ p, p.1.length ≤ k → (p ∈ rs ↔ p ∈ rt)) {w v : List S} |
| (hw : w.length ≤ k) : Step rs w v ↔ Step rt w v := by |
| constructor |
| · intro h |
| cases h with |
| | apply hm x y => |
| apply Step.apply ((stable _ (by simp only [List.length_append] at hw; dsimp only; omega)).mp hm) |
| · intro h |
| cases h with |
| | apply hm x y => |
| apply Step.apply ((stable _ (by simp only [List.length_append] at hw; dsimp only; omega)).mpr hm) |
|
|
| variable [DecidableEq S] |
|
|
| /-- The fixed choice of rule at the leftmost position, then table order. -/ |
| def rootNext (w : List S) : List (List S × List S) → Option (List S) |
| | [] => none |
| | (u,v)::rs => if w.take u.length = u then some (v ++ w.drop u.length) else rootNext w rs |
|
|
| def next (rules : List (List S × List S)) : List S → Option (List S) |
| | [] => rootNext [] rules |
| | a::w => (rootNext (a::w) rules).or ((next rules w).map (a::·)) |
|
|
| theorem rootNext_sound {w v : List S} {rules : List (List S × List S)} |
| (h : rootNext w rules = some v) : ∃ u t, (u,t) ∈ rules ∧ |
| ∃ y, w = u++y ∧ v = t++y := by |
| induction rules with |
| | nil => simp [rootNext] at h |
| | cons p rs ih => |
| rcases p with ⟨u,t⟩ |
| simp only [rootNext] at h |
| split at h |
| next he => |
| obtain rfl := Option.some.inj h |
| exact ⟨u,t,List.mem_cons_self, w.drop u.length, |
| by simpa only [he] using (List.take_append_drop u.length w).symm,rfl⟩ |
| next he => |
| obtain ⟨u,t,hm,y,hw,hv⟩ := ih h |
| exact ⟨u,t,List.mem_cons_of_mem _ hm,y,hw,hv⟩ |
|
|
| theorem rootNext_none {w : List S} {rules : List (List S × List S)} |
| (h : rootNext w rules = none) {u t y : List S} (hm : (u,t) ∈ rules) : w ≠ u ++ y := by |
| induction rules with |
| | nil => simp at hm |
| | cons p rs ih => |
| rcases p with ⟨a,b⟩ |
| simp only [rootNext] at h |
| split at h |
| · simp at h |
| next he => |
| rcases List.mem_cons.mp hm with hp | hm |
| · cases hp |
| intro hw |
| exact he (by simp [hw]) |
| · exact ih h hm |
|
|
| theorem next_sound {rules : List (List S × List S)} {w v : List S} |
| (h : next rules w = some v) : Step rules w v := by |
| induction w generalizing v with |
| | nil => |
| obtain ⟨u,t,hm,y,hw,hv⟩ := rootNext_sound h |
| have hh : Step rules (u++y) (t++y) := by |
| simpa only [List.nil_append] using Step.apply hm [] y |
| rw [← hw,← hv] at hh |
| exact hh |
| | cons a w ih => |
| simp only [next] at h |
| cases hr : rootNext (a::w) rules with |
| | some z => |
| simp [hr] at h |
| subst z |
| obtain ⟨u,t,hm,y,hw,hv⟩ := rootNext_sound hr |
| have hh : Step rules (u++y) (t++y) := by |
| simpa only [List.nil_append] using Step.apply hm [] y |
| rw [← hw,← hv] at hh |
| exact hh |
| | none => |
| simp only [hr,Option.none_or,Option.map_eq_some_iff] at h |
| obtain ⟨z,hz,rfl⟩ := h |
| simpa only [List.singleton_append,List.append_nil] using step_context (ih hz) [a] [] |
|
|
| theorem next_none_root {rules : List (List S × List S)} {w : List S} |
| (h : next rules w = none) : rootNext w rules = none := by |
| cases w with |
| | nil => exact h |
| | cons a w => exact (Option.or_eq_none_iff.mp h).1 |
|
|
| theorem next_none_tail {rules : List (List S × List S)} {a : S} {w : List S} |
| (h : next rules (a::w) = none) : next rules w = none := by |
| exact Option.map_eq_none_iff.mp (Option.or_eq_none_iff.mp h).2 |
|
|
| theorem next_none {rules : List (List S × List S)} {w : List S} |
| (h : next rules w = none) : Irreducible (Step rules) w := by |
| intro v hv |
| cases hv with |
| | @apply u t hm x y => |
| induction x with |
| | nil => exact rootNext_none (next_none_root h) hm rfl |
| | cons a x ih => exact ih (next_none_tail h) |
|
|
| /-- Fully specified finite-table reduction; divergence is retained for arbitrary |
| (possibly nonterminating) tables. -/ |
| def iteration (s : List (List S × List S) × List S) : |
| List S ⊕ (List (List S × List S) × List S) := |
| match next s.1 s.2 with |
| | none => .inl s.2 |
| | some v => .inr (s.1,v) |
|
|
| def evaluate (rules : List (List S × List S)) (w : List S) : Part (List S) := |
| PFun.fix (fun s => Part.some (iteration s)) (rules,w) |
|
|
| theorem evaluate_sound {rules : List (List S × List S)} {w v : List S} |
| (h : v ∈ evaluate rules w) : Steps rules w v ∧ Irreducible (Step rules) v := by |
| change v ∈ PFun.fix _ (rules,w) at h |
| refine PFun.fixInduction' (C := fun s => Steps s.1 s.2 v ∧ Irreducible (Step s.1) v) h ?_ ?_ |
| · rintro ⟨rs,a⟩ ha |
| simp only [Part.mem_some_iff,iteration] at ha |
| cases hn : next rs a with |
| | none => |
| simp only [hn,Sum.inl.injEq] at ha |
| subst a |
| exact ⟨.refl,next_none hn⟩ |
| | some b => simp [hn] at ha |
| · rintro ⟨rs,a⟩ ⟨rt,b⟩ _ hab ih |
| simp only [Part.mem_some_iff,iteration] at hab |
| cases hn : next rs a with |
| | none => simp [hn] at hab |
| | some c => |
| simp only [hn,Sum.inr.injEq,Prod.mk.injEq] at hab |
| rcases hab with ⟨rfl,rfl⟩ |
| exact ⟨.head (next_sound hn) ih.1,ih.2⟩ |
|
|
| theorem evaluate_total {rules : List (List S × List S)} |
| (wf : WellFounded (flip (Step rules))) (w : List S) : (evaluate rules w).Dom := by |
| induction w using wf.induction with |
| | h w ih => |
| cases hn : next rules w with |
| | none => |
| exact Part.dom_iff_mem.mpr ⟨w,PFun.fix_stop (by simp [iteration,hn])⟩ |
| | some v => |
| obtain ⟨z,hz⟩ := Part.dom_iff_mem.mp (ih v (next_sound hn)) |
| apply Part.dom_iff_mem.mpr |
| refine ⟨z,PFun.mem_fix_iff.mpr (Or.inr ⟨(rules,v),?_,hz⟩)⟩ |
| simp [iteration,hn] |
|
|
| omit [DecidableEq S] in |
| /-- Bounded local confluence is enough: every intervening reduction has |
| nonincreasing length, so no confluence outside the source budget is used. -/ |
| theorem evaluate_unique_on {r : S → S → Prop} {rules : List (List S × List S)} |
| (wf : WellFounded r) (dec : ∀ p ∈ rules, List.Shortlex r p.2 p.1) (n : ℕ) |
| (localJoin : ∀ a b c, a.length ≤ n → Step rules a b → Step rules a c → |
| Join (Steps rules) b c) {a b c : List S} (ha : a.length ≤ n) |
| (hab : Steps rules a b) (hac : Steps rules a c) |
| (hb : Irreducible (Step rules) b) (hc : Irreducible (Step rules) c) : b = c := by |
| induction a using (steps_wellFounded wf dec).induction generalizing b c with |
| | h a ih => |
| rcases hab.cases_head with rfl | ⟨b₁,hab₁,hb₁b⟩ |
| · exact irreducible_reaches _ hb hac |
| rcases hac.cases_head with rfl | ⟨c₁,hac₁,hc₁c⟩ |
| · exact (irreducible_reaches _ hc (.head hab₁ hb₁b)).symm |
| obtain ⟨d,hb₁d,hc₁d⟩ := localJoin a b₁ c₁ ha hab₁ hac₁ |
| obtain ⟨e,hde,he⟩ := exists_irreducible _ (steps_wellFounded wf dec) d |
| have hb₁ : b₁.length ≤ n := (steps_length dec (.single hab₁)).trans ha |
| have hc₁ : c₁.length ≤ n := (steps_length dec (.single hac₁)).trans ha |
| exact (ih b₁ hab₁ hb₁ hb₁b (hb₁d.trans hde) hb he).trans |
| (ih c₁ hac₁ hc₁ hc₁c (hc₁d.trans hde) hc he).symm |
|
|
| theorem evaluate_context_on {r : S → S → Prop} {rules : List (List S × List S)} |
| (wf : WellFounded r) (dec : ∀ p ∈ rules, List.Shortlex r p.2 p.1) (n : ℕ) |
| (localJoin : ∀ a b c, a.length ≤ n → Step rules a b → Step rules a c → |
| Join (Steps rules) b c) {w v : List S} (hv : v ∈ evaluate rules w) |
| (x y : List S) (hm : (x++w++y).length ≤ n) : |
| evaluate rules (x++v++y) = evaluate rules (x++w++y) := by |
| obtain ⟨a,ha⟩ := Part.dom_iff_mem.mp (evaluate_total (steps_wellFounded wf dec) (x++v++y)) |
| obtain ⟨b,hb⟩ := Part.dom_iff_mem.mp (evaluate_total (steps_wellFounded wf dec) (x++w++y)) |
| obtain ⟨hva,haI⟩ := evaluate_sound ha |
| obtain ⟨hwb,hbI⟩ := evaluate_sound hb |
| have hab := evaluate_unique_on wf dec n localJoin hm |
| ((steps_context (evaluate_sound hv).1 x y).trans hva) hwb haI hbI |
| subst b |
| exact (Part.eq_some_iff.mpr ha).trans (Part.eq_some_iff.mpr hb).symm |
|
|
| variable [Primcodable S] |
|
|
| theorem primrec_rootNext : Primrec₂ (@rootNext S _) := by |
| apply Primrec₂.of_eq (Primrec.list_rec Primrec.snd (Primrec.const none) |
| ((Primrec.ite |
| (Primrec.eq.comp |
| (Primrec.list_take.comp (Primrec.list_length.comp (Primrec.fst.comp (Primrec.fst.comp Primrec.snd))) |
| (Primrec.fst.comp Primrec.fst)) |
| (Primrec.fst.comp (Primrec.fst.comp Primrec.snd))) |
| (Primrec.option_some.comp (Primrec.list_append.comp |
| (Primrec.snd.comp (Primrec.fst.comp Primrec.snd)) |
| (Primrec.list_drop.comp |
| (Primrec.list_length.comp (Primrec.fst.comp (Primrec.fst.comp Primrec.snd))) |
| (Primrec.fst.comp Primrec.fst)))) |
| (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))).to₂)).to₂ |
| intro w rs |
| induction rs with |
| | nil => rfl |
| | cons p rs ih => |
| simpa [rootNext] using (congrArg |
| (fun t => if w.take p.1.length = p.1 then some (p.2++w.drop p.1.length) else t) ih) |
|
|
| theorem primrec_next : Primrec₂ (@next S _) := by |
| have hor : Primrec₂ (Option.or : Option (List S) → Option (List S) → Option (List S)) := |
| Primrec.option_orElse.of_eq (by intro a b; cases a <;> rfl) |
| apply Primrec₂.of_eq (Primrec.list_rec Primrec.snd |
| (primrec_rootNext.comp (Primrec.const []) Primrec.fst) |
| ((hor.comp |
| (primrec_rootNext.comp |
| (Primrec.list_cons.comp (Primrec.fst.comp Primrec.snd) |
| (Primrec.fst.comp (Primrec.snd.comp Primrec.snd))) |
| (Primrec.fst.comp Primrec.fst)) |
| (Primrec.option_map (Primrec.snd.comp (Primrec.snd.comp Primrec.snd)) |
| ((Primrec.list_cons.comp |
| (Primrec.fst.comp (Primrec.snd.comp Primrec.fst)) Primrec.snd).to₂))).to₂)).to₂ |
| intro rs w |
| induction w with |
| | nil => rfl |
| | cons a w ih => |
| simpa [next] using (congrArg |
| (fun t => (rootNext (a::w) rs).or (t.map (a::·))) ih) |
|
|
| theorem primrec_iteration : Primrec (@iteration S _) := by |
| exact (Primrec.option_casesOn (primrec_next.comp Primrec.fst Primrec.snd) |
| (Primrec.sumInl.comp Primrec.snd) |
| ((Primrec.sumInr.comp ((Primrec.fst.comp Primrec.fst).pair Primrec.snd)).to₂)).of_eq |
| (by intro s; cases h : next s.1 s.2 <;> simp [iteration,h]) |
|
|
| theorem partrec_evaluate : Partrec₂ (@evaluate S _) := |
| Partrec.fix primrec_iteration.to_comp |
|
|
| end |
|
|
| /- The marker/constant-width code used in the self-reference construction. |
| A block has its marker only at the start, not at the end. -/ |
|
|
| structure BlockCode (A S : Type*) where |
| marker : S |
| tail : A → List S |
| width : ℕ |
| tail_length : ∀ a, (tail a).length = width |
| tail_avoids : ∀ a, marker ∉ tail a |
| injective : Function.Injective tail |
|
|
| namespace BlockCode |
| variable {A S : Type*} (C : BlockCode A S) |
|
|
| def block (a : A) : List S := C.marker :: C.tail a |
|
|
| def encode (w : List A) : List S := w.flatMap C.block |
|
|
| @[simp] theorem block_length (a : A) : (C.block a).length = C.width+1 := by |
| simp [block,C.tail_length] |
|
|
| @[simp] theorem encode_nil : C.encode [] = [] := rfl |
| @[simp] theorem encode_cons (a : A) (w : List A) : C.encode (a::w) = C.block a ++ C.encode w := rfl |
| @[simp] theorem encode_append (u v : List A) : C.encode (u++v) = C.encode u ++ C.encode v := by |
| simp [encode] |
| @[simp] theorem encode_length (w : List A) : (C.encode w).length = (C.width+1)*w.length := by |
| induction w with |
| | nil => simp |
| | cons a w ih => simp [ih,Nat.mul_add,Nat.add_comm] |
|
|
| theorem block_injective : Function.Injective C.block := by |
| intro a b h |
| exact C.injective (List.cons.inj h).2 |
|
|
| theorem prefix_decode {u v : List A} {y : List S} (h : C.encode v = C.encode u ++ y) : |
| ∃ w, v = u++w ∧ y = C.encode w := by |
| induction u generalizing v with |
| | nil => exact ⟨v,rfl,h.symm⟩ |
| | cons a u ih => |
| cases v with |
| | nil => simp [block] at h |
| | cons b v => |
| simp only [encode_cons,List.append_assoc] at h |
| obtain ⟨hab,ht⟩ := List.append_inj h (by simp) |
| have : b=a := C.block_injective hab |
| subst b |
| obtain ⟨w,rfl,rfl⟩ := ih ht |
| exact ⟨w,rfl,rfl⟩ |
|
|
| theorem encode_injective : Function.Injective C.encode := by |
| intro u v h |
| obtain ⟨w,hu,hw⟩ := C.prefix_decode (y := []) (by simpa using h) |
| have he := congrArg List.length hw |
| have : w=[] := by simpa using he |
| simpa [this] using hu |
|
|
| theorem split_past_avoiding {b : S} {t z x y : List S} (ht : b ∉ t) |
| (h : t++z = x++b::y) : ∃ x', x=t++x' ∧ z=x'++b::y := by |
| induction t generalizing x with |
| | nil => exact ⟨x,rfl,h⟩ |
| | cons a t ih => |
| cases x with |
| | nil => |
| have ha : a=b := (List.cons.inj h).1 |
| exact False.elim (ht (by simp [ha])) |
| | cons c x => |
| obtain ⟨rfl,htail⟩ := List.cons.inj h |
| obtain ⟨x',rfl,hz⟩ := ih (fun hh => ht (List.mem_cons_of_mem _ hh)) htail |
| exact ⟨x',rfl,hz⟩ |
|
|
| /-- Every marker inside an encoded word starts a complete generator block. -/ |
| theorem marker_alignment {v : List A} {x y : List S} |
| (h : C.encode v = x ++ C.marker :: y) : |
| ∃ u a w, v=u++a::w ∧ x=C.encode u ∧ y=C.tail a ++ C.encode w := by |
| induction v generalizing x with |
| | nil => simp at h |
| | cons a v ih => |
| cases x with |
| | nil => |
| have hy : C.tail a ++ C.encode v = y := (List.cons.inj h).2 |
| exact ⟨[],a,v,rfl,rfl,hy.symm⟩ |
| | cons b x => |
| obtain ⟨hb,hv⟩ := List.cons.inj h |
| subst b |
| obtain ⟨x',rfl,hv'⟩ := split_past_avoiding (C.tail_avoids a) hv |
| obtain ⟨u,b,w,rfl,hx,hy⟩ := ih hv' |
| exact ⟨a::u,b,w,rfl,by simp [block,hx],hy⟩ |
|
|
| /-- A nonempty code occurrence in a code sequence has both boundaries aligned. -/ |
| theorem occurrence_decode {v u : List A} (hu : u≠[]) {x y : List S} |
| (h : C.encode v = x++C.encode u++y) : |
| ∃ p q, v=p++u++q ∧ x=C.encode p ∧ y=C.encode q := by |
| cases u with |
| | nil => contradiction |
| | cons a u => |
| have hm : C.encode v = x++C.marker::(C.tail a++C.encode u++y) := by |
| simpa [block,List.append_assoc] using h |
| obtain ⟨p,b,w,hv,rfl,hy⟩ := C.marker_alignment hm |
| have hh : C.encode (b::w) = C.encode (a::u)++y := by |
| apply List.append_cancel_left (as := C.encode p) |
| simpa only [hv,encode_append,List.append_assoc] using h |
| obtain ⟨q,hq,hqy⟩ := C.prefix_decode hh |
| refine ⟨p,q,?_,rfl,hqy⟩ |
| rw [hv,hq,List.append_assoc] |
|
|
| /-- Overlapping code left sides have a union which is itself a full code; |
| the common part is an entire (nonempty) code suffix/prefix. -/ |
| theorem overlap_decode {u v : List A} {p middle q : List S} |
| (hm : middle≠[]) (h₁ : C.encode u = p++middle) |
| (h₂ : C.encode v = middle++q) : |
| ∃ a b c, u=a++b ∧ v=b++c ∧ p=C.encode a ∧ |
| middle=C.encode b ∧ q=C.encode c := by |
| cases v with |
| | nil => simp at h₂; exact False.elim (hm h₂.1) |
| | cons v vs => |
| cases middle with |
| | nil => contradiction |
| | cons m middle => |
| have hmark : m=C.marker := (List.cons.inj h₂).1.symm |
| subst m |
| obtain ⟨a,b,bs,hu,hp,ht⟩ := C.marker_alignment h₁ |
| have hs : C.marker::middle = C.encode (b::bs) := by simp [block,ht] |
| have hv : C.encode (v::vs) = C.encode (b::bs)++q := by simpa [hs] using h₂ |
| obtain ⟨c,hv,hq⟩ := C.prefix_decode hv |
| exact ⟨a,b::bs,c,hu,hv,hp,hs,hq⟩ |
|
|
| theorem encode_avoids {s : S} (hm : s≠C.marker) (ht : ∀ a, s∉C.tail a) |
| (u : List A) : s ∉ C.encode u := by |
| simp only [encode,List.mem_flatMap,block,List.mem_cons] |
| rintro ⟨a,_,h | h⟩ |
| · exact hm h |
| · exact ht a h |
|
|
| theorem lex_append_two {r : S → S → Prop} {u v : List S} |
| (h : List.Lex r u v) (hlen : u.length=v.length) (x y : List S) : |
| List.Lex r (u++x) (v++y) := by |
| induction h with |
| | nil => simp at hlen |
| | rel hh => exact .rel hh |
| | cons h ih => exact .cons (ih (by simpa using hlen)) |
|
|
| /-- The chosen generator order is transported from the equal-width blocks. -/ |
| theorem encode_lex {r : A → A → Prop} {s : S → S → Prop} |
| (hblock : ∀ a b, r a b → List.Lex s (C.block a) (C.block b)) |
| {u v : List A} (h : List.Lex r u v) : List.Lex s (C.encode u) (C.encode v) := by |
| induction h with |
| | nil => exact List.Lex.nil |
| | rel hh => exact lex_append_two (hblock _ _ hh) (by simp) _ _ |
| | @cons a u v hh ih => exact List.Lex.append_left s ih (C.block a) |
|
|
| theorem encode_shortlex {r : A → A → Prop} {s : S → S → Prop} |
| (hblock : ∀ a b, r a b → List.Lex s (C.block a) (C.block b)) |
| {u v : List A} (h : List.Shortlex r u v) : List.Shortlex s (C.encode u) (C.encode v) := by |
| rcases List.shortlex_def.mp h with hl | ⟨hl,hlex⟩ |
| · exact List.Shortlex.of_length_lt (by simpa using Nat.mul_lt_mul_of_pos_left hl (Nat.succ_pos C.width)) |
| · exact List.Shortlex.of_lex (by simp [hl]) (C.encode_lex hblock hlex) |
|
|
| end BlockCode |
|
|
| /-- An explicit computable constant-width binary tail family. Choosing the |
| generator order by its lexicographic order implements the source convention. |
| The generous width still obeys D₀>M=2, with no machine-size restriction. -/ |
| def binaryTail {S : Type*} (a c : S) (m : ℕ) (i : Fin m) : List S := |
| List.replicate i.val a ++ c :: List.replicate (m+1-i.val) a |
|
|
| @[simp] theorem binaryTail_length {S : Type*} (a c : S) (m : ℕ) (i : Fin m) : |
| (binaryTail a c m i).length=m+2 := by |
| simp only [binaryTail,List.length_append,List.length_replicate,List.length_cons] |
| have hi := i.isLt |
| omega |
|
|
| theorem binaryTail_injective {S : Type*} [DecidableEq S] {a c : S} (hac : a≠c) (m : ℕ) : |
| Function.Injective (binaryTail a c m) := by |
| have hx (i : Fin m) : (binaryTail a c m i).idxOf c=i.val := by |
| rw [binaryTail,List.idxOf_append_of_notMem (by simp [hac.symm])] |
| simp |
| intro i j he |
| apply Fin.ext |
| simpa only [hx] using congrArg (List.idxOf c) he |
|
|
| def binaryCode {S : Type*} [DecidableEq S] (b a c : S) |
| (hba : b≠a) (hbc : b≠c) (hac : a≠c) (m : ℕ) : BlockCode (Fin m) S where |
| marker := b |
| tail := binaryTail a c m |
| width := m+2 |
| tail_length := binaryTail_length a c m |
| tail_avoids := by intro i; simp [binaryTail,hba,hbc] |
| injective := binaryTail_injective hac m |
|
|
| namespace Canonical |
| variable {A Q : Type*} {r : A → A → Prop} (wf : WellFounded r) |
| variable (q : List A → Q) |
|
|
| /-- Exactly the bounded tested-class candidate set in the self-reference construction. -/ |
| def candidates (w : List A) : Set (List A) := {v | v.length ≤ w.length ∧ q v=q w} |
|
|
| noncomputable def least (w : List A) : List A := |
| (List.Shortlex.wf wf).min (candidates q w) ⟨w,le_rfl,rfl⟩ |
|
|
| theorem least_mem (w : List A) : least wf q w ∈ candidates q w := |
| (List.Shortlex.wf wf).min_mem _ _ |
|
|
| theorem least_length (w : List A) : (least wf q w).length ≤ w.length := |
| (least_mem wf q w).1 |
|
|
| theorem least_class (w : List A) : q (least wf q w)=q w := (least_mem wf q w).2 |
|
|
| theorem least_min {w v : List A} (hv : v.length≤w.length) (hq : q v=q w) : |
| ¬ List.Shortlex r v (least wf q w) := |
| (List.Shortlex.wf wf).not_lt_min (candidates q w) ⟨hv,hq⟩ |
|
|
| theorem least_lt_or_eq [Std.Trichotomous r] (w : List A) : |
| List.Shortlex r (least wf q w) w ∨ least wf q w=w := by |
| have hh := Std.Trichotomous.trichotomous (r := List.Shortlex r) (least wf q w) w |
| by_cases h : List.Shortlex r (least wf q w) w |
| · exact Or.inl h |
| · exact Or.inr (hh h (least_min wf q le_rfl rfl)) |
|
|
| theorem least_global_min {w v : List A} (hq : q v=q w) : ¬ List.Shortlex r v (least wf q w) := by |
| intro hd |
| have hlen : v.length≤w.length := by |
| have hm := least_length wf q w |
| have he := List.shortlex_def.mp hd |
| omega |
| exact least_min wf q hlen hq hd |
|
|
| /-- Changing the finite search bound to that of another same-class candidate |
| cannot change the result, including when the result is empty. -/ |
| theorem least_congr [Std.Trichotomous r] {u v : List A} (hq : q u=q v) : |
| least wf q u=least wf q v := by |
| apply Std.Trichotomous.trichotomous (r := List.Shortlex r) |
| · exact least_global_min wf q ((least_class wf q u).trans hq) |
| · exact least_global_min wf q ((least_class wf q v).trans hq.symm) |
|
|
| theorem least_idem [Std.Trichotomous r] (w : List A) : |
| least wf q (least wf q w)=least wf q w := |
| least_congr wf q (least_class wf q w) |
|
|
| theorem least_nil : least wf q []=[] := by |
| have hh := least_length wf q [] |
| simpa using hh |
|
|
| /-- Literal characterization which requires no class tests longer than w. -/ |
| theorem eq_least_iff [Std.Trichotomous r] {w v : List A} : v=least wf q w ↔ |
| v.length≤w.length ∧ q v=q w ∧ |
| ∀ t, t.length≤w.length → q t=q w → ¬ List.Shortlex r t v := by |
| constructor |
| · rintro rfl |
| exact ⟨least_length wf q w,least_class wf q w,fun _ ht hq => least_min wf q ht hq⟩ |
| · rintro ⟨hv,hq,hm⟩ |
| exact Std.Trichotomous.trichotomous _ _ |
| (least_min wf q hv hq) (hm _ (least_length wf q w) (least_class wf q w)) |
|
|
| end Canonical |
|
|
| open Relation |
| variable {S : Type*} |
|
|
| theorem step_mono {rs rt : List (List S × List S)} (h : ∀ p∈rs, p∈rt) |
| {u v : List S} (huv : Step rs u v) : Step rt u v := by |
| cases huv with |
| | apply hp x y => exact .apply (h _ hp) x y |
|
|
| theorem steps_mono {rs rt : List (List S × List S)} (h : ∀ p∈rs, p∈rt) |
| {u v : List S} (huv : Steps rs u v) : Steps rt u v := by |
| induction huv with |
| | refl => exact .refl |
| | tail hh hs ih => exact .tail ih (step_mono h hs) |
|
|
| /-- The absorbing equations, stated as finite-table membership, not as an |
| additional computation oracle. -/ |
| def Absorbs (rs : List (List S × List S)) (z : S) : Prop := |
| ∀ a, ([z,a],[z])∈rs ∧ ([a,z],[z])∈rs |
|
|
| theorem absorbs_context {rs : List (List S × List S)} {z : S} (hz : Absorbs rs z) |
| (x y : List S) : Steps rs (x++[z]++y) [z] := by |
| have hr : ∀ y : List S, Steps rs ([z]++y) [z] := by |
| intro y |
| induction y with |
| | nil => exact .refl |
| | cons a y ih => |
| have hs : Steps rs ([z]++a::y) ([z]++y) := |
| .single (by simpa using Step.apply (hz a).1 [] y) |
| exact hs.trans ih |
| induction x with |
| | nil => exact hr y |
| | cons a x ih => |
| have hh := steps_context ih [a] [] |
| have hs : Step rs [a,z] [z] := by simpa using Step.apply (hz a).2 [] [] |
| have hh' : Steps rs (a::x++[z]++y) [a,z] := by simpa using hh |
| exact hh'.trans (.single hs) |
|
|
| theorem absorbs_mem {rs : List (List S × List S)} {z : S} (hz : Absorbs rs z) |
| {w : List S} (hw : z∈w) : Steps rs w [z] := by |
| induction w with |
| | nil => simp at hw |
| | cons a w ih => |
| rcases List.mem_cons.mp hw with rfl | hw |
| · exact absorbs_context hz [] w |
| · have hh := steps_context (ih hw) [a] [] |
| have hh' : Steps rs (a::w) [a,z] := by simpa using hh |
| exact hh'.trans (.single (by simpa using Step.apply (hz a).2 [] [])) |
|
|
| theorem step_preserves_letter {rs : List (List S × List S)} {z : S} |
| (hz : ∀ p∈rs, z∈p.1 → z∈p.2) {w v : List S} (hw : z∈w) (h : Step rs w v) : z∈v := by |
| cases h with |
| | apply hp x y => |
| simp only [List.mem_append] at hw ⊢ |
| rcases hw with (hx | hu) | hy |
| · exact Or.inl (Or.inl hx) |
| · exact Or.inl (Or.inr (hz _ hp hu)) |
| · exact Or.inr hy |
|
|
| namespace Static |
| variable {A Q : Type*} [Fintype A] [DecidableEq S] |
| variable {r : A → A → Prop} |
| variable (C : BlockCode A S) (wf : WellFounded r) (q : List A → Option Q) (z : S) |
|
|
| noncomputable def letters (A : Type*) [Fintype A] : List A := (Finset.univ : Finset A).toList |
| noncomputable def words (A : Type*) [Fintype A] : ℕ → List (List A) |
| | 0 => [[]] |
| | n+1 => [] :: (letters A).flatMap (fun a => (words A n).map (a::·)) |
|
|
| @[simp] theorem mem_words (n : ℕ) (w : List A) : w∈words A n ↔ w.length≤n := by |
| classical |
| induction n generalizing w with |
| | zero => simp [words] |
| | succ n ih => |
| cases w with |
| | nil => simp [words] |
| | cons a w => simp [words,letters,ih] |
|
|
| noncomputable def output (v : List A) : List S := |
| if q v=none then [z] else C.encode (Canonical.least wf q v) |
|
|
| noncomputable def table (n : ℕ) : List (List S × List S) := |
| ((words A n).filter fun v => v≠[] ∧ output C wf q z v≠C.encode v).map |
| (fun v => (C.encode v,output C wf q z v)) |
|
|
| theorem mem_table {n : ℕ} {a b : List S} : (a,b)∈table C wf q z n ↔ |
| ∃ v, v.length≤n ∧ v≠[] ∧ output C wf q z v≠C.encode v ∧ |
| a=C.encode v ∧ b=output C wf q z v := by |
| simp only [table,List.mem_map,List.mem_filter,mem_words,decide_eq_true_eq,Prod.mk.injEq] |
| aesop |
|
|
| omit [Fintype A] [DecidableEq S] in |
| theorem output_congr [Std.Trichotomous r] {u v : List A} (hq : q u=q v) : |
| output C wf q z u=output C wf q z v := by |
| simp only [output,hq,Canonical.least_congr wf q hq] |
|
|
| omit [Fintype A] [DecidableEq S] in |
| theorem output_nil (hzero : q []≠none) : output C wf q z []=[] := by |
| simp [output,hzero,Canonical.least_nil] |
|
|
| theorem whole_steps (hzero : q []≠none) {n : ℕ} {v : List A} (hv : v.length≤n) : |
| Steps (table C wf q z n) (C.encode v) (output C wf q z v) := by |
| by_cases hn : v=[] |
| · subst v |
| rw [C.encode_nil,output_nil C wf q z hzero] |
| by_cases he : output C wf q z v=C.encode v |
| · rw [he] |
| · exact .single (by simpa using Step.apply ((mem_table C wf q z).mpr ⟨v,hv,hn,he,rfl,rfl⟩) [] []) |
|
|
| /-- Precisely the bounded contextual tests used at source bootstrap:273–297. -/ |
| def Contextual (n : ℕ) : Prop := |
| ∀ a b u v : List A, (a++u++b).length≤n → (a++v++b).length≤n → q u=q v → |
| q (a++u++b)=q (a++v++b) |
|
|
| def ZeroIdeal (n : ℕ) : Prop := |
| ∀ a b u : List A, (a++u++b).length≤n → q u=none → q (a++u++b)=none |
|
|
| variable [Std.Trichotomous r] |
|
|
| /-- A single contextual static replacement inside a full code reduces to the |
| same literal whole-code output. Both endpoint bounds are proved separately. -/ |
| theorem branch_normalizes {n : ℕ} {rs : List (List S × List S)} |
| (hzero : q []≠none) (hz : Absorbs rs z) |
| (ht : ∀ p∈table C wf q z n, p∈rs) |
| (hc : Contextual q n) (hi : ZeroIdeal q n) |
| {v : List A} {a b : List A} (hlen : (a++v++b).length≤n) : |
| Steps rs (C.encode a++output C wf q z v++C.encode b) (output C wf q z (a++v++b)) := by |
| by_cases hq : q v=none |
| · have hzq := hi a b v hlen hq |
| simp only [output,ite_eq_left hq,ite_eq_left hzq] |
| exact absorbs_context hz _ _ |
| · let v' := Canonical.least wf q v |
| have hlen' : (a++v'++b).length≤n := by |
| have hh := Canonical.least_length wf q v |
| simp only [List.length_append] at hlen ⊢ |
| dsimp only [v'] |
| omega |
| have hqq : q (a++v'++b)=q (a++v++b) := |
| hc a b v' v hlen' hlen (Canonical.least_class wf q v) |
| have hh := steps_mono ht (whole_steps C wf q z hzero hlen') |
| rw [output_congr C wf q z hqq] at hh |
| simpa only [output,ite_eq_right hq,BlockCode.encode_append,v'] using hh |
|
|
| /-- Contained code occurrences are aligned, so the preceding branch analysis |
| applies at exactly the source code boundaries. -/ |
| theorem occurrence_normalizes {n : ℕ} {rs : List (List S × List S)} |
| (hzero : q []≠none) (hz : Absorbs rs z) |
| (ht : ∀ p∈table C wf q z n, p∈rs) |
| (hc : Contextual q n) (hi : ZeroIdeal q n) |
| {w v : List A} {x y : List S} (hw : w.length≤n) (hv : v≠[]) |
| (he : C.encode w=x++C.encode v++y) : |
| Steps rs (x++output C wf q z v++y) (output C wf q z w) := by |
| obtain ⟨a,b,rfl,rfl,rfl⟩ := C.occurrence_decode hv he |
| exact branch_normalizes C wf q z hzero hz ht hc hi hw |
|
|
| /-- Static containment criticals join at the canonical output of the union. -/ |
| theorem critical_containment {n k l : ℕ} {rs : List (List S × List S)} |
| (hzero : q []≠none) (hz : Absorbs rs z) |
| (ht : ∀ p∈table C wf q z n, p∈rs) |
| (hc : Contextual q n) (hi : ZeroIdeal q n) |
| {u u' v v' x y : List S} |
| (hu : (u,u')∈table C wf q z k) (hv : (v,v')∈table C wf q z l) |
| (he : u=x++v++y) (hlen : u.length≤(C.width+1)*n) : |
| Join (Steps rs) u' (x++v'++y) := by |
| obtain ⟨a,_,_,_,rfl,rfl⟩ := (mem_table C wf q z).mp hu |
| obtain ⟨b,_,hbn,_,rfl,rfl⟩ := (mem_table C wf q z).mp hv |
| have ha : a.length≤n := by |
| rw [C.encode_length] at hlen |
| exact Nat.le_of_mul_le_mul_left hlen (by omega) |
| exact ⟨output C wf q z a,.refl, |
| occurrence_normalizes C wf q z hzero hz ht hc hi ha hbn he⟩ |
|
|
| /-- Static boundary criticals have a full, aligned code union, and both |
| contextual branches reach its same literal output. -/ |
| theorem critical_overlap {n k l : ℕ} {rs : List (List S × List S)} |
| (hzero : q []≠none) (hz : Absorbs rs z) |
| (ht : ∀ p∈table C wf q z n, p∈rs) |
| (hc : Contextual q n) (hi : ZeroIdeal q n) |
| {u u' v v' x middle y : List S} |
| (hu : (u,u')∈table C wf q z k) (hv : (v,v')∈table C wf q z l) |
| (hm : middle≠[]) (he : u=x++middle) (hf : v=middle++y) |
| (hlen : (x++middle++y).length≤(C.width+1)*n) : |
| Join (Steps rs) (u'++y) (x++v') := by |
| obtain ⟨a,_,_,_,rfl,rfl⟩ := (mem_table C wf q z).mp hu |
| obtain ⟨b,_,_,_,rfl,rfl⟩ := (mem_table C wf q z).mp hv |
| obtain ⟨c,d,e,rfl,rfl,rfl,rfl,rfl⟩ := C.overlap_decode hm he hf |
| have hlen' : (c++d++e).length≤n := by |
| have hh : (C.encode (c++d++e)).length≤(C.width+1)*n := by |
| simpa only [BlockCode.encode_append] using hlen |
| rw [C.encode_length] at hh |
| exact Nat.le_of_mul_le_mul_left hh (by omega) |
| refine ⟨output C wf q z (c++d++e),?_,?_⟩ |
| · simpa only [List.nil_append,BlockCode.encode_nil] using |
| branch_normalizes C wf q z hzero hz ht hc hi (a := []) (v := c++d) (b := e) |
| (by simpa only [List.nil_append] using hlen') |
| · simpa only [List.append_nil,BlockCode.encode_nil,List.append_assoc] using |
| branch_normalizes C wf q z hzero hz ht hc hi (a := c) (v := d++e) (b := []) |
| (by simpa only [List.append_nil,List.append_assoc] using hlen') |
|
|
| end Static |
| end FiniteAlgebraicEnvelopes.Bootstrap |
|
|
| end OAI |
|
|
