| import Mathlib |
| import OAI.Computability.FiniteCompiler.Quotients |
| import OAI.Computability.FiniteCompiler.SelfReference |
| import OAI.Computability.FiniteCompiler.UniformPaths |
| import OAI.GroupTheory.BooneHigman.Basic |
| import OAI.GroupTheory.BooneHigman.PartialAffine |
| import OAI.GroupTheory.BooneHigman.WordProblem |
| import OAI.GroupTheory.SimpleOvergroups.TruncatedAlgebra |
|
|
| namespace OAI |
|
|
|
|
| namespace SimpleFInftyOvergroups.ContextualEncoding |
| open FiniteAlgebraicEnvelopes Bootstrap BoundedEncoding |
| noncomputable section |
| open scoped Classical |
|
|
| namespace GroupFamily |
| variable {G : Type*} [Group G] {k : ℕ} (s : Fin k → G) |
|
|
| def test (w : List (Fin k × Bool)) : Part (Option (List (Fin k × Bool))) := |
| Part.some (some (WordProblem.testedClass s w)) |
|
|
| theorem partrec_test (h : ComputablePred (fun w => FiniteAlgebraicEnvelopes.evalWord s w = 1)) : |
| Partrec (test s) := |
| (Primrec.option_some.to_comp.comp (WordProblem.computable_testedClass s h)).partrec |
|
|
| theorem context {u v : List (Fin k × Bool)} (h : WordProblem.testedClass s u = WordProblem.testedClass s v) |
| (a b : List (Fin k × Bool)) : |
| WordProblem.testedClass s (a++u++b) = WordProblem.testedClass s (a++v++b) := by |
| apply (WordProblem.testedClass_eq_iff s _ _).mpr |
| simp only [WordProblem.evalWord_append] |
| rw [(WordProblem.testedClass_eq_iff s _ _).mp h] |
| end GroupFamily |
|
|
| namespace ProductFamily |
| variable {A : Type*} |
| abbrev Letter (A : Type*) := A ⊕ PartialAffine.Letter |
| abbrev Key (A : Type*) := List A × List PartialAffine.Letter |
|
|
| def cost (c : A → ℕ) : Letter A → ℕ := Sum.elim c (fun _ => 0) |
| def wordCost (c : A → ℕ) (w : List (Letter A)) : ℕ := (w.map (cost c)).sum |
|
|
| @[simp] theorem wordCost_append (c : A → ℕ) (u v : List (Letter A)) : |
| wordCost c (u++v) = wordCost c u + wordCost c v := by simp [wordCost] |
|
|
| theorem wordCost_projection (c : A → ℕ) (w : List (Letter A)) : |
| wordCost c w = ((Projection.left w).map c).sum := by |
| induction w with |
| | nil => rfl |
| | cons a w ih => |
| cases a <;> simp only [wordCost, List.map_cons, cost, Sum.elim_inl, Sum.elim_inr, |
| List.sum_cons, Projection.left, List.filterMap_cons, List.map_cons, List.sum_cons, zero_add] |
| · exact congrArg (c _ + ·) ih |
| · exact ih |
| |
| variable [DecidableEq A] |
| def combine (zero : List A) (q : Key A) : Option (Key A) := |
| if q.1 = zero then none else some q |
|
|
| def test (zero : List A) (f : List A → Part (List A)) (w : List (Letter A)) : |
| Part (Option (Key A)) := |
| (f (Projection.left w)).map (fun u => combine zero (u,PartialAffine.testedClass (Projection.right w))) |
|
|
| variable {m : ℕ} (C : WordCalculus (FreeMonoid A) m) |
|
|
| def normal (w : List (Letter A)) : List A := |
| (C.normal (FreeMonoid.ofList (Projection.left w))).toList |
|
|
| def value (w : List (Letter A)) : Option (Key A) := |
| combine C.omega.toList (normal C w,PartialAffine.testedClass (Projection.right w)) |
|
|
| def grade (w : List (Letter A)) : ℕ := C.grade (FreeMonoid.ofList (Projection.left w)) |
|
|
| omit [DecidableEq A] in |
| @[simp] theorem grade_nil : grade C [] = 0 := C.grade_one |
| omit [DecidableEq A] in |
| @[simp] theorem grade_append (u v : List (Letter A)) : grade C (u++v) = grade C u + grade C v := by |
| simp only [grade, Projection.left_append, FreeMonoid.ofList_append, C.grade_mul] |
|
|
| omit [DecidableEq A] in |
| theorem grade_cost (g : A → ℕ) (hg : ∀ u, C.grade (FreeMonoid.ofList u) = (u.map g).sum) |
| (w : List (Letter A)) : grade C w = wordCost g w := by |
| rw [grade, hg, wordCost_projection] |
|
|
| omit [DecidableEq A] in |
| theorem normal_context {u v : List (Letter A)} (h : normal C u = normal C v) |
| (a b : List (Letter A)) (hu : grade C (a++u++b) ≤ m) (hv : grade C (a++v++b) ≤ m) : |
| normal C (a++u++b) = normal C (a++v++b) := by |
| apply congrArg FreeMonoid.toList |
| simp only [grade, Projection.left_append, FreeMonoid.ofList_append] at hu hv ⊢ |
| exact C.context (FreeMonoid.toList.injective h) _ _ hu hv |
|
|
| omit [DecidableEq A] in |
| theorem normal_zero_context {u : List (Letter A)} (h : normal C u = C.omega.toList) |
| (a b : List (Letter A)) (hu : grade C (a++u++b) ≤ m) : |
| normal C (a++u++b) = C.omega.toList := by |
| apply congrArg FreeMonoid.toList |
| have he : C.normal (FreeMonoid.ofList (Projection.left u)) = C.normal C.omega := by |
| rw [C.normal_omega] |
| exact FreeMonoid.toList.injective h |
| have hb : C.grade (FreeMonoid.ofList (Projection.left a) * C.omega * FreeMonoid.ofList (Projection.left b)) ≤ m := by |
| simp only [grade, Projection.left_append, FreeMonoid.ofList_append, C.grade_mul] at hu |
| simp only [C.grade_mul, C.grade_omega] |
| omega |
| simp only [grade, Projection.left_append, FreeMonoid.ofList_append] at hu ⊢ |
| exact (C.context he _ _ hu hb).trans (C.absorbs _ _) |
|
|
| theorem value_context {u v : List (Letter A)} (h : value C u = value C v) |
| (a b : List (Letter A)) (hu : grade C (a++u++b) ≤ m) (hv : grade C (a++v++b) ≤ m) : |
| value C (a++u++b) = value C (a++v++b) := by |
| by_cases hz : normal C u = C.omega.toList |
| · have hvz : normal C v = C.omega.toList := by |
| by_contra hvz |
| simp [value, combine, hz, hvz] at h |
| simp only [value, combine, normal_zero_context C hz a b hu, |
| normal_zero_context C hvz a b hv, ite_true] |
| · have hvz : normal C v ≠ C.omega.toList := by |
| intro hvz |
| simp [value, combine, hz, hvz] at h |
| have he : normal C u = normal C v ∧ |
| PartialAffine.testedClass (Projection.right u) = PartialAffine.testedClass (Projection.right v) := by |
| simpa only [value,combine,ite_eq_right hz,ite_eq_right hvz,Option.some.injEq,Prod.mk.injEq] using h |
| have hcontext : PartialAffine.testedClass (Projection.right (a++u++b)) = |
| PartialAffine.testedClass (Projection.right (a++v++b)) := by |
| apply (PartialAffine.testedClass_eq_iff _ _).mpr |
| have hmaps := (PartialAffine.testedClass_eq_iff _ _).mp he.2 |
| simp only [PartialAffine.value] at hmaps |
| simp only [Projection.right_append, PartialAffine.value, List.map_append, List.prod_append] |
| rw [hmaps] |
| simp only [value, normal_context C he.1 a b hu hv, hcontext] |
|
|
| theorem value_zero_context {u : List (Letter A)} (h : value C u = none) |
| (a b : List (Letter A)) (hu : grade C (a++u++b) ≤ m) : value C (a++u++b) = none := by |
| have hz : normal C u = C.omega.toList := by simpa [value,combine] using h |
| simp only [value,combine,normal_zero_context C hz a b hu,ite_true] |
|
|
| @[simp] theorem value_nil : value C [] ≠ none := by |
| have hn : normal C [] ≠ C.omega.toList := by |
| intro h |
| have he := FreeMonoid.toList.injective h |
| exact C.omega_ne_one (by simpa only [Projection.left, List.filterMap_nil, FreeMonoid.ofList_nil, C.normal_one] using he.symm) |
| simp only [value,combine,ite_eq_right hn,ne_eq,Option.some_ne_none,not_false_eq_true] |
|
|
| theorem test_full {f : List A → Part (List A)} {d : ℕ} (w : List (Letter A)) |
| (hw : grade C w ≤ d) |
| (hf : ∀ u, C.grade (FreeMonoid.ofList u) ≤ d → (C.normal (FreeMonoid.ofList u)).toList ∈ f u) : |
| value C w ∈ test C.omega.toList f w := |
| (Part.mem_map_iff _).mpr ⟨_,hf _ hw,rfl⟩ |
|
|
| variable [Primcodable A] |
| theorem primrec_combine (zero : List A) : Primrec (combine zero) := |
| Primrec.ite (Primrec.eq.comp Primrec.fst (Primrec.const _)) (Primrec.const none) |
| (Primrec.option_some.comp Primrec.id) |
|
|
| omit [DecidableEq A] in |
| theorem primrec_cost {c : A → ℕ} (hc : Primrec c) : Primrec (cost c) := |
| Effect.primrec_sumElim hc (Primrec.const 0) |
|
|
| theorem partrec_test {P : Type*} [Primcodable P] {f : P → List A → Part (List A)} |
| (zero : List A) (hf : Partrec₂ f) : Partrec₂ (fun p => test zero (f p)) := by |
| have hp : Partrec₂ (fun p (w : List (Letter A)) => f p (Projection.left w)) := |
| hf.comp Computable.fst (Projection.primrec_left.to_comp.comp Computable.snd) |
| exact (hp.map ((primrec_combine zero).to_comp.comp |
| (Computable.snd.pair (PartialAffine.computable_testedClass.comp |
| (Projection.primrec_right.to_comp.comp (Computable.snd.comp Computable.fst))))).to₂).to₂ |
| end ProductFamily |
| end |
| end SimpleFInftyOvergroups.ContextualEncoding |
|
|
| end OAI |
|
|
