openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Definability /ExternalWordRewriteRelations.lean
| import Mathlib.GroupTheory.CoprodI | |
| import Mathlib.GroupTheory.FreeGroup.Reduce | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.RectangleTile | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Compression.RecursiveMaps.CosetGeometry | |
| universe u | |
| variable (J S : Type u) [Group J] | |
| def Factor : Bool → Type u | |
| | false => J | |
| | true => FreeGroup S | |
| instance factorGroup (b : Bool) : Group (Factor J S b) := by | |
| cases b <;> dsimp [Factor] <;> infer_instance | |
| abbrev External := Monoid.CoprodI (Factor J S) | |
| def old : J →* External J S := Monoid.CoprodI.of (M := Factor J S) (i := false) | |
| def free : FreeGroup S →* External J S := Monoid.CoprodI.of (M := Factor J S) (i := true) | |
| def generator (s : S) : External J S := free J S (FreeGroup.of s) | |
| def signed (a : S × Bool) : External J S := free J S (FreeGroup.mk [a]) | |
| theorem old_injective : Function.Injective (old J S) := Monoid.CoprodI.of_injective (M := Factor J S) false | |
| def Cancel (a b : S × Bool) : Prop := a.1 = b.1 ∧ a.2 = !b.2 | |
| def Reduced : List ((S × Bool) × J) → Prop | |
| | [] => True | |
| | [_] => True | |
| | x :: y :: rest => (x.2 = 1 → ¬ Cancel S x.1 y.1) ∧ Reduced (y :: rest) | |
| def eval : List ((S × Bool) × J) → External J S | |
| | [] => 1 | |
| | (a, j) :: rest => signed J S a * old J S j * eval rest | |
| open Monoid.CoprodI | |
| noncomputable def oldWord (j : J) : Word (Factor J S) := by | |
| classical | |
| exact if h : j = 1 then Word.empty else Word.cons (i := false) j Word.empty (by simp [Word.fstIdx, Word.empty]) h | |
| theorem oldWord_prod (j : J) : (oldWord J S j).prod = old J S j := by | |
| classical | |
| by_cases h : j = 1 | |
| · subst j | |
| rw [oldWord, dite_eq_left rfl] | |
| exact (map_one (old J S)).symm | |
| · rw [oldWord, dite_eq_right h] | |
| exact (Word.prod_cons (M := Factor J S) false j Word.empty h _).trans (mul_one _) | |
| theorem oldWord_not_free (j : J) : (oldWord J S j).fstIdx ≠ some true := by | |
| classical | |
| by_cases h : j = 1 | |
| · simp [oldWord, h, Word.fstIdx, Word.empty] | |
| · rw [oldWord, dite_eq_right h] | |
| change (some false : Option Bool) ≠ some true | |
| decide | |
| theorem free_head_not_old (w : Word (Factor J S)) (head : w.fstIdx = some true) (j : J) : | |
| w.prod ≠ old J S j := by | |
| classical | |
| intro eq | |
| have same : w = oldWord J S j := by | |
| apply (Word.equiv (M := Factor J S)).symm.injective | |
| exact eq.trans (oldWord_prod J S j).symm | |
| exact oldWord_not_free J S j (same ▸ head) | |
| variable [DecidableEq S] | |
| theorem free_prepend (a b : S × Bool) (f : FreeGroup S) | |
| (head : f.toWord.head? = some b) (safe : ¬ Cancel S a b) : | |
| (FreeGroup.mk (a :: f.toWord)).toWord = a :: f.toWord := by | |
| classical | |
| rw [FreeGroup.toWord_mk, FreeGroup.reduce.cons, FreeGroup.reduce_toWord] | |
| cases h : f.toWord with | |
| | nil => simp [h] at head | |
| | cons c rest => | |
| have cb : c = b := by simpa [h] using head | |
| subst c | |
| change (if a.1 = b.1 ∧ a.2 = !b.2 then rest else a :: b :: rest) = a :: b :: rest | |
| change ¬ (a.1 = b.1 ∧ a.2 = !b.2) at safe | |
| rw [ite_eq_right safe] | |
| theorem signed_mul_free (a : S × Bool) (f : FreeGroup S) : | |
| signed J S a * free J S f = free J S (FreeGroup.mk (a :: f.toWord)) := by | |
| change free J S (FreeGroup.mk [a]) * free J S f = _ | |
| rw [← map_mul] | |
| apply congrArg (free J S) | |
| calc | |
| FreeGroup.mk [a] * f = FreeGroup.mk [a] * FreeGroup.mk f.toWord := by rw [FreeGroup.mk_toWord] | |
| _ = _ := FreeGroup.mul_mk | |
| theorem head_nontrivial (a : S × Bool) (f : FreeGroup S) | |
| (head : f.toWord.head? = some a) : f ≠ 1 := by | |
| intro eq | |
| simp [eq] at head | |
| theorem relative_normal_form (a : S × Bool) (j : J) (rest : List ((S × Bool) × J)) | |
| (reduced : Reduced J S ((a, j) :: rest)) : | |
| ∃ (f : FreeGroup S) (tail : Word (Factor J S)), | |
| f.toWord.head? = some a ∧ tail.fstIdx ≠ some true ∧ | |
| eval J S ((a, j) :: rest) = free J S f * tail.prod := by | |
| classical | |
| induction rest generalizing a j with | |
| | nil => | |
| refine ⟨FreeGroup.mk [a], oldWord J S j, rfl, oldWord_not_free J S j, ?_⟩ | |
| rw [oldWord_prod] | |
| exact mul_one _ | |
| | cons b rest ih => | |
| rcases b with ⟨b, k⟩ | |
| rcases ih b k reduced.2 with ⟨f, tail, first, tailHead, value⟩ | |
| by_cases jone : j = 1 | |
| · subst j | |
| have safe := reduced.1 rfl | |
| have prep := free_prepend S a b f first safe | |
| refine ⟨FreeGroup.mk (a :: f.toWord), tail, ?_, tailHead, ?_⟩ | |
| · rw [prep] | |
| rfl | |
| · change signed J S a * old J S 1 * eval J S ((b, k) :: rest) = _ | |
| rw [map_one, mul_one, value, ← mul_assoc, signed_mul_free] | |
| · let w := Word.cons (i := true) f tail tailHead (head_nontrivial S b f first) | |
| have wHead : w.fstIdx ≠ some false := by | |
| change (some true : Option Bool) ≠ some false | |
| decide | |
| let t := Word.cons (i := false) j w wHead jone | |
| refine ⟨FreeGroup.mk [a], t, rfl, ?_, ?_⟩ | |
| · change (some false : Option Bool) ≠ some true | |
| decide | |
| · change signed J S a * old J S j * eval J S ((b, k) :: rest) = | |
| signed J S a * (old J S j * (free J S f * tail.prod)) | |
| rw [value, mul_assoc] | |
| theorem reduced_not_old (a : S × Bool) (j : J) (rest : List ((S × Bool) × J)) | |
| (reduced : Reduced J S ((a, j) :: rest)) (k : J) : | |
| eval J S ((a, j) :: rest) ≠ old J S k := by | |
| classical | |
| rcases relative_normal_form J S a j rest reduced with ⟨f, tail, head, tailHead, value⟩ | |
| let w := Word.cons (i := true) f tail tailHead (head_nontrivial S a f head) | |
| have prod : w.prod = eval J S ((a, j) :: rest) := by | |
| rw [value] | |
| exact Word.prod_cons true f tail _ _ | |
| intro eq | |
| exact free_head_not_old J S w rfl k (prod.trans eq) | |
| end PartitionPilot.Compression.RecursiveMaps.CosetGeometry | |
| namespace PartitionPilot.Forcing.ExternalWordRewrite | |
| universe u | |
| abbrev Alphabet (J S : Type u) := J ⊕ (S × Bool) | |
| variable {J S : Type u} [Group J] | |
| inductive Atomic : List (Alphabet J S) → List (Alphabet J S) → Prop | |
| | old_one : Atomic [.inl 1] [] | |
| | old_mul (g h : J) : Atomic [.inl g, .inl h] [.inl (g * h)] | |
| | cancel (s : S) (b : Bool) : Atomic [.inr (s, b), .inr (s, !b)] [] | |
| def Step (xs ys : List (Alphabet J S)) : Prop := | |
| ∃ pre post l r, Atomic l r ∧ | |
| ((xs = pre ++ l ++ post ∧ ys = pre ++ r ++ post) ∨ | |
| (ys = pre ++ l ++ post ∧ xs = pre ++ r ++ post)) | |
| def Path : List (Alphabet J S) → List (Alphabet J S) → Prop := | |
| Relation.ReflTransGen Step | |
| def congruence (J S : Type u) [Group J] : Con (FreeMonoid (Alphabet J S)) := | |
| conGen Atomic | |
| theorem Atomic.step {xs ys : List (Alphabet J S)} (h : Atomic xs ys) : Step xs ys := | |
| ⟨[], [], xs, ys, h, Or.inl ⟨by simp, by simp⟩⟩ | |
| theorem Step.symm {xs ys : List (Alphabet J S)} (h : Step xs ys) : Step ys xs := by | |
| obtain ⟨pre, post, l, r, atom, eq⟩ := h | |
| exact ⟨pre, post, l, r, atom, eq.symm⟩ | |
| theorem Step.append_left (p : List (Alphabet J S)) {xs ys : List (Alphabet J S)} | |
| (h : Step xs ys) : Step (p ++ xs) (p ++ ys) := by | |
| obtain ⟨pre, post, l, r, atom, eq⟩ := h | |
| refine ⟨p ++ pre, post, l, r, atom, ?_⟩ | |
| rcases eq with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ | |
| · exact Or.inl ⟨by simp only [List.append_assoc], by simp only [List.append_assoc]⟩ | |
| · exact Or.inr ⟨by simp only [List.append_assoc], by simp only [List.append_assoc]⟩ | |
| theorem Step.append_right (p : List (Alphabet J S)) {xs ys : List (Alphabet J S)} | |
| (h : Step xs ys) : Step (xs ++ p) (ys ++ p) := by | |
| obtain ⟨pre, post, l, r, atom, eq⟩ := h | |
| refine ⟨pre, post ++ p, l, r, atom, ?_⟩ | |
| rcases eq with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ | |
| · exact Or.inl ⟨by simp only [List.append_assoc], by simp only [List.append_assoc]⟩ | |
| · exact Or.inr ⟨by simp only [List.append_assoc], by simp only [List.append_assoc]⟩ | |
| theorem Path.symm {xs ys : List (Alphabet J S)} (h : Path xs ys) : Path ys xs := by | |
| induction h with | |
| | refl => exact Relation.ReflTransGen.refl | |
| | tail _ step ih => exact ih.head step.symm | |
| theorem Path.append {xs ys zs ws : List (Alphabet J S)} (first : Path xs ys) | |
| (second : Path zs ws) : Path (xs ++ zs) (ys ++ ws) := | |
| (first.lift (fun l => l ++ zs) (fun _ _ step => step.append_right zs)).trans | |
| (second.lift (fun l => ys ++ l) (fun _ _ step => step.append_left ys)) | |
| theorem Step.to_congruence {xs ys : List (Alphabet J S)} (h : Step xs ys) : | |
| congruence J S xs ys := by | |
| obtain ⟨pre, post, l, r, atom, eq⟩ := h | |
| have core : congruence J S l r := ConGen.Rel.of (M := FreeMonoid (Alphabet J S)) _ _ atom | |
| have contextual : congruence J S (pre ++ l ++ post) (pre ++ r ++ post) := | |
| (congruence J S).mul ((congruence J S).mul ((congruence J S).refl pre) core) | |
| ((congruence J S).refl post) | |
| rcases eq with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ | |
| · exact contextual | |
| · exact (congruence J S).symm contextual | |
| theorem path_iff_conGen (xs ys : List (Alphabet J S)) : | |
| Path xs ys ↔ congruence J S xs ys := by | |
| constructor | |
| · intro path | |
| induction path with | |
| | refl => exact (congruence J S).refl _ | |
| | tail path step ih => exact (congruence J S).trans ih step.to_congruence | |
| · intro h | |
| change ConGen.Rel (M := FreeMonoid (Alphabet J S)) Atomic xs ys at h | |
| induction h with | |
| | of _ _ atom => exact Relation.ReflTransGen.single atom.step | |
| | refl _ => exact Relation.ReflTransGen.refl | |
| | symm _ ih => exact ih.symm | |
| | trans _ _ ih jh => exact ih.trans jh | |
| | mul _ _ ih jh => exact ih.append jh | |
| end PartitionPilot.Forcing.ExternalWordRewrite | |
| end | |
| end OAI | |