File size: 2,929 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 | import Mathlib
import OAI.GroupTheory.SimpleOvergroups.PolynomialNames
namespace OAI
namespace SimpleFInftyOvergroups.EffectiveNames.Polynomial
open BoundedEncoding
noncomputable section
open scoped Classical
variable {A k : Type*} [CommSemiring k]
omit [CommSemiring k] in
@[simp] theorem cost_nil (grade : List A → ℕ) : cost grade ([] : Name k A) = 0 := rfl
omit [CommSemiring k] in
theorem cost_append (grade : List A → ℕ) (p q : Name k A) :
cost grade (p++q) = max (cost grade p) (cost grade q) := by
apply Nat.le_antisymm
· rw [cost_le_iff]
intro a ha
rcases List.mem_append.mp ha with ha | ha
· exact (term_cost_le grade ha).trans (Nat.le_max_left _ _)
· exact (term_cost_le grade ha).trans (Nat.le_max_right _ _)
· rw [max_le_iff, cost_le_iff, cost_le_iff]
exact ⟨fun a ha => term_cost_le grade (List.mem_append_left _ ha),
fun a ha => term_cost_le grade (List.mem_append_right _ ha)⟩
theorem value_flatten (ps : List (Name k A)) : value ps.flatten = (ps.map value).sum := by
induction ps with
| nil => rfl
| cons p ps ih => simp [ih]
omit [CommSemiring k] in
theorem cost_flatten_le (grade : List A → ℕ) {ps : List (Name k A)} {b : ℕ}
(h : ∀ p ∈ ps, cost grade p ≤ b) : cost grade ps.flatten ≤ b := by
rw [cost_le_iff]
intro a ha
obtain ⟨p,hp,ha⟩ := List.mem_flatten.mp ha
exact (term_cost_le grade ha).trans (h p hp)
theorem cost_product_le (grade : List A → ℕ)
(ha : ∀ u v, grade (u++v) = grade u + grade v) (p q : Name k A) :
cost grade (product p q) ≤ cost grade p + cost grade q := by
rw [cost_le_iff]
intro x hx
obtain ⟨a,ha',hx⟩ := List.mem_flatMap.mp hx
obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hx
rw [ha]
exact Nat.add_le_add (term_cost_le grade ha') (term_cost_le grade hb)
theorem cost_oneName (grade : List A → ℕ) (h0 : grade [] = 0) :
cost grade (oneName : Name k A) = 0 := by simp [oneName,cost,h0]
variable {R : Type*} [CommRing R]
def negate (p : Name R A) : Name R A := p.map (fun a => (-a.1,a.2))
@[simp] theorem value_negate (p : Name R A) : value (negate p) = -value p := by
induction p with
| nil => simp [negate]
| cons a p ih =>
change MonoidAlgebra.single (FreeMonoid.ofList a.2) (-a.1) + value (negate p) =
-(MonoidAlgebra.single (FreeMonoid.ofList a.2) a.1 + value p)
rw [MonoidAlgebra.single_neg,ih]
abel
@[simp] theorem cost_negate (grade : List A → ℕ) (p : Name R A) :
cost grade (negate p) = cost grade p := by
simp only [negate,cost,List.map_map,Function.comp_def]
theorem primrec_negate [Primcodable A] [Primcodable R] [Finite R] :
Primrec (negate (R:=R) (A:=A)) := by
exact Primrec.list_map Primrec.id
(((Primrec.dom_finite (Neg.neg : R → R)).comp (Primrec.fst.comp Primrec.snd)).pair
(Primrec.snd.comp Primrec.snd)).to₂
end
end SimpleFInftyOvergroups.EffectiveNames.Polynomial
end OAI
|