| import Mathlib |
| import OAI.GroupTheory.SimpleOvergroups.PrefixLists |
|
|
| namespace OAI |
|
|
|
|
| namespace BinaryPrefixOperators.Arithmetic |
| variable (K : Type*) [CommRing K] |
|
|
| def cancel (w u : Word) : Option Pair := |
| if u.take w.length = w then some (u.drop w.length, []) else |
| if w.take u.length = u then some ([], w.drop u.length) else none |
|
|
| noncomputable section |
|
|
| theorem deletion_insertion (w u : Word) : |
| deletion K w * insertion K u = |
| if u.take w.length = w then insertion K (u.drop w.length) else |
| if w.take u.length = u then deletion K (w.drop u.length) else 0 := by |
| induction w generalizing u with |
| | nil => simp |
| | cons i w ih => |
| cases u with |
| | nil => simp |
| | cons j u => |
| have hh : (deletion K w * r K i) * (l K j * insertion K u) = |
| deletion K w * (r K i * l K j) * insertion K u := by simp [mul_assoc] |
| rw [deletion_cons, prefix_cons, hh, r_l] |
| by_cases hij : i=j |
| · subst j |
| simp only [List.length_cons, List.take_succ_cons, |
| List.drop_succ_cons, List.cons.injEq, true_and] |
| exact ih u |
| · simp [hij, Ne.symm hij] |
|
|
| theorem deletion_insertion_cancel (w u : Word) : |
| deletion K w * insertion K u = (cancel w u).elim 0 (replacement K) := by |
| rw [deletion_insertion] |
| unfold cancel |
| split |
| · simp [replacement] |
| · split <;> simp [replacement] |
|
|
| end |
|
|
| def multiplyPair (p q : Pair) : Option Pair := |
| (cancel p.2 q.1).map (fun r => (p.1++r.1,q.2++r.2)) |
|
|
| noncomputable section |
| theorem replacement_mul (p q : Pair) : |
| replacement K p * replacement K q = (multiplyPair p q).elim 0 (replacement K) := by |
| have hh : replacement K p * replacement K q = |
| insertion K p.1 * (deletion K p.2 * insertion K q.1) * deletion K q.2 := by |
| simp [replacement, mul_assoc] |
| rw [hh, deletion_insertion_cancel] |
| cases h : cancel p.2 q.1 with |
| | none => simp [multiplyPair, h] |
| | some r => simp [multiplyPair, h, replacement, mul_assoc] |
| end |
|
|
| namespace Lists |
| variable {K} |
|
|
| def mulTerm (a b : K × Pair) : Poly K := |
| ((multiplyPair a.2 b.2).map (fun p => (a.1*b.1,p))).toList |
|
|
| def product (p q : Poly K) : Poly K := |
| p.flatMap (fun a => q.flatMap (mulTerm a)) |
|
|
| noncomputable def value (p : Poly K) : algebra K := evaluate K (toArray p) |
|
|
| @[simp] theorem value_nil : value ([] : Poly K) = 0 := rfl |
| @[simp] theorem value_cons (a : K) (p : Pair) (ps : Poly K) : |
| value ((a,p)::ps) = a • replacement K p + value ps := by |
| simp [value] |
| @[simp] theorem value_append (p q : Poly K) : value (p++q) = value p + value q := by |
| simp [value] |
|
|
| @[simp] theorem value_singleton (a : K) (p : Pair) : |
| value [(a,p)] = a • replacement K p := by simp |
|
|
| theorem value_mulTerm (a b : K × Pair) : |
| value (mulTerm a b) = (a.1 • replacement K a.2) * (b.1 • replacement K b.2) := by |
| rw [smul_mul_smul_comm, replacement_mul] |
| cases h : multiplyPair a.2 b.2 <;> simp [mulTerm, h] |
|
|
| theorem value_product (p q : Poly K) : value (product p q) = value p * value q := by |
| induction p with |
| | nil => simp [product] |
| | cons a p ih => |
| rcases a with ⟨a,v⟩ |
| simp only [product, List.flatMap_cons, value_append, value_cons, add_mul] at * |
| rw [ih] |
| congr 1 |
| clear ih |
| induction q with |
| | nil => simp |
| | cons b q ih => |
| rcases b with ⟨b,w⟩ |
| simp only [List.flatMap_cons, value_append, value_cons, value_mulTerm, mul_add, ih] |
|
|
| theorem value_surjective : Function.Surjective (value (K:=K)) := by |
| intro x |
| have hx := x.property |
| change x.val ∈ Algebra.adjoin K (Set.range (left K) ∪ Set.range (right K)) at hx |
| have hh : ∃ p : Poly K, (value p : Module.End K (Space K)) = x.val := by |
| apply Algebra.adjoin_induction (p := fun x _ => ∃ p : Poly K, |
| (value p : Module.End K (Space K)) = x) ?_ ?_ ?_ ?_ hx |
| · intro x hx |
| rcases hx with ⟨i,rfl⟩ | ⟨i,rfl⟩ |
| · exact ⟨[(1,([i],[]))], by simp [replacement, l]⟩ |
| · exact ⟨[(1,([],[i]))], by simp [replacement, r]⟩ |
| · intro a |
| exact ⟨[(a,([],[]))], by simp [replacement, Algebra.algebraMap_eq_smul_one]⟩ |
| · intro x y hx hy hp hq |
| obtain ⟨p,rfl⟩ := hp |
| obtain ⟨q,rfl⟩ := hq |
| exact ⟨p++q, by simp⟩ |
| · intro x y hx hy hp hq |
| obtain ⟨p,rfl⟩ := hp |
| obtain ⟨q,rfl⟩ := hq |
| exact ⟨product p q, by simp [value_product]⟩ |
| obtain ⟨p,hp⟩ := hh |
| exact ⟨p, Subtype.ext hp⟩ |
|
|
| end Lists |
| end BinaryPrefixOperators.Arithmetic |
|
|
| end OAI |
|
|
