File size: 4,418 Bytes
0dd3af4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | 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
|