import UnitConjecture.FreeModule

/-!
# Group Rings

We construct the Group ring `R[G]` given a group `G` and a ring `R`, both having decidable equality. The ring structures is constructed using the (implicit) universal property of `R`-modules. As a check on our definitions, `R[G]` is proved to be a Ring.

We first define multiplication on formal sums. We prove many properties that are used both to show invariance under elementary moves and to prove that `R[G]` is a ring.

-/

variable {
R: Type
R : 
Type: Type 1
Type} [
Ring: Type ?u.6428 → Type ?u.6428
Ring 
R: Type
R] [
DecidableEq: Sort ?u.49 → Sort (max1?u.49)
DecidableEq 
R: Type
R]

variable {
G: Type
G: 
Type: Type 1
Type} [
Group: Type ?u.1721 → Type ?u.1721
Group 
G: Type
G] [
DecidableEq: Sort ?u.1191 → Sort (max1?u.1191)
DecidableEq 
G: Type
G]

/-! 
## Multiplication on formal sums
-/
section FormalSumMul

/-- multiplication by a monomial -/
def 
FormalSum.mulMonom: R → G → FormalSum R G → FormalSum R G
FormalSum.mulMonom (
b: R
b: 
R: Type
R)(
h: G
h: 
G: Type
G) : 
FormalSum: (R : Type ?u.78) → Type ?u.77 → [inst : Ring R] → Type (max?u.77?u.78)
FormalSum 
R: Type
R 
G: Type
G → 
FormalSum: (R : Type ?u.86) → Type ?u.85 → [inst : Ring R] → Type (max?u.85?u.86)
FormalSum 
R: Type
R 
G: Type
G 
| [] => 
[]: List ?m.109
[]
| (
a: R
a, 
g: G
g) :: 
tail: List (R × G)
tail => (
a: R
a * 
b: R
b, 
g: G
g * 
h: G
h) :: (
mulMonom: R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
tail: List (R × G)
tail)

/-- multiplication for formal sums -/
def 
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul(
fst: FormalSum R G
fst: 
FormalSum: (R : Type ?u.1201) → Type ?u.1200 → [inst : Ring R] → Type (max?u.1200?u.1201)
FormalSum 
R: Type
R 
G: Type
G) : 
FormalSum: (R : Type ?u.1211) → Type ?u.1210 → [inst : Ring R] → Type (max?u.1210?u.1211)
FormalSum 
R: Type
R 
G: Type
G → 
FormalSum: (R : Type ?u.1215) → Type ?u.1214 → [inst : Ring R] → Type (max?u.1214?u.1215)
FormalSum 
R: Type
R 
G: Type
G
| [] =>    
[]: List ?m.1236
[]
| (
b: R
b, 
h: G
h) :: 
ys: List (R × G)
ys =>  
  (
FormalSum.mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
FormalSum.mulMonom  
b: R
b 
h: G
h 
fst: FormalSum R G
fst) ++ (
mul: FormalSum R G → FormalSum R G → FormalSum R G
mul 
fst: FormalSum R G
fst 
ys: List (R × G)
ys)
end FormalSumMul

/-! 

## Properties of multiplication on formal sums
-/
namespace GroupRing

open FormalSum
/-- multiplication by the zero monomial -/
theorem 
mul_monom_zero: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (g x₀ : G) (s : FormalSum R G),
  coords (mulMonom 0 g s) x₀ = 0
mul_monom_zero (
g: G
g 
x₀: G
x₀: 
G: Type
G)(
s: FormalSum R G
s: 
FormalSum: (R : Type ?u.1738) → Type ?u.1737 → [inst : Ring R] → Type (max?u.1737?u.1738)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.1748} → [inst : Ring R] → {X : Type ?u.1747} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
0: ?m.1766
0 
g: G
g 
s: FormalSum R G
s) 
x₀: G
x₀ = 
0: ?m.1876
0 := by
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

s: FormalSum R G

coords (mulMonom 0 g s) x₀ = 0induction 
s: FormalSum R G
s with
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

s: FormalSum R G

coords (mulMonom 0 g s) x₀ = 0| 
nil: {α : Type u} → List α
nil =>  
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

nil
coords (mulMonom 0 g []) x₀ = 0simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.2376} → [inst : Ring R] → {X : Type ?u.2375} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

s: FormalSum R G

coords (mulMonom 0 g s) x₀ = 0| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.1916
h 
t: List ?m.1916
t 
ih: ?m.1917 t
ih => 
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 0 g t) x₀ = 0

cons
coords (mulMonom 0 g (h :: t)) x₀ = 0simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.3200} → [inst : Ring R] → {X : Type ?u.3199} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monom_coords_at_zero: ∀ {R : Type ?u.3238} [inst : Ring R] {X : Type ?u.3239} [inst_1 : DecidableEq X] (x₀ x : X),
  monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 0 g t) x₀ = 0

cons
coords (mulMonom 0 g t) x₀ = 0
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

g, x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 0 g t) x₀ = 0

cons
coords (mulMonom 0 g (h :: t)) x₀ = 0assumption
Goals accomplished! 🐙

/-- distributivity of multiplication by a monomial -/
theorem 
mul_monom_dist: ∀ (b : R) (h x₀ : G) (s₁ s₂ : FormalSum R G),
  coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀
mul_monom_dist(
b: R
b : 
R: Type
R)(
h: G
h 
x₀: G
x₀ : 
G: Type
G)(
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂: 
FormalSum: (R : Type ?u.4016) → Type ?u.4015 → [inst : Ring R] → Type (max?u.4015?u.4016)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.4031} → [inst : Ring R] → {X : Type ?u.4030} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h (
s₁: FormalSum R G
s₁  ++ 
s₂: FormalSum R G
s₂)) 
x₀: G
x₀ = 
coords: {R : Type ?u.4136} → [inst : Ring R] → {X : Type ?u.4135} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
s₁: FormalSum R G
s₁) 
x₀: G
x₀ + 
coords: {R : Type ?u.4157} → [inst : Ring R] → {X : Type ?u.4156} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
s₂: FormalSum R G
s₂) 
x₀: G
x₀ := by
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀induction 
s₁: FormalSum R G
s₁ with
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀| 
nil: {α : Type u} → List α
nil => 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

nil
coords (mulMonom b h ([] ++ s₂)) x₀ = coords (mulMonom b h []) x₀ + coords (mulMonom b h s₂) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.4342} → [inst : Ring R] → {X : Type ?u.4341} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.4285
head 
tail: List ?m.4285
tail 
ih: ?m.4286 tail
ih =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
coords (mulMonom b h (head :: tail ++ s₂)) x₀ = coords (mulMonom b h (head :: tail)) x₀ + coords (mulMonom b h s₂) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.4872} → [inst : Ring R] → {X : Type ?u.4871} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h (tail ++ s₂)) x₀ =   monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
coords (mulMonom b h (head :: tail ++ s₂)) x₀ = coords (mulMonom b h (head :: tail)) x₀ + coords (mulMonom b h s₂) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h (tail ++ s₂)) x₀ =   monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀
ih: ?m.4286 tail
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
monomCoeff R G x₀ (head.fst * b, head.snd * h) + (coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀) =   monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
monomCoeff R G x₀ (head.fst * b, head.snd * h) + (coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀) =   monomCoeff R G x₀ (head.fst * b, head.snd * h) + coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₂: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (tail ++ s₂)) x₀ = coords (mulMonom b h tail) x₀ + coords (mulMonom b h s₂) x₀

cons
coords (mulMonom b h (head :: tail ++ s₂)) x₀ = coords (mulMonom b h (head :: tail)) x₀ + coords (mulMonom b h s₂) x₀simp [
add_assoc: ∀ {G : Type ?u.6086} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙

/-- right distributivity -/
theorem 
mul_dist: ∀ (x₀ : G) (s₁ s₂ s₃ : FormalSum R G), coords (mul s₁ (s₂ ++ s₃)) x₀ = coords (mul s₁ s₂) x₀ + coords (mul s₁ s₃) x₀
mul_dist(
x₀: G
x₀ : 
G: Type
G)(
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂ 
s₃: FormalSum R G
s₃: 
FormalSum: (R : Type ?u.6471) → Type ?u.6470 → [inst : Ring R] → Type (max?u.6470?u.6471)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.6477} → [inst : Ring R] → {X : Type ?u.6476} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s₁: FormalSum R G
s₁ (
s₂: FormalSum R G
s₂  ++ 
s₃: FormalSum R G
s₃)) 
x₀: G
x₀ = 
coords: {R : Type ?u.6582} → [inst : Ring R] → {X : Type ?u.6581} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂) 
x₀: G
x₀ + 
coords: {R : Type ?u.6603} → [inst : Ring R] → {X : Type ?u.6602} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s₁: FormalSum R G
s₁ 
s₃: FormalSum R G
s₃) 
x₀: G
x₀ := by
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₂, s₃: FormalSum R G

coords (mul s₁ (s₂ ++ s₃)) x₀ = coords (mul s₁ s₂) x₀ + coords (mul s₁ s₃) x₀induction 
s₂: FormalSum R G
s₂ with
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₂, s₃: FormalSum R G

coords (mul s₁ (s₂ ++ s₃)) x₀ = coords (mul s₁ s₂) x₀ + coords (mul s₁ s₃) x₀| 
nil: {α : Type u} → List α
nil => 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

nil
coords (mul s₁ ([] ++ s₃)) x₀ = coords (mul s₁ []) x₀ + coords (mul s₁ s₃) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.6787} → [inst : Ring R] → {X : Type ?u.6786} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₂, s₃: FormalSum R G

coords (mul s₁ (s₂ ++ s₃)) x₀ = coords (mul s₁ s₂) x₀ + coords (mul s₁ s₃) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.6730
head 
tail: List ?m.6730
tail 
ih: ?m.6731 tail
ih =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mul s₁ (head :: tail ++ s₃)) x₀ = coords (mul s₁ (head :: tail)) x₀ + coords (mul s₁ s₃) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.7299} → [inst : Ring R] → {X : Type ?u.7298} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁ ++ mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁ ++ mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mul s₁ (head :: tail ++ s₃)) x₀ = coords (mul s₁ (head :: tail)) x₀ + coords (mul s₁ s₃) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁ ++ mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁ ++ mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀← 
append_coords: ∀ {R : Type ?u.8224} [inst : Ring R] {X : Type ?u.8225} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁ ++ mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁ ++ mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mul s₁ (head :: tail ++ s₃)) x₀ = coords (mul s₁ (head :: tail)) x₀ + coords (mul s₁ s₃) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁ ++ mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀← 
append_coords: ∀ {R : Type ?u.8334} [inst : Ring R] {X : Type ?u.8335} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mul s₁ (head :: tail ++ s₃)) x₀ = coords (mul s₁ (head :: tail)) x₀ + coords (mul s₁ s₃) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ (tail ++ s₃)) x₀ =   coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀
ih: ?m.6731 tail
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + (coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀) =   coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mulMonom head.fst head.snd s₁) x₀ + (coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀) =   coords (mulMonom head.fst head.snd s₁) x₀ + coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

s₁, s₃: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mul s₁ (tail ++ s₃)) x₀ = coords (mul s₁ tail) x₀ + coords (mul s₁ s₃) x₀

cons
coords (mul s₁ (head :: tail ++ s₃)) x₀ = coords (mul s₁ (head :: tail)) x₀ + coords (mul s₁ s₃) x₀simp [
add_assoc: ∀ {G : Type ?u.8464} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙

/-- associativity with two terms monomials -/
theorem 
mul_monom_monom_assoc: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] {x : G} (a b : R) (h x₀ : G)
  (s : FormalSum R G), coords (mulMonom b h (mulMonom a x s)) x₀ = coords (mulMonom (a * b) (x * h) s) x₀
mul_monom_monom_assoc(
a: R
a 
b: R
b : 
R: Type
R)(
h: G
h 
x₀: G
x₀ : 
G: Type
G)(
s: FormalSum R G
s : 
FormalSum: (R : Type ?u.8755) → Type ?u.8754 → [inst : Ring R] → Type (max?u.8754?u.8755)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.8812} → [inst : Ring R] → {X : Type ?u.8811} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
a: R
a 
x: ?m.8794
x 
s: FormalSum R G
s)) 
x₀: G
x₀ = 
    
coords: {R : Type ?u.8877} → [inst : Ring R] → {X : Type ?u.8876} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom (
a: R
a * 
b: R
b) (
x: ?m.8794
x * 
h: G
h) 
s: FormalSum R G
s) 
x₀: G
x₀  := by 
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

s: FormalSum R G

coords (mulMonom b h (mulMonom a x s)) x₀ = coords (mulMonom (a * b) (x * h) s) x₀induction 
s: FormalSum R G
s with
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

s: FormalSum R G

coords (mulMonom b h (mulMonom a x s)) x₀ = coords (mulMonom (a * b) (x * h) s) x₀| 
nil: {α : Type u} → List α
nil => 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

nil
coords (mulMonom b h (mulMonom a x [])) x₀ = coords (mulMonom (a * b) (x * h) []) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.9426} → [inst : Ring R] → {X : Type ?u.9425} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

s: FormalSum R G

coords (mulMonom b h (mulMonom a x s)) x₀ = coords (mulMonom (a * b) (x * h) s) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.9369
head 
tail: List ?m.9369
tail 
ih: ?m.9370 tail
ih =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

cons
coords (mulMonom b h (mulMonom a x (head :: tail))) x₀ = coords (mulMonom (a * b) (x * h) (head :: tail)) x₀let (
a₁: R
a₁, 
x₁: G
x₁) := 
head: ?m.9369
head
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

a₁: R

x₁: G

cons
coords (mulMonom b h (mulMonom a x ((a₁, x₁) :: tail))) x₀ = coords (mulMonom (a * b) (x * h) ((a₁, x₁) :: tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

cons
coords (mulMonom b h (mulMonom a x (head :: tail))) x₀ = coords (mulMonom (a * b) (x * h) (head :: tail)) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.9718} → [inst : Ring R] → {X : Type ?u.9717} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
mul_assoc: ∀ {G : Type ?u.9774} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

a₁: R

x₁: G

cons
coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

cons
coords (mulMonom b h (mulMonom a x (head :: tail))) x₀ = coords (mulMonom (a * b) (x * h) (head :: tail)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

a₁: R

x₁: G

cons
coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀
ih: ?m.9370 tail
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: G

a, b: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mulMonom a x tail)) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀

a₁: R

x₁: G

cons
coords (mulMonom (a * b) (x * h) tail) x₀ = coords (mulMonom (a * b) (x * h) tail) x₀]
Goals accomplished! 🐙

/-- associativity with one term a monomial -/
theorem 
mul_monom_assoc: ∀ (b : R) (h x₀ : G) (s₁ s₂ : FormalSum R G),
  coords (mulMonom b h (mul s₁ s₂)) x₀ = coords (mul s₁ (mulMonom b h s₂)) x₀
mul_monom_assoc(
b: R
b : 
R: Type
R)(
h: G
h 
x₀: G
x₀ : 
G: Type
G)(
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂: 
FormalSum: (R : Type ?u.11315) → Type ?u.11314 → [inst : Ring R] → Type (max?u.11314?u.11315)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.11330} → [inst : Ring R] → {X : Type ?u.11329} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h (
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂)) 
x₀: G
x₀ = 
    
coords: {R : Type ?u.11399} → [inst : Ring R] → {X : Type ?u.11398} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s₁: FormalSum R G
s₁ (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
s₂: FormalSum R G
s₂)) 
x₀: G
x₀  := by
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (mul s₁ s₂)) x₀ = coords (mul s₁ (mulMonom b h s₂)) x₀induction 
s₂: FormalSum R G
s₂ with
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (mul s₁ s₂)) x₀ = coords (mul s₁ (mulMonom b h s₂)) x₀| 
nil: {α : Type u} → List α
nil => 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

nil
coords (mulMonom b h (mul s₁ [])) x₀ = coords (mul s₁ (mulMonom b h [])) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.11511} → [inst : Ring R] → {X : Type ?u.11510} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

coords (mulMonom b h (mul s₁ s₂)) x₀ = coords (mul s₁ (mulMonom b h s₂)) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.11454
head 
tail: List ?m.11454
tail 
ih: ?m.11455 tail
ih =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀let (
a: R
a, 
x: G
x) := 
head: ?m.11454
head
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mul s₁ ((a, x) :: tail))) x₀ = coords (mul s₁ (mulMonom b h ((a, x) :: tail))) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.11802} → [inst : Ring R] → {X : Type ?u.11801} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁ ++ mul s₁ (mulMonom b h tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁ ++ mul s₁ (mulMonom b h tail)) x₀← 
append_coords: ∀ {R : Type ?u.12746} [inst : Ring R] {X : Type ?u.12747} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁ ++ mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
mul_monom_dist: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (b : R) (h x₀ : G)
  (s₁ s₂ : FormalSum R G),
  coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀
mul_monom_dist
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ + coords (mulMonom b h (mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ + coords (mulMonom b h (mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ + coords (mulMonom b h (mul s₁ tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
ih: ?m.11455 tail
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀ =   coords (mulMonom (a * b) (x * h) s₁) x₀ + coords (mul s₁ (mulMonom b h tail)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀simp [
add_assoc: ∀ {G : Type ?u.13156} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ = coords (mulMonom (a * b) (x * h) s₁) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

cons
coords (mulMonom b h (mul s₁ (head :: tail))) x₀ = coords (mul s₁ (mulMonom b h (head :: tail))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom b h (mulMonom a x s₁)) x₀ = coords (mulMonom (a * b) (x * h) s₁) x₀
mul_monom_monom_assoc: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] {x : G} (a b : R) (h x₀ : G)
  (s : FormalSum R G), coords (mulMonom b h (mulMonom a x s)) x₀ = coords (mulMonom (a * b) (x * h) s) x₀
mul_monom_monom_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁: FormalSum R G

head: R × G

tail: List (R × G)

ih: coords (mulMonom b h (mul s₁ tail)) x₀ = coords (mul s₁ (mulMonom b h tail)) x₀

a: R

x: G

cons
coords (mulMonom (a * b) (x * h) s₁) x₀ = coords (mulMonom (a * b) (x * h) s₁) x₀]
Goals accomplished! 🐙

/-- left distributivity for multiplication by a monomial -/
theorem 
mul_monom_add: ∀ (b₁ b₂ : R) (h x₀ : G) (s : FormalSum R G),
  coords (mulMonom (b₁ + b₂) h s) x₀ = coords (mulMonom b₁ h s) x₀ + coords (mulMonom b₂ h s) x₀
mul_monom_add(
b₁: R
b₁ 
b₂: R
b₂ : 
R: Type
R)(
h: G
h 
x₀: G
x₀ : 
G: Type
G)(
s: FormalSum R G
s: 
FormalSum: (R : Type ?u.14098) → Type ?u.14097 → [inst : Ring R] → Type (max?u.14097?u.14098)
FormalSum 
R: Type
R 
G: Type
G): 
coords: {R : Type ?u.14108} → [inst : Ring R] → {X : Type ?u.14107} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom (
b₁: R
b₁ + 
b₂: R
b₂) 
h: G
h 
s: FormalSum R G
s) 
x₀: G
x₀ = 
coords: {R : Type ?u.14257} → [inst : Ring R] → {X : Type ?u.14256} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b₁: R
b₁ 
h: G
h 
s: FormalSum R G
s) 
x₀: G
x₀ + 
coords: {R : Type ?u.14278} → [inst : Ring R] → {X : Type ?u.14277} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b₂: R
b₂ 
h: G
h 
s: FormalSum R G
s) 
x₀: G
x₀ := by
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

s: FormalSum R G

coords (mulMonom (b₁ + b₂) h s) x₀ = coords (mulMonom b₁ h s) x₀ + coords (mulMonom b₂ h s) x₀induction 
s: FormalSum R G
s with
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

s: FormalSum R G

coords (mulMonom (b₁ + b₂) h s) x₀ = coords (mulMonom b₁ h s) x₀ + coords (mulMonom b₂ h s) x₀| 
nil: {α : Type u} → List α
nil => 
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

nil
coords (mulMonom (b₁ + b₂) h []) x₀ = coords (mulMonom b₁ h []) x₀ + coords (mulMonom b₂ h []) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.14421} → [inst : Ring R] → {X : Type ?u.14420} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

s: FormalSum R G

coords (mulMonom (b₁ + b₂) h s) x₀ = coords (mulMonom b₁ h s) x₀ + coords (mulMonom b₂ h s) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.14364
head 
tail: List ?m.14364
tail 
ih: ?m.14365 tail
ih => 
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀let (
a: R
a, 
g: G
g) := 
head: ?m.14364
head
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
coords (mulMonom (b₁ + b₂) h ((a, g) :: tail)) x₀ =   coords (mulMonom b₁ h ((a, g) :: tail)) x₀ + coords (mulMonom b₂ h ((a, g) :: tail)) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.14791} → [inst : Ring R] → {X : Type ?u.14790} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * (b₁ + b₂), g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * (b₁ + b₂), g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
left_distrib: ∀ {R : Type ?u.16787} [inst : Mul R] [inst_1 : Add R] [inst_2 : LeftDistribClass R] (a b c : R),
  a * (b + c) = a * b + a * c
left_distrib
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁ + a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁ + a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁ + a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
monom_coords_hom: ∀ {R : Type ?u.17019} [inst : Ring R] {X : Type ?u.17020} [inst_1 : DecidableEq X] (x₀ x : X) (a b : R),
  monomCoeff R X x₀ (a + b, x) = monomCoeff R X x₀ (a, x) + monomCoeff R X x₀ (b, x)
monom_coords_hom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom (b₁ + b₂) h tail) x₀ =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
ih: ?m.14365 tail
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀conv =>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₂ h tail) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)lhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +   (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +   (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀)
add_assoc: ∀ {G : Type ?u.17177} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (monomCoeff R G x₀ (a * b₂, g * h) + (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (monomCoeff R G x₀ (a * b₂, g * h) + (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀))
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)arg 2
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₂, g * h) + (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₂, g * h) + (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.17328} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)congr
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₁ h tail) x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₂ h tail) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + monomCoeff R G x₀ (a * b₂, g * h) +     (coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₁ h tail) x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₂ h tail) x₀
add_comm: ∀ {G : Type ?u.17441} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₂ h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

a
coords (mulMonom b₂ h tail) x₀    
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀conv =>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)rhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +   (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +     (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) + coords (mulMonom b₁ h tail) x₀ +   (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
add_assoc: ∀ {G : Type ?u.17659} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

cons
coords (mulMonom (b₁ + b₂) h (head :: tail)) x₀ =   coords (mulMonom b₁ h (head :: tail)) x₀ + coords (mulMonom b₂ h (head :: tail)) x₀conv =>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

cons
monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))rhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +   (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)) 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))arg 2
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))skip
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀) =   monomCoeff R G x₀ (a * b₁, g * h) +     (coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀))rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + (monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.17898} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b₁, b₂: R

h, x₀: G

head: R × G

tail: List (R × G)

ih: coords (mulMonom (b₁ + b₂) h tail) x₀ = coords (mulMonom b₁ h tail) x₀ + coords (mulMonom b₂ h tail) x₀

a: R

g: G

coords (mulMonom b₁ h tail) x₀ + monomCoeff R G x₀ (a * b₂, g * h) + coords (mulMonom b₂ h tail) x₀

/-- multiplication equivalent when adding term with `0` coefficient -/
theorem 
mul_zero_cons: ∀ {h : G} (s t : FormalSum R G), mul s ((0, h) :: t) ≈ mul s t
mul_zero_cons (
s: FormalSum R G
s 
t: FormalSum R G
t : 
FormalSum: (R : Type ?u.18202) → Type ?u.18201 → [inst : Ring R] → Type (max?u.18201?u.18202)
FormalSum 
R: Type
R 
G: Type
G) :  
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s: FormalSum R G
s ((
0: ?m.18238
0, 
h: ?m.18198
h) :: 
t: FormalSum R G
t) ≈  
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul 
s: FormalSum R G
s 
t: FormalSum R G
t := by
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

s, t: FormalSum R G

mul s ((0, h) :: t) ≈ mul s tinduction 
s: FormalSum R G
s
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

nil
mul [] ((0, h) :: t) ≈ mul [] t
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head✝: R × G

tail✝: List (R × G)

tail_ih✝: mul tail✝ ((0, h) :: t) ≈ mul tail✝ t

cons
mul (head✝ :: tail✝) ((0, h) :: t) ≈ mul (head✝ :: tail✝) t
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

s, t: FormalSum R G

mul s ((0, h) :: t) ≈ mul s tcase nil =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

mul [] ((0, h) :: t) ≈ mul [] tsimp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

mul [] t ≈ mul [] t
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

mul [] ((0, h) :: t) ≈ mul [] tapply 
eqlCoords.refl: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s : FormalSum R X), eqlCoords R X s s
eqlCoords.refl
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

s, t: FormalSum R G

mul s ((0, h) :: t) ≈ mul s tcase cons 
head: ?m.18322
head 
tail: List ?m.18322
tail _ =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tsimp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

(0, head.snd * h) :: (mulMonom 0 h tail ++ mul (head :: tail) t) ≈ mul (head :: tail) t
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tapply 
funext: ∀ {α : Sort ?u.18880} {β : α → Sort ?u.18879} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

h
∀ (x : G), coords ((0, head.snd * h) :: (mulMonom 0 h tail ++ mul (head :: tail) t)) x = coords (mul (head :: tail) t) x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) t;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

h
∀ (x : G), coords ((0, head.snd * h) :: (mulMonom 0 h tail ++ mul (head :: tail) t)) x = coords (mul (head :: tail) t) x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tintro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords ((0, head.snd * h) :: (mulMonom 0 h tail ++ mul (head :: tail) t)) x₀ = coords (mul (head :: tail) t) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tsimp [
coords: {R : Type ?u.18903} → [inst : Ring R] → {X : Type ?u.18902} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
monomCoeff R G x₀ (0, head.snd * h) + coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ =   coords (mul (head :: tail) t) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) trw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
monomCoeff R G x₀ (0, head.snd * h) + coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ =   coords (mul (head :: tail) t) x₀
monom_coords_at_zero: ∀ {R : Type ?u.19914} [inst : Ring R] {X : Type ?u.19915} [inst_1 : DecidableEq X] (x₀ x : X),
  monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
0 + coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
0 + coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) trw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
0 + coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀
zero_add: ∀ {M : Type ?u.20052} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) trw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail ++ mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀← 
append_coords: ∀ {R : Type ?u.20166} [inst : Ring R] {X : Type ?u.20167} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail) x₀ + coords (mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail) x₀ + coords (mul (head :: tail) t) x₀ = coords (mul (head :: tail) t) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tsimp [
coords: {R : Type ?u.20278} → [inst : Ring R] → {X : Type ?u.20277} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

h
coords (mulMonom 0 h tail) x₀ = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) tlet 
l: ?m.20744
l := 
mul_monom_zero: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (g x₀ : G) (s : FormalSum R G),
  coords (mulMonom 0 g s) x₀ = 0
mul_monom_zero 
h: G
h 
x₀: ?α
x₀ 
tail: List ?m.18322
tail
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

l:= mul_monom_zero h x₀ tail: coords (mulMonom 0 h tail) x₀ = 0

h
coords (mulMonom 0 h tail) x₀ = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

mul (head :: tail) ((0, h) :: t) ≈ mul (head :: tail) trw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

l:= mul_monom_zero h x₀ tail: coords (mulMonom 0 h tail) x₀ = 0

h
coords (mulMonom 0 h tail) x₀ = 0
l: ?m.20744
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: G

t: FormalSum R G

head: R × G

tail: List (R × G)

tail_ih✝: mul tail ((0, h) :: t) ≈ mul tail t

x₀: G

l:= mul_monom_zero h x₀ tail: coords (mulMonom 0 h tail) x₀ = 0

h
0 = 0]
Goals accomplished! 🐙

/-!
## Induced product on the quotient 
-/

/-- Quotient in second argument for group ring multiplication 
-/
def 
mulAux: FormalSum R G → R[G] → R[G]
mulAux : 
FormalSum: (R : Type ?u.20839) → Type ?u.20838 → [inst : Ring R] → Type (max?u.20838?u.20839)
FormalSum 
R: Type
R 
G: Type
G → 
R: Type
R[
G: Type
G] → 
R: Type
R[
G: Type
G] := by
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]intro 
s: FormalSum R G
s
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s: FormalSum R G

R[G] → R[G]
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]apply  
Quotient.lift: {α : Sort ?u.20927} →
  {β : Sort ?u.20926} → {s : Setoid α} → (f : α → β) → (∀ (a b : α), a ≈ b → f a = f b) → Quotient s → β
Quotient.lift (⟦
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul 
s: FormalSum R G
s ·⟧)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s: FormalSum R G

∀ (a b : FormalSum R G),
  a ≈ b → Quotient.mk (formalSumSetoid R G) (mul s a) = Quotient.mk (formalSumSetoid R G) (mul s b)
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]apply 
func_eql_of_move_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] {β : Sort ?u.20969}
  (f : FormalSum R X → β),
  (∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂) → ∀ (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → f s₁ = f s₂
func_eql_of_move_equiv
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s: FormalSum R G

a
∀ (s₁ s₂ : FormalSum R G),
  ElementaryMove R G s₁ s₂ → Quotient.mk (formalSumSetoid R G) (mul s s₁) = Quotient.mk (formalSumSetoid R G) (mul s s₂)
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]intro 
t: FormalSum ?R ?X
t 
t': FormalSum ?R ?X
t' 
rel: ElementaryMove ?R ?X t t'
rel
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
Quotient.mk (formalSumSetoid R G) (mul s t) = Quotient.mk (formalSumSetoid R G) (mul s t')
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
mul s t ≈ mul s t' 
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

FormalSum R G → R[G] → R[G]induction 
rel: ElementaryMove ?R ?X t t'
rel with
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
mul s t ≈ mul s t'| 
zeroCoeff: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (tail : FormalSum R X) (x : X) (a : R),
  a = 0 → ElementaryMove R X ((a, x) :: tail) tail
zeroCoeff 
tail: FormalSum ?m.21309 ?m.21310
tail 
g: ?m.21310
g 
a: ?m.21309
a 
hyp: a = 0
hyp =>
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailrw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tail
hyp: a = 0
hyp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((0, g) :: tail) ≈ mul s tail]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((0, g) :: tail) ≈ mul s tail
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s taildsimp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mulMonom 0 g s ++ mul s tail ≈ mul s tail
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailapply 
funext: ∀ {α : Sort ?u.21375} {β : α → Sort ?u.21374} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff.h
∀ (x : G), coords (mulMonom 0 g s ++ mul s tail) x = coords (mul s tail) x
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailintro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

a.zeroCoeff.h
coords (mulMonom 0 g s ++ mul s tail) x₀ = coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailrw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

a.zeroCoeff.h
coords (mulMonom 0 g s ++ mul s tail) x₀ = coords (mul s tail) x₀← 
append_coords: ∀ {R : Type ?u.21397} [inst : Ring R] {X : Type ?u.21398} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

a.zeroCoeff.h
coords (mulMonom 0 g s) x₀ + coords (mul s tail) x₀ = coords (mul s tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

a.zeroCoeff.h
coords (mulMonom 0 g s) x₀ + coords (mul s tail) x₀ = coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s taillet 
l: ?m.21536
l := 
mul_monom_zero: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (g x₀ : G) (s : FormalSum R G),
  coords (mulMonom 0 g s) x₀ = 0
mul_monom_zero 
g: ?m.21310
g 
x₀: ?α
x₀ 
s: FormalSum R G
s
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

l:= mul_monom_zero g x₀ s: coords (mulMonom 0 g s) x₀ = 0

a.zeroCoeff.h
coords (mulMonom 0 g s) x₀ + coords (mul s tail) x₀ = coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailrw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

l:= mul_monom_zero g x₀ s: coords (mulMonom 0 g s) x₀ = 0

a.zeroCoeff.h
coords (mulMonom 0 g s) x₀ + coords (mul s tail) x₀ = coords (mul s tail) x₀
l: ?m.21536
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

l:= mul_monom_zero g x₀ s: coords (mulMonom 0 g s) x₀ = 0

a.zeroCoeff.h
0 + coords (mul s tail) x₀ = coords (mul s tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

l:= mul_monom_zero g x₀ s: coords (mulMonom 0 g s) x₀ = 0

a.zeroCoeff.h
0 + coords (mul s tail) x₀ = coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t', tail: FormalSum R G

g: G

a: R

hyp: a = 0

a.zeroCoeff
mul s ((a, g) :: tail) ≈ mul s tailsimp [
zero_add: ∀ {M : Type ?u.21566} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add]
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
mul s t ≈ mul s t'| 
addCoeffs: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a b : R) (x : X)
  (tail : FormalSum R X), ElementaryMove R X ((a, x) :: (b, x) :: tail) ((a + b, x) :: tail)
addCoeffs 
a: ?m.21309
a 
b: ?m.21309
b 
x: ?m.21310
x 
tail: FormalSum ?m.21309 ?m.21310
tail =>
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)apply 
funext: ∀ {α : Sort ?u.21840} {β : α → Sort ?u.21839} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs.h
∀ (x_1 : G), coords (mul s ((a, x) :: (b, x) :: tail)) x_1 = coords (mul s ((a + b, x) :: tail)) x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs.h
∀ (x_1 : G), coords (mul s ((a, x) :: (b, x) :: tail)) x_1 = coords (mul s ((a + b, x) :: tail)) x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mul s ((a, x) :: (b, x) :: tail)) x₀ = coords (mul s ((a + b, x) :: tail)) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s ++ (mulMonom b x s ++ mul s tail)) x₀ = coords (mulMonom (a + b) x s ++ mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)repeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s ++ (mulMonom b x s ++ mul s tail)) x₀ = coords (mulMonom (a + b) x s ++ mul s tail) x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s) x₀ + (coords (mulMonom b x s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom (a + b) x s) x₀ + coords (mul s tail) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s ++ (mulMonom b x s ++ mul s tail)) x₀ = coords (mulMonom (a + b) x s ++ mul s tail) x₀← 
append_coords: ∀ {R : Type ?u.22328} [inst : Ring R] {X : Type ?u.22329} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s) x₀ + (coords (mulMonom b x s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom (a + b) x s ++ mul s tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s) x₀ + coords (mulMonom b x s ++ mul s tail) x₀ = coords (mulMonom (a + b) x s ++ mul s tail) x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s) x₀ + (coords (mulMonom b x s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom (a + b) x s) x₀ + coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

x₀: G

a.addCoeffs.h
coords (mulMonom a x s) x₀ + (coords (mulMonom b x s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom (a + b) x s) x₀ + coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a, b: R

x: G

tail: FormalSum R G

a.addCoeffs
mul s ((a, x) :: (b, x) :: tail) ≈ mul s ((a + b, x) :: tail)simp [
mul_monom_add: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (b₁ b₂ : R) (h x₀ : G)
  (s : FormalSum R G), coords (mulMonom (b₁ + b₂) h s) x₀ = coords (mulMonom b₁ h s) x₀ + coords (mulMonom b₂ h s) x₀
mul_monom_add, 
add_assoc: ∀ {G : Type ?u.23015} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙    
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
mul s t ≈ mul s t'| 
cons: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a : R) (x : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → ElementaryMove R X ((a, x) :: s₁) ((a, x) :: s₂)
cons 
a: ?m.21309
a 
x: ?m.21310
x 
s₁: FormalSum ?m.21309 ?m.21310
s₁ 
s₂: FormalSum ?m.21309 ?m.21310
s₂ 
_: ElementaryMove ?m.21309 ?m.21310 s₁ s₂
_ 
step: ?m.21314 s₁ s₂ a✝
step =>
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)apply 
funext: ∀ {α : Sort ?u.23274} {β : α → Sort ?u.23273} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons.h
∀ (x_1 : G), coords (mul s ((a, x) :: s₁)) x_1 = coords (mul s ((a, x) :: s₂)) x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂);
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons.h
∀ (x_1 : G), coords (mul s ((a, x) :: s₁)) x_1 = coords (mul s ((a, x) :: s₂)) x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mul s ((a, x) :: s₁)) x₀ = coords (mul s ((a, x) :: s₂)) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s ++ mul s s₁) x₀ = coords (mulMonom a x s ++ mul s s₂) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s ++ mul s s₁) x₀ = coords (mulMonom a x s ++ mul s s₂) x₀← 
append_coords: ∀ {R : Type ?u.23478} [inst : Ring R] {X : Type ?u.23479} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s) x₀ + coords (mul s s₁) x₀ = coords (mulMonom a x s ++ mul s s₂) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s) x₀ + coords (mul s s₁) x₀ = coords (mulMonom a x s ++ mul s s₂) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s) x₀ + coords (mul s s₁) x₀ = coords (mulMonom a x s ++ mul s s₂) x₀← 
append_coords: ∀ {R : Type ?u.23589} [inst : Ring R] {X : Type ?u.23590} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s) x₀ + coords (mul s s₁) x₀ = coords (mulMonom a x s) x₀ + coords (mul s s₂) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mulMonom a x s) x₀ + coords (mul s s₁) x₀ = coords (mulMonom a x s) x₀ + coords (mul s s₂) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

a.cons.h
coords (mul s s₁) x₀ = coords (mul s s₂) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)let 
l: ?m.24280
l := 
congrFun: ∀ {α : Sort ?u.24282} {β : α → Sort ?u.24281} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
step: ?m.21314 s₁ s₂ a✝
step 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

l:= congrFun step x₀: coords (mul s s₁) x₀ = coords (mul s s₂) x₀

a.cons.h
coords (mul s s₁) x₀ = coords (mul s s₂) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

a.cons
mul s ((a, x) :: s₁) ≈ mul s ((a, x) :: s₂)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

l:= congrFun step x₀: coords (mul s s₁) x₀ = coords (mul s s₂) x₀

a.cons.h
coords (mul s s₁) x₀ = coords (mul s s₂) x₀
l: ?m.24280
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a: R

x: G

s₁, s₂: FormalSum R G

a✝: ElementaryMove R G s₁ s₂

step: mul s s₁ ≈ mul s s₂

x₀: G

l:= congrFun step x₀: coords (mul s s₁) x₀ = coords (mul s s₂) x₀

a.cons.h
coords (mul s s₂) x₀ = coords (mul s s₂) x₀]
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

rel: ElementaryMove R G t t'

a
mul s t ≈ mul s t'| 
swap: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a₁ a₂ : R) (x₁ x₂ : X)
  (tail : FormalSum R X), ElementaryMove R X ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
swap 
a₁: ?m.21309
a₁ 
a₂: ?m.21309
a₂ 
x₁: ?m.21310
x₁ 
x₂: ?m.21310
x₂ 
tail: FormalSum ?m.21309 ?m.21310
tail =>
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)apply 
funext: ∀ {α : Sort ?u.24325} {β : α → Sort ?u.24324} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap.h
∀ (x : G), coords (mul s ((a₁, x₁) :: (a₂, x₂) :: tail)) x = coords (mul s ((a₂, x₂) :: (a₁, x₁) :: tail)) x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail);
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap.h
∀ (x : G), coords (mul s ((a₁, x₁) :: (a₂, x₂) :: tail)) x = coords (mul s ((a₂, x₂) :: (a₁, x₁) :: tail)) x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mul s ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ = coords (mul s ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul, ← 
append_coords: ∀ {R : Type ?u.24373} [inst : Ring R] {X : Type ?u.24374} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + (coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom a₂ x₂ s) x₀ + (coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + (coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀) =   coords (mulMonom a₂ x₂ s) x₀ + (coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀)← 
add_assoc: ∀ {G : Type ?u.25528} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + (coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + (coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + (coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀)← 
add_assoc: ∀ {G : Type ?u.25669} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ + coords (mul s tail) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀ + coords (mul s tail) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)let 
lc: ?m.26156
lc := 
      
add_comm: ∀ {G : Type ?u.26157} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm 
        (
coords: {R : Type ?u.26161} → [inst : Ring R] → {X : Type ?u.26160} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
a₁: ?m.21309
a₁ 
x₁: ?m.21310
x₁ 
s: FormalSum R G
s) 
x₀: ?α
x₀)
        (
coords: {R : Type ?u.26224} → [inst : Ring R] → {X : Type ?u.26223} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
a₂: ?m.21309
a₂ 
x₂: ?m.21310
x₂ 
s: FormalSum R G
s) 
x₀: ?α
x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

lc:= add_comm (coords (mulMonom a₁ x₁ s) x₀) (coords (mulMonom a₂ x₂ s) x₀): coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

a.swap
mul s ((a₁, x₁) :: (a₂, x₂) :: tail) ≈ mul s ((a₂, x₂) :: (a₁, x₁) :: tail)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

lc:= add_comm (coords (mulMonom a₁ x₁ s) x₀) (coords (mulMonom a₂ x₂ s) x₀): coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀

a.swap.h
coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀
lc: ?m.26156
lc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s, t, t': FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

lc:= add_comm (coords (mulMonom a₁ x₁ s) x₀) (coords (mulMonom a₂ x₂ s) x₀): coords (mulMonom a₁ x₁ s) x₀ + coords (mulMonom a₂ x₂ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀

a.swap.h
coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀ =   coords (mulMonom a₂ x₂ s) x₀ + coords (mulMonom a₁ x₁ s) x₀]
Goals accomplished! 🐙 

open ElementaryMove
/-- invariance under moves of multiplication by monomials -/
theorem 
mul_monom_invariant: ∀ (b : R) (h x₀ : G) (s₁ s₂ : FormalSum R G),
  ElementaryMove R G s₁ s₂ → coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀
mul_monom_invariant (
b: R
b : 
R: Type
R)(
h: G
h 
x₀: G
x₀ : 
G: Type
G)(
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂ : 
FormalSum: (R : Type ?u.26636) → Type ?u.26635 → [inst : Ring R] → Type (max?u.26635?u.26636)
FormalSum 
R: Type
R 
G: Type
G) (
rel: ElementaryMove R G s₁ s₂
rel : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G 
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂) : 
coords: {R : Type ?u.26725} → [inst : Ring R] → {X : Type ?u.26724} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
s₁: FormalSum R G
s₁) 
x₀: G
x₀ = 
coords: {R : Type ?u.26750} → [inst : Ring R] → {X : Type ?u.26749} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom 
b: R
b 
h: G
h 
s₂: FormalSum R G
s₂) 
x₀: G
x₀ := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀induction 
rel: ElementaryMove R G s₁ s₂
rel with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀| 
zeroCoeff: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (tail : FormalSum R X) (x : X) (a : R),
  a = 0 → ElementaryMove R X ((a, x) :: tail) tail
zeroCoeff 
tail: FormalSum ?m.26854 ?m.26855
tail 
g: ?m.26855
g 
a: ?m.26854
a 
hyp: a = 0
hyp => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂, tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
coords (mulMonom b h ((a, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂, tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
coords (mulMonom b h ((a, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀
hyp: a = 0
hyp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂, tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
coords (mulMonom b h ((0, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂, tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
coords (mulMonom b h ((0, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂, tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
coords (mulMonom b h ((a, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.26965} → [inst : Ring R] → {X : Type ?u.26964} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords,
monom_coords_at_zero: ∀ {R : Type ?u.27021} [inst : Ring R] {X : Type ?u.27022} [inst_1 : DecidableEq X] (x₀ x : X),
  monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero]
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀| 
addCoeffs: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a b : R) (x : X)
  (tail : FormalSum R X), ElementaryMove R X ((a, x) :: (b, x) :: tail) ((a + b, x) :: tail)
addCoeffs 
a₁: ?m.26854
a₁ 
a₂: ?m.26854
a₂ 
x: ?m.26855
x 
tail: FormalSum ?m.26854 ?m.26855
tail => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ = coords (mulMonom b h ((a₁ + a₂, x) :: tail)) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.27720} → [inst : Ring R] → {X : Type ?u.27719} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
right_distrib: ∀ {R : Type ?u.27750} [inst : Mul R] [inst_1 : Add R] [inst_2 : RightDistribClass R] (a b c : R),
  (a + b) * c = a * c + b * c
right_distrib, 
monom_coords_hom: ∀ {R : Type ?u.27778} [inst : Ring R] {X : Type ?u.27779} [inst_1 : DecidableEq X] (x₀ x : X) (a b : R),
  monomCoeff R X x₀ (a + b, x) = monomCoeff R X x₀ (a, x) + monomCoeff R X x₀ (b, x)
monom_coords_hom, 
add_assoc: ∀ {G : Type ?u.27805} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙
        
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀| 
cons: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a : R) (x : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → ElementaryMove R X ((a, x) :: s₁) ((a, x) :: s₂)
cons 
a: ?m.26854
a 
x: ?m.26855
x 
t₁: FormalSum ?m.26854 ?m.26855
t₁ 
t₂: FormalSum ?m.26854 ?m.26855
t₂ 
_: ElementaryMove ?m.26854 ?m.26855 t₁ t₂
_ 
step: ?m.26859 t₁ t₂ a✝
step => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a: R

x: G

t₁, t₂: FormalSum R G

a✝: ElementaryMove R G t₁ t₂

step: coords (mulMonom b h t₁) x₀ = coords (mulMonom b h t₂) x₀

cons
coords (mulMonom b h ((a, x) :: t₁)) x₀ = coords (mulMonom b h ((a, x) :: t₂)) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.28343} → [inst : Ring R] → {X : Type ?u.28342} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
step: ?m.26859 t₁ t₂ a✝
step]
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀| 
swap: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a₁ a₂ : R) (x₁ x₂ : X)
  (tail : FormalSum R X), ElementaryMove R X ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
swap 
a₁: ?m.26854
a₁ 
a₂: ?m.26854
a₂ 
x₁: ?m.26855
x₁ 
x₂: ?m.26855
x₂ 
tail: FormalSum ?m.26854 ?m.26855
tail => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ = coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀simp [
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.28716} → [inst : Ring R] → {X : Type ?u.28715} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ = coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀conv =>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)lhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.29726} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)arg 1
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h)
add_comm: ∀ {G : Type ?u.29852} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ = coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.30037} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

b: R

h, x₀: G

s₁, s₂: FormalSum R G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀]
Goals accomplished! 🐙      


/-- invariance under moves for the first argument for multipilication -/
theorem 
first_arg_invariant: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {G : Type} [inst_2 : Group G] [inst_3 : DecidableEq G]
  (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → mul s₁ t ≈ mul s₂ t
first_arg_invariant (
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂ 
t: FormalSum R G
t : 
FormalSum: (R : Type ?u.30290) → Type ?u.30289 → [inst : Ring R] → Type (max?u.30289?u.30290)
FormalSum 
R: Type
R 
G: Type
G) (
rel: ElementaryMove R G s₁ s₂
rel : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G 
s₁: FormalSum R G
s₁ 
s₂: FormalSum R G
s₂) : 
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul 
s₁: FormalSum R G
s₁ 
t: FormalSum R G
t ≈  
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul 
s₂: FormalSum R G
s₂ 
t: FormalSum R G
t := by 
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂, t: FormalSum R G

rel: ElementaryMove R G s₁ s₂

mul s₁ t ≈ mul s₂ tcases 
t: FormalSum R G
t
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

nil
mul s₁ [] ≈ mul s₂ []
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head✝: R × G

tail✝: List (R × G)

cons
mul s₁ (head✝ :: tail✝) ≈ mul s₂ (head✝ :: tail✝)
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂, t: FormalSum R G

rel: ElementaryMove R G s₁ s₂

mul s₁ t ≈ mul s₂ tcase nil => 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

mul s₁ [] ≈ mul s₂ []simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

[] ≈ []
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

mul s₁ [] ≈ mul s₂ []rfl
Goals accomplished! 🐙
    
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂, t: FormalSum R G

rel: ElementaryMove R G s₁ s₂

mul s₁ t ≈ mul s₂ tcase cons 
head': ?m.30488
head' 
tail': List ?m.30488
tail' =>
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

mul s₁ (head' :: tail') ≈ mul s₂ (head' :: tail')let (
b: R
b, 
h: G
h) := 
head': ?m.30488
head'
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

b: R

h: G

mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

mul s₁ (head' :: tail') ≈ mul s₂ (head' :: tail')induction 
rel: ElementaryMove R G s₁ s₂
rel with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

b: R

h: G

mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')| 
zeroCoeff: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (tail : FormalSum R X) (x : X) (a : R),
  a = 0 → ElementaryMove R X ((a, x) :: tail) tail
zeroCoeff 
tail: FormalSum ?m.30808 ?m.30809
tail 
g: ?m.30809
g 
a: ?m.30808
a 
hyp: a = 0
hyp => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')
hyp: a = 0
hyp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((0, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((0, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
(0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail') ≈ mulMonom b h tail ++ mul tail tail'
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')apply 
funext: ∀ {α : Sort ?u.31170} {β : α → Sort ?u.31169} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff.h
∀ (x : G),
  coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x =     coords (mulMonom b h tail ++ mul tail tail') x;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff.h
∀ (x : G),
  coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x =     coords (mulMonom b h tail ++ mul tail tail') x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =   coords (mulMonom b h tail ++ mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =   coords (mulMonom b h tail ++ mul tail tail') x₀← 
append_coords: ∀ {R : Type ?u.31192} [inst : Ring R] {X : Type ?u.31193} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =   coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =   coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =   coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')simp [
coords: {R : Type ?u.31537} → [inst : Ring R] → {X : Type ?u.31536} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monom_coords_at_zero: ∀ {R : Type ?u.31593} [inst : Ring R] {X : Type ?u.31594} [inst_1 : DecidableEq X] (x₀ x : X),
  monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mulMonom b h tail ++ mul ((0, g) :: tail) tail') x₀ = coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mulMonom b h tail ++ mul ((0, g) :: tail) tail') x₀ = coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀← 
append_coords: ∀ {R : Type ?u.32112} [inst : Ring R] {X : Type ?u.32113} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mulMonom b h tail) x₀ + coords (mul ((0, g) :: tail) tail') x₀ =   coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mulMonom b h tail) x₀ + coords (mul ((0, g) :: tail) tail') x₀ =   coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀  
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')let 
rel': ElementaryMove R G ((0, g) :: tail) tail
rel' : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G ((
0: ?m.32863
0, 
g: ?m.30809
g) :: 
tail: FormalSum ?m.30808 ?m.30809
tail)  
tail: FormalSum ?m.30808 ?m.30809
tail := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

zeroCoeff.h
coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀by 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

ElementaryMove R G ((0, g) :: tail) tailapply 
ElementaryMove.zeroCoeff: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (tail : FormalSum R X) (x : X) (a : R),
  a = 0 → ElementaryMove R X ((a, x) :: tail) tail
ElementaryMove.zeroCoeff
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

h
0 = 0
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

ElementaryMove R G ((0, g) :: tail) tailrfl
Goals accomplished! 🐙
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')let 
prev: ?m.32970
prev  := 
first_arg_invariant: ∀ (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → mul s₁ t ≈ mul s₂ t
first_arg_invariant  
_: FormalSum R G
_ 
_: FormalSum R G
_ 
tail': List ?m.30488
tail' 
rel': ElementaryMove R G ((0, g) :: tail) tail
rel'
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

rel':= zeroCoeff tail g 0 (Eq.refl 0): ElementaryMove R G ((0, g) :: tail) tail

prev:= first_arg_invariant ((0, g) :: tail) tail tail' rel': mul ((0, g) :: tail) tail' ≈ mul tail tail'

zeroCoeff.h
coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀ 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')let 
pl: ?m.32978
pl := 
congrFun: ∀ {α : Sort ?u.32980} {β : α → Sort ?u.32979} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
prev: ?m.32970
prev 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

rel':= zeroCoeff tail g 0 (Eq.refl 0): ElementaryMove R G ((0, g) :: tail) tail

prev:= first_arg_invariant ((0, g) :: tail) tail tail' rel': mul ((0, g) :: tail) tail' ≈ mul tail tail'

pl:= congrFun prev x₀: coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀

zeroCoeff.h
coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

zeroCoeff
mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

rel':= zeroCoeff tail g 0 (Eq.refl 0): ElementaryMove R G ((0, g) :: tail) tail

prev:= first_arg_invariant ((0, g) :: tail) tail tail' rel': mul ((0, g) :: tail) tail' ≈ mul tail tail'

pl:= congrFun prev x₀: coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀

zeroCoeff.h
coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
pl: ?m.32978
pl
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

tail: FormalSum R G

g: G

a: R

hyp: a = 0

x₀: G

rel':= zeroCoeff tail g 0 (Eq.refl 0): ElementaryMove R G ((0, g) :: tail) tail

prev:= first_arg_invariant ((0, g) :: tail) tail tail' rel': mul ((0, g) :: tail) tail' ≈ mul tail tail'

pl:= congrFun prev x₀: coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀

zeroCoeff.h
coords (mul tail tail') x₀ = coords (mul tail tail') x₀]
Goals accomplished! 🐙  
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

b: R

h: G

mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')| 
addCoeffs: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a b : R) (x : X)
  (tail : FormalSum R X), ElementaryMove R X ((a, x) :: (b, x) :: tail) ((a + b, x) :: tail)
addCoeffs 
a₁: ?m.30808
a₁ 
a₂: ?m.30808
a₂ 
x: ?m.30809
x 
tail: FormalSum ?m.30808 ?m.30809
tail => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈   mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail'
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')apply 
funext: ∀ {α : Sort ?u.33075} {β : α → Sort ?u.33074} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs.h
∀ (x_1 : G),
  coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x_1 =     coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs.h
∀ (x_1 : G),
  coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x_1 =     coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀← 
append_coords: ∀ {R : Type ?u.33096} [inst : Ring R] {X : Type ?u.33097} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ + coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ + coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ + coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀← 
append_coords: ∀ {R : Type ?u.33207} [inst : Ring R] {X : Type ?u.33208} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ + coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail)) x₀ + coords (mul ((a₁ + a₂, x) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ + coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   coords (mulMonom b h ((a₁ + a₂, x) :: tail)) x₀ + coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')simp [
coords: {R : Type ?u.33323} → [inst : Ring R] → {X : Type ?u.33322} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ ((a₁ + a₂) * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ ((a₁ + a₂) * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
right_distrib: ∀ {R : Type ?u.34240} [inst : Mul R] [inst_1 : Add R] [inst_2 : RightDistribClass R] (a b c : R),
  (a + b) * c = a * c + b * c
right_distrib
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b + a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b + a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')simp [
monom_coords_hom: ∀ {R : Type ?u.34472} [inst : Ring R] {X : Type ?u.34473} [inst_1 : DecidableEq X] (x₀ x : X) (a b : R),
  monomCoeff R X x₀ (a + b, x) = monomCoeff R X x₀ (a, x) + monomCoeff R X x₀ (b, x)
monom_coords_hom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')let 
rel': ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)
rel' : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G 
          ((
a₁: ?m.30808
a₁, 
x: ?m.30809
x) :: (
a₂: ?m.30808
a₂, 
x: ?m.30809
x) :: 
tail: FormalSum ?m.30808 ?m.30809
tail)
            ((
a₁: ?m.30808
a₁ + 
a₂: ?m.30808
a₂, 
x: ?m.30809
x) :: 
tail: FormalSum ?m.30808 ?m.30809
tail) := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀by 
            
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)apply 
ElementaryMove.addCoeffs: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a b : R) (x : X)
  (tail : FormalSum R X), ElementaryMove R X ((a, x) :: (b, x) :: tail) ((a + b, x) :: tail)
ElementaryMove.addCoeffs
Goals accomplished! 🐙
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')let 
prev: ?m.35450
prev  := 
first_arg_invariant: ∀ (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → mul s₁ t ≈ mul s₂ t
first_arg_invariant  
_: FormalSum R G
_ 
_: FormalSum R G
_ 
tail': List ?m.30488
tail' 
rel': ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)
rel'
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

rel':= addCoeffs a₁ a₂ x tail: ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)

prev:= first_arg_invariant ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail) tail' rel': mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈ mul ((a₁ + a₂, x) :: tail) tail'

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀ 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')let 
pl: ?m.35458
pl := 
congrFun: ∀ {α : Sort ?u.35460} {β : α → Sort ?u.35459} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
prev: ?m.35450
prev 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

rel':= addCoeffs a₁ a₂ x tail: ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)

prev:= first_arg_invariant ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail) tail' rel': mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈ mul ((a₁ + a₂, x) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ = coords (mul ((a₁ + a₂, x) :: tail) tail') x₀

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

rel':= addCoeffs a₁ a₂ x tail: ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)

prev:= first_arg_invariant ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail) tail' rel': mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈ mul ((a₁ + a₂, x) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ = coords (mul ((a₁ + a₂, x) :: tail) tail') x₀

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
pl: ?m.35458
pl
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

rel':= addCoeffs a₁ a₂ x tail: ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)

prev:= first_arg_invariant ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail) tail' rel': mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈ mul ((a₁ + a₂, x) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ = coords (mul ((a₁ + a₂, x) :: tail) tail') x₀

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

x₀: G

rel':= addCoeffs a₁ a₂ x tail: ElementaryMove R G ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail)

prev:= first_arg_invariant ((a₁, x) :: (a₂, x) :: tail) ((a₁ + a₂, x) :: tail) tail' rel': mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈ mul ((a₁ + a₂, x) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ = coords (mul ((a₁ + a₂, x) :: tail) tail') x₀

addCoeffs.h
monomCoeff R G x₀ (a₁ * b, x * h) + (monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₁ * b, x * h) + monomCoeff R G x₀ (a₂ * b, x * h) + coords (mulMonom b h tail) x₀ +     coords (mul ((a₁ + a₂, x) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x: G

tail: FormalSum R G

addCoeffs
mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')simp [
add_assoc: ∀ {G : Type ?u.35491} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

b: R

h: G

mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')| 
cons: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a : R) (x : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → ElementaryMove R X ((a, x) :: s₁) ((a, x) :: s₂)
cons 
a: ?m.30808
a 
x: ?m.30809
x 
s₁: FormalSum ?m.30808 ?m.30809
s₁ 
s₂: FormalSum ?m.30808 ?m.30809
s₂ 
r: ElementaryMove ?m.30808 ?m.30809 s₁ s₂
r 
_: ?m.30813 s₁ s₂ r
_ => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mulMonom b h ((a, x) :: s₁) ++ mul ((a, x) :: s₁) tail' ≈ mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail'
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')apply 
funext: ∀ {α : Sort ?u.35957} {β : α → Sort ?u.35956} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons.h
∀ (x_1 : G),
  coords (mulMonom b h ((a, x) :: s₁) ++ mul ((a, x) :: s₁) tail') x_1 =     coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons.h
∀ (x_1 : G),
  coords (mulMonom b h ((a, x) :: s₁) ++ mul ((a, x) :: s₁) tail') x_1 =     coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁) ++ mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁) ++ mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x₀← 
append_coords: ∀ {R : Type ?u.35978} [inst : Ring R] {X : Type ?u.35979} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁)) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁)) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁)) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂) ++ mul ((a, x) :: s₂) tail') x₀← 
append_coords: ∀ {R : Type ?u.36089} [inst : Ring R] {X : Type ?u.36090} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁)) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂)) x₀ + coords (mul ((a, x) :: s₂) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
coords (mulMonom b h ((a, x) :: s₁)) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   coords (mulMonom b h ((a, x) :: s₂)) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')simp [
coords: {R : Type ?u.36205} → [inst : Ring R] → {X : Type ?u.36204} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')let 
rel': ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)
rel' : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G 
          ((
a: ?m.30808
a, 
x: ?m.30809
x) :: 
s₁: FormalSum ?m.30808 ?m.30809
s₁)
            ((
a: ?m.30808
a, 
x: ?m.30809
x) :: 
s₂: FormalSum ?m.30808 ?m.30809
s₂) := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀by 
            
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)apply 
ElementaryMove.cons: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a : R) (x : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → ElementaryMove R X ((a, x) :: s₁) ((a, x) :: s₂)
ElementaryMove.cons
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

a
ElementaryMove R G s₁ s₂
            
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)assumption
Goals accomplished! 🐙 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')let 
prev: ?m.37164
prev  := 
first_arg_invariant: ∀ (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → mul s₁ t ≈ mul s₂ t
first_arg_invariant  
_: FormalSum R G
_ 
_: FormalSum R G
_ 
tail': List ?m.30488
tail' 
rel': ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)
rel'
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')let 
pl: ?m.37172
pl := 
congrFun: ∀ {α : Sort ?u.37174} {β : α → Sort ?u.37173} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
prev: ?m.37164
prev 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₁) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
pl: ?m.37172
pl
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')let 
ps: ?m.37206
ps := 
mul_monom_invariant: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {G : Type} [inst_2 : Group G] [inst_3 : DecidableEq G] (b : R)
  (h x₀ : G) (s₁ s₂ : FormalSum R G),
  ElementaryMove R G s₁ s₂ → coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀
mul_monom_invariant 
b: R
b 
h: G
h 
x₀: ?α
x₀ 
s₁: FormalSum ?m.30808 ?m.30809
s₁ 
s₂: FormalSum ?m.30808 ?m.30809
s₂ 
r: ElementaryMove ?m.30808 ?m.30809 s₁ s₂
r
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

ps:= mul_monom_invariant b h x₀ s₁ s₂ r: coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

cons
mul ((a, x) :: s₁) ((b, h) :: tail') ≈ mul ((a, x) :: s₂) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

ps:= mul_monom_invariant b h x₀ s₁ s₂ r: coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₁) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀
ps: ?m.37206
ps
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁✝, s₂✝: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a: R

x: G

s₁, s₂: FormalSum R G

r: ElementaryMove R G s₁ s₂

a_ih✝: mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')

x₀: G

rel':= cons a x s₁ s₂ r: ElementaryMove R G ((a, x) :: s₁) ((a, x) :: s₂)

prev:= first_arg_invariant ((a, x) :: s₁) ((a, x) :: s₂) tail' rel': mul ((a, x) :: s₁) tail' ≈ mul ((a, x) :: s₂) tail'

pl:= congrFun prev x₀: coords (mul ((a, x) :: s₁) tail') x₀ = coords (mul ((a, x) :: s₂) tail') x₀

ps:= mul_monom_invariant b h x₀ s₁ s₂ r: coords (mulMonom b h s₁) x₀ = coords (mulMonom b h s₂) x₀

cons.h
monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀ =   monomCoeff R G x₀ (a * b, x * h) + coords (mulMonom b h s₂) x₀ + coords (mul ((a, x) :: s₂) tail') x₀]
Goals accomplished! 🐙       
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

head': R × G

tail': List (R × G)

b: R

h: G

mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')| 
swap: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a₁ a₂ : R) (x₁ x₂ : X)
  (tail : FormalSum R X), ElementaryMove R X ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
swap 
a₁: ?m.30808
a₁ 
a₂: ?m.30808
a₂ 
x₁: ?m.30809
x₁ 
x₂: ?m.30809
x₂ 
tail: FormalSum ?m.30808 ?m.30809
tail => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')simp [
mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail) ++ mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈   mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')apply 
funext: ∀ {α : Sort ?u.37308} {β : α → Sort ?u.37307} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap.h
∀ (x : G),
  coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail) ++ mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x =     coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap.h
∀ (x : G),
  coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail) ++ mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x =     coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail) ++ mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail) ++ mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀← 
append_coords: ∀ {R : Type ?u.37329} [inst : Ring R] {X : Type ?u.37330} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail) ++ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀← 
append_coords: ∀ {R : Type ?u.37440} [inst : Ring R] {X : Type ?u.37441} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: mulMonom b h ((a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: mulMonom b h ((a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: mulMonom b h ((a₂, x₂) :: tail)) x₀ + coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: (a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: (a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
coords ((a₁ * b, x₁ * h) :: (a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
coords: {R : Type ?u.38246} → [inst : Ring R] → {X : Type ?u.38245} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords ((a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords ((a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords ((a₂ * b, x₂ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
coords: {R : Type ?u.38435} → [inst : Ring R] → {X : Type ?u.38434} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: mulMonom b h ((a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: mulMonom b h ((a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: mulMonom b h ((a₁, x₁) :: tail)) x₀ + coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: (a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: (a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   coords ((a₂ * b, x₂ * h) :: (a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
coords: {R : Type ?u.38746} → [inst : Ring R] → {X : Type ?u.38745} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords ((a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords ((a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords ((a₁ * b, x₁ * h) :: mulMonom b h tail) x₀ +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
coords: {R : Type ?u.38935} → [inst : Ring R] → {X : Type ?u.38934} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')let 
rel': ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
rel' : 
ElementaryMove: (R X : Type) →
  [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
ElementaryMove 
R: Type
R 
G: Type
G 
          ((
a₁: ?m.30808
a₁, 
x₁: ?m.30809
x₁) :: (
a₂: ?m.30808
a₂, 
x₂: ?m.30809
x₂) :: 
tail: FormalSum ?m.30808 ?m.30809
tail)
            ((
a₂: ?m.30808
a₂, 
x₂: ?m.30809
x₂) :: (
a₁: ?m.30808
a₁, 
x₁: ?m.30809
x₁) :: 
tail: FormalSum ?m.30808 ?m.30809
tail) := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀by 
            
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)apply 
ElementaryMove.swap: ∀ {R X : Type} [inst : Ring R] [inst_1 : DecidableEq R] [inst_2 : DecidableEq X] (a₁ a₂ : R) (x₁ x₂ : X)
  (tail : FormalSum R X), ElementaryMove R X ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
ElementaryMove.swap
Goals accomplished! 🐙
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')let 
prev: ?m.39514
prev  := 
first_arg_invariant: ∀ (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → mul s₁ t ≈ mul s₂ t
first_arg_invariant  
_: FormalSum R G
_ 
_: FormalSum R G
_ 
tail': List ?m.30488
tail' 
rel': ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)
rel'
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀ 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')let 
pl: ?m.39522
pl := 
congrFun: ∀ {α : Sort ?u.39524} {β : α → Sort ?u.39523} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
prev: ?m.39514
prev 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
pl: ?m.39522
pl
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) +     coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀) 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.41272} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)← 
add_assoc: ∀ {G : Type ?u.41360} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀ =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

swap
mul ((a₁, x₁) :: (a₂, x₂) :: tail) ((b, h) :: tail') ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) ((b, h) :: tail')conv =>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

swap.h
monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)lhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h) =   monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₁ * b, x₁ * h) + monomCoeff R G x₀ (a₂ * b, x₂ * h)
add_comm: ∀ {G : Type ?u.42105} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

s₁, s₂: FormalSum R G

head': R × G

tail': List (R × G)

b: R

h: G

a₁, a₂: R

x₁, x₂: G

tail: FormalSum R G

x₀: G

rel':= swap a₁ a₂ x₁ x₂ tail: ElementaryMove R G ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail)

prev:= first_arg_invariant ((a₁, x₁) :: (a₂, x₂) :: tail) ((a₂, x₂) :: (a₁, x₁) :: tail) tail' rel': mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail' ≈ mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail'

pl:= congrFun prev x₀: coords (mul ((a₁, x₁) :: (a₂, x₂) :: tail) tail') x₀ = coords (mul ((a₂, x₂) :: (a₁, x₁) :: tail) tail') x₀

monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h)    
        
/-- multiplication for free modules -/
def 
mul: R[G] → R[G] → R[G]
mul : 
R: Type
R[
G: Type
G] → 
R: Type
R[
G: Type
G] → 
R: Type
R[
G: Type
G] := by
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]let 
f: ?m.42790
f  := fun (
s: FormalSum R G
s : 
FormalSum: (R : Type ?u.42793) → Type ?u.42792 → [inst : Ring R] → Type (max?u.42792?u.42793)
FormalSum 
R: Type
R 
G: Type
G) => 
    fun  (
t: R[G]
t : 
R: Type
R[
G: Type
G]) => 
mulAux: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → FormalSum R G → R[G] → R[G]
mulAux  
s: FormalSum R G
s 
t: R[G]
t
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

R[G] → R[G] → R[G] 
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]apply  
Quotient.lift: {α : Sort ?u.42884} →
  {β : Sort ?u.42883} → {s : Setoid α} → (f : α → β) → (∀ (a b : α), a ≈ b → f a = f b) → Quotient s → β
Quotient.lift 
f: ?m.42790
f
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

∀ (a b : FormalSum R G), a ≈ b → f a = f b
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]apply 
func_eql_of_move_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] {β : Sort ?u.42907}
  (f : FormalSum R X → β),
  (∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂) → ∀ (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → f s₁ = f s₂
func_eql_of_move_equiv
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

a
∀ (s₁ s₂ : FormalSum R G), ElementaryMove R G s₁ s₂ → f s₁ = f s₂  
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]intro 
s₁: FormalSum ?R ?X
s₁ 
s₂: FormalSum ?R ?X
s₂ 
rel: ElementaryMove ?R ?X s₁ s₂
rel
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

a
f s₁ = f s₂
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

a
(fun t => mulAux s₁ t) = fun t => mulAux s₂ t 
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]apply 
funext: ∀ {α : Sort ?u.43784} {β : α → Sort ?u.43783} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

a.h
∀ (x : R[G]), mulAux s₁ x = mulAux s₂ x
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]apply 
Quotient.ind: ∀ {α : Sort ?u.43803} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

a.h.a
∀ (a : FormalSum R G), mulAux s₁ (Quotient.mk (formalSumSetoid R G) a) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) a) 
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]intro 
t: ?α
t
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

a.h.a
mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]let 
lhs: mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk ?m.43855 (FormalSum.mul s₁ t)
lhs : 
mulAux: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → FormalSum R G → R[G] → R[G]
mulAux 
s₁: FormalSum ?R ?X
s₁ (
Quotient.mk: {α : Sort ?u.43834} → (s : Setoid α) → α → Quotient s
Quotient.mk (
formalSumSetoid: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → Setoid (FormalSum R X)
formalSumSetoid 
R: Type
R 
G: Type
G) 
t: ?α
t) = 
    ⟦
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul 
s₁: FormalSum ?R ?X
s₁ 
t: ?α
t⟧ := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

a.h.a
mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)by 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)rfl
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]let 
rhs: mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk ?m.43937 (FormalSum.mul s₂ t)
rhs : 
mulAux: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → FormalSum R G → R[G] → R[G]
mulAux 
s₂: FormalSum ?R ?X
s₂ (
Quotient.mk: {α : Sort ?u.43916} → (s : Setoid α) → α → Quotient s
Quotient.mk (
formalSumSetoid: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → Setoid (FormalSum R X)
formalSumSetoid 
R: Type
R 
G: Type
G) 
t: ?α
t) = 
    ⟦
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul 
s₂: FormalSum ?R ?X
s₂ 
t: ?α
t⟧ := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

a.h.a
mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)by 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)rfl
Goals accomplished! 🐙
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)
lhs: mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk ?m.43855 (FormalSum.mul s₁ t)
lhs,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)
rhs: mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk ?m.43937 (FormalSum.mul s₂ t)
rhs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a
FormalSum.mul s₁ t ≈ FormalSum.mul s₂ t
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]apply 
first_arg_invariant: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {G : Type} [inst_2 : Group G] [inst_3 : DecidableEq G]
  (s₁ s₂ t : FormalSum R G), ElementaryMove R G s₁ s₂ → FormalSum.mul s₁ t ≈ FormalSum.mul s₂ t
first_arg_invariant
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

f:= fun s t => mulAux s t: FormalSum R G → R[G] → R[G]

s₁, s₂: FormalSum R G

rel: ElementaryMove R G s₁ s₂

t: FormalSum R G

lhs:= Eq.refl (mulAux s₁ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₁ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₁ t)

rhs:= Eq.refl (mulAux s₂ (Quotient.mk (formalSumSetoid R G) t)): mulAux s₂ (Quotient.mk (formalSumSetoid R G) t) = Quotient.mk (formalSumSetoid R G) (FormalSum.mul s₂ t)

a.h.a.rel
ElementaryMove R G s₁ s₂
  
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

R[G] → R[G] → R[G]exact 
rel: ElementaryMove ?R ?X s₁ s₂
rel
Goals accomplished! 🐙

/-!
## The Ring Structure
-/

instance 
groupRingMul: Mul (R[G])
groupRingMul : 
Mul: Type ?u.44472 → Type ?u.44472
Mul (
R: Type
R[
G: Type
G]) := 
  ⟨
mul: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → R[G] → R[G] → R[G]
mul⟩

instance: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → [inst_2 : DecidableEq G] → One (R[G])
instance : 
One: Type ?u.44839 → Type ?u.44839
One (
R: Type
R[
G: Type
G]) := 
  ⟨⟦[(
1: ?m.44918
1, 
1: ?m.44951
1)]⟧⟩

instance: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : DecidableEq G] → AddCommGroup (R[G])
instance : 
AddCommGroup: Type ?u.45330 → Type ?u.45330
AddCommGroup (
R: Type
R[
G: Type
G]) := 
  {
    zero := ⟦ 
[]: List ?m.45566
[] ⟧
    add := 
FreeModule.add: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X] → R[X] → R[X]
FreeModule.add
    
    add_assoc := 
FreeModule.addn_assoc: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x₁ x₂ x₃ : R[X]), x₁ + x₂ + x₃ = x₁ + (x₂ + x₃)
FreeModule.addn_assoc
    add_zero := 
FreeModule.addn_zero: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), x + FreeModule.zero = x
FreeModule.addn_zero
    zero_add := 
FreeModule.zero_addn: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), FreeModule.zero + x = x
FreeModule.zero_addn
    add_comm := 
FreeModule.addn_comm: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x₁ x₂ : R[X]), x₁ + x₂ = x₂ + x₁
FreeModule.addn_comm
    add_left_neg := by
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0intro 
x: R[G]
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0let 
l: ?m.46183
l := 
FreeModule.coeffs_distrib: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (a b : R) (x : R[X]), a • x + b • x = (a + b) • x
FreeModule.coeffs_distrib (-
1: ?m.46191
1 : 
R: Type
R) (
1: ?m.46219
1 : 
R: Type
R) 
x: R[G]
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l:= FreeModule.coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l:= FreeModule.coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
add_left_neg: ∀ {G : Type ?u.46257} [inst : AddGroup G] (a : G), -a + a = 0
add_left_neg,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + 1 • x = 0 • x

-x + x = 0 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l:= FreeModule.coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
FreeModule.unit_coeffs: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), 1 • x = x
FreeModule.unit_coeffs,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = 0 • x

-x + x = 0 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l:= FreeModule.coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
FreeModule.zero_coeffs: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]),
  0 • x = Quotient.mk (formalSumSetoid R X) []
FreeModule.zero_coeffs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

-x + x = 0]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

-x + x = 0 at 
l: ?m.46183
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0exact 
l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []
l
Goals accomplished! 🐙
  }

/-- The group ring is a ring -/
instance: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → Ring (R[G])
instance : 
Ring: Type ?u.46963 → Type ?u.46963
Ring (
R: Type
R[
G: Type
G]) :=
  {
    mul := 
mul: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {G : Type} → [inst_2 : Group G] → [inst_3 : DecidableEq G] → R[G] → R[G] → R[G]
mul
    neg := fun 
x: ?m.47542
x => (-
1: ?m.47555
1 : 
R: Type
R) • 
x: ?m.47542
x

    sub_eq_add_neg := by 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b : R[G]), a - b = a + -bintro 
x: R[G]
x 
y: R[G]
y
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: R[G]

x - y = x + -y 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b : R[G]), a - b = a + -brfl
Goals accomplished! 🐙

    add_left_neg := by 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0intro 
x: R[G]
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0let 
l: ?m.67165
l := 
FreeModule.coeffs_distrib: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (a b : R) (x : R[X]), a • x + b • x = (a + b) • x
FreeModule.coeffs_distrib (-
1: ?m.67173
1 : 
R: Type
R) (
1: ?m.67203
1 : 
R: Type
R) 
x: R[G]
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l:= FreeModule.coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0simp at 
l: ?m.67165
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + 1 • x = 0 • x

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0have 
lc: -1 + 1 = 0
lc : (-
1: ?m.67648
1 : 
R: Type
R) + 
1: ?m.67666
1 = 
0: ?m.67687
0 := 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + 1 • x = 0 • x

-x + x = 0by 
            
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + 1 • x = 0 • x

-1 + 1 = 0apply 
add_left_neg: ∀ {G : Type ?u.67840} [inst : AddGroup G] (a : G), -a + a = 0
add_left_neg
Goals accomplished! 🐙
        -- rw [lc] at l
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + 1 • x = 0 • x

lc: -1 + 1 = 0

-x + x = 0
FreeModule.unit_coeffs: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), 1 • x = x
FreeModule.unit_coeffs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = 0 • x

lc: -1 + 1 = 0

-x + x = 0]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = 0 • x

lc: -1 + 1 = 0

-x + x = 0 at 
l: -1 • x + 1 • x = 0 • x
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = 0 • x

lc: -1 + 1 = 0

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = 0 • x

lc: -1 + 1 = 0

-x + x = 0
FreeModule.zero_coeffs: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]),
  0 • x = Quotient.mk (formalSumSetoid R X) []
FreeModule.zero_coeffs
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

lc: -1 + 1 = 0

-x + x = 0]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

lc: -1 + 1 = 0

-x + x = 0 at 
l: -1 • x + x = 0 • x
l
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: R[G]

l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []

lc: -1 + 1 = 0

-x + x = 0
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), -a + a = 0exact 
l: -1 • x + x = Quotient.mk (formalSumSetoid R G) []
l
Goals accomplished! 🐙

    left_distrib := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * capply @
Quotient.ind: ∀ {α : Sort ?u.47798} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
a: ?m.47811
a  =>
        ∀ 
b: ?m.47814
b 
c: ?m.47817
c, 
a: ?m.47811
a * (
b: ?m.47814
b + 
c: ?m.47817
c) = 
a: ?m.47811
a * 
b: ?m.47814
b + 
a: ?m.47811
a * 
c: ?m.47817
c)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : FormalSum R G) (b c : R[G]),
  Quotient.mk (formalSumSetoid R G) a * (b + c) =     Quotient.mk (formalSumSetoid R G) a * b + Quotient.mk (formalSumSetoid R G) a * c
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * cintro 
x: ?m.47804
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (b c : R[G]),
  Quotient.mk (formalSumSetoid R G) x * (b + c) =     Quotient.mk (formalSumSetoid R G) x * b + Quotient.mk (formalSumSetoid R G) x * c
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * capply @
Quotient.ind₂: ∀ {α : Sort ?u.48470} {β : Sort ?u.48469} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop},
  (∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)) →
    ∀ (q₁ : Quotient s₁) (q₂ : Quotient s₂), motive q₁ q₂
Quotient.ind₂ (motive := fun 
b: ?m.48502
b 
c: ?m.48505
c =>
        ⟦ 
x: ?m.47804
x ⟧ * (
b: ?m.48502
b + 
c: ?m.48505
c) = ⟦ 
x: ?m.47804
x ⟧ * 
b: ?m.48502
b + ⟦ 
x: ?m.47804
x ⟧ * 
c: ?m.48505
c)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (a b : FormalSum R G),
  Quotient.mk (formalSumSetoid R G) x * (Quotient.mk (formalSumSetoid R G) a + Quotient.mk (formalSumSetoid R G) b) =     Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) a +       Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) b
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * cintro 
y: ?m.48479
y 
z: ?m.48487
z
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

Quotient.mk (formalSumSetoid R G) x * (Quotient.mk (formalSumSetoid R G) y + Quotient.mk (formalSumSetoid R G) z) =   Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) y +     Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) z
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * capply 
Quotient.sound: ∀ {α : Sort ?u.49162} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul x (y ++ z) ≈ FormalSum.mul x y ++ FormalSum.mul x z
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * (b + c) = a * b + a * cinduction 
y: ?m.48479
y with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul x (y ++ z) ≈ FormalSum.mul x y ++ FormalSum.mul x z| 
nil: {α : Type u} → List α
nil => 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

a.nil
FormalSum.mul x ([] ++ z) ≈ FormalSum.mul x [] ++ FormalSum.mul x zsimp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

a.nil
FormalSum.mul x z ≈ FormalSum.mul x [] ++ FormalSum.mul x z
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

a.nil
FormalSum.mul x ([] ++ z) ≈ FormalSum.mul x [] ++ FormalSum.mul x zsimp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

a.nil
FormalSum.mul x z ≈ FormalSum.mul x z
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

a.nil
FormalSum.mul x ([] ++ z) ≈ FormalSum.mul x [] ++ FormalSum.mul x zapply 
eqlCoords.refl: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s : FormalSum R X), eqlCoords R X s s
eqlCoords.refl
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul x (y ++ z) ≈ FormalSum.mul x y ++ FormalSum.mul x z| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.49212
h 
t: List ?m.49212
t 
ih: ?m.49213 t
ih =>
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zsimp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
mulMonom h.fst h.snd x ++ FormalSum.mul x (t ++ z) ≈ mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zapply 
funext: ∀ {α : Sort ?u.49615} {β : α → Sort ?u.49614} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons.h
∀ (x_1 : G),
  coords (mulMonom h.fst h.snd x ++ FormalSum.mul x (t ++ z)) x_1 =     coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons.h
∀ (x_1 : G),
  coords (mulMonom h.fst h.snd x ++ FormalSum.mul x (t ++ z)) x_1 =     coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zintro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x ++ FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zrepeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x ++ FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x ++ (FormalSum.mul x t ++ FormalSum.mul x z)) x₀← 
append_coords: ∀ {R : Type ?u.49889} [inst : Ring R] {X : Type ?u.49890} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x) x₀ + (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀)]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x t ++ FormalSum.mul x z) x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x (t ++ z)) x₀ =   coords (mulMonom h.fst h.snd x) x₀ + coords (FormalSum.mul x t ++ FormalSum.mul x z) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zsimp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zlet 
lih: ?m.50826
lih := 
congrFun: ∀ {α : Sort ?u.50828} {β : α → Sort ?u.50827} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
ih: ?m.49213 t
ih 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t ++ FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zrw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t ++ FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀← 
append_coords: ∀ {R : Type ?u.50844} [inst : Ring R] {X : Type ?u.50845} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀ at 
lih: ?m.50826
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

a.cons
FormalSum.mul x (h :: t ++ z) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul x zrw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀
lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, z: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul x (t ++ z) ≈ FormalSum.mul x t ++ FormalSum.mul x z

x₀: G

lih: coords (FormalSum.mul x (t ++ z)) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀

a.cons.h
coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀ =   coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul x z) x₀]
Goals accomplished! 🐙
    right_distrib := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * capply @
Quotient.ind: ∀ {α : Sort ?u.50988} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
a: ?m.51001
a  =>
        ∀ 
b: ?m.51004
b 
c: ?m.51007
c, (
a: ?m.51001
a + 
b: ?m.51004
b) * 
c: ?m.51007
c = 
a: ?m.51001
a * 
c: ?m.51007
c + 
b: ?m.51004
b * 
c: ?m.51007
c)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : FormalSum R G) (b c : R[G]),
  (Quotient.mk (formalSumSetoid R G) a + b) * c = Quotient.mk (formalSumSetoid R G) a * c + b * c
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * cintro 
x: ?m.50994
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (b c : R[G]), (Quotient.mk (formalSumSetoid R G) x + b) * c = Quotient.mk (formalSumSetoid R G) x * c + b * c
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * capply @
Quotient.ind₂: ∀ {α : Sort ?u.51573} {β : Sort ?u.51572} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop},
  (∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)) →
    ∀ (q₁ : Quotient s₁) (q₂ : Quotient s₂), motive q₁ q₂
Quotient.ind₂ (motive := fun 
b: ?m.51605
b 
c: ?m.51608
c =>
        (⟦ 
x: ?m.50994
x ⟧ + 
b: ?m.51605
b) * 
c: ?m.51608
c = ⟦ 
x: ?m.50994
x ⟧ * 
c: ?m.51608
c + 
b: ?m.51605
b * 
c: ?m.51608
c)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (a b : FormalSum R G),
  (Quotient.mk (formalSumSetoid R G) x + Quotient.mk (formalSumSetoid R G) a) * Quotient.mk (formalSumSetoid R G) b =     Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) b +       Quotient.mk (formalSumSetoid R G) a * Quotient.mk (formalSumSetoid R G) b
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * cintro 
y: ?m.51582
y 
z: ?m.51590
z
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

(Quotient.mk (formalSumSetoid R G) x + Quotient.mk (formalSumSetoid R G) y) * Quotient.mk (formalSumSetoid R G) z =   Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) z +     Quotient.mk (formalSumSetoid R G) y * Quotient.mk (formalSumSetoid R G) z
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * capply 
Quotient.sound: ∀ {α : Sort ?u.52011} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul (x ++ y) z ≈ FormalSum.mul x z ++ FormalSum.mul y z
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), (a + b) * c = a * c + b * cinduction 
z: ?m.51590
z with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul (x ++ y) z ≈ FormalSum.mul x z ++ FormalSum.mul y z| 
nil: {α : Type u} → List α
nil => 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

a.nil
FormalSum.mul (x ++ y) [] ≈ FormalSum.mul x [] ++ FormalSum.mul y []simp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

a.nil
[] ≈ []
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

a.nil
FormalSum.mul (x ++ y) [] ≈ FormalSum.mul x [] ++ FormalSum.mul y []apply 
eqlCoords.refl: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s : FormalSum R X), eqlCoords R X s s
eqlCoords.refl
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul (x ++ y) z ≈ FormalSum.mul x z ++ FormalSum.mul y z| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.52052
h 
t: List ?m.52052
t 
ih: ?m.52053 t
ih => 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)let (
a: R
a, 
h: G
h) := 
h: ?m.52052
h
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h: G

a.cons
FormalSum.mul (x ++ y) ((a, h) :: t) ≈ FormalSum.mul x ((a, h) :: t) ++ FormalSum.mul y ((a, h) :: t)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)simp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h: G

a.cons
mulMonom a h (x ++ y) ++ FormalSum.mul (x ++ y) t ≈   mulMonom a h x ++ (FormalSum.mul x t ++ (mulMonom a h y ++ FormalSum.mul y t))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)funext 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y) ++ FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x ++ (FormalSum.mul x t ++ (mulMonom a h y ++ FormalSum.mul y t))) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)repeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y) ++ FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x ++ (FormalSum.mul x t ++ (mulMonom a h y ++ FormalSum.mul y t))) x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ + coords (FormalSum.mul x t ++ (mulMonom a h y ++ FormalSum.mul y t)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ + coords (FormalSum.mul x t ++ (mulMonom a h y ++ FormalSum.mul y t)) x₀← 
append_coords: ∀ {R : Type ?u.52503} [inst : Ring R] {X : Type ?u.52504} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ + (coords (FormalSum.mul x t) x₀ + coords (mulMonom a h y ++ FormalSum.mul y t) x₀))
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ + (coords (FormalSum.mul x t) x₀ + coords (mulMonom a h y ++ FormalSum.mul y t) x₀)
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)let 
lih: ?m.53344
lih := 
congrFun: ∀ {α : Sort ?u.53346} {β : α → Sort ?u.53345} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
ih: ?m.52053 t
ih 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t ++ FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t ++ FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))← 
append_coords: ∀ {R : Type ?u.53362} [inst : Ring R] {X : Type ?u.53363} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀)) at 
lih: ?m.53344
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + coords (FormalSum.mul (x ++ y) t) x₀ =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)simp only [
add_assoc: ∀ {G : Type ?u.53509} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h (x ++ y)) x₀ + (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
mul_monom_dist: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (b : R) (h x₀ : G)
  (s₁ s₂ : FormalSum R G),
  coords (mulMonom b h (s₁ ++ s₂)) x₀ = coords (mulMonom b h s₁) x₀ + coords (mulMonom b h s₂) x₀
mul_monom_dist
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h x) x₀ + coords (mulMonom a h y) x₀ +     (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h✝: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a: R

h, x₀: G

lih: coords (FormalSum.mul (x ++ y) t) x₀ = coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀

a.cons.h
coords (mulMonom a h x) x₀ + coords (mulMonom a h y) x₀ +     (coords (FormalSum.mul x t) x₀ + coords (FormalSum.mul y t) x₀) =   coords (mulMonom a h x) x₀ +     (coords (FormalSum.mul x t) x₀ + (coords (mulMonom a h y) x₀ + coords (FormalSum.mul y t) x₀))
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

h: R × G

t: List (R × G)

ih: FormalSum.mul (x ++ y) t ≈ FormalSum.mul x t ++ FormalSum.mul y t

a.cons
FormalSum.mul (x ++ y) (h :: t) ≈ FormalSum.mul x (h :: t) ++ FormalSum.mul y (h :: t)simp only [
add_assoc: ∀ {G : Type ?u.53760} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc, 
add_left_comm: ∀ {G : Type ?u.53772} [inst : AddCommSemigroup G] (a b c : G), a + (b + c) = b + (a + c)
add_left_comm, 
add_left_cancel_iff: ∀ {G : Type ?u.53784} [inst : Add G] [inst_1 : IsLeftCancelAdd G] {a b c : G}, a + b = a + c ↔ b = c
add_left_cancel_iff]
Goals accomplished! 🐙
    zero_mul := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 0 * a = 0apply 
Quotient.ind: ∀ {α : Sort ?u.54431} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a
∀ (a : FormalSum R G), 0 * Quotient.mk (formalSumSetoid R G) a = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 0 * a = 0intro 
x: ?α
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a
0 * Quotient.mk (formalSumSetoid R G) x = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 0 * a = 0apply 
Quotient.sound: ∀ {α : Sort ?u.54455} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a
FormalSum.mul [] x ≈ []
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 0 * a = 0induction 
x: ?α
x with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a
FormalSum.mul [] x ≈ []| 
nil: {α : Type u} → List α
nil =>        
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a.a.nil
FormalSum.mul [] [] ≈ []rfl
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a
FormalSum.mul [] x ≈ []| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.54511
h 
t: List ?m.54511
t 
ih: ?m.54512 t
ih =>        
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
mulMonom h.fst h.snd [] ++ FormalSum.mul [] t ≈ []]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
mulMonom h.fst h.snd [] ++ FormalSum.mul [] t ≈ []
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
mulMonom h.fst h.snd [] ++ FormalSum.mul [] t ≈ []
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []apply 
funext: ∀ {α : Sort ?u.54722} {β : α → Sort ?u.54721} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons.h
∀ (x : G), coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x = coords [] x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ [];
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons.h
∀ (x : G), coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x = coords [] x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []let 
lih: ?m.54745
lih := 
congrFun: ∀ {α : Sort ?u.54747} {β : α → Sort ?u.54746} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
ih: ?m.54512 t
ih 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul [] t) x₀ = coords [] x₀

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih:= congrFun ih x₀: coords (FormalSum.mul [] t) x₀ = coords [] x₀

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀
coords: {R : Type ?u.54892} → [inst : Ring R] → {X : Type ?u.54891} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀ at 
lih: ?m.54745
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd [] ++ FormalSum.mul [] t) x₀ = coords [] x₀← 
append_coords: ∀ {R : Type ?u.54897} [inst : Ring R] {X : Type ?u.54898} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ + coords (FormalSum.mul [] t) x₀ = coords [] x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ + coords (FormalSum.mul [] t) x₀ = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ + coords (FormalSum.mul [] t) x₀ = coords [] x₀
lih: coords (FormalSum.mul [] t) x₀ = 0
lih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ + 0 = coords [] x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ + 0 = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ = coords [] x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

a.a.cons
FormalSum.mul [] (h :: t) ≈ []rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords (mulMonom h.fst h.snd []) x₀ = coords [] x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

h: R × G

t: List (R × G)

ih: FormalSum.mul [] t ≈ []

x₀: G

lih: coords (FormalSum.mul [] t) x₀ = 0

a.a.cons.h
coords [] x₀ = coords [] x₀]
Goals accomplished! 🐙

    mul_zero := by 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 0 = 0apply 
Quotient.ind: ∀ {α : Sort ?u.55271} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a
∀ (a : FormalSum R G), Quotient.mk (formalSumSetoid R G) a * 0 = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 0 = 0intro 
x: ?α
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a
Quotient.mk (formalSumSetoid R G) x * 0 = 0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 0 = 0rfl
Goals accomplished! 🐙

    one := ⟦[(
1: ?m.47331
1, 
1: ?m.47361
1)]⟧
    natCast := fun 
n: ?m.47470
n => ⟦ [(
n: ?m.47470
n, 
1: ?m.47527
1)] ⟧
    natCast_zero := 
      by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

NatCast.natCast 0 = 0apply 
Quotient.sound: ∀ {α : Sort ?u.63923} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a
[(↑0, 1)] ≈ []
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

NatCast.natCast 0 = 0apply 
funext: ∀ {α : Sort ?u.63957} {β : α → Sort ?u.63956} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a.h
∀ (x : G), coords [(↑0, 1)] x = coords [] x;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a.h
∀ (x : G), coords [(↑0, 1)] x = coords [] x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

NatCast.natCast 0 = 0intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h
coords [(↑0, 1)] x₀ = coords [] x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

NatCast.natCast 0 = 0simp [
coords: {R : Type ?u.63980} → [inst : Ring R] → {X : Type ?u.63979} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.64037) → (X : Type ?u.64036) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h
(match 1 == x₀ with
  | true => 0
  | false => 0) =   0
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

NatCast.natCast 0 = 0cases 
1: ?m.65195
1 == 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h.false
(match false with
  | true => 0
  | false => 0) =   0
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h.true
(match true with
  | true => 0
  | false => 0) =   0 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h
(match 1 == x₀ with
  | true => 0
  | false => 0) =   0<;>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h.false
(match false with
  | true => 0
  | false => 0) =   0
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h.true
(match true with
  | true => 0
  | false => 0) =   0 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.h
(match 1 == x₀ with
  | true => 0
  | false => 0) =   0rfl
Goals accomplished! 🐙
    natCast_succ := by 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1intro 
n: ℕ
n
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

NatCast.natCast (n + 1) = NatCast.natCast n + 1
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1apply 
Quotient.sound: ∀ {α : Sort ?u.65396} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

a
[(↑(n + 1), 1)] ≈ [(↑n, 1)] ++ [(1, 1)]
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1apply 
funext: ∀ {α : Sort ?u.65421} {β : α → Sort ?u.65420} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

a.h
∀ (x : G), coords [(↑(n + 1), 1)] x = coords ([(↑n, 1)] ++ [(1, 1)]) x;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

a.h
∀ (x : G), coords [(↑(n + 1), 1)] x = coords ([(↑n, 1)] ++ [(1, 1)]) x 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

a.h
coords [(↑(n + 1), 1)] x₀ = coords ([(↑n, 1)] ++ [(1, 1)]) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

a.h
coords [(↑(n + 1), 1)] x₀ = coords ([(↑n, 1)] ++ [(1, 1)]) x₀← 
append_coords: ∀ {R : Type ?u.65442} [inst : Ring R] {X : Type ?u.65443} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

a.h
coords [(↑(n + 1), 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

a.h
coords [(↑(n + 1), 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

a.h
coords [(↑n + 1, 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1cases m:
1: ?m.65824
1 == 
x₀: ?α
x₀ with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

x✝: Bool

m: (1 == x₀) = x✝

a.h
coords [(↑n + 1, 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀| 
true: Bool
true => 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

m: (1 == x₀) = true

a.h.true
coords [(↑n + 1, 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀simp only [
coords: {R : Type ?u.65911} → [inst : Ring R] → {X : Type ?u.65910} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.65942) → (X : Type ?u.65941) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff, 
m: (1 == x₀) = true
m, 
add_zero: ∀ {M : Type ?u.65959} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero]
Goals accomplished! 🐙 
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

x✝: Bool

m: (1 == x₀) = x✝

a.h
coords [(↑n + 1, 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀| 
false: Bool
false => 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

n: ℕ

x₀: G

m: (1 == x₀) = false

a.h.false
coords [(↑n + 1, 1)] x₀ = coords [(↑n, 1)] x₀ + coords [(1, 1)] x₀simp only [
coords: {R : Type ?u.66452} → [inst : Ring R] → {X : Type ?u.66451} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.66483) → (X : Type ?u.66482) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff, 
m: (1 == x₀) = false
m, 
add_zero: ∀ {M : Type ?u.66500} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero]
Goals accomplished! 🐙        
    mul_assoc := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)apply @
Quotient.ind: ∀ {α : Sort ?u.55312} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
a: ?m.55325
a  =>
        ∀ 
b: ?m.55328
b 
c: ?m.55331
c, 
a: ?m.55325
a * 
b: ?m.55328
b * 
c: ?m.55331
c = 
a: ?m.55325
a * (
b: ?m.55328
b * 
c: ?m.55331
c))
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : FormalSum R G) (b c : R[G]),
  Quotient.mk (formalSumSetoid R G) a * b * c = Quotient.mk (formalSumSetoid R G) a * (b * c)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)intro 
x: ?m.55318
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (b c : R[G]), Quotient.mk (formalSumSetoid R G) x * b * c = Quotient.mk (formalSumSetoid R G) x * (b * c)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)apply @
Quotient.ind₂: ∀ {α : Sort ?u.55953} {β : Sort ?u.55952} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop},
  (∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)) →
    ∀ (q₁ : Quotient s₁) (q₂ : Quotient s₂), motive q₁ q₂
Quotient.ind₂ (motive := fun 
b: ?m.55985
b 
c: ?m.55988
c =>
        ⟦ 
x: ?m.55318
x ⟧ * 
b: ?m.55985
b * 
c: ?m.55988
c = ⟦ 
x: ?m.55318
x ⟧ * (
b: ?m.55985
b  * 
c: ?m.55988
c))
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

∀ (a b : FormalSum R G),
  Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) a * Quotient.mk (formalSumSetoid R G) b =     Quotient.mk (formalSumSetoid R G) x * (Quotient.mk (formalSumSetoid R G) a * Quotient.mk (formalSumSetoid R G) b)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)intro 
y: ?m.55962
y 
z: ?m.55970
z
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

Quotient.mk (formalSumSetoid R G) x * Quotient.mk (formalSumSetoid R G) y * Quotient.mk (formalSumSetoid R G) z =   Quotient.mk (formalSumSetoid R G) x * (Quotient.mk (formalSumSetoid R G) y * Quotient.mk (formalSumSetoid R G) z)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)apply 
Quotient.sound: ∀ {α : Sort ?u.56587} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a
FormalSum.mul (FormalSum.mul x y) z ≈ FormalSum.mul x (FormalSum.mul y z)
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)apply 
funext: ∀ {α : Sort ?u.56609} {β : α → Sort ?u.56608} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a.h
∀ (x_1 : G), coords (FormalSum.mul (FormalSum.mul x y) z) x_1 = coords (FormalSum.mul x (FormalSum.mul y z)) x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

a.h
∀ (x_1 : G), coords (FormalSum.mul (FormalSum.mul x y) z) x_1 = coords (FormalSum.mul x (FormalSum.mul y z)) x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)intro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

x₀: G

a.h
coords (FormalSum.mul (FormalSum.mul x y) z) x₀ = coords (FormalSum.mul x (FormalSum.mul y z)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)simp [
coords: {R : Type ?u.56631} → [inst : Ring R] → {X : Type ?u.56630} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

x₀: G

a.h
coords (FormalSum.mul (FormalSum.mul x y) z) x₀ = coords (FormalSum.mul x (FormalSum.mul y z)) x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a b c : R[G]), a * b * c = a * (b * c)induction 
z: ?m.55970
z with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

x₀: G

a.h
coords (FormalSum.mul (FormalSum.mul x y) z) x₀ = coords (FormalSum.mul x (FormalSum.mul y z)) x₀| 
nil: {α : Type u} → List α
nil => 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

a.h.nil
coords (FormalSum.mul (FormalSum.mul x y) []) x₀ = coords (FormalSum.mul x (FormalSum.mul y [])) x₀simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

a.h.nil
coords (FormalSum.mul (FormalSum.mul x y) []) x₀ = coords (FormalSum.mul x (FormalSum.mul y [])) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

a.h.nil
coords (FormalSum.mul (FormalSum.mul x y) []) x₀ = coords (FormalSum.mul x (FormalSum.mul y [])) x₀simp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul]
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y, z: FormalSum R G

x₀: G

a.h
coords (FormalSum.mul (FormalSum.mul x y) z) x₀ = coords (FormalSum.mul x (FormalSum.mul y z)) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.56882
h 
t: List ?m.56882
t 
ih: ?m.56883 t
ih => 
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀let (
a: R
a, 
h: G
h) := 
h: ?m.56882
h
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) ((a, h) :: t)) x₀ =   coords (FormalSum.mul x (FormalSum.mul y ((a, h) :: t))) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀simp [
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y) ++ FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀repeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y) ++ FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y) ++ FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀← 
append_coords: ∀ {R : Type ?u.57792} [inst : Ring R] {X : Type ?u.57793} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y ++ FormalSum.mul y t)) x₀
mul_dist: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (x₀ : G) (s₁ s₂ s₃ : FormalSum R G),
  coords (FormalSum.mul s₁ (s₂ ++ s₃)) x₀ = coords (FormalSum.mul s₁ s₂) x₀ + coords (FormalSum.mul s₁ s₃) x₀
mul_dist
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul (FormalSum.mul x y) t) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀
ih: ?m.56883 t
ih
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀
          
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a.h.cons
coords (FormalSum.mul (FormalSum.mul x y) (h :: t)) x₀ = coords (FormalSum.mul x (FormalSum.mul y (h :: t))) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (mulMonom a h (FormalSum.mul x y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀
mul_monom_assoc: ∀ {R : Type} [inst : Ring R] {G : Type} [inst_1 : Group G] [inst_2 : DecidableEq G] (b : R) (h x₀ : G)
  (s₁ s₂ : FormalSum R G),
  coords (mulMonom b h (FormalSum.mul s₁ s₂)) x₀ = coords (FormalSum.mul s₁ (mulMonom b h s₂)) x₀
mul_monom_assoc
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x, y: FormalSum R G

x₀: G

h✝: R × G

t: List (R × G)

ih: coords (FormalSum.mul (FormalSum.mul x y) t) x₀ = coords (FormalSum.mul x (FormalSum.mul y t)) x₀

a: R

h: G

a.h.cons
coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀ =   coords (FormalSum.mul x (mulMonom a h y)) x₀ + coords (FormalSum.mul x (FormalSum.mul y t)) x₀]
Goals accomplished! 🐙
    mul_one := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = aapply 
Quotient.ind: ∀ {α : Sort ?u.59732} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a
∀ (a : FormalSum R G), Quotient.mk (formalSumSetoid R G) a * 1 = Quotient.mk (formalSumSetoid R G) a
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = aintro 
x: ?α
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a
Quotient.mk (formalSumSetoid R G) x * 1 = Quotient.mk (formalSumSetoid R G) x
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = aapply 
Quotient.sound: ∀ {α : Sort ?u.59753} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a
FormalSum.mul x [(1, 1)] ≈ x
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = aapply 
funext: ∀ {α : Sort ?u.59777} {β : α → Sort ?u.59776} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a.h
∀ (x_1 : G), coords (FormalSum.mul x [(1, 1)]) x_1 = coords x x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a.h
∀ (x_1 : G), coords (FormalSum.mul x [(1, 1)]) x_1 = coords x x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = aintro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul x [(1, 1)]) x₀ = coords x x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = arepeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul x [(1, 1)]) x₀ = coords x x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul x [(1, 1)]) x₀ = coords x x₀rw[
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul x [(1, 1)]) x₀ = coords x x₀
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x ++ []) x₀ = coords x x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x ++ FormalSum.mul x []) x₀ = coords x x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x ++ FormalSum.mul x []) x₀ = coords x x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = asimp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x) x₀ = coords x x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), a * 1 = ainduction 
x: ?α
x with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x) x₀ = coords x x₀| 
nil: {α : Type u} → List α
nil => 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.a.h.nil
coords (mulMonom 1 1 []) x₀ = coords [] x₀rfl
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (mulMonom 1 1 x) x₀ = coords x x₀| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.60109
h 
t: List ?m.60109
t 
ih: ?m.60110 t
ih => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a.a.h.cons
coords (mulMonom 1 1 (h :: t)) x₀ = coords (h :: t) x₀let (
a: R
a, 
x: G
x) := 
h: ?m.60109
h
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom 1 1 ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a.a.h.cons
coords (mulMonom 1 1 (h :: t)) x₀ = coords (h :: t) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom 1 1 ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords ((a * 1, x * 1) :: mulMonom 1 1 t) x₀ = coords ((a, x) :: t) x₀ 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom 1 1 ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
coords: {R : Type ?u.60455} → [inst : Ring R] → {X : Type ?u.60454} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
monomCoeff R G x₀ (a * 1, x * 1) + coords (mulMonom 1 1 t) x₀ = coords ((a, x) :: t) x₀ 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom 1 1 ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
monomCoeff: (R : Type ?u.60536) → (X : Type ?u.60535) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match (a * 1, x * 1).snd == x₀ with
    | true => (a * 1, x * 1).fst
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   coords ((a, x) :: t) x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match (a * 1, x * 1).snd == x₀ with
    | true => (a * 1, x * 1).fst
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   coords ((a, x) :: t) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a.a.h.cons
coords (mulMonom 1 1 (h :: t)) x₀ = coords (h :: t) x₀simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   coords ((a, x) :: t) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a.a.h.cons
coords (mulMonom 1 1 (h :: t)) x₀ = coords (h :: t) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   coords ((a, x) :: t) x₀
coords: {R : Type ?u.63399} → [inst : Ring R] → {X : Type ?u.63398} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords,
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   monomCoeff R G x₀ (a, x) + coords t x₀ 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   coords ((a, x) :: t) x₀
monomCoeff: (R : Type ?u.63451) → (X : Type ?u.63450) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     coords t x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     coords t x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a.a.h.cons
coords (mulMonom 1 1 (h :: t)) x₀ = coords (h :: t) x₀cases m:
x: G
x == 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

m: (x == x₀) = false

a.a.h.cons.false
(match false with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match false with
    | true => (a, x).fst
    | false => 0) +     coords t x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

m: (x == x₀) = true

a.a.h.cons.true
(match true with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match true with
    | true => (a, x).fst
    | false => 0) +     coords t x₀ 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     coords t x₀<;>
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

m: (x == x₀) = false

a.a.h.cons.false
(match false with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match false with
    | true => (a, x).fst
    | false => 0) +     coords t x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

m: (x == x₀) = true

a.a.h.cons.true
(match true with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match true with
    | true => (a, x).fst
    | false => 0) +     coords t x₀ 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (mulMonom 1 1 t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
(match x == x₀ with
    | true => a
    | false => 0) +     coords (mulMonom 1 1 t) x₀ =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     coords t x₀simp [
ih: ?m.60110 t
ih]
Goals accomplished! 🐙
        
    one_mul := by
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = aapply 
Quotient.ind: ∀ {α : Sort ?u.58127} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

a
∀ (a : FormalSum R G), 1 * Quotient.mk (formalSumSetoid R G) a = Quotient.mk (formalSumSetoid R G) a
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = aintro 
x: ?α
x
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a
1 * Quotient.mk (formalSumSetoid R G) x = Quotient.mk (formalSumSetoid R G) x
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = aapply 
Quotient.sound: ∀ {α : Sort ?u.58148} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a
FormalSum.mul [(1, 1)] x ≈ x
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = aapply 
funext: ∀ {α : Sort ?u.58172} {β : α → Sort ?u.58171} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a.h
∀ (x_1 : G), coords (FormalSum.mul [(1, 1)] x) x_1 = coords x x_1;
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

a.a.h
∀ (x_1 : G), coords (FormalSum.mul [(1, 1)] x) x_1 = coords x x_1 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = aintro 
x₀: ?α
x₀
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul [(1, 1)] x) x₀ = coords x x₀
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

∀ (a : R[G]), 1 * a = ainduction 
x: ?α
x with
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul [(1, 1)] x) x₀ = coords x x₀| 
nil: {α : Type u} → List α
nil => 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

a.a.h.nil
coords (FormalSum.mul [(1, 1)] []) x₀ = coords [] x₀rfl
Goals accomplished! 🐙
      
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x: FormalSum R G

x₀: G

a.a.h
coords (FormalSum.mul [(1, 1)] x) x₀ = coords x x₀| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.58211
h 
t: List ?m.58211
t 
ih: ?m.58212 t
ih => 
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀let (
a: R
a, 
x: G
x) := 
h: ?m.58211
h
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀repeat 
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀(
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = coords ((a, x) :: t) x₀
coords: {R : Type ?u.58516} → [inst : Ring R] → {X : Type ?u.58515} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀)
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀simp
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (FormalSum.mul [(1, 1)] ((a, x) :: t)) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀
FormalSum.mul: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → FormalSum R G → FormalSum R G → FormalSum R G
FormalSum.mul
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom a x [(1, 1)] ++ FormalSum.mul [(1, 1)] t) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom a x [(1, 1)] ++ FormalSum.mul [(1, 1)] t) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀rw [
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom a x [(1, 1)] ++ FormalSum.mul [(1, 1)] t) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀← 
append_coords: ∀ {R : Type ?u.59034} [inst : Ring R] {X : Type ?u.59035} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom a x [(1, 1)]) x₀ + coords (FormalSum.mul [(1, 1)] t) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀]
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a: R

x: G

a.a.h.cons
coords (mulMonom a x [(1, 1)]) x₀ + coords (FormalSum.mul [(1, 1)] t) x₀ = monomCoeff R G x₀ (a, x) + coords t x₀
        
R: Type

inst✝³: Ring R

inst✝²: DecidableEq R

G: Type

inst✝¹: Group G

inst✝: DecidableEq G

x₀: G

h: R × G

t: List (R × G)

ih: coords (FormalSum.mul [(1, 1)] t) x₀ = coords t x₀

a.a.h.cons
coords (FormalSum.mul [(1, 1)] (h :: t)) x₀ = coords (h :: t) x₀simp [
ih: ?m.58212 t
ih, 
mulMonom: {R : Type} → [inst : Ring R] → {G : Type} → [inst_1 : Group G] → R → G → FormalSum R G → FormalSum R G
mulMonom, 
coords: {R : Type ?u.59186} → [inst : Ring R] → {X : Type ?u.59185} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙      
  }
  
end GroupRing