import Mathlib.Algebra.Ring.Basic
import Mathlib.Algebra.Group.Defs

/-!
# Free modules 

We construct the free module over a ring `R` generated by a set `X`. It is assumed that both `R` and `X` have decidable equality. 
This is to obtain decidable equality for the elements of the module, which we do (`FreeModule.decEq`).
We choose our definition to allow both such computations and to prove results.

The definition is as a quotient of *Formal Sums* (`FormalSum`), 
which are simply lists of pairs `(a,x)` where `a` is a coefficient in `R` and `x` is a term in `X`. 
We associate to such a formal sum a coordinate function `X → R` (`FormalSum.coords`). 
We see that having the same coordinate functions gives an equivalence relation on the formal sums. 
The free module (`FreeModule`) is then defined as the corresponding quotient of such formal sums.

We also give an alternative description via moves, which is more convenient for universal properties.
-/

variable {
R: Type ?u.74981
R : 
Type _: Type (?u.17+1)
Type _} [
Ring: Type ?u.45431 → Type ?u.45431
Ring 
R: Type ?u.2
R] [
DecidableEq: Sort ?u.12220 → Sort (max1?u.12220)
DecidableEq 
R: Type ?u.2
R]

variable {
X: Type ?u.7987
X : 
Type _: Type (?u.2237+1)
Type _} [
DecidableEq: Sort ?u.645 → Sort (max1?u.645)
DecidableEq 
X: Type ?u.32
X]

section FormalSumCoords

/-! 

## Formal sums
-/



/-- A *formal sum* represents an `R`-linear combination of finitely many elements of `X`.
  This is implemented as a list `R × X`, which associates to each element `X` of the list a coefficient from `R`. -/
abbrev 
FormalSum: (R : Type u_1) → Type u_2 → [inst : Ring R] → Type (maxu_2u_1)
FormalSum (
R: Type ?u.71
R 
X: Type ?u.74
X : 
Type _: Type (?u.71+1)
Type _) [
Ring: Type ?u.77 → Type ?u.77
Ring 
R: Type ?u.71
R] :=
  
List: Type ?u.86 → Type ?u.86
List (
R: Type ?u.71
R × 
X: Type ?u.74
X)

/-!
## Coordinate functions and Supports

* We define coordinate functions X → R for formal sums.
* We define (weak) support, relate non-zero coordinates.
* We prove decidable equality on a list (easy fact).

-/

/-!
### Coordinate functions

The definition of coordinate functions is in two steps. We first define the coordinate for a pair `(a,x)`, and then define the coordinate function for a formal sum by summing over such terms.

-/

/-- Coordinates for a formal sum with one term. -/
def 
monomCoeff: (R : Type ?u.130) → (X : Type ?u.133) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff (
R: Type ?u.130
R 
X: Type ?u.133
X : 
Type _: Type (?u.133+1)
Type _) [
Ring: Type ?u.136 → Type ?u.136
Ring 
R: Type ?u.130
R] [
DecidableEq: Sort ?u.139 → Sort (max1?u.139)
DecidableEq 
X: Type ?u.133
X](
x₀: X
x₀ : 
X: Type ?u.133
X) (
nx: R × X
nx : 
R: Type ?u.130
R × 
X: Type ?u.133
X) : 
R: Type ?u.130
R :=
  match (
nx: R × X
nx.
2: {α : Type ?u.165} → {β : Type ?u.164} → α × β → β
2 == 
x₀: X
x₀) with
  | 
true: Bool
true => 
nx: R × X
nx.
1: {α : Type ?u.211} → {β : Type ?u.210} → α × β → α
1
  | 
false: Bool
false => 
0: ?m.219
0

/-- Homomorphism property for coordinates for a formal sum with one term. -/
theorem 
monom_coords_hom: ∀ {R : Type u_1} [inst : Ring R] {X : Type u_2} [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  (
x₀: X
x₀ 
x: X
x : 
X: Type ?u.642
X) (
a: R
a 
b: R
b : 
R: Type ?u.627
R) : 
monomCoeff: (R : Type ?u.664) → (X : Type ?u.663) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.627
R 
X: Type ?u.642
X 
x₀: X
x₀ (
a: R
a + 
b: R
b, 
x: X
x) = 
monomCoeff: (R : Type ?u.803) → (X : Type ?u.802) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.627
R 
X: Type ?u.642
X 
x₀: X
x₀ (
a: R
a, 
x: X
x) + 
monomCoeff: (R : Type ?u.841) → (X : Type ?u.840) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.627
R 
X: Type ?u.642
X 
x₀: X
x₀ (
b: R
b, 
x: X
x) := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: 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)repeat
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: 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)(
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: 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)rw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     monomCoeff R X x₀ (b, x)
monomCoeff: (R : Type ?u.1156) → (X : Type ?u.1155) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   monomCoeff R X x₀ (a, x) + monomCoeff R X x₀ (b, x))
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   monomCoeff R X x₀ (a, x) + monomCoeff R X x₀ (b, x)
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: 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)cases 
x: X
x == 
x₀: X
x₀
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

false
(match false with
  | true => (a + b, x).fst
  | false => 0) =   (match false with
    | true => (a, x).fst
    | false => 0) +     match false with
    | true => (b, x).fst
    | false => 0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

true
(match true with
  | true => (a + b, x).fst
  | false => 0) =   (match true with
    | true => (a, x).fst
    | false => 0) +     match true with
    | true => (b, x).fst
    | false => 0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0<;>
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

false
(match false with
  | true => (a + b, x).fst
  | false => 0) =   (match false with
    | true => (a, x).fst
    | false => 0) +     match false with
    | true => (b, x).fst
    | false => 0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

true
(match true with
  | true => (a + b, x).fst
  | false => 0) =   (match true with
    | true => (a, x).fst
    | false => 0) +     match true with
    | true => (b, x).fst
    | false => 0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

a, b: R

(match (a + b, x).snd == x₀ with
  | true => (a + b, x).fst
  | false => 0) =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0simp
Goals accomplished! 🐙

/-- Associativity of scalar multiplication coordinates for a formal sum with one term. -/
theorem 
monom_coords_mul: ∀ {x : X} (x₀ : X) (a b : R), monomCoeff R X x₀ (a * b, x) = a * monomCoeff R X x₀ (b, x)
monom_coords_mul (
x₀: X
x₀ : 
X: Type ?u.1476
X) (
a: R
a 
b: R
b : 
R: Type ?u.1461
R) : 
monomCoeff: (R : Type ?u.1590) → (X : Type ?u.1589) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.1461
R 
X: Type ?u.1476
X 
x₀: X
x₀ (
a: R
a * 
b: R
b, 
x: ?m.1579
x) = 
a: R
a * 
monomCoeff: (R : Type ?u.1698) → (X : Type ?u.1697) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.1461
R 
X: Type ?u.1476
X 
x₀: X
x₀ (
b: R
b, 
x: ?m.1579
x) := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

monomCoeff R X x₀ (a * b, x) = a * monomCoeff R X x₀ (b, x)repeat
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

monomCoeff R X x₀ (a * b, x) = a * monomCoeff R X x₀ (b, x)(
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a * monomCoeff R X x₀ (b, x)rw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a * monomCoeff R X x₀ (b, x)
monomCoeff: (R : Type ?u.1928) → (X : Type ?u.1927) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a * monomCoeff R X x₀ (b, x)]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a *     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0)
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a *     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

monomCoeff R X x₀ (a * b, x) = a * monomCoeff R X x₀ (b, x)cases 
x: X
x == 
x₀: X
x₀
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

false
(match false with
  | true => (a * b, x).fst
  | false => 0) =   a *     match false with
    | true => (b, x).fst
    | false => 0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

true
(match true with
  | true => (a * b, x).fst
  | false => 0) =   a *     match true with
    | true => (b, x).fst
    | false => 0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a *     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0<;>
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

false
(match false with
  | true => (a * b, x).fst
  | false => 0) =   a *     match false with
    | true => (b, x).fst
    | false => 0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

true
(match true with
  | true => (a * b, x).fst
  | false => 0) =   a *     match true with
    | true => (b, x).fst
    | false => 0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x, x₀: X

a, b: R

(match (a * b, x).snd == x₀ with
  | true => (a * b, x).fst
  | false => 0) =   a *     match (b, x).snd == x₀ with
    | true => (b, x).fst
    | false => 0simp
Goals accomplished! 🐙

/-- Coordinates for a formal sum with one term with scalar `0`.
-/
theorem 
monom_coords_at_zero: ∀ (x₀ x : X), monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero (
x₀: X
x₀ 
x: X
x : 
X: Type ?u.2237
X) : 
monomCoeff: (R : Type ?u.2255) → (X : Type ?u.2254) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.2222
R 
X: Type ?u.2237
X 
x₀: X
x₀ (
0: ?m.2265
0, 
x: X
x) = 
0: ?m.2368
0 := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

monomCoeff R X x₀ (0, x) = 0rw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

monomCoeff R X x₀ (0, x) = 0
monomCoeff: (R : Type ?u.2493) → (X : Type ?u.2492) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

(match (0, x).snd == x₀ with
  | true => (0, x).fst
  | false => 0) =   0]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

(match (0, x).snd == x₀ with
  | true => (0, x).fst
  | false => 0) =   0
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

monomCoeff R X x₀ (0, x) = 0cases 
x: X
x == 
x₀: X
x₀
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

false
(match false with
  | true => (0, x).fst
  | false => 0) =   0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

true
(match true with
  | true => (0, x).fst
  | false => 0) =   0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

(match (0, x).snd == x₀ with
  | true => (0, x).fst
  | false => 0) =   0<;>
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

false
(match false with
  | true => (0, x).fst
  | false => 0) =   0
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

true
(match true with
  | true => (0, x).fst
  | false => 0) =   0 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

x₀, x: X

(match (0, x).snd == x₀ with
  | true => (0, x).fst
  | false => 0) =   0rfl
Goals accomplished! 🐙

/-- The coordinates for a formal sum. -/
def 
FormalSum.coords: FormalSum R X → X → R
FormalSum.coords  : 
FormalSum: (R : Type ?u.2673) → Type ?u.2672 → [inst : Ring R] → Type (max?u.2672?u.2673)
FormalSum 
R: Type ?u.2644
R 
X: Type ?u.2659
X → 
X: Type ?u.2659
X → 
R: Type ?u.2644
R
  | [], _ => 
0: ?m.2708
0
  | 
h: R × X
h :: 
t: List (R × X)
t, 
x₀: X
x₀ => 
monomCoeff: (R : Type ?u.2802) → (X : Type ?u.2801) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type ?u.2644
R 
X: Type ?u.2659
X 
x₀: X
x₀ 
h: R × X
h + 
coords: FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀

/-!

### Support of a formal sum

We next define the support of a formal sum and prove the property that coordinates vanish outside the support.
-/

/-- Support for a formal sum in a weak sense (coordinates may vanish on this). -/
def 
FormalSum.support: {R : Type u_1} → [inst : Ring R] → {X : Type u_2} → FormalSum R X → List X
FormalSum.support  (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.3697) → Type ?u.3696 → [inst : Ring R] → Type (max?u.3696?u.3697)
FormalSum 
R: Type ?u.3669
R 
X: Type ?u.3684
X) : 
List: Type ?u.3705 → Type ?u.3705
List 
X: Type ?u.3684
X :=
  
s: FormalSum R X
s.
map: {α : Type ?u.3709} → {β : Type ?u.3708} → (α → β) → List α → List β
map <| fun (_, 
x: X
x) => 
x: X
x

open FormalSum

/-- Support contains elements `x : X` where the coordinate is not `0`. -/
theorem 
nonzero_coord_in_support: ∀ {R : Type u_1} [inst : Ring R] {X : Type u_2} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ coords s x → x ∈ support s
nonzero_coord_in_support  (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.3926) → Type ?u.3925 → [inst : Ring R] → Type (max?u.3925?u.3926)
FormalSum 
R: Type ?u.3898
R 
X: Type ?u.3913
X) : ∀ 
x: X
x : 
X: Type ?u.3913
X, 
0: ?m.3941
0 ≠ 
s: FormalSum R X
s.
coords: {R : Type ?u.3952} → [inst : Ring R] → {X : Type ?u.3951} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x → 
x: X
x ∈ 
s: FormalSum R X
s.
support: {R : Type ?u.4024} → [inst : Ring R] → {X : Type ?u.4023} → FormalSum R X → List X
support :=
  match 
s: FormalSum R X
s with
  | [] => fun 
x: ?m.4135
x 
hyp: ?m.4138
hyp => by
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

x ∈ support []have 
d: coords [] x = 0
d : 
coords: {R : Type ?u.4267} → [inst : Ring R] → {X : Type ?u.4266} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
[]: List ?m.4273
[] 
x: X
x = (
0: ?m.4308
0 : 
R: Type u_1
R) := 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

x ∈ support []by
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

coords [] x = 0rfl
Goals accomplished! 🐙
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

x ∈ support []rw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

d: coords [] x = 0

x ∈ support []
d: coords [] x = 0
d
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ 0

d: coords [] x = 0

x ∈ support []]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ 0

d: coords [] x = 0

x ∈ support [] at 
hyp: 0 ≠ coords [] x
hyp
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ 0

d: coords [] x = 0

x ∈ support []
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

x: X

hyp: 0 ≠ coords [] x

x ∈ support []contradiction
Goals accomplished! 🐙
  | 
h: R × X
h :: 
t: List (R × X)
t => by
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

∀ (x : X), 0 ≠ coords (h :: t) x → x ∈ support (h :: t)intro 
x: X
x 
hyp: 0 ≠ coords (h :: t) x
hyp
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

hyp: 0 ≠ coords (h :: t) x

x ∈ support (h :: t)
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

∀ (x : X), 0 ≠ coords (h :: t) x → x ∈ support (h :: t)let (
a₀: R
a₀, 
x₀: X
x₀) := 
h: R × X
h
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

x ∈ support ((a₀, x₀) :: t)
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

∀ (x : X), 0 ≠ coords (h :: t) x → x ∈ support (h :: t)have 
d: support ((a₀, x₀) :: t) = x₀ :: support t
d : 
support: {R : Type ?u.4593} → [inst : Ring R] → {X : Type ?u.4592} → FormalSum R X → List X
support ((
a₀: R
a₀, 
x₀: X
x₀) :: 
t: List (R × X)
t) = 
x₀: X
x₀ :: (
support: {R : Type ?u.4616} → [inst : Ring R] → {X : Type ?u.4615} → FormalSum R X → List X
support 
t: List (R × X)
t) := 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

x ∈ support ((a₀, x₀) :: t)by
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

support ((a₀, x₀) :: t) = x₀ :: support trfl
Goals accomplished! 🐙
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

∀ (x : X), 0 ≠ coords (h :: t) x → x ∈ support (h :: t)rw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ support ((a₀, x₀) :: t)
d: support ((a₀, x₀) :: t) = x₀ :: support t
d
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support t]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support t
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

∀ (x : X), 0 ≠ coords (h :: t) x → x ∈ support (h :: t)match 
p: (x₀ == x) = true
p : 
x₀: X
x₀ == 
x: X
x with
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support t| 
true: Bool
true =>
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

x ∈ x₀ :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support thave 
eqn: x₀ = x
eqn : 
x₀: X
x₀ = 
x: X
x := 
of_decide_eq_true: ∀ {p : Prop} [inst : Decidable p], decide p = true → p
of_decide_eq_true 
p: (x₀ == x) = true
p
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

eqn: x₀ = x

x ∈ x₀ :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

x ∈ x₀ :: support trw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

eqn: x₀ = x

x ∈ x₀ :: support t
eqn: x₀ = x
eqn
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

eqn: x₀ = x

x ∈ x :: support t]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

eqn: x₀ = x

x ∈ x :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

x ∈ x₀ :: support tapply 
List.mem_of_elem_eq_true: ∀ {α : Type ?u.4870} [inst : DecidableEq α] {a : α} {as : List α}, List.elem a as = true → a ∈ as
List.mem_of_elem_eq_true
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

eqn: x₀ = x

a
List.elem x (x :: support t) = true
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = true

x ∈ x₀ :: support tsimp [
List.elem: {α : Type ?u.4910} → [inst : BEq α] → α → List α → Bool
List.elem]
Goals accomplished! 🐙
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support t| 
false: Bool
false =>
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

x ∈ x₀ :: support trw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
coords: {R : Type ?u.6653} → [inst : Ring R] → {X : Type ?u.6652} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords,
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ monomCoeff R X x (a₀, x₀) + coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
monomCoeff: (R : Type ?u.6705) → (X : Type ?u.6704) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff,
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠   (match (a₀, x₀).snd == x with
    | true => (a₀, x₀).fst
    | false => 0) +     coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
p: (x₀ == x) = false
p,
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠   (match false with
    | true => (a₀, x₀).fst
    | false => 0) +     coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
zero_add: ∀ {M : Type ?u.6736} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t at 
hyp: 0 ≠ coords ((a₀, x₀) :: t) x
hyp
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support tlet 
step: ?m.6884
step := 
nonzero_coord_in_support: ∀ (s : FormalSum R X) (x : X), 0 ≠ coords s x → x ∈ support s
nonzero_coord_in_support 
t: List (R × X)
t 
x: X
x 
hyp: 0 ≠ coords t x
hyp
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

x ∈ x₀ :: support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support tapply 
List.mem_of_elem_eq_true: ∀ {α : Type ?u.6891} [inst : DecidableEq α] {a : α} {as : List α}, List.elem a as = true → a ∈ as
List.mem_of_elem_eq_true
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

a
List.elem x (x₀ :: support t) = true
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support tsimp [
List.elem: {α : Type ?u.6913} → [inst : BEq α] → α → List α → Bool
List.elem]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

a
(match x == x₀ with
  | true => true
  | false => List.elem x (support t)) =   true
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support thave 
p': (x == x₀) = false
p' : (
x: X
x == 
x₀: X
x₀) = 
false: Bool
false := 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

a
(match x == x₀ with
  | true => true
  | false => List.elem x (support t)) =   trueby
        
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

(x == x₀) = falsehave 
eqn: ?m.7480
eqn := 
of_decide_eq_false: ∀ {p : Prop} [inst : Decidable p], decide p = false → ¬p
of_decide_eq_false 
p: (x₀ == x) = false
p
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

(x == x₀) = false
        
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

(x == x₀) = falsehave 
eqn': ¬x = x₀
eqn' : ¬(
x: X
x = 
x₀: X
x₀) := 
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

(x == x₀) = falseby
          
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

¬x = x₀intro 
contra: x = x₀
contra
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

contra: x = x₀

False
          
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

¬x = x₀let 
contra': ?m.7564
contra' := 
Eq.symm: ∀ {α : Sort ?u.7565} {a b : α}, a = b → b = a
Eq.symm 
contra: x = x₀
contra
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

contra: x = x₀

contra':= Eq.symm contra: x₀ = x

False
          
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

eqn: ¬x₀ = x

¬x = x₀contradiction
Goals accomplished! 🐙
        
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

(x == x₀) = falseexact 
decide_eq_false: ∀ {p : Prop} [inst : Decidable p], ¬p → decide p = false
decide_eq_false 
eqn': ¬x = x₀
eqn'
Goals accomplished! 🐙
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support trw [
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

p': (x == x₀) = false

a
(match x == x₀ with
  | true => true
  | false => List.elem x (support t)) =   true
p': (x == x₀) = false
p'
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

p': (x == x₀) = false

a
(match false with
  | true => true
  | false => List.elem x (support t)) =   true]
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

p': (x == x₀) = false

a
(match false with
  | true => true
  | false => List.elem x (support t)) =   true
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support tapply 
List.elem_eq_true_of_mem: ∀ {α : Type ?u.7752} [inst : DecidableEq α] {a : α} {as : List α}, a ∈ as → List.elem a as = true
List.elem_eq_true_of_mem
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords t x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

step:= nonzero_coord_in_support t x hyp: x ∈ support t

p': (x == x₀) = false

a.h
x ∈ support t
      
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

x: X

a₀: R

x₀: X

hyp: 0 ≠ coords ((a₀, x₀) :: t) x

d: support ((a₀, x₀) :: t) = x₀ :: support t

p: (x₀ == x) = false

x ∈ x₀ :: support texact 
step: ?m.6884
step
Goals accomplished! 🐙

/-!
### Equality of coordinates on a list

We define equality of coordinates on a list and prove that it is decidable and implied by equality of formal sums.
-/

/-- The condition of being equal on all elements is a given list -/
def 
equalOnList: List X → (X → R) → (X → R) → Prop
equalOnList  (
l: List X
l : 
List: Type ?u.7999 → Type ?u.7999
List 
X: Type ?u.7987
X) (
f: X → R
f 
g: X → R
g : 
X: Type ?u.7987
X → 
R: Type ?u.7972
R) : 
Prop: Type
Prop :=
  match 
l: List X
l with
  | [] => 
true: Bool
true
  | 
h: X
h :: 
t: List X
t => (
f: X → R
f 
h: X
h = 
g: X → R
g 
h: X
h) ∧ (
equalOnList: List X → (X → R) → (X → R) → Prop
equalOnList 
t: List X
t 
f: X → R
f 
g: X → R
g)

/-- Equal functions are equal on arbitrary supports. -/
theorem 
equalOnList_of_equal: ∀ (l : List X) (f g : X → R), f = g → equalOnList l f g
equalOnList_of_equal  (
l: List X
l : 
List: Type ?u.8364 → Type ?u.8364
List 
X: Type ?u.8352
X) (
f: X → R
f 
g: X → R
g : 
X: Type ?u.8352
X → 
R: Type ?u.8337
R) :
    
f: X → R
f = 
g: X → R
g → 
equalOnList: {R : Type ?u.8383} → {X : Type ?u.8382} → List X → (X → R) → (X → R) → Prop
equalOnList 
l: List X
l 
f: X → R
f 
g: X → R
g := by
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

f = g → equalOnList l f gintro 
hyp: f = g
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: f = g

equalOnList l f g
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

f = g → equalOnList l f ginduction 
l: List X
l with
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: f = g

equalOnList l f g| 
nil: {α : Type u} → List α
nil =>
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

nil
equalOnList [] f grw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

nil
equalOnList [] f g
equalOnList: {R : Type ?u.8766} → {X : Type ?u.8765} → List X → (X → R) → (X → R) → Prop
equalOnList
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

nil
true = true]
Goals accomplished! 🐙
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: f = g

equalOnList l f g| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.8425
h 
t: List ?m.8425
t 
step: ?m.8426 t
step =>
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
equalOnList (h :: t) f grw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
equalOnList (h :: t) f g
equalOnList: {R : Type ?u.8811} → {X : Type ?u.8810} → List X → (X → R) → (X → R) → Prop
equalOnList
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
f h = g h ∧ equalOnList t f g]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
f h = g h ∧ equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
equalOnList (h :: t) f gapply 
And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.left
f h = g h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.right
equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
equalOnList (h :: t) f grw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.left
f h = g h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.right
equalOnList t f g
hyp: f = g
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.left
g h = g h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.right
equalOnList t f g]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons.right
equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: f = g

h: X

t: List X

step: equalOnList t f g

cons
equalOnList (h :: t) f gexact 
step: ?m.8426 t
step
Goals accomplished! 🐙

/-- Functions equal on support `l` are equal on each `x ∈ l`. -/
theorem 
eq_mem_of_equalOnList: ∀ (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList  (
l: List X
l : 
List: Type ?u.8887 → Type ?u.8887
List 
X: Type ?u.8875
X) (
f: X → R
f 
g: X → R
g : 
X: Type ?u.8875
X → 
R: Type ?u.8860
R) (
x: X
x : 
X: Type ?u.8875
X)(
mhyp: x ∈ l
mhyp : 
x: X
x ∈ 
l: List X
l) : 
equalOnList: {R : Type ?u.8929} → {X : Type ?u.8928} → List X → (X → R) → (X → R) → Prop
equalOnList 
l: List X
l 
f: X → R
f 
g: X → R
g → 
f: X → R
f 
x: X
x = 
g: X → R
g 
x: X
x :=
  match 
l: List X
l with
  | [] => by
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x: X

mhyp: x ∈ []

equalOnList [] f g → f x = g xcontradiction
Goals accomplished! 🐙
  | 
h: X
h :: 
t: List X
t => by
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xintro 
hyp: equalOnList (h :: t) f g
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

hyp: equalOnList (h :: t) f g

f x = g x
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xsimp [
equalOnList: {R : Type ?u.9180} → {X : Type ?u.9179} → List X → (X → R) → (X → R) → Prop
equalOnList] at 
hyp: equalOnList (h :: t) f g
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

hyp: f h = g h ∧ equalOnList t f g

f x = g x
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xcases 
mhyp: x ∈ h :: t
mhyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x: X

t: List X

hyp: f x = g x ∧ equalOnList t f g

head
f x = g x
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

hyp: f h = g h ∧ equalOnList t f g

a✝: List.Mem x t

tail
f x = g x
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xexact 
hyp: f x = g x ∧ equalOnList t f g
hyp.
left: ∀ {a b : Prop}, a ∧ b → a
left
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

hyp: f h = g h ∧ equalOnList t f g

a✝: List.Mem x t

tail
f x = g x
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xhave 
inTail: x ∈ t
inTail : 
x: X
x ∈ 
t: List X
t := 
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

hyp: f h = g h ∧ equalOnList t f g

a✝: List.Mem x t

tail
f x = g xby
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

hyp: f h = g h ∧ equalOnList t f g

a✝: List.Mem x t

x ∈ tassumption
Goals accomplished! 🐙
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xhave 
step: ?m.9495
step := 
eq_mem_of_equalOnList: ∀ (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList 
t: List X
t 
f: X → R
f 
g: X → R
g 
x: X
x 
inTail: x ∈ t
inTail 
hyp: f h = g h ∧ equalOnList t f g
hyp.
right: ∀ {a b : Prop}, a ∧ b → b
right
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

hyp: f h = g h ∧ equalOnList t f g

a✝: List.Mem x t

inTail: x ∈ t

step: f x = g x

tail
f x = g x
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

x, h: X

t: List X

mhyp: x ∈ h :: t

equalOnList (h :: t) f g → f x = g xexact 
step: ?m.9495
step
Goals accomplished! 🐙

/-- Decidability of equality on list. -/
@[instance] def 
decidableEqualOnList: {R : Type u_1} → [inst : DecidableEq R] → {X : Type u_2} → (l : List X) → (f g : X → R) → Decidable (equalOnList l f g)
decidableEqualOnList  (
l: List X
l : 
List: Type ?u.9751 → Type ?u.9751
List 
X: Type ?u.9739
X) (
f: X → R
f 
g: X → R
g : 
X: Type ?u.9739
X → 
R: Type ?u.9724
R) : 
Decidable: Prop → Type
Decidable (
equalOnList: {R : Type ?u.9763} → {X : Type ?u.9762} → List X → (X → R) → (X → R) → Prop
equalOnList 
l: List X
l 
f: X → R
f 
g: X → R
g) :=
  match 
l: List X
l with
  | [] =>
    
Decidable.isTrue: {p : Prop} → p → Decidable p
Decidable.isTrue
      (by
        
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

equalOnList [] f gsimp [
equalOnList: {R : Type ?u.9875} → {X : Type ?u.9874} → List X → (X → R) → (X → R) → Prop
equalOnList]
Goals accomplished! 🐙)
  | 
h: X
h :: 
t: List X
t => by
    
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

Decidable (equalOnList (h :: t) f g)simp [
equalOnList: {R : Type ?u.9935} → {X : Type ?u.9934} → List X → (X → R) → (X → R) → Prop
equalOnList]
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

Decidable (f h = g h ∧ equalOnList t f g)
    
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

Decidable (equalOnList (h :: t) f g)cases (
decidableEqualOnList: (l : List X) → (f g : X → R) → Decidable (equalOnList l f g)
decidableEqualOnList 
t: List X
t 
f: X → R
f 
g: X → R
g)with
    
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

x✝: Decidable (equalOnList t f g)

Decidable (f h = g h ∧ equalOnList t f g)| 
isTrue: {p : Prop} → p → Decidable p
isTrue 
hs: ?m.10052
hs =>
      
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

isTrue
Decidable (f h = g h ∧ equalOnList t f g)exact
        (if 
c: ?m.10100
c : 
f: X → R
f 
h: X
h = 
g: X → R
g 
h: X
h then (
Decidable.isTrue: {p : Prop} → p → Decidable p
Decidable.isTrue ⟨
c: ?m.10100
c, 
hs: ?m.10052
hs⟩)
        else 
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

isTrue
Decidable (f h = g h ∧ equalOnList t f g)by
          
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

Decidable (f h = g h ∧ equalOnList t f g)apply 
Decidable.isFalse: {p : Prop} → ¬p → Decidable p
Decidable.isFalse
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

h
¬(f h = g h ∧ equalOnList t f g)
          
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

Decidable (f h = g h ∧ equalOnList t f g)intro 
contra: f h = g h ∧ equalOnList t f g
contra
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

contra: f h = g h ∧ equalOnList t f g

h
False
          
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

Decidable (f h = g h ∧ equalOnList t f g)have 
contra': ?m.10143
contra' := 
contra: f h = g h ∧ equalOnList t f g
contra.
left: ∀ {a b : Prop}, a ∧ b → a
left
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

contra: f h = g h ∧ equalOnList t f g

contra': f h = g h

h
False
          
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: equalOnList t f g

c: ¬f h = g h

Decidable (f h = g h ∧ equalOnList t f g)contradiction
Goals accomplished! 🐙)
Goals accomplished! 🐙
    
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

x✝: Decidable (equalOnList t f g)

Decidable (f h = g h ∧ equalOnList t f g)| 
isFalse: {p : Prop} → ¬p → Decidable p
isFalse 
hs: ¬?m.10052
hs =>
      
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

isFalse
Decidable (f h = g h ∧ equalOnList t f g)apply 
Decidable.isFalse: {p : Prop} → ¬p → Decidable p
Decidable.isFalse
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

isFalse.h
¬(f h = g h ∧ equalOnList t f g)
      
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

isFalse
Decidable (f h = g h ∧ equalOnList t f g)intro 
contra: f h = g h ∧ equalOnList t f g
contra
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

contra: f h = g h ∧ equalOnList t f g

isFalse.h
False
      
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

isFalse
Decidable (f h = g h ∧ equalOnList t f g)have 
contra': ?m.10223
contra' := 
contra: f h = g h ∧ equalOnList t f g
contra.
right: ∀ {a b : Prop}, a ∧ b → b
right
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

contra: f h = g h ∧ equalOnList t f g

contra': equalOnList t f g

isFalse.h
False
      
R: Type ?u.9724

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.9739

inst✝: DecidableEq X

l: List X

f, g: X → R

h: X

t: List X

hs: ¬equalOnList t f g

isFalse
Decidable (f h = g h ∧ equalOnList t f g)contradiction
Goals accomplished! 🐙


end FormalSumCoords

/-! 
## Quotient Free Module 


* We define relation by having equal coordinates
* We show this is an equivalence relation and define the quotient 
-/
section QuotientFreeModule


/-- Relation by equal coordinates. -/
def 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords (
R: Type
R 
X: Type
X : 
Type: Type 1
Type) [
Ring: Type ?u.10931 → Type ?u.10931
Ring 
R: Type
R] [
DecidableEq: Sort ?u.10934 → Sort (max1?u.10934)
DecidableEq 
X: Type
X](
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.10953) → Type ?u.10952 → [inst : Ring R] → Type (max?u.10952?u.10953)
FormalSum 
R: Type
R 
X: Type
X) : 
Prop: Type
Prop :=
  
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.10968} → [inst : Ring R] → {X : Type ?u.10967} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.11014} → [inst : Ring R] → {X : Type ?u.11013} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords

namespace eqlCoords

/-- Relation by equal coordinates is reflexive. -/
theorem 
refl: ∀ (s : FormalSum R X), eqlCoords R X s s
refl  (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.11086) → Type ?u.11085 → [inst : Ring R] → Type (max?u.11085?u.11086)
FormalSum 
R: Type ?u.11058
R 
X: Type ?u.11073
X) : 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11058
R 
X: Type ?u.11073
X 
s: FormalSum R X
s 
s: FormalSum R X
s :=
  by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

eqlCoords R X s srfl
Goals accomplished! 🐙

/-- Relation by equal coordinates is  symmetric. -/
theorem 
symm: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] {s₁ s₂ : FormalSum R X},
  eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁
symm  {
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.11199) → Type ?u.11198 → [inst : Ring R] → Type (max?u.11198?u.11199)
FormalSum 
R: Type ?u.11162
R 
X: Type ?u.11177
X} : 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11162
R 
X: Type ?u.11177
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ → 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11162
R 
X: Type ?u.11177
X 
s₂: FormalSum R X
s₂ 
s₁: FormalSum R X
s₁ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁intro 
hyp: eqlCoords R X s₁ s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: eqlCoords R X s₁ s₂

eqlCoords R X s₂ s₁
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁apply 
funext: ∀ {α : Sort ?u.11271} {β : α → Sort ?u.11270} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: eqlCoords R X s₁ s₂

h
∀ (x : X), FormalSum.coords s₂ x = FormalSum.coords s₁ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁intro 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: eqlCoords R X s₁ s₂

x: X

h
FormalSum.coords s₂ x = FormalSum.coords s₁ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁apply 
Eq.symm: ∀ {α : Sort ?u.11293} {a b : α}, a = b → b = a
Eq.symm
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: eqlCoords R X s₁ s₂

x: X

h.h
FormalSum.coords s₁ x = FormalSum.coords s₂ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁exact 
congrFun: ∀ {α : Sort ?u.11306} {β : α → Sort ?u.11305} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
hyp: eqlCoords R X s₁ s₂
hyp 
x: ?α
x
Goals accomplished! 🐙

/-- Relation by equal coordinates is transitive. -/
theorem 
trans: ∀ {s₁ s₂ s₃ : FormalSum R X}, eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃
trans  {
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
s₃: FormalSum R X
s₃ : 
FormalSum: (R : Type ?u.11374) → Type ?u.11373 → [inst : Ring R] → Type (max?u.11373?u.11374)
FormalSum 
R: Type ?u.11337
R 
X: Type ?u.11352
X} : 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11337
R 
X: Type ?u.11352
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ → 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11337
R 
X: Type ?u.11352
X 
s₂: FormalSum R X
s₂ 
s₃: FormalSum R X
s₃ → 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11337
R 
X: Type ?u.11352
X 
s₁: FormalSum R X
s₁ 
s₃: FormalSum R X
s₃ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃intro 
hyp₁: eqlCoords R X s₁ s₂
hyp₁ 
hyp₂: eqlCoords R X s₂ s₃
hyp₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

hyp₁: eqlCoords R X s₁ s₂

hyp₂: eqlCoords R X s₂ s₃

eqlCoords R X s₁ s₃
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃apply 
funext: ∀ {α : Sort ?u.11467} {β : α → Sort ?u.11466} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

hyp₁: eqlCoords R X s₁ s₂

hyp₂: eqlCoords R X s₂ s₃

h
∀ (x : X), FormalSum.coords s₁ x = FormalSum.coords s₃ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃intro 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

hyp₁: eqlCoords R X s₁ s₂

hyp₂: eqlCoords R X s₂ s₃

x: X

h
FormalSum.coords s₁ x = FormalSum.coords s₃ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃have 
l₁: ?m.11490
l₁ := 
congrFun: ∀ {α : Sort ?u.11492} {β : α → Sort ?u.11491} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
hyp₁: eqlCoords R X s₁ s₂
hyp₁ 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

hyp₁: eqlCoords R X s₁ s₂

hyp₂: eqlCoords R X s₂ s₃

x: X

l₁: FormalSum.coords s₁ x = FormalSum.coords s₂ x

h
FormalSum.coords s₁ x = FormalSum.coords s₃ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃have 
l₂: ?m.11512
l₂ := 
congrFun: ∀ {α : Sort ?u.11514} {β : α → Sort ?u.11513} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
hyp₂: eqlCoords R X s₂ s₃
hyp₂ 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

hyp₁: eqlCoords R X s₁ s₂

hyp₂: eqlCoords R X s₂ s₃

x: X

l₁: FormalSum.coords s₁ x = FormalSum.coords s₂ x

l₂: FormalSum.coords s₂ x = FormalSum.coords s₃ x

h
FormalSum.coords s₁ x = FormalSum.coords s₃ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

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

eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃exact 
Eq.trans: ∀ {α : Sort ?u.11530} {a b c : α}, a = b → b = c → a = c
Eq.trans 
l₁: ?m.11490
l₁ 
l₂: ?m.11512
l₂
Goals accomplished! 🐙

/-- Relation by equal coordinates is an equivalence relation. -/
theorem 
is_equivalence: Equivalence (eqlCoords R X)
is_equivalence  : 
Equivalence: {α : Sort ?u.11582} → (α → α → Prop) → Prop
Equivalence (
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type ?u.11555
R 
X: Type ?u.11570
X) :=
  { refl := 
refl: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s : FormalSum R X), eqlCoords R X s s
refl, symm := 
symm: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] {s₁ s₂ : FormalSum R X},
  eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁
symm, trans := 
trans: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] {s₁ s₂ s₃ : FormalSum R X},
  eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₃ → eqlCoords R X s₁ s₃
trans }

end eqlCoords

/-- Setoid based on equal coordinates. -/
instance 
formalSumSetoid: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → Setoid (FormalSum R X)
formalSumSetoid (
R: Type
R 
X: Type
X : 
Type: Type 1
Type) [
Ring: Type ?u.11867 → Type ?u.11867
Ring 
R: Type
R] [
DecidableEq: Sort ?u.11870 → Sort (max1?u.11870)
DecidableEq 
X: Type
X] : 
Setoid: Sort ?u.11879 → Sort (max1?u.11879)
Setoid (
FormalSum: (R : Type ?u.11881) → Type ?u.11880 → [inst : Ring R] → Type (max?u.11880?u.11881)
FormalSum 
R: Type
R 
X: Type
X) :=
  ⟨
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type
R 
X: Type
X, 
eqlCoords.is_equivalence: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X], Equivalence (eqlCoords R X)
eqlCoords.is_equivalence⟩

/-- Quotient free module. -/
abbrev 
FreeModule: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → ?m.12113 R X
FreeModule (
R: Type
R 
X: Type
X : 
Type: Type 1
Type) [
Ring: Type ?u.12100 → Type ?u.12100
Ring 
R: Type
R] [
DecidableEq: Sort ?u.12103 → Sort (max1?u.12103)
DecidableEq 
X: Type
X] :=
  
Quotient: {α : Sort ?u.12121} → Setoid α → Sort ?u.12121
Quotient (
formalSumSetoid: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → Setoid (FormalSum R X)
formalSumSetoid 
R: Type
R 
X: Type
X)

notation 
R: ?m.14433
R"["
G: ?m.14424
G"]" => 
FreeModule: (R X : Type) → [inst : Ring R] → [inst : DecidableEq X] → Type
FreeModule 
R: ?m.15230
R 
G: ?m.12378
G

end QuotientFreeModule

section DecidableEqQuotFreeModule

/-! 
## Decidable equality on quotient free modules
  
We show that the free module `F[X]` has decidable equality. This has two steps:
  
* show decidable equality for images of formal sums.
* lift to quotient (by relating to formal sums).

We also show that the coordinate functions are defined on the quotient. -/
  


namespace FreeModule

/-- Decidable equality for quotient elements in the free module -/
@[instance]
def 
decideEqualQuotient: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] →
      {X : Type} →
        [inst_2 : DecidableEq X] →
          (s₁ s₂ : FormalSum R X) →
            Decidable (Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂)
decideEqualQuotient  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.20888) → Type ?u.20887 → [inst : Ring R] → Type (max?u.20887?u.20888)
FormalSum 
R: Type ?u.20851
R 
X: Type ?u.20866
X) : 
Decidable: Prop → Type
Decidable (@
Eq: {α : Sort ?u.20894} → α → α → Prop
Eq (
R: Type ?u.20851
R[
X: Type ?u.20866
X]) ⟦
s₁: FormalSum R X
s₁⟧ ⟦
s₂: FormalSum R X
s₂⟧) :=
  if 
ch₁: ?m.21212
ch₁ : 
equalOnList: {R : Type ?u.20964} → {X : Type ?u.20963} → List X → (X → R) → (X → R) → Prop
equalOnList 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.20968} → [inst : Ring R] → {X : Type ?u.20967} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.20982} → [inst : Ring R] → {X : Type ?u.20981} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21003} → [inst : Ring R] → {X : Type ?u.21002} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords then
    if 
ch₂: ?m.21191
ch₂ : 
equalOnList: {R : Type ?u.21087} → {X : Type ?u.21086} → List X → (X → R) → (X → R) → Prop
equalOnList 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.21091} → [inst : Ring R] → {X : Type ?u.21090} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.21101} → [inst : Ring R] → {X : Type ?u.21100} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21122} → [inst : Ring R] → {X : Type ?u.21121} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords then
      
Decidable.isTrue: {p : Prop} → p → Decidable p
Decidable.isTrue
        (by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂apply 
Quotient.sound: ∀ {α : Sort ?u.21222} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

a
s₁ ≈ s₂
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂apply 
funext: ∀ {α : Sort ?u.21243} {β : α → Sort ?u.21242} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

a.h
∀ (x : X), FormalSum.coords s₁ x = FormalSum.coords s₂ x
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂intro 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ x
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂exact
            if 
h₁: ?m.21453
h₁ : (
0: ?m.21267
0 = 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.21283} → [inst : Ring R] → {X : Type ?u.21282} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: ?α
x) then
              if 
h₂: ?m.21442
h₂ : (
0: ?m.21383
0 = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21399} → [inst : Ring R] → {X : Type ?u.21398} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: ?α
x) then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x← 
h₁: 0 = FormalSum.coords s₁ x
h₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

0 = FormalSum.coords s₂ x 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
h₂: 0 = FormalSum.coords s₂ x
h₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₂ x = FormalSum.coords s₂ x]
Goals accomplished! 🐙
              else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xhave 
lem: x ∈ FormalSum.support s₂
lem : 
x: X
x ∈ 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.21524} → [inst : Ring R] → {X : Type ?u.21523} → FormalSum R X → List X
support := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xby
                  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

x ∈ FormalSum.support s₂apply 
nonzero_coord_in_support: ∀ {R : Type ?u.21545} [inst : Ring R] {X : Type ?u.21546} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ FormalSum.coords s x → x ∈ FormalSum.support s
nonzero_coord_in_support
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

a
0 ≠ FormalSum.coords s₂ x
                  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

x ∈ FormalSum.support s₂assumption
Goals accomplished! 🐙
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xlet 
lem': ?m.21577
lem' := 
eq_mem_of_equalOnList: ∀ {R : Type ?u.21579} {X : Type ?u.21578} (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.21583} → [inst : Ring R] → {X : Type ?u.21582} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.21593} → [inst : Ring R] → {X : Type ?u.21592} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21612} → [inst : Ring R] → {X : Type ?u.21611} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x 
lem: x ∈ FormalSum.support s₂
lem 
ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)
ch₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

lem: x ∈ FormalSum.support s₂

lem':= eq_mem_of_equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) x lem ch₂: FormalSum.coords s₁ x = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xexact 
lem': ?m.21577
lem'
Goals accomplished! 🐙
            else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xhave 
lem: x ∈ FormalSum.support s₁
lem : 
x: X
x ∈ 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.21718} → [inst : Ring R] → {X : Type ?u.21717} → FormalSum R X → List X
support := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xby
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

x ∈ FormalSum.support s₁apply 
nonzero_coord_in_support: ∀ {R : Type ?u.21730} [inst : Ring R] {X : Type ?u.21731} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ FormalSum.coords s x → x ∈ FormalSum.support s
nonzero_coord_in_support
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

a
0 ≠ FormalSum.coords s₁ x
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

x ∈ FormalSum.support s₁assumption
Goals accomplished! 🐙
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xlet 
lem': ?m.21761
lem' := 
eq_mem_of_equalOnList: ∀ {R : Type ?u.21763} {X : Type ?u.21762} (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.21767} → [inst : Ring R] → {X : Type ?u.21766} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.21777} → [inst : Ring R] → {X : Type ?u.21776} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21796} → [inst : Ring R] → {X : Type ?u.21795} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x 
lem: x ∈ FormalSum.support s₁
lem 
ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)
ch₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

lem: x ∈ FormalSum.support s₁

lem':= eq_mem_of_equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) x lem ch₁: FormalSum.coords s₁ x = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xexact 
lem': ?m.21761
lem'
Goals accomplished! 🐙)
    else
      
Decidable.isFalse: {p : Prop} → ¬p → Decidable p
Decidable.isFalse
        (by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: ¬equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂intro 
contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
contra
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: ¬equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: ¬equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂let 
lem: ?m.21857
lem := 
equalOnList_of_equal: ∀ {R : Type ?u.21859} {X : Type ?u.21858} (l : List X) (f g : X → R), f = g → equalOnList l f g
equalOnList_of_equal 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.21863} → [inst : Ring R] → {X : Type ?u.21862} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.21873} → [inst : Ring R] → {X : Type ?u.21872} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.21892} → [inst : Ring R] → {X : Type ?u.21891} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
Quotient.exact: ∀ {α : Sort ?u.21931} {s : Setoid α} {a b : α}, Quotient.mk s a = Quotient.mk s b → a ≈ b
Quotient.exact 
contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
contra)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: ¬equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

lem:= equalOnList_of_equal (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) (Quotient.exact contra): equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂: ¬equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂contradiction
Goals accomplished! 🐙)
  else
    
Decidable.isFalse: {p : Prop} → ¬p → Decidable p
Decidable.isFalse
      (by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: ¬equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂intro 
contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
contra
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: ¬equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

False
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: ¬equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂let 
lem: ?m.22057
lem := 
equalOnList_of_equal: ∀ {R : Type ?u.22059} {X : Type ?u.22058} (l : List X) (f g : X → R), f = g → equalOnList l f g
equalOnList_of_equal 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.22063} → [inst : Ring R] → {X : Type ?u.22062} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.22073} → [inst : Ring R] → {X : Type ?u.22072} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.22092} → [inst : Ring R] → {X : Type ?u.22091} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
Quotient.exact: ∀ {α : Sort ?u.22131} {s : Setoid α} {a b : α}, Quotient.mk s a = Quotient.mk s b → a ≈ b
Quotient.exact 
contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
contra)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: ¬equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

contra: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

lem:= equalOnList_of_equal (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) (Quotient.exact contra): equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

False
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

ch₁: ¬equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂contradiction
Goals accomplished! 🐙)

/-! 
### Lift to quotient 
-/

/-- Boolean equality on support. -/
def 
beqOnSupport: List X → (X → R) → (X → R) → Bool
beqOnSupport  (
l: List X
l : 
List: Type ?u.22479 → Type ?u.22479
List 
X: Type ?u.22467
X) (
f: X → R
f 
g: X → R
g : 
X: Type ?u.22467
X → 
R: Type ?u.22452
R) :
Bool: Type
Bool :=
  
l: List X
l.
all: {α : Type ?u.22494} → List α → (α → Bool) → Bool
all <| fun 
x: ?m.22501
x => 
decide: (p : Prop) → [h : Decidable p] → Bool
decide (
f: X → R
f 
x: ?m.22501
x = 
g: X → R
g 
x: ?m.22501
x)

/-- Equality on support from boolean equality. -/
theorem 
eql_on_support_of_true: ∀ {l : List X} {f g : X → R}, beqOnSupport l f g = true → equalOnList l f g
eql_on_support_of_true {
l: List X
l : 
List: Type ?u.22647 → Type ?u.22647
List 
X: Type ?u.22635
X} {
f: X → R
f 
g: X → R
g : 
X: Type ?u.22635
X → 
R: Type ?u.22620
R} : 
beqOnSupport: {R : Type ?u.22661} → [inst : DecidableEq R] → {X : Type ?u.22660} → List X → (X → R) → (X → R) → Bool
beqOnSupport 
l: List X
l 
f: X → R
f 
g: X → R
g = 
true: Bool
true → 
equalOnList: {R : Type ?u.22719} → {X : Type ?u.22718} → List X → (X → R) → (X → R) → Prop
equalOnList 
l: List X
l 
f: X → R
f 
g: X → R
g := by
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

beqOnSupport l f g = true → equalOnList l f gintro 
hyp: beqOnSupport l f g = true
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: beqOnSupport l f g = true

equalOnList l f g
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

beqOnSupport l f g = true → equalOnList l f ginduction 
l: List X
l with
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: beqOnSupport l f g = true

equalOnList l f g| 
nil: {α : Type u} → List α
nil =>
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

hyp: beqOnSupport [] f g = true

nil
equalOnList [] f gsimp [
equalOnList: {R : Type ?u.22774} → {X : Type ?u.22773} → List X → (X → R) → (X → R) → Prop
equalOnList]
Goals accomplished! 🐙
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

l: List X

f, g: X → R

hyp: beqOnSupport l f g = true

equalOnList l f g| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.22761
h 
t: List ?m.22761
t 
step: ?m.22762 t
step =>
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: beqOnSupport (h :: t) f g = true

cons
equalOnList (h :: t) f gsimp [
equalOnList: {R : Type ?u.22846} → {X : Type ?u.22845} → List X → (X → R) → (X → R) → Prop
equalOnList]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: beqOnSupport (h :: t) f g = true

cons
f h = g h ∧ equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: beqOnSupport (h :: t) f g = true

cons
equalOnList (h :: t) f gsimp [
beqOnSupport: {R : Type ?u.22939} → [inst : DecidableEq R] → {X : Type ?u.22938} → List X → (X → R) → (X → R) → Bool
beqOnSupport, 
List.all: {α : Type ?u.22941} → List α → (α → Bool) → Bool
List.all] at 
hyp: beqOnSupport (h :: t) f g = true
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: f h = g h ∧ List.foldr (fun a r => decide (f a = g a) && r) true t = true

cons
f h = g h ∧ equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: beqOnSupport (h :: t) f g = true

cons
equalOnList (h :: t) f glet 
p₂: ?m.23555
p₂ := 
step: ?m.22762 t
step 
hyp: f h = g h ∧ List.foldr (fun a r => decide (f a = g a) && r) true t = true
hyp.
right: ∀ {a b : Prop}, a ∧ b → b
right
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: f h = g h ∧ List.foldr (fun a r => decide (f a = g a) && r) true t = true

p₂:= step hyp.right: equalOnList t f g

cons
f h = g h ∧ equalOnList t f g
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

f, g: X → R

h: X

t: List X

step: beqOnSupport t f g = true → equalOnList t f g

hyp: beqOnSupport (h :: t) f g = true

cons
equalOnList (h :: t) f gexact 
And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro 
hyp: f h = g h ∧ List.foldr (fun a r => decide (f a = g a) && r) true t = true
hyp.
left: ∀ {a b : Prop}, a ∧ b → a
left 
p₂: ?m.23555
p₂
Goals accomplished! 🐙

/-- Boolean equality on support gives equal quotients. -/
theorem 
eqlquot_of_beq_support: ∀ (s₁ s₂ : FormalSum R X),
  beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true →
    beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true →
      Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
eqlquot_of_beq_support (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.23659) → Type ?u.23658 → [inst : Ring R] → Type (max?u.23658?u.23659)
FormalSum 
R: Type ?u.23622
R 
X: Type ?u.23637
X)
  (
c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true
c₁ : 
beqOnSupport: {R : Type ?u.23666} → [inst : DecidableEq R] → {X : Type ?u.23665} → List X → (X → R) → (X → R) → Bool
beqOnSupport 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.23706} → [inst : Ring R] → {X : Type ?u.23705} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.23753} → [inst : Ring R] → {X : Type ?u.23752} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.23849} → [inst : Ring R] → {X : Type ?u.23848} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords)
  (
c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true
c₂ : 
beqOnSupport: {R : Type ?u.23916} → [inst : DecidableEq R] → {X : Type ?u.23915} → List X → (X → R) → (X → R) → Bool
beqOnSupport 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.23955} → [inst : Ring R] → {X : Type ?u.23954} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.23998} → [inst : Ring R] → {X : Type ?u.23997} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.24079} → [inst : Ring R] → {X : Type ?u.24078} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords) : @
Eq: {α : Sort ?u.24143} → α → α → Prop
Eq (
R: Type ?u.23622
R[
X: Type ?u.23637
X]) ⟦
s₁: FormalSum R X
s₁⟧ ⟦
s₂: FormalSum R X
s₂⟧ := 
        by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂let 
ch₁: ?m.24211
ch₁ := 
eql_on_support_of_true: ∀ {R : Type ?u.24213} [inst : DecidableEq R] {X : Type ?u.24212} {l : List X} {f g : X → R},
  beqOnSupport l f g = true → equalOnList l f g
eql_on_support_of_true 
c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true
c₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂let 
ch₂: ?m.24335
ch₂ := 
eql_on_support_of_true: ∀ {R : Type ?u.24337} [inst : DecidableEq R] {X : Type ?u.24336} {l : List X} {f g : X → R},
  beqOnSupport l f g = true → equalOnList l f g
eql_on_support_of_true 
c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true
c₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂apply 
Quotient.sound: ∀ {α : Sort ?u.24420} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

a
s₁ ≈ s₂
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂apply 
funext: ∀ {α : Sort ?u.24441} {β : α → Sort ?u.24440} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

a.h
∀ (x : X), FormalSum.coords s₁ x = FormalSum.coords s₂ x
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂intro 
x: ?α
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ x
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂exact
          if 
h₁: ?m.24580
h₁ : (
0: ?m.24465
0 = 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.24481} → [inst : Ring R] → {X : Type ?u.24480} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: ?α
x) then
            if 
h₂: ?m.24643
h₂ : (
0: ?m.24584
0 = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.24600} → [inst : Ring R] → {X : Type ?u.24599} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: ?α
x) then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x← 
h₁: 0 = FormalSum.coords s₁ x
h₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

0 = FormalSum.coords s₂ x 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
h₂: 0 = FormalSum.coords s₂ x
h₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: 0 = FormalSum.coords s₂ x

FormalSum.coords s₂ x = FormalSum.coords s₂ x]
Goals accomplished! 🐙
            else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xhave 
lem: x ∈ FormalSum.support s₂
lem : 
x: X
x ∈ 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.24726} → [inst : Ring R] → {X : Type ?u.24725} → FormalSum R X → List X
support := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xby
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

x ∈ FormalSum.support s₂apply 
nonzero_coord_in_support: ∀ {R : Type ?u.24747} [inst : Ring R] {X : Type ?u.24748} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ FormalSum.coords s x → x ∈ FormalSum.support s
nonzero_coord_in_support
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

a
0 ≠ FormalSum.coords s₂ x
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

x ∈ FormalSum.support s₂assumption
Goals accomplished! 🐙
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xlet 
lem': ?m.24779
lem' := 
eq_mem_of_equalOnList: ∀ {R : Type ?u.24781} {X : Type ?u.24780} (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.24785} → [inst : Ring R] → {X : Type ?u.24784} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.24795} → [inst : Ring R] → {X : Type ?u.24794} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.24814} → [inst : Ring R] → {X : Type ?u.24813} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x 
lem: x ∈ FormalSum.support s₂
lem 
ch₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)
ch₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

lem: x ∈ FormalSum.support s₂

lem':= eq_mem_of_equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) x lem ch₂: FormalSum.coords s₁ x = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: 0 = FormalSum.coords s₁ x

h₂: ¬0 = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xexact 
lem': ?m.24779
lem'
Goals accomplished! 🐙
          else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

a.h
FormalSum.coords s₁ x = FormalSum.coords s₂ xby
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xhave 
lem: x ∈ FormalSum.support s₁
lem : 
x: X
x ∈ 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.24905} → [inst : Ring R] → {X : Type ?u.24904} → FormalSum R X → List X
support := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xby
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

x ∈ FormalSum.support s₁apply 
nonzero_coord_in_support: ∀ {R : Type ?u.24917} [inst : Ring R] {X : Type ?u.24918} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ FormalSum.coords s x → x ∈ FormalSum.support s
nonzero_coord_in_support
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

a
0 ≠ FormalSum.coords s₁ x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

x ∈ FormalSum.support s₁assumption
Goals accomplished! 🐙
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xlet 
lem': ?m.24948
lem' := 
eq_mem_of_equalOnList: ∀ {R : Type ?u.24950} {X : Type ?u.24949} (l : List X) (f g : X → R) (x : X), x ∈ l → equalOnList l f g → f x = g x
eq_mem_of_equalOnList 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.24954} → [inst : Ring R] → {X : Type ?u.24953} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.24964} → [inst : Ring R] → {X : Type ?u.24963} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.24983} → [inst : Ring R] → {X : Type ?u.24982} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x 
lem: x ∈ FormalSum.support s₁
lem 
ch₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)
ch₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

lem: x ∈ FormalSum.support s₁

lem':= eq_mem_of_equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) x lem ch₁: FormalSum.coords s₁ x = FormalSum.coords s₂ x

FormalSum.coords s₁ x = FormalSum.coords s₂ x
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

c₁: beqOnSupport (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

c₂: beqOnSupport (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂) = true

ch₁:= eql_on_support_of_true c₁: equalOnList (FormalSum.support s₁) (FormalSum.coords s₁) (FormalSum.coords s₂)

ch₂:= eql_on_support_of_true c₂: equalOnList (FormalSum.support s₂) (FormalSum.coords s₁) (FormalSum.coords s₂)

x: X

h₁: ¬0 = FormalSum.coords s₁ x

FormalSum.coords s₁ x = FormalSum.coords s₂ xexact 
lem': ?m.24948
lem'
Goals accomplished! 🐙


/--
Boolean equality for the quotient via lifting
-/
def 
beq_quot: R[X] → R[X] → Bool
beq_quot : (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.25078
R[
X: Type ?u.25093
X]) → 
Bool: Type
Bool := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → Boolapply 
Quotient.lift₂: {α : Sort ?u.25189} →
  {β : Sort ?u.25188} →
    {φ : Sort ?u.25187} →
      {s₁ : Setoid α} →
        {s₂ : Setoid β} →
          (f : α → β → φ) →
            (∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂) →
              Quotient s₁ → Quotient s₂ → φ
Quotient.lift₂ (fun (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.25202) → Type ?u.25201 → [inst : Ring R] → Type (max?u.25201?u.25202)
FormalSum 
R: Type
R 
X: Type
X) => 
decide: (p : Prop) → [h : Decidable p] → Bool
decide (@
Eq: {α : Sort ?u.25205} → α → α → Prop
Eq (
R: Type
R[
X: Type
X]) ⟦
s₁: FormalSum R X
s₁⟧ ⟦
s₂: FormalSum R X
s₂⟧))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a₁ b₁ a₂ b₂ : FormalSum R X),
  a₁ ≈ a₂ →
    b₁ ≈ b₂ →
      decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =         decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → Boolintro 
a₁: FormalSum R X
a₁ 
b₁: FormalSum R X
b₁ 
a₂: FormalSum R X
a₂ 
b₂: FormalSum R X
b₂ 
eqv₁: a₁ ≈ a₂
eqv₁ 
eqv₂: b₁ ≈ b₂
eqv₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → Boollet 
eq₁: Quotient.mk ?m.25352 a₁ = Quotient.mk ?m.25355 a₂
eq₁ : 
Eq: {α : Sort ?u.25332} → α → α → Prop
Eq (α := 
R: Type
R[
X: Type
X]) ⟦
a₁: FormalSum R X
a₁⟧ ⟦
a₂: FormalSum R X
a₂⟧ := 
Quot.sound: ∀ {α : Sort ?u.25356} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound 
eqv₁: a₁ ≈ a₂
eqv₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → Boollet 
eq₂: Quotient.mk ?m.25396 b₁ = Quotient.mk ?m.25399 b₂
eq₂ : 
Eq: {α : Sort ?u.25376} → α → α → Prop
Eq (α := 
R: Type
R[
X: Type
X]) ⟦
b₁: FormalSum R X
b₁⟧ ⟦
b₂: FormalSum R X
b₂⟧ := 
Quot.sound: ∀ {α : Sort ?u.25400} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound 
eqv₂: b₁ ≈ b₂
eqv₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → Boolconv =>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)lhs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁);
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)congr
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473;
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

decide (Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁) =   decide (Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473
eq₁: Quotient.mk ?m.25352 a₁ = Quotient.mk ?m.25355 a₂
eq₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) b₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473
eq₂: Quotient.mk ?m.25396 b₁ = Quotient.mk ?m.25399 b₂
eq₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

p
Quotient.mk (formalSumSetoid R X) a₂ = Quotient.mk (formalSumSetoid R X) b₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a₁, b₁, a₂, b₂: FormalSum R X

eqv₁: a₁ ≈ a₂

eqv₂: b₁ ≈ b₂

eq₁:= Quot.sound eqv₁: Quotient.mk (formalSumSetoid R X) a₁ = Quotient.mk (formalSumSetoid R X) a₂

eq₂:= Quot.sound eqv₂: Quotient.mk (formalSumSetoid R X) b₁ = Quotient.mk (formalSumSetoid R X) b₂

Decidable ?m.25473

/--
Boolean equality for the quotient is equality.
-/
lemma 
eq_of_beq_true: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₁ x₂ : R[X]),
  beq_quot x₁ x₂ = true → x₁ = x₂
eq_of_beq_true  : ∀ 
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.25781
R[
X: Type ?u.25796
X], 
x₁: R[X]
x₁.
beq_quot: {R : Type} → [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → R[X] → Bool
beq_quot 
x₂: R[X]
x₂ = 
true: Bool
true → 
x₁: R[X]
x₁ = 
x₂: R[X]
x₂ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = true → x₁ = x₂apply 
Quotient.ind₂: ∀ {α : Sort ?u.25967} {β : Sort ?u.25966} {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 (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type
R[
X: Type
X]) => 
x₁: R[X]
x₁.
beq_quot: {R : Type} → [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → R[X] → Bool
beq_quot 
x₂: R[X]
x₂ = 
true: Bool
true → 
x₁: R[X]
x₁ = 
x₂: R[X]
x₂)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a b : FormalSum R X),
  beq_quot (Quotient.mk (formalSumSetoid R X) a) (Quotient.mk (formalSumSetoid R X) b) = true →
    Quotient.mk (formalSumSetoid R X) a = Quotient.mk (formalSumSetoid R X) b
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = true → x₁ = x₂intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
eqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = true
eqv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = true

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = true → x₁ = x₂let 
eql: ?m.26099
eql := 
of_decide_eq_true: ∀ {p : Prop} [inst : Decidable p], decide p = true → p
of_decide_eq_true 
eqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = true
eqv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

eqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = true

eql:= of_decide_eq_true eqv: Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = true → x₁ = x₂assumption
Goals accomplished! 🐙

/--
Boolean inequality for the quotient is inequality.
-/
lemma 
neq_of_beq_false: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₁ x₂ : R[X]),
  beq_quot x₁ x₂ = false → ¬x₁ = x₂
neq_of_beq_false  : ∀ 
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.26442
R[
X: Type ?u.26457
X], 
x₁: R[X]
x₁.
beq_quot: {R : Type} → [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → R[X] → Bool
beq_quot 
x₂: R[X]
x₂ = 
false: Bool
false → 
Not: Prop → Prop
Not (
x₁: R[X]
x₁ = 
x₂: R[X]
x₂) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = false → ¬x₁ = x₂apply 
Quotient.ind₂: ∀ {α : Sort ?u.26631} {β : Sort ?u.26630} {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 (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type
R[
X: Type
X]) => 
x₁: R[X]
x₁.
beq_quot: {R : Type} → [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → R[X] → Bool
beq_quot 
x₂: R[X]
x₂ = 
false: Bool
false → 
Not: Prop → Prop
Not (
x₁: R[X]
x₁ = 
x₂: R[X]
x₂))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a b : FormalSum R X),
  beq_quot (Quotient.mk (formalSumSetoid R X) a) (Quotient.mk (formalSumSetoid R X) b) = false →
    ¬Quotient.mk (formalSumSetoid R X) a = Quotient.mk (formalSumSetoid R X) b
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = false → ¬x₁ = x₂intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
neqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = false
neqv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

neqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = false

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = false → ¬x₁ = x₂let 
neql: ?m.26769
neql := 
of_decide_eq_false: ∀ {p : Prop} [inst : Decidable p], decide p = false → ¬p
of_decide_eq_false 
neqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = false
neqv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

neqv: beq_quot (Quotient.mk (formalSumSetoid R X) s₁) (Quotient.mk (formalSumSetoid R X) s₂) = false

neql:= of_decide_eq_false neqv: ¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂

¬Quotient.mk (formalSumSetoid R X) s₁ = Quotient.mk (formalSumSetoid R X) s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (x₁ x₂ : R[X]), beq_quot x₁ x₂ = false → ¬x₁ = x₂assumption
Goals accomplished! 🐙

/--
Decidable equality for the free module.
-/
@[instance] def 
decEq: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → (x₁ x₂ : R[X]) → Decidable (x₁ = x₂)
decEq  (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.27114
R[
X: Type ?u.27129
X]) : 
Decidable: Prop → Type
Decidable (
x₁: R[X]
x₁ = 
x₂: R[X]
x₂) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

Decidable (x₁ = x₂)match 
p: beq_quot x₁ x₂ = false
p : 
x₁: R[X]
x₁.
beq_quot: {R : Type} → [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → R[X] → Bool
beq_quot 
x₂: R[X]
x₂ with
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

Decidable (x₁ = x₂)| 
true: Bool
true =>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = true

Decidable (x₁ = x₂)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

Decidable (x₁ = x₂)apply 
Decidable.isTrue: {p : Prop} → p → Decidable p
Decidable.isTrue
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = true

h
x₁ = x₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = true

Decidable (x₁ = x₂)apply 
FreeModule.eq_of_beq_true: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₁ x₂ : R[X]),
  beq_quot x₁ x₂ = true → x₁ = x₂
FreeModule.eq_of_beq_true
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = true

h.a
beq_quot x₁ x₂ = true
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = true

Decidable (x₁ = x₂)assumption
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

Decidable (x₁ = x₂)| 
false: Bool
false =>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = false

Decidable (x₁ = x₂)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

Decidable (x₁ = x₂)apply 
Decidable.isFalse: {p : Prop} → ¬p → Decidable p
Decidable.isFalse
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = false

h
¬x₁ = x₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = false

Decidable (x₁ = x₂)apply 
FreeModule.neq_of_beq_false: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₁ x₂ : R[X]),
  beq_quot x₁ x₂ = false → ¬x₁ = x₂
FreeModule.neq_of_beq_false
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = false

h.a
beq_quot x₁ x₂ = false
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

p: beq_quot x₁ x₂ = false

Decidable (x₁ = x₂)assumption
Goals accomplished! 🐙

/-!
### Induced coordinates on the quotient.
-/

/-- Coordinates are well defined on the quotient. -/
theorem 
equal_coords_of_approx: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X),
  s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂
equal_coords_of_approx (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.27768) → Type ?u.27767 → [inst : Ring R] → Type (max?u.27767?u.27768)
FormalSum 
R: Type ?u.27740
R 
X: Type ?u.27755
X): 
s₁: FormalSum R X
s₁ ≈ 
s₂: FormalSum R X
s₂ → 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.27850} → [inst : Ring R] → {X : Type ?u.27849} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.27900} → [inst : Ring R] → {X : Type ?u.27899} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords := by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂intro 
hyp: s₁ ≈ s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: s₁ ≈ s₂

FormalSum.coords s₁ = FormalSum.coords s₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂apply 
funext: ∀ {α : Sort ?u.27930} {β : α → Sort ?u.27929} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: s₁ ≈ s₂

h
∀ (x : X), FormalSum.coords s₁ x = FormalSum.coords s₂ x;
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: s₁ ≈ s₂

h
∀ (x : X), FormalSum.coords s₁ x = FormalSum.coords s₂ x 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: s₁ ≈ s₂

x₀: X

h
FormalSum.coords s₁ x₀ = FormalSum.coords s₂ x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂exact 
congrFun: ∀ {α : Sort ?u.27953} {β : α → Sort ?u.27952} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
hyp: s₁ ≈ s₂
hyp 
x₀: ?α
x₀
Goals accomplished! 🐙

/-- coordinates for the quotient -/
def 
coordinates: X → R[X] → R
coordinates (
x₀: X
x₀ : 
X: Type ?u.28025
X) : 
R: Type ?u.28010
R[
X: Type ?u.28025
X] →  
R: Type ?u.28010
R := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

R[X] → Rapply 
Quotient.lift: {α : Sort ?u.28102} →
  {β : Sort ?u.28101} → {s : Setoid α} → (f : α → β) → (∀ (a b : α), a ≈ b → f a = f b) → Quotient s → β
Quotient.lift (fun 
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.28108) → Type ?u.28107 → [inst : Ring R] → Type (max?u.28107?u.28108)
FormalSum 
R: Type
R 
X: Type
X => 
s: FormalSum R X
s.
coords: {R : Type ?u.28112} → [inst : Ring R] → {X : Type ?u.28111} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

∀ (a b : FormalSum R X), a ≈ b → FormalSum.coords a x₀ = FormalSum.coords b x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

R[X] → Rintro 
a: FormalSum R X
a 
b: FormalSum R X
b
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

a, b: FormalSum R X

a ≈ b → FormalSum.coords a x₀ = FormalSum.coords b x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

R[X] → Rintro 
hyp: a ≈ b
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

a, b: FormalSum R X

hyp: a ≈ b

FormalSum.coords a x₀ = FormalSum.coords b x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

R[X] → Rlet 
l: ?m.28154
l :=  
equal_coords_of_approx: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X),
  s₁ ≈ s₂ → FormalSum.coords s₁ = FormalSum.coords s₂
equal_coords_of_approx 
_: FormalSum ?m.28155 ?m.28157
_ 
_: FormalSum ?m.28155 ?m.28157
_ 
hyp: a ≈ b
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

a, b: FormalSum R X

hyp: a ≈ b

l:= equal_coords_of_approx a b hyp: FormalSum.coords a = FormalSum.coords b

FormalSum.coords a x₀ = FormalSum.coords b x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

R[X] → Rexact 
congrFun: ∀ {α : Sort ?u.28226} {β : α → Sort ?u.28225} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
l: ?m.28154
l 
x₀: X
x₀
Goals accomplished! 🐙 

end FreeModule
end DecidableEqQuotFreeModule

/-! 
## Module structure  

We define the module structure on the quotient of the free module by the equivalence relation.

* We define scalar multiplication and addition on formal sums.
* We show that we have induced operations on the quotient.
* We show that the induced operations give a module structure on the quotient.
-/
section ModuleStruture


open FormalSum
namespace FormalSum
/-!
### Scalar multiplication: on formal sums and on the quotient.
-/

/-- Scalar multiplication on formal sums. -/
def 
scmul: R → FormalSum R X → FormalSum R X
scmul  : 
R: Type ?u.28436
R → 
FormalSum: (R : Type ?u.28467) → Type ?u.28466 → [inst : Ring R] → Type (max?u.28466?u.28467)
FormalSum 
R: Type ?u.28436
R 
X: Type ?u.28451
X → 
FormalSum: (R : Type ?u.28475) → Type ?u.28474 → [inst : Ring R] → Type (max?u.28474?u.28475)
FormalSum 
R: Type ?u.28436
R 
X: Type ?u.28451
X
  | _, [] => 
[]: List ?m.28508
[]
  | 
r: R
r, (
h: R × X
h :: 
t: List (R × X)
t) =>
    let (
a₀: R
a₀, 
x₀: X
x₀) := 
h: R × X
h
    (
r: R
r * 
a₀: R
a₀, 
x₀: X
x₀) :: (
scmul: R → FormalSum R X → FormalSum R X
scmul 
r: R
r 
t: List (R × X)
t)

/-- Coordinates after scalar multiplication. -/
theorem 
scmul_coords: ∀ (r : R) (s : FormalSum R X) (x₀ : X), r * coords s x₀ = coords (scmul r s) x₀
scmul_coords  (
r: R
r : 
R: Type ?u.29241
R) (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.29271) → Type ?u.29270 → [inst : Ring R] → Type (max?u.29270?u.29271)
FormalSum 
R: Type ?u.29241
R 
X: Type ?u.29256
X) (
x₀: X
x₀ : 
X: Type ?u.29256
X) : (
r: R
r * 
s: FormalSum R X
s.
coords: {R : Type ?u.29286} → [inst : Ring R] → {X : Type ?u.29285} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀) = (
s: FormalSum R X
s.
scmul: {R : Type ?u.29342} → [inst : Ring R] → {X : Type ?u.29341} → R → FormalSum R X → FormalSum R X
scmul 
r: R
r).
coords: {R : Type ?u.29354} → [inst : Ring R] → {X : Type ?u.29353} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀ := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

r: R

s: FormalSum R X

x₀: X

r * coords s x₀ = coords (scmul r s) x₀induction 
s: FormalSum R X
s with
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

r: R

s: FormalSum R X

x₀: X

r * coords s x₀ = coords (scmul r s) x₀| 
nil: {α : Type u} → List α
nil =>
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

r: R

x₀: X

nil
r * coords [] x₀ = coords (scmul r []) x₀simp [
coords: {R : Type ?u.29499} → [inst : Ring R] → {X : Type ?u.29498} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

r: R

s: FormalSum R X

x₀: X

r * coords s x₀ = coords (scmul r s) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.29490
h 
t: List ?m.29490
t 
ih: ?m.29491 t
ih =>
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

r: R

x₀: X

h: R × X

t: List (R × X)

ih: r * coords t x₀ = coords (scmul r t) x₀

cons
r * coords (h :: t) x₀ = coords (scmul r (h :: t)) x₀simp [
scmul: {R : Type ?u.29732} → [inst : Ring R] → {X : Type ?u.29731} → R → FormalSum R X → FormalSum R X
scmul, 
coords: {R : Type ?u.30238} → [inst : Ring R] → {X : Type ?u.30237} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monom_coords_mul: ∀ {R : Type ?u.30288} [inst : Ring R] {X : Type ?u.30289} [inst_1 : DecidableEq X] {x : X} (x₀ : X) (a b : R),
  monomCoeff R X x₀ (a * b, x) = a * monomCoeff R X x₀ (b, x)
monom_coords_mul, 
left_distrib: ∀ {R : Type ?u.30331} [inst : Mul R] [inst_1 : Add R] [inst_2 : LeftDistribClass R] (a b c : R),
  a * (b + c) = a * b + a * c
left_distrib, 
ih: ?m.29491 t
ih]
Goals accomplished! 🐙

/-- Scalar multiplication on the Free Module. -/
def 
FreeModule.scmul: R → R[X] → R[X]
FreeModule.scmul  : 
R: Type ?u.31052
R → 
R: Type ?u.31052
R[
X: Type ?u.31067
X] → 
R: Type ?u.31052
R[
X: Type ?u.31067
X] := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]intro 
r: R
r
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

R[X] → R[X]
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]let 
f: FormalSum R X → R[X]
f : 
FormalSum: (R : Type ?u.31168) → Type ?u.31167 → [inst : Ring R] → Type (max?u.31167?u.31168)
FormalSum 
R: Type
R 
X: Type
X → 
R: Type
R[
X: Type
X] := fun 
s: ?m.31191
s => ⟦
s: ?m.31191
s.
scmul: {R : Type ?u.31200} → [inst : Ring R] → {X : Type ?u.31199} → R → FormalSum R X → FormalSum R X
scmul 
r: R
r⟧
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

R[X] → R[X]
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]apply 
Quotient.lift: {α : Sort ?u.31224} →
  {β : Sort ?u.31223} → {s : Setoid α} → (f : α → β) → (∀ (a b : α), a ≈ b → f a = f b) → Quotient s → β
Quotient.lift 
f: FormalSum R X → R[X]
f
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

∀ (a b : FormalSum R X), a ≈ b → f a = f b
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → f s₁ = f s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]simp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

s₁ ≈ s₂ → FormalSum.scmul r s₁ ≈ FormalSum.scmul r s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]intro 
hypeq: s₁ ≈ s₂
hypeq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

FormalSum.scmul r s₁ ≈ FormalSum.scmul r s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]apply 
funext: ∀ {α : Sort ?u.32016} {β : α → Sort ?u.32015} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

h
∀ (x : X), coords (FormalSum.scmul r s₁) x = coords (FormalSum.scmul r s₂) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

h
coords (FormalSum.scmul r s₁) x₀ = coords (FormalSum.scmul r s₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]have 
l₁: ?m.32039
l₁ := 
scmul_coords: ∀ {R : Type ?u.32040} [inst : Ring R] {X : Type ?u.32041} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (FormalSum.scmul r s) x₀
scmul_coords 
r: R
r 
s₁: FormalSum R X
s₁ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

h
coords (FormalSum.scmul r s₁) x₀ = coords (FormalSum.scmul r s₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]have 
l₂: ?m.32059
l₂ := 
scmul_coords: ∀ {R : Type ?u.32060} [inst : Ring R] {X : Type ?u.32061} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (FormalSum.scmul r s) x₀
scmul_coords 
r: R
r 
s₂: FormalSum R X
s₂ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
coords (FormalSum.scmul r s₁) x₀ = coords (FormalSum.scmul r s₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
coords (FormalSum.scmul r s₁) x₀ = coords (FormalSum.scmul r s₂) x₀← 
l₁: ?m.32039
l₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
r * coords s₁ x₀ = coords (FormalSum.scmul r s₂) x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
coords (FormalSum.scmul r s₁) x₀ = coords (FormalSum.scmul r s₂) x₀← 
l₂: ?m.32059
l₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
r * coords s₁ x₀ = r * coords s₂ x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
r * coords s₁ x₀ = r * coords s₂ x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R → R[X] → R[X]rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
r * coords s₁ x₀ = r * coords s₂ x₀
hypeq: s₁ ≈ s₂
hypeq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

r: R

f:= fun s => Quotient.mk (formalSumSetoid R X) (FormalSum.scmul r s): FormalSum R X → R[X]

s₁, s₂: FormalSum R X

hypeq: s₁ ≈ s₂

x₀: X

l₁: r * coords s₁ x₀ = coords (FormalSum.scmul r s₁) x₀

l₂: r * coords s₂ x₀ = coords (FormalSum.scmul r s₂) x₀

h
r * coords s₂ x₀ = r * coords s₂ x₀]
Goals accomplished! 🐙

/-!
### Addition: on formal sums and on the quotient.
-/

/-- Coordinates add when appending. -/
theorem 
append_coords: ∀ {R : Type u_1} [inst : Ring R] {X : Type u_2} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.32372) → Type ?u.32371 → [inst : Ring R] → Type (max?u.32371?u.32372)
FormalSum 
R: Type ?u.32344
R 
X: Type ?u.32359
X) (
x₀: X
x₀ : 
X: Type ?u.32359
X) : (
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.32394} → [inst : Ring R] → {X : Type ?u.32393} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀) + (
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.32450} → [inst : Ring R] → {X : Type ?u.32449} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀) = (
s₁: FormalSum R X
s₁ ++ 
s₂: FormalSum R X
s₂).
coords: {R : Type ?u.32537} → [inst : Ring R] → {X : Type ?u.32536} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀ := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

x₀: X

coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀induction 
s₁: FormalSum R X
s₁ with
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s₂: FormalSum R X

x₀: X

nil
coords [] x₀ + coords s₂ x₀ = coords ([] ++ s₂) x₀simp [
coords: {R : Type ?u.32695} → [inst : Ring R] → {X : Type ?u.32694} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

x₀: X

coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.32686
h 
t: List ?m.32686
t 
ih: ?m.32687 t
ih =>
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

s₂: FormalSum R X

x₀: X

h: R × X

t: List (R × X)

ih: coords t x₀ + coords s₂ x₀ = coords (t ++ s₂) x₀

cons
coords (h :: t) x₀ + coords s₂ x₀ = coords (h :: t ++ s₂) x₀simp [
coords: {R : Type ?u.33089} → [inst : Ring R] → {X : Type ?u.33088} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, ← 
ih: ?m.32687 t
ih, 
add_assoc: ∀ {G : Type ?u.33121} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙

/-- Coordinates well-defined up to equivalence. -/
theorem 
append_equiv: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s₁ s₂ t₁ t₂ : FormalSum R X),
  s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂
append_equiv  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
t₁: FormalSum R X
t₁ 
t₂: FormalSum R X
t₂ : 
FormalSum: (R : Type ?u.33535) → Type ?u.33534 → [inst : Ring R] → Type (max?u.33534?u.33535)
FormalSum 
R: Type ?u.33507
R 
X: Type ?u.33522
X) :(
s₁: FormalSum R X
s₁ ≈ 
s₂: FormalSum R X
s₂) → (
t₁: FormalSum R X
t₁ ≈ 
t₂: FormalSum R X
t₂) → 
s₁: FormalSum R X
s₁ ++ 
t₁: FormalSum R X
t₁ ≈ 
s₂: FormalSum R X
s₂ ++ 
t₂: FormalSum R X
t₂ := by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂intro 
eqv₁: s₁ ≈ s₂
eqv₁ 
eqv₂: t₁ ≈ t₂
eqv₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

s₁ ++ t₁ ≈ s₂ ++ t₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂apply 
funext: ∀ {α : Sort ?u.33802} {β : α → Sort ?u.33801} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

h
∀ (x : X), coords (s₁ ++ t₁) x = coords (s₂ ++ t₂) x
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords (s₁ ++ t₁) x₀ = coords (s₂ ++ t₂) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords (s₁ ++ t₁) x₀ = coords (s₂ ++ t₂) x₀← 
append_coords: ∀ {R : Type ?u.33824} [inst : Ring R] {X : Type ?u.33825} [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

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords (s₂ ++ t₂) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords (s₂ ++ t₂) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords (s₂ ++ t₂) x₀← 
append_coords: ∀ {R : Type ?u.33981} [inst : Ring R] {X : Type ?u.33982} [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

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂have 
ls: coords s₁ x₀ = coords s₂ x₀
ls : 
coords: {R : Type ?u.34111} → [inst : Ring R] → {X : Type ?u.34110} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₁: FormalSum R X
s₁ 
x₀: ?α
x₀ = 
coords: {R : Type ?u.34122} → [inst : Ring R] → {X : Type ?u.34121} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂ 
x₀: ?α
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀by 
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

coords s₁ x₀ = coords s₂ x₀apply 
congrFun: ∀ {α : Sort ?u.34138} {β : α → Sort ?u.34137} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
eqv₁: s₁ ≈ s₂
eqv₁
Goals accomplished! 🐙
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂have 
lt: coords t₁ x₀ = coords t₂ x₀
lt : 
coords: {R : Type ?u.34176} → [inst : Ring R] → {X : Type ?u.34175} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t₁: FormalSum R X
t₁ 
x₀: ?α
x₀ = 
coords: {R : Type ?u.34187} → [inst : Ring R] → {X : Type ?u.34186} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t₂: FormalSum R X
t₂ 
x₀: ?α
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀by 
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

coords t₁ x₀ = coords t₂ x₀apply 
congrFun: ∀ {α : Sort ?u.34203} {β : α → Sort ?u.34202} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
eqv₂: t₁ ≈ t₂
eqv₂
Goals accomplished! 🐙
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

s₁ ≈ s₂ → t₁ ≈ t₂ → s₁ ++ t₁ ≈ s₂ ++ t₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

lt: coords t₁ x₀ = coords t₂ x₀

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀← 
ls: coords s₁ x₀ = coords s₂ x₀
ls,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

lt: coords t₁ x₀ = coords t₂ x₀

h
coords s₁ x₀ + coords t₁ x₀ = coords s₁ x₀ + coords t₂ x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

lt: coords t₁ x₀ = coords t₂ x₀

h
coords s₁ x₀ + coords t₁ x₀ = coords s₂ x₀ + coords t₂ x₀← 
lt: coords t₁ x₀ = coords t₂ x₀
lt
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂, t₁, t₂: FormalSum R X

eqv₁: s₁ ≈ s₂

eqv₂: t₁ ≈ t₂

x₀: X

ls: coords s₁ x₀ = coords s₂ x₀

lt: coords t₁ x₀ = coords t₂ x₀

h
coords s₁ x₀ + coords t₁ x₀ = coords s₁ x₀ + coords t₁ x₀]
Goals accomplished! 🐙

end FormalSum

/-- Addition of elements in the free module. -/
def 
FreeModule.add: R[X] → R[X] → R[X]
FreeModule.add  : 
R: Type ?u.34280
R[
X: Type ?u.34295
X] → 
R: Type ?u.34280
R[
X: Type ?u.34295
X] → 
R: Type ?u.34280
R[
X: Type ?u.34295
X] := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]let 
f: FormalSum R X → FormalSum R X → R[X]
f : 
FormalSum: (R : Type ?u.34412) → Type ?u.34411 → [inst : Ring R] → Type (max?u.34411?u.34412)
FormalSum 
R: Type
R 
X: Type
X → 
FormalSum: (R : Type ?u.34417) → Type ?u.34416 → [inst : Ring R] → Type (max?u.34416?u.34417)
FormalSum 
R: Type
R 
X: Type
X → 
R: Type
R[
X: Type
X] := fun 
s₁: ?m.34440
s₁ 
s₂: ?m.34443
s₂ => ⟦
s₁: ?m.34440
s₁ ++ 
s₂: ?m.34443
s₂⟧
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

R[X] → R[X] → R[X]
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]apply 
Quotient.lift₂: {α : Sort ?u.34505} →
  {β : Sort ?u.34504} →
    {φ : Sort ?u.34503} →
      {s₁ : Setoid α} →
        {s₂ : Setoid β} →
          (f : α → β → φ) →
            (∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂) →
              Quotient s₁ → Quotient s₂ → φ
Quotient.lift₂ 
f: FormalSum R X → FormalSum R X → R[X]
f
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

∀ (a₁ b₁ a₂ b₂ : FormalSum R X), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]intro 
a₁: FormalSum R X
a₁ 
b₁: FormalSum R X
b₁ 
a₂: FormalSum R X
a₂ 
b₂: FormalSum R X
b₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]simp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

a₁ ≈ a₂ → b₁ ≈ b₂ → a₁ ++ b₁ ≈ a₂ ++ b₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]intro 
eq₁: a₁ ≈ a₂
eq₁ 
eq₂: b₁ ≈ b₂
eq₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

a₁ ++ b₁ ≈ a₂ ++ b₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]apply 
funext: ∀ {α : Sort ?u.35684} {β : α → Sort ?u.35683} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

h
∀ (x : X), coords (a₁ ++ b₁) x = coords (a₂ ++ b₂) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

h
coords (a₁ ++ b₁) x₀ = coords (a₂ ++ b₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]have 
l₁: ?m.35707
l₁ := 
append_coords: ∀ {R : Type ?u.35708} [inst : Ring R] {X : Type ?u.35709} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords 
a₁: FormalSum R X
a₁ 
b₁: FormalSum R X
b₁ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

h
coords (a₁ ++ b₁) x₀ = coords (a₂ ++ b₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]have 
l₂: ?m.35727
l₂ := 
append_coords: ∀ {R : Type ?u.35728} [inst : Ring R] {X : Type ?u.35729} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords 
a₂: FormalSum R X
a₂ 
b₂: FormalSum R X
b₂ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords (a₁ ++ b₁) x₀ = coords (a₂ ++ b₂) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords (a₁ ++ b₁) x₀ = coords (a₂ ++ b₂) x₀← 
l₁: ?m.35707
l₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₁ x₀ + coords b₁ x₀ = coords (a₂ ++ b₂) x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords (a₁ ++ b₁) x₀ = coords (a₂ ++ b₂) x₀← 
l₂: ?m.35727
l₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₁ x₀ + coords b₁ x₀ = coords a₂ x₀ + coords b₂ x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₁ x₀ + coords b₁ x₀ = coords a₂ x₀ + coords b₂ x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

R[X] → R[X] → R[X]rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₁ x₀ + coords b₁ x₀ = coords a₂ x₀ + coords b₂ x₀
eq₁: a₁ ≈ a₂
eq₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₂ x₀ + coords b₁ x₀ = coords a₂ x₀ + coords b₂ x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₁ x₀ + coords b₁ x₀ = coords a₂ x₀ + coords b₂ x₀
eq₂: b₁ ≈ b₂
eq₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

f:= fun s₁ s₂ => Quotient.mk (formalSumSetoid R X) (s₁ ++ s₂): FormalSum R X → FormalSum R X → R[X]

a₁, b₁, a₂, b₂: FormalSum R X

eq₁: a₁ ≈ a₂

eq₂: b₁ ≈ b₂

x₀: X

l₁: coords a₁ x₀ + coords b₁ x₀ = coords (a₁ ++ b₁) x₀

l₂: coords a₂ x₀ + coords b₂ x₀ = coords (a₂ ++ b₂) x₀

h
coords a₂ x₀ + coords b₂ x₀ = coords a₂ x₀ + coords b₂ x₀]
Goals accomplished! 🐙

instance: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → Add (R[X])
instance  : 
Add: Type ?u.36102 → Type ?u.36102
Add (
R: Type ?u.36075
R[
X: Type ?u.36090
X]) :=
  ⟨
FreeModule.add: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X] → R[X] → R[X]
FreeModule.add⟩

instance: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → HSMul R (R[X]) (R[X])
instance  : 
HSMul: Type ?u.36343 → Type ?u.36342 → outParam (Type ?u.36341) → Type (max(max?u.36343?u.36342)?u.36341)
HSMul 
R: Type ?u.36314
R (
R: Type ?u.36314
R[
X: Type ?u.36329
X]) (
R: Type ?u.36314
R[
X: Type ?u.36329
X]) :=
  ⟨
FreeModule.scmul: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R → R[X] → R[X]
FreeModule.scmul⟩
namespace FormalSum

/-!
### Properties of operations on formal sums.
-/

/-- Associativity for scalar multiplication for formal sums. -/
theorem 
action: ∀ (a b : R) (s : FormalSum R X), scmul a (scmul b s) = scmul (a * b) s
action  (
a: R
a 
b: R
b : 
R: Type ?u.36592
R) (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.36624) → Type ?u.36623 → [inst : Ring R] → Type (max?u.36623?u.36624)
FormalSum 
R: Type ?u.36592
R 
X: Type ?u.36607
X) : (
s: FormalSum R X
s.
scmul: {R : Type ?u.36634} → [inst : Ring R] → {X : Type ?u.36633} → R → FormalSum R X → FormalSum R X
scmul 
b: R
b).
scmul: {R : Type ?u.36649} → [inst : Ring R] → {X : Type ?u.36648} → R → FormalSum R X → FormalSum R X
scmul 
a: R
a = 
s: FormalSum R X
s.
scmul: {R : Type ?u.36661} → [inst : Ring R] → {X : Type ?u.36660} → R → FormalSum R X → FormalSum R X
scmul (
a: R
a * 
b: R
b) := by
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a (scmul b s) = scmul (a * b) sinduction 
s: FormalSum R X
s with
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a (scmul b s) = scmul (a * b) s| 
nil: {α : Type u} → List α
nil =>
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

a, b: R

nil
scmul a (scmul b []) = scmul (a * b) []simp [
scmul: {R : Type ?u.36777} → [inst : Ring R] → {X : Type ?u.36776} → R → FormalSum R X → FormalSum R X
scmul]
Goals accomplished! 🐙
  
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a (scmul b s) = scmul (a * b) s| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.36768
h 
t: List ?m.36768
t 
ih: ?m.36769 t
ih =>
    
R: Type u_1

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_2

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a (scmul b t) = scmul (a * b) t

cons
scmul a (scmul b (h :: t)) = scmul (a * b) (h :: t)simp [
scmul: {R : Type ?u.36873} → [inst : Ring R] → {X : Type ?u.36872} → R → FormalSum R X → FormalSum R X
scmul, 
ih: ?m.36769 t
ih, 
mul_assoc: ∀ {G : Type ?u.36896} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc]
Goals accomplished! 🐙

/-- Distributivity for the module operations. -/
theorem 
act_sum: ∀ (a b : R) (s : FormalSum R X), scmul a s ++ scmul b s ≈ scmul (a + b) s
act_sum (
a: R
a 
b: R
b : 
R: Type ?u.37203
R) (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.37235) → Type ?u.37234 → [inst : Ring R] → Type (max?u.37234?u.37235)
FormalSum 
R: Type ?u.37203
R 
X: Type ?u.37218
X) : (
s: FormalSum R X
s.
scmul: {R : Type ?u.37259} → [inst : Ring R] → {X : Type ?u.37258} → R → FormalSum R X → FormalSum R X
scmul 
a: R
a) ++ (
s: FormalSum R X
s.
scmul: {R : Type ?u.37274} → [inst : Ring R] → {X : Type ?u.37273} → R → FormalSum R X → FormalSum R X
scmul 
b: R
b) ≈  
s: FormalSum R X
s.
scmul: {R : Type ?u.37326} → [inst : Ring R] → {X : Type ?u.37325} → R → FormalSum R X → FormalSum R X
scmul (
a: R
a + 
b: R
b) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a s ++ scmul b s ≈ scmul (a + b) sinduction 
s: FormalSum R X
s with
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a s ++ scmul b s ≈ scmul (a + b) s| 
nil: {α : Type u} → List α
nil =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

nil
scmul a [] ++ scmul b [] ≈ scmul (a + b) []simp [
scmul: {R : Type ?u.37510} → [inst : Ring R] → {X : Type ?u.37509} → R → FormalSum R X → FormalSum R X
scmul]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

nil
[] ≈ []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

nil
scmul a [] ++ scmul b [] ≈ scmul (a + b) []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

X: Type

inst✝: DecidableEq X

a, b: R

s: FormalSum R X

scmul a s ++ scmul b s ≈ scmul (a + b) s| 
cons: {α : Type u} → α → List α → List α
cons 
h: ?m.37501
h 
t: List ?m.37501
t 
ih: ?m.37502 t
ih =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)apply 
funext: ∀ {α : Sort ?u.37724} {β : α → Sort ?u.37723} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons.h
∀ (x : X), coords (scmul a (h :: t) ++ scmul b (h :: t)) x = coords (scmul (a + b) (h :: t)) x;
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons.h
∀ (x : X), coords (scmul a (h :: t) ++ scmul b (h :: t)) x = coords (scmul (a + b) (h :: t)) x 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

cons.h
coords (scmul a (h :: t) ++ scmul b (h :: t)) x₀ = coords (scmul (a + b) (h :: t)) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)let 
il₁: ?m.37747
il₁ := 
congrFun: ∀ {α : Sort ?u.37749} {β : α → Sort ?u.37748} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
ih: ?m.37502 t
ih 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
coords (scmul a (h :: t) ++ scmul b (h :: t)) x₀ = coords (scmul (a + b) (h :: t)) x₀    
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
coords (scmul a (h :: t) ++ scmul b (h :: t)) x₀ = coords (scmul (a + b) (h :: t)) x₀← 
append_coords: ∀ {R : Type ?u.37768} [inst : Ring R] {X : Type ?u.37769} [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

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
coords (scmul a (h :: t)) x₀ + coords (scmul b (h :: t)) x₀ = coords (scmul (a + b) (h :: t)) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
coords (scmul a (h :: t)) x₀ + coords (scmul b (h :: t)) x₀ = coords (scmul (a + b) (h :: t)) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)simp [
scmul: {R : Type ?u.37892} → [inst : Ring R] → {X : Type ?u.37891} → R → FormalSum R X → FormalSum R X
scmul, 
coords: {R : Type ?u.37915} → [inst : Ring R] → {X : Type ?u.37914} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
right_distrib: ∀ {R : Type ?u.37965} [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.37993} [inst : Ring R] {X : Type ?u.37994} [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

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁:= congrFun ih x₀: coords (scmul a t ++ scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀← 
append_coords: ∀ {R : Type ?u.40224} [inst : Ring R] {X : Type ?u.40225} [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

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀ at 
il₁: ?m.37747
il₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀ 
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul (a + b) t) x₀← 
il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀
il₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)simp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)conv =>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)lhs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +   (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +   (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀)
add_assoc: ∀ {G : Type ?u.41174} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (coords (scmul a t) x₀ + (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀))]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (coords (scmul a t) x₀ + (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀))
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)arg 2
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀)← 
add_assoc: ∀ {G : Type ?u.41347} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)arg 1
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + monomCoeff R X x₀ (b * h.fst, h.snd)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + coords (scmul a t) x₀ +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

coords (scmul a t) x₀ + monomCoeff R X x₀ (b * h.fst, h.snd)
add_comm: ∀ {G : Type ?u.41464} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

cons
scmul a (h :: t) ++ scmul b (h :: t) ≈ scmul (a + b) (h :: t)conv =>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +   (coords (scmul a t) x₀ + coords (scmul b t) x₀)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

cons.h
monomCoeff R X x₀ (a * h.fst, h.snd) +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀ + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)lhs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀ + coords (scmul b t) x₀)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀ + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀ + coords (scmul b t) x₀)
add_assoc: ∀ {G : Type ?u.41686} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (monomCoeff R X x₀ (b * h.fst, h.snd) + (coords (scmul a t) x₀ + coords (scmul b t) x₀))]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (monomCoeff R X x₀ (b * h.fst, h.snd) + (coords (scmul a t) x₀ + coords (scmul b t) x₀))
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +     (monomCoeff R X x₀ (b * h.fst, h.snd) + coords (scmul a t) x₀ + coords (scmul b t) x₀) =   monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +     (coords (scmul a t) x₀ + coords (scmul b t) x₀)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) +   (monomCoeff R X x₀ (b * h.fst, h.snd) + (coords (scmul a t) x₀ + coords (scmul b t) x₀))← 
add_assoc: ∀ {G : Type ?u.41778} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +   (coords (scmul a t) x₀ + coords (scmul b t) x₀)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

h: R × X

t: List (R × X)

ih: scmul a t ++ scmul b t ≈ scmul (a + b) t

x₀: X

il₁: coords (scmul a t) x₀ + coords (scmul b t) x₀ = coords (scmul (a + b) t) x₀

monomCoeff R X x₀ (a * h.fst, h.snd) + monomCoeff R X x₀ (b * h.fst, h.snd) +   (coords (scmul a t) x₀ + coords (scmul b t) x₀)
    

end FormalSum

namespace FreeModule

/-!
### Module properties for the free module.
-/

/-- Associativity for scalar and ring products. -/
theorem 
module_action: ∀ (a b : R) (x : R[X]), a • b • x = (a * b) • x
module_action  (
a: R
a 
b: R
b : 
R: Type ?u.41995
R) (
x: R[X]
x : 
R: Type ?u.41995
R[
X: Type ?u.42010
X]) : 
a: R
a • (
b: R
b • 
x: R[X]
x) = (
a: R
a * 
b: R
b) • 
x: R[X]
x := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • b • x = (a * b) • xapply @
Quotient.ind: ∀ {α : Sort ?u.42290} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
a: R
a • (
b: R
b • 
x: R[X]
x) = (
a: R
a * 
b: R
b) • 
x: R[X]
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a
∀ (a_1 : FormalSum R X), a • b • Quotient.mk (formalSumSetoid R X) a_1 = (a * b) • Quotient.mk (formalSumSetoid R X) a_1
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • b • x = (a * b) • xintro 
s: FormalSum R X
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a
a • b • Quotient.mk (formalSumSetoid R X) s = (a * b) • Quotient.mk (formalSumSetoid R X) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • b • x = (a * b) • xapply 
Quotient.sound: ∀ {α : Sort ?u.42479} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a
scmul a (scmul b s) ≈ scmul (a * b) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • b • x = (a * b) • xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a
scmul a (scmul b s) ≈ scmul (a * b) s
FormalSum.action: ∀ {R : Type ?u.42521} [inst : Ring R] {X : Type ?u.42522} (a b : R) (s : FormalSum R X),
  scmul a (scmul b s) = scmul (a * b) s
FormalSum.action
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a
scmul (a * b) s ≈ scmul (a * b) s]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a
scmul (a * b) s ≈ scmul (a * b) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • b • x = (a * b) • xapply 
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! 🐙

/-- Commutativity of addition. -/
theorem 
addn_comm: ∀ (x₁ x₂ : R[X]), x₁ + x₂ = x₂ + x₁
addn_comm  (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.42614
R[
X: Type ?u.42629
X]) : 
x₁: R[X]
x₁ + 
x₂: R[X]
x₂ = 
x₂: R[X]
x₂ + 
x₁: R[X]
x₁ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁apply @
Quotient.ind₂: ∀ {α : Sort ?u.42869} {β : Sort ?u.42868} {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 
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type
R[
X: Type
X] => 
x₁: R[X]
x₁ + 
x₂: R[X]
x₂ = 
x₂: R[X]
x₂ + 
x₁: R[X]
x₁)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

h
∀ (a b : FormalSum R X),
  Quotient.mk (formalSumSetoid R X) a + Quotient.mk (formalSumSetoid R X) b =     Quotient.mk (formalSumSetoid R X) b + Quotient.mk (formalSumSetoid R X) a
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h
Quotient.mk (formalSumSetoid R X) s₁ + Quotient.mk (formalSumSetoid R X) s₂ =   Quotient.mk (formalSumSetoid R X) s₂ + Quotient.mk (formalSumSetoid R X) s₁
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁apply 
Quotient.sound: ∀ {α : Sort ?u.43046} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h.a
s₁ ++ s₂ ≈ s₂ ++ s₁
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁apply 
funext: ∀ {α : Sort ?u.43089} {β : α → Sort ?u.43088} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h.a.h
∀ (x : X), coords (s₁ ++ s₂) x = coords (s₂ ++ s₁) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁let 
lm₁: ?m.43112
lm₁ := 
append_coords: ∀ {R : Type ?u.43113} [inst : Ring R] {X : Type ?u.43114} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁let 
lm₂: ?m.43129
lm₂ := 
append_coords: ∀ {R : Type ?u.43130} [inst : Ring R] {X : Type ?u.43131} [inst_1 : DecidableEq X] (s₁ s₂ : FormalSum R X) (x₀ : X),
  coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀
append_coords 
s₂: FormalSum R X
s₂ 
s₁: FormalSum R X
s₁ 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

h.a.h
coords (s₁ ++ s₂) x₀ = coords (s₂ ++ s₁) x₀← 
lm₁: ?m.43112
lm₁,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

h.a.h
coords (s₁ ++ s₂) x₀ = coords (s₂ ++ s₁) x₀← 
lm₂: ?m.43129
lm₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

h.a.h
coords s₁ x₀ + coords s₂ x₀ = coords s₂ x₀ + coords s₁ x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

lm₁:= append_coords s₁ s₂ x₀: coords s₁ x₀ + coords s₂ x₀ = coords (s₁ ++ s₂) x₀

lm₂:= append_coords s₂ s₁ x₀: coords s₂ x₀ + coords s₁ x₀ = coords (s₂ ++ s₁) x₀

h.a.h
coords s₁ x₀ + coords s₂ x₀ = coords s₂ x₀ + coords s₁ x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂: R[X]

x₁ + x₂ = x₂ + x₁simp [
add_comm: ∀ {G : Type ?u.43214} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm]
Goals accomplished! 🐙

theorem 
add_assoc_aux: ∀ (s₁ : FormalSum R X) (x₂ x₃ : R[X]),
  Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)
add_assoc_aux  (
s₁: FormalSum R X
s₁ : 
FormalSum: (R : Type ?u.43576) → Type ?u.43575 → [inst : Ring R] → Type (max?u.43575?u.43576)
FormalSum 
R: Type ?u.43548
R 
X: Type ?u.43563
X) (
x₂: R[X]
x₂ 
x₃: R[X]
x₃ : 
R: Type ?u.43548
R[
X: Type ?u.43563
X]) : (⟦
s₁: FormalSum R X
s₁⟧ + 
x₂: R[X]
x₂) + 
x₃: R[X]
x₃ = ⟦
s₁: FormalSum R X
s₁⟧ + (
x₂: R[X]
x₂ + 
x₃: R[X]
x₃) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)apply @
Quotient.ind₂: ∀ {α : Sort ?u.44078} {β : Sort ?u.44077} {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 
x₂: R[X]
x₂ 
x₃: R[X]
x₃ : 
R: Type
R[
X: Type
X] => (⟦
s₁: FormalSum R X
s₁⟧ + 
x₂: R[X]
x₂) + 
x₃: R[X]
x₃ = ⟦
s₁: FormalSum R X
s₁⟧ + (
x₂: R[X]
x₂ + 
x₃: R[X]
x₃))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

h
∀ (a b : FormalSum R X),
  Quotient.mk (formalSumSetoid R X) s₁ + Quotient.mk (formalSumSetoid R X) a + Quotient.mk (formalSumSetoid R X) b =     Quotient.mk (formalSumSetoid R X) s₁ + (Quotient.mk (formalSumSetoid R X) a + Quotient.mk (formalSumSetoid R X) b)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)intro 
x₂: FormalSum R X
x₂ 
x₃: FormalSum R X
x₃
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

h
Quotient.mk (formalSumSetoid R X) s₁ + Quotient.mk (formalSumSetoid R X) x₂ + Quotient.mk (formalSumSetoid R X) x₃ =   Quotient.mk (formalSumSetoid R X) s₁ + (Quotient.mk (formalSumSetoid R X) x₂ + Quotient.mk (formalSumSetoid R X) x₃)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)apply 
Quotient.sound: ∀ {α : Sort ?u.44501} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

h.a
s₁ ++ x₂ ++ x₃ ≈ s₁ ++ (x₂ ++ x₃)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)apply 
funext: ∀ {α : Sort ?u.44530} {β : α → Sort ?u.44529} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

h.a.h
∀ (x : X), coords (s₁ ++ x₂ ++ x₃) x = coords (s₁ ++ (x₂ ++ x₃)) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

h.a.h
coords (s₁ ++ x₂ ++ x₃) x₀ = coords (s₁ ++ (x₂ ++ x₃)) x₀← 
append_coords: ∀ {R : Type ?u.44552} [inst : Ring R] {X : Type ?u.44553} [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

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

h.a.h
coords (s₁ ++ x₂) x₀ + coords x₃ x₀ = coords (s₁ ++ (x₂ ++ x₃)) x₀← 
append_coords: ∀ {R : Type ?u.44700} [inst : Ring R] {X : Type ?u.44701} [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

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

h.a.h
coords s₁ x₀ + coords x₂ x₀ + coords x₃ x₀ = coords (s₁ ++ (x₂ ++ x₃)) x₀← 
append_coords: ∀ {R : Type ?u.44817} [inst : Ring R] {X : Type ?u.44818} [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

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

h.a.h
coords s₁ x₀ + coords x₂ x₀ + coords x₃ x₀ = coords s₁ x₀ + coords (x₂ ++ x₃) x₀← 
append_coords: ∀ {R : Type ?u.44952} [inst : Ring R] {X : Type ?u.44953} [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

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂✝, x₃✝: R[X]

x₂, x₃: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁: FormalSum R X

x₂, x₃: R[X]

Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)simp [
add_assoc: ∀ {G : Type ?u.45077} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc]
Goals accomplished! 🐙

/-- Associativity of addition. -/
theorem 
addn_assoc: ∀ (x₁ x₂ x₃ : R[X]), x₁ + x₂ + x₃ = x₁ + (x₂ + x₃)
addn_assoc  (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ 
x₃: R[X]
x₃ : 
R: Type ?u.45428
R[
X: Type ?u.45443
X]) : (
x₁: R[X]
x₁ + 
x₂: R[X]
x₂) + 
x₃: R[X]
x₃ = 
x₁: R[X]
x₁ + (
x₂: R[X]
x₂ + 
x₃: R[X]
x₃) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂, x₃: R[X]

x₁ + x₂ + x₃ = x₁ + (x₂ + x₃)apply @
Quotient.ind: ∀ {α : Sort ?u.45796} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x₁: R[X]
x₁ : 
R: Type
R[
X: Type
X] => (
x₁: R[X]
x₁ + 
x₂: R[X]
x₂) + 
x₃: R[X]
x₃ = 
x₁: R[X]
x₁ + (
x₂: R[X]
x₂ + 
x₃: R[X]
x₃))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂, x₃: R[X]

a
∀ (a : FormalSum R X), Quotient.mk (formalSumSetoid R X) a + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) a + (x₂ + x₃)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂, x₃: R[X]

x₁ + x₂ + x₃ = x₁ + (x₂ + x₃)intro 
x₁: FormalSum R X
x₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁✝, x₂, x₃: R[X]

x₁: FormalSum R X

a
Quotient.mk (formalSumSetoid R X) x₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) x₁ + (x₂ + x₃)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₁, x₂, x₃: R[X]

x₁ + x₂ + x₃ = x₁ + (x₂ + x₃)apply 
add_assoc_aux: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (s₁ : FormalSum R X) (x₂ x₃ : R[X]),
  Quotient.mk (formalSumSetoid R X) s₁ + x₂ + x₃ = Quotient.mk (formalSumSetoid R X) s₁ + (x₂ + x₃)
add_assoc_aux
Goals accomplished! 🐙

/-- The zero element of the free module. -/
def 
zero: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X]
zero : 
R: Type ?u.46057
R[
X: Type ?u.46072
X] := ⟦
[]: List ?m.46148
[]⟧

/-- adding zero-/
theorem 
addn_zero: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), x + zero = x
addn_zero (
x: R[X]
x: 
R: Type ?u.46241
R[
X: Type ?u.46256
X]) : 
x: R[X]
x + 
zero: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X]
zero = 
x: R[X]
x := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xapply @
Quotient.ind: ∀ {α : Sort ?u.46694} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
x: R[X]
x + 
zero: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X]
zero = 
x: R[X]
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

a
∀ (a : FormalSum R X), Quotient.mk (formalSumSetoid R X) a + zero = Quotient.mk (formalSumSetoid R X) a
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xintro 
x: FormalSum R X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a
Quotient.mk (formalSumSetoid R X) x + zero = Quotient.mk (formalSumSetoid R X) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xapply 
Quotient.sound: ∀ {α : Sort ?u.47097} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a.a
x ++ [] ≈ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xapply 
funext: ∀ {α : Sort ?u.47128} {β : α → Sort ?u.47127} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a.a.h
∀ (x_1 : X), coords (x ++ []) x_1 = coords x x_1
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xintro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords (x ++ []) x₀ = coords x x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords (x ++ []) x₀ = coords x x₀← 
append_coords: ∀ {R : Type ?u.47150} [inst : Ring R] {X : Type ?u.47151} [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

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords x x₀ + coords [] x₀ = coords x x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords x x₀ + coords [] x₀ = coords x x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

x + zero = xsimp [
add_zero: ∀ {M : Type ?u.47298} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero, 
coords: {R : Type ?u.47316} → [inst : Ring R] → {X : Type ?u.47315} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙

/-- adding zero-/
theorem 
zero_addn: ∀ (x : R[X]), zero + x = x
zero_addn (
x: R[X]
x: 
R: Type ?u.47663
R[
X: Type ?u.47678
X]) : 
zero: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X]
zero + 
x: R[X]
x = 
x: R[X]
x := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xapply @
Quotient.ind: ∀ {α : Sort ?u.48116} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
zero: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → R[X]
zero + 
x: R[X]
x = 
x: R[X]
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

a
∀ (a : FormalSum R X), zero + Quotient.mk (formalSumSetoid R X) a = Quotient.mk (formalSumSetoid R X) a
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xintro 
x: FormalSum R X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a
zero + Quotient.mk (formalSumSetoid R X) x = Quotient.mk (formalSumSetoid R X) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xapply 
Quotient.sound: ∀ {α : Sort ?u.48515} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a.a
[] ++ x ≈ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xapply 
funext: ∀ {α : Sort ?u.48546} {β : α → Sort ?u.48545} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

a.a.h
∀ (x_1 : X), coords ([] ++ x) x_1 = coords x x_1
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xintro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords ([] ++ x) x₀ = coords x x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords ([] ++ x) x₀ = coords x x₀← 
append_coords: ∀ {R : Type ?u.48568} [inst : Ring R] {X : Type ?u.48569} [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

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords [] x₀ + coords x x₀ = coords x x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x✝: R[X]

x: FormalSum R X

x₀: X

a.a.h
coords [] x₀ + coords x x₀ = coords x x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

zero + x = xsimp [
add_zero: ∀ {M : Type ?u.48716} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero, 
coords: {R : Type ?u.48734} → [inst : Ring R] → {X : Type ?u.48733} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙

/-- Distributivity for addition of module elements. -/
theorem 
elem_distrib: ∀ (a : R) (x₁ x₂ : R[X]), a • (x₁ + x₂) = a • x₁ + a • x₂
elem_distrib  (
a: R
a : 
R: Type ?u.49081
R) (
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type ?u.49081
R[
X: Type ?u.49096
X]) : 
a: R
a • (
x₁: R[X]
x₁ + 
x₂: R[X]
x₂) = 
a: R
a • 
x₁: R[X]
x₁ + 
a: R
a • 
x₂: R[X]
x₂ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂apply @
Quotient.ind₂: ∀ {α : Sort ?u.49456} {β : Sort ?u.49455} {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 
x₁: R[X]
x₁ 
x₂: R[X]
x₂ : 
R: Type
R[
X: Type
X] => 
a: R
a • (
x₁: R[X]
x₁ + 
x₂: R[X]
x₂) = 
a: R
a • 
x₁: R[X]
x₁ + 
a: R
a • 
x₂: R[X]
x₂)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

h
∀ (a_1 b : FormalSum R X),
  a • (Quotient.mk (formalSumSetoid R X) a_1 + Quotient.mk (formalSumSetoid R X) b) =     a • Quotient.mk (formalSumSetoid R X) a_1 + a • Quotient.mk (formalSumSetoid R X) b
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h
a • (Quotient.mk (formalSumSetoid R X) s₁ + Quotient.mk (formalSumSetoid R X) s₂) =   a • Quotient.mk (formalSumSetoid R X) s₁ + a • Quotient.mk (formalSumSetoid R X) s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂apply 
Quotient.sound: ∀ {α : Sort ?u.49735} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h.a
scmul a (s₁ ++ s₂) ≈ scmul a s₁ ++ scmul a s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂apply 
funext: ∀ {α : Sort ?u.49778} {β : α → Sort ?u.49777} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

h.a.h
∀ (x : X), coords (scmul a (s₁ ++ s₂)) x = coords (scmul a s₁ ++ scmul a s₂) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
coords (scmul a (s₁ ++ s₂)) x₀ = coords (scmul a s₁ ++ scmul a s₂) x₀← 
scmul_coords: ∀ {R : Type ?u.49800} [inst : Ring R] {X : Type ?u.49801} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (scmul r s) x₀
scmul_coords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * coords (s₁ ++ s₂) x₀ = coords (scmul a s₁ ++ scmul a s₂) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * coords (s₁ ++ s₂) x₀ = coords (scmul a s₁ ++ scmul a s₂) x₀← 
append_coords: ∀ {R : Type ?u.49953} [inst : Ring R] {X : Type ?u.49954} [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

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = coords (scmul a s₁ ++ scmul a s₂) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = coords (scmul a s₁ ++ scmul a s₂) x₀← 
append_coords: ∀ {R : Type ?u.50076} [inst : Ring R] {X : Type ?u.50077} [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

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = coords (scmul a s₁) x₀ + coords (scmul a s₂) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = coords (scmul a s₁) x₀ + coords (scmul a s₂) x₀← 
scmul_coords: ∀ {R : Type ?u.50203} [inst : Ring R] {X : Type ?u.50204} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (scmul r s) x₀
scmul_coords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = a * coords s₁ x₀ + coords (scmul a s₂) x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

h.a.h
a * (coords s₁ x₀ + coords s₂ x₀) = a * coords s₁ x₀ + coords (scmul a s₂) x₀← 
scmul_coords: ∀ {R : Type ?u.50324} [inst : Ring R] {X : Type ?u.50325} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (scmul r s) x₀
scmul_coords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

s₁, s₂: FormalSum R X

x₀: X

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

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a: R

x₁, x₂: R[X]

a • (x₁ + x₂) = a • x₁ + a • x₂simp [
left_distrib: ∀ {R : Type ?u.50447} [inst : Mul R] [inst_1 : Add R] [inst_2 : LeftDistribClass R] (a b c : R),
  a * (b + c) = a * b + a * c
left_distrib]
Goals accomplished! 🐙

/-- Distributivity with respect to scalars. -/
theorem 
coeffs_distrib: ∀ (a b : R) (x : R[X]), a • x + b • x = (a + b) • x
coeffs_distrib (
a: R
a 
b: R
b: 
R: Type ?u.50828
R)(
x: R[X]
x: 
R: Type ?u.50828
R[
X: Type ?u.50843
X]) : 
a: R
a • 
x: R[X]
x + 
b: R
b • 
x: R[X]
x = (
a: R
a + 
b: R
b) • 
x: R[X]
x:= by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xapply @
Quotient.ind: ∀ {α : Sort ?u.51213} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
    
a: R
a • 
x: R[X]
x + 
b: R
b • 
x: R[X]
x = (
a: R
a + 
b: R
b) • 
x: R[X]
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a
∀ (a_1 : FormalSum R X),
  a • Quotient.mk (formalSumSetoid R X) a_1 + b • Quotient.mk (formalSumSetoid R X) a_1 =     (a + b) • Quotient.mk (formalSumSetoid R X) a_1
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xintro 
s: FormalSum R X
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a
a • Quotient.mk (formalSumSetoid R X) s + b • Quotient.mk (formalSumSetoid R X) s =   (a + b) • Quotient.mk (formalSumSetoid R X) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xapply 
Quotient.sound: ∀ {α : Sort ?u.51451} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a
scmul a s ++ scmul b s ≈ scmul (a + b) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xapply 
funext: ∀ {α : Sort ?u.51494} {β : α → Sort ?u.51493} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

a.a.h
∀ (x : X), coords (scmul a s ++ scmul b s) x = coords (scmul (a + b) s) x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xintro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

x₀: X

a.a.h
coords (scmul a s ++ scmul b s) x₀ = coords (scmul (a + b) s) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xlet 
l: ?m.51517
l := 
act_sum: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (a b : R) (s : FormalSum R X),
  scmul a s ++ scmul b s ≈ scmul (a + b) s
act_sum 
a: R
a 
b: R
b 
s: FormalSum R X
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

x₀: X

l:= act_sum a b s: scmul a s ++ scmul b s ≈ scmul (a + b) s

a.a.h
coords (scmul a s ++ scmul b s) x₀ = coords (scmul (a + b) s) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xlet 
l'': ?m.51532
l'' := 
congrFun: ∀ {α : Sort ?u.51534} {β : α → Sort ?u.51533} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
l: ?m.51517
l 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

s: FormalSum R X

x₀: X

l:= act_sum a b s: scmul a s ++ scmul b s ≈ scmul (a + b) s

l'':= congrFun l x₀: coords (scmul a s ++ scmul b s) x₀ = coords (scmul (a + b) s) x₀

a.a.h
coords (scmul a s ++ scmul b s) x₀ = coords (scmul (a + b) s) x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a, b: R

x: R[X]

a • x + b • x = (a + b) • xexact 
l'': ?m.51532
l''
Goals accomplished! 🐙

/-- Multiplication by `1 : R`. -/
theorem 
unit_coeffs: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), 1 • x = x
unit_coeffs (
x: R[X]
x: 
R: Type ?u.51602
R[
X: Type ?u.51617
X]) : (
1: ?m.51698
1 : 
R: Type ?u.51602
R) • 
x: R[X]
x =  
x: R[X]
x:= by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xapply @
Quotient.ind: ∀ {α : Sort ?u.51779} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
    (
1: ?m.51826
1 : 
R: Type
R) • 
x: R[X]
x =  
x: R[X]
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

a
∀ (a : FormalSum R X), 1 • Quotient.mk (formalSumSetoid R X) a = Quotient.mk (formalSumSetoid R X) a
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xintro 
s: FormalSum R X
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a
1 • Quotient.mk (formalSumSetoid R X) s = Quotient.mk (formalSumSetoid R X) s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xapply 
Quotient.sound: ∀ {α : Sort ?u.51871} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a.a
scmul 1 s ≈ s
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xapply 
funext: ∀ {α : Sort ?u.51914} {β : α → Sort ?u.51913} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a.a.h
∀ (x : X), coords (scmul 1 s) x = coords s x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xintro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

a.a.h
coords (scmul 1 s) x₀ = coords s x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xlet 
l: ?m.51937
l := 
scmul_coords: ∀ {R : Type ?u.51938} [inst : Ring R] {X : Type ?u.51939} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (scmul r s) x₀
scmul_coords 
1: ?m.51945
1 
s: FormalSum R X
s 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 1 s x₀: 1 * coords s x₀ = coords (scmul 1 s) x₀

a.a.h
coords (scmul 1 s) x₀ = coords s x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 1 s x₀: 1 * coords s x₀ = coords (scmul 1 s) x₀

a.a.h
coords (scmul 1 s) x₀ = coords s x₀← 
l: ?m.51937
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 1 s x₀: 1 * coords s x₀ = coords (scmul 1 s) x₀

a.a.h
1 * coords s x₀ = coords s x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 1 s x₀: 1 * coords s x₀ = coords (scmul 1 s) x₀

a.a.h
1 * coords s x₀ = coords s x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

1 • x = xsimp
Goals accomplished! 🐙

/-- Multiplication by `0 : R`. -/
theorem 
zero_coeffs: ∀ (x : R[X]), 0 • x = Quotient.mk (formalSumSetoid R X) []
zero_coeffs (
x: R[X]
x: 
R: Type ?u.52262
R[
X: Type ?u.52277
X]) : (
0: ?m.52358
0 : 
R: Type ?u.52262
R) • 
x: R[X]
x =  ⟦ 
[]: List ?m.52466
[] ⟧:= by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []apply @
Quotient.ind: ∀ {α : Sort ?u.52523} {s : Setoid α} {motive : Quotient s → Prop},
  (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quot Setoid.r), motive q
Quotient.ind (motive := fun 
x: R[X]
x : 
R: Type
R[
X: Type
X] => 
    (
0: ?m.52568
0 : 
R: Type
R) • 
x: R[X]
x =  ⟦ 
[]: List ?m.52598
[] ⟧)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

a
∀ (a : FormalSum R X), 0 • Quotient.mk (formalSumSetoid R X) a = Quotient.mk (formalSumSetoid R X) []
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []intro 
s: FormalSum R X
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a
0 • Quotient.mk (formalSumSetoid R X) s = Quotient.mk (formalSumSetoid R X) []
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []apply 
Quotient.sound: ∀ {α : Sort ?u.52656} {s : Setoid α} {a b : α}, a ≈ b → Quotient.mk s a = Quotient.mk s b
Quotient.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a.a
scmul 0 s ≈ []
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []apply 
funext: ∀ {α : Sort ?u.52697} {β : α → Sort ?u.52696} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) → f = g
funext
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

a.a.h
∀ (x : X), coords (scmul 0 s) x = coords [] x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []intro 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

a.a.h
coords (scmul 0 s) x₀ = coords [] x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []let 
l: ?m.52720
l := 
scmul_coords: ∀ {R : Type ?u.52721} [inst : Ring R] {X : Type ?u.52722} [inst_1 : DecidableEq X] (r : R) (s : FormalSum R X) (x₀ : X),
  r * coords s x₀ = coords (scmul r s) x₀
scmul_coords 
0: ?m.52728
0 
s: FormalSum R X
s 
x₀: ?α
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 0 s x₀: 0 * coords s x₀ = coords (scmul 0 s) x₀

a.a.h
coords (scmul 0 s) x₀ = coords [] x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 0 s x₀: 0 * coords s x₀ = coords (scmul 0 s) x₀

a.a.h
coords (scmul 0 s) x₀ = coords [] x₀← 
l: ?m.52720
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 0 s x₀: 0 * coords s x₀ = coords (scmul 0 s) x₀

a.a.h
0 * coords s x₀ = coords [] x₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

s: FormalSum R X

x₀: X

l:= scmul_coords 0 s x₀: 0 * coords s x₀ = coords (scmul 0 s) x₀

a.a.h
0 * coords s x₀ = coords [] x₀
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

0 • x = Quotient.mk (formalSumSetoid R X) []simp [
coords: {R : Type ?u.52792} → [inst : Ring R] → {X : Type ?u.52791} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
Goals accomplished! 🐙

/-- The module is an additive commutative group, mainly proved as a check -/
instance: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → AddCommGroup (R[X])
instance : 
AddCommGroup: Type ?u.53167 → Type ?u.53167
AddCommGroup (
R: Type ?u.53140
R[
X: Type ?u.53155
X]) :=
  {
    zero := ⟦ 
[]: List ?m.53403
[]⟧
    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 + zero = x
FreeModule.addn_zero
    zero_add := 
FreeModule.zero_addn: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] (x : R[X]), zero + x = x
FreeModule.zero_addn
    neg := fun 
x: ?m.53549
x => (-
1: ?m.53562
1 : 
R: Type ?u.53140
R) • 
x: ?m.53549
x

    sub_eq_add_neg := by 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a b : R[X]), a - b = a + -bintros
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a✝, b✝: R[X]

a✝ - b✝ = a✝ + -b✝;
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

a✝, b✝: R[X]

a✝ - b✝ = a✝ + -b✝ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a b : R[X]), a - b = a + -brfl
Goals accomplished! 🐙

    add_left_neg := by 
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0intro 
x: R[X]
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

-x + x = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0let 
l: ?m.54114
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.54122
1 : 
R: Type
R) (
1: ?m.54141
1 : 
R: Type
R) 
x: R[X]
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l:= coeffs_distrib (-1) 1 x: -1 • x + 1 • x = (-1 + 1) • x

-x + x = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0simp at 
l: ?m.54114
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + 1 • x = 0 • x

-x + x = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + 1 • x = 0 • 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

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = 0 • x

-x + x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = 0 • x

-x + x = 0 at 
l: -1 • x + 1 • x = 0 • x
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = 0 • x

-x + x = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = 0 • 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

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = Quotient.mk (formalSumSetoid R X) []

-x + x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = Quotient.mk (formalSumSetoid R X) []

-x + x = 0 at 
l: -1 • x + x = 0 • x
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

l: -1 • x + x = Quotient.mk (formalSumSetoid R X) []

-x + x = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

∀ (a : R[X]), -a + a = 0exact 
l: -1 • x + x = Quotient.mk (formalSumSetoid R X) []
l
Goals accomplished! 🐙

    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
  }

end FreeModule

end ModuleStruture

/-! 
## Equivalent definition of the relation via moves 

For conceptual results such as the universal property (needed for the group ring structure) it is useful to define the relation on the free module in terms of moves. We do this, and show that this is the same as the relation defined by equality of coordinates.

* We define elementary moves on formal sums 
* We show coordinates equal if and only if related by elementary moves
* Hence can define map on Free Module when invariant under elementary moves 
  -/

section ElementaryMoves

open FormalSum
/-- Elementary moves for formal sums. -/
inductive 
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 
X: Type
X : 
Type: Type 1
Type) [
Ring: Type ?u.56206 → Type ?u.56206
Ring 
R: Type
R] [
DecidableEq: Sort ?u.56209 → Sort (max1?u.56209)
DecidableEq 
R: Type
R][
DecidableEq: Sort ?u.56218 → Sort (max1?u.56218)
DecidableEq 
X: Type
X] : 
FormalSum: (R : Type ?u.56229) → Type ?u.56228 → [inst : Ring R] → Type (max?u.56228?u.56229)
FormalSum 
R: Type
R 
X: Type
X → 
FormalSum: (R : Type ?u.56238) → Type ?u.56237 → [inst : Ring R] → Type (max?u.56237?u.56238)
FormalSum 
R: Type
R 
X: Type
X → 
Prop: Type
Prop where
  | 
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 R X
tail : 
FormalSum: (R : Type ?u.56255) → Type ?u.56254 → [inst : Ring R] → Type (max?u.56254?u.56255)
FormalSum 
R: Type
R 
X: Type
X) (
x: X
x : 
X: Type
X) (
a: R
a : 
R: Type
R) (
h: a = 0
h : 
a: R
a = 
0: ?m.56267
0) : 
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 
X: Type
X ((
a: R
a, 
x: X
x) :: 
tail: FormalSum R X
tail) 
tail: FormalSum R X
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: R
a 
b: R
b : 
R: Type
R) (
x: X
x : 
X: Type
X) (
tail: FormalSum R X
tail : 
FormalSum: (R : Type ?u.56446) → Type ?u.56445 → [inst : Ring R] → Type (max?u.56445?u.56446)
FormalSum 
R: Type
R 
X: Type
X) : 
    
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 
X: Type
X ((
a: R
a, 
x: X
x) :: (
b: R
b, 
x: X
x) :: 
tail: FormalSum R X
tail) ((
a: R
a + 
b: R
b, 
x: X
x) :: 
tail: FormalSum R X
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: R
a : 
R: Type
R) (
x: X
x : 
X: Type
X) (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.56578) → Type ?u.56577 → [inst : Ring R] → Type (max?u.56577?u.56578)
FormalSum 
R: Type
R 
X: Type
X) : 
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 
X: Type
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ → 
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 
X: Type
X ((
a: R
a, 
x: X
x) :: 
s₁: FormalSum R X
s₁) ((
a: R
a, 
x: X
x) :: 
s₂: FormalSum R X
s₂)
  | 
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₁: R
a₁ 
a₂: R
a₂ : 
R: Type
R) (
x₁: X
x₁ 
x₂: X
x₂ : 
X: Type
X) (
tail: FormalSum R X
tail : 
FormalSum: (R : Type ?u.56635) → Type ?u.56634 → [inst : Ring R] → Type (max?u.56634?u.56635)
FormalSum 
R: Type
R 
X: Type
X) :
    
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 
X: Type
X ((
a₁: R
a₁, 
x₁: X
x₁) :: (
a₂: R
a₂, 
x₂: X
x₂) :: 
tail: FormalSum R X
tail) ((
a₂: R
a₂, 
x₂: X
x₂) :: (
a₁: R
a₁, 
x₁: X
x₁) :: 
tail: FormalSum R X
tail)

def 
FreeModuleAux: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq R] → [inst_2 : DecidableEq X] → ?m.57283 R X
FreeModuleAux (
R: Type
R 
X: Type
X : 
Type: Type 1
Type) [
Ring: Type ?u.57261 → Type ?u.57261
Ring 
R: Type
R] [
DecidableEq: Sort ?u.57264 → Sort (max1?u.57264)
DecidableEq 
R: Type
R][
DecidableEq: Sort ?u.57273 → Sort (max1?u.57273)
DecidableEq 
X: Type
X] :=
  
Quot: {α : Sort ?u.57294} → (α → α → Prop) → Sort ?u.57294
Quot (
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 
X: Type
X)

namespace FormalSum

/-- Image in the quotient (i.e., actual, not formal, sum). -/
def 
sum: FormalSum R X → FreeModuleAux R X
sum  (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.57439) → Type ?u.57438 → [inst : Ring R] → Type (max?u.57438?u.57439)
FormalSum 
R: Type ?u.57411
R 
X: Type ?u.57426
X) : 
FreeModuleAux: (R X : Type) → [inst : Ring R] → [inst : DecidableEq R] → [inst : DecidableEq X] → Type
FreeModuleAux 
R: Type ?u.57411
R 
X: Type ?u.57426
X :=
  
Quot.mk: {α : Sort ?u.57532} → (r : α → α → Prop) → α → Quot r
Quot.mk (
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 ?u.57411
R 
X: Type ?u.57426
X) 
s: FormalSum R X
s

/-- Equivalence by having the same image. -/
def 
equiv: FormalSum R X → FormalSum R X → Prop
equiv  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.57736) → Type ?u.57735 → [inst : Ring R] → Type (max?u.57735?u.57736)
FormalSum 
R: Type ?u.57699
R 
X: Type ?u.57714
X) : 
Prop: Type
Prop :=
  
s₁: FormalSum R X
s₁.
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum = 
s₂: FormalSum R X
s₂.
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum

infix:65 " ≃ " => 
FormalSum.equiv: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
FormalSum.equiv

/-!
### Invariance of coordinates under elementary moves
-/

/-- Coordinates are invariant under moves. -/
theorem 
coords_move_invariant: ∀ (x₀ : X) (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → coords s₁ x₀ = coords s₂ x₀
coords_move_invariant (
x₀: X
x₀ : 
X: Type ?u.66342
X) (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.66366) → Type ?u.66365 → [inst : Ring R] → Type (max?u.66365?u.66366)
FormalSum 
R: Type ?u.66327
R 
X: Type ?u.66342
X) (
h: ElementaryMove R X s₁ s₂
h : 
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 ?u.66327
R 
X: Type ?u.66342
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂) : 
coords: {R : Type ?u.66461} → [inst : Ring R] → {X : Type ?u.66460} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₁: FormalSum R X
s₁ 
x₀: X
x₀ = 
coords: {R : Type ?u.66474} → [inst : Ring R] → {X : Type ?u.66473} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂ 
x₀: X
x₀ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

h: ElementaryMove R X s₁ s₂

coords s₁ x₀ = coords s₂ x₀induction 
h: ElementaryMove R X s₁ s₂
h with
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

h: ElementaryMove R X s₁ s₂

coords s₁ x₀ = coords 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.66568 ?m.66569
tail 
x: ?m.66569
x 
a: ?m.66568
a 
hyp: a = 0
hyp =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂, tail: FormalSum R X

x: X

a: R

hyp: a = 0

zeroCoeff
coords ((a, x) :: tail) x₀ = coords tail x₀simp [
coords: {R : Type ?u.66600} → [inst : Ring R] → {X : Type ?u.66599} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
hyp: a = 0
hyp, 
monom_coords_at_zero: ∀ {R : Type ?u.66657} [inst : Ring R] {X : Type ?u.66658} [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

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

h: ElementaryMove R X s₁ s₂

coords s₁ x₀ = coords 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.66568
a 
b: ?m.66568
b 
x: ?m.66569
x 
tail: FormalSum ?m.66568 ?m.66569
tail =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

a, b: R

x: X

tail: FormalSum R X

addCoeffs
coords ((a, x) :: (b, x) :: tail) x₀ = coords ((a + b, x) :: tail) x₀simp [
coords: {R : Type ?u.67154} → [inst : Ring R] → {X : Type ?u.67153} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monom_coords_at_zero: ∀ {R : Type ?u.67184} [inst : Ring R] {X : Type ?u.67185} [inst_1 : DecidableEq X] (x₀ x : X),
  monomCoeff R X x₀ (0, x) = 0
monom_coords_at_zero, ← 
add_assoc: ∀ {G : Type ?u.67201} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc, 
monom_coords_hom: ∀ {R : Type ?u.67224} [inst : Ring R] {X : Type ?u.67225} [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]
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

h: ElementaryMove R X s₁ s₂

coords s₁ x₀ = coords 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.66568
a 
x: ?m.66569
x 
s₁: FormalSum ?m.66568 ?m.66569
s₁ 
s₂: FormalSum ?m.66568 ?m.66569
s₂ 
_: ElementaryMove ?m.66568 ?m.66569 s₁ s₂
_ 
step: ?m.66573 s₁ s₂ a✝
step =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁✝, s₂✝: FormalSum R X

a: R

x: X

s₁, s₂: FormalSum R X

a✝: ElementaryMove R X s₁ s₂

step: coords s₁ x₀ = coords s₂ x₀

cons
coords ((a, x) :: s₁) x₀ = coords ((a, x) :: s₂) x₀simp [
coords: {R : Type ?u.67788} → [inst : Ring R] → {X : Type ?u.67787} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
step: ?m.66573 s₁ s₂ a✝
step]
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

h: ElementaryMove R X s₁ s₂

coords s₁ x₀ = coords 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.66568
a₁ 
a₂: ?m.66568
a₂ 
x₁: ?m.66569
x₁ 
x₂: ?m.66569
x₂ 
tail: FormalSum ?m.66568 ?m.66569
tail =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s₁, s₂: FormalSum R X

a₁, a₂: R

x₁, x₂: X

tail: FormalSum R X

swap
coords ((a₁, x₁) :: (a₂, x₂) :: tail) x₀ = coords ((a₂, x₂) :: (a₁, x₁) :: tail) x₀simp [
coords: {R : Type ?u.68097} → [inst : Ring R] → {X : Type ?u.68096} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, ← 
add_assoc: ∀ {G : Type ?u.68127} [inst : AddSemigroup G] (a b c : G), a + b + c = a + (b + c)
add_assoc, 
add_comm: ∀ {G : Type ?u.68144} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm]
Goals accomplished! 🐙

end FormalSum

/-- Coordinates on the quotients. -/
def 
FreeModuleAux.coeff: X → FreeModuleAux R X → R
FreeModuleAux.coeff (
x₀: X
x₀ : 
X: Type ?u.68743
X) : 
FreeModuleAux: (R X : Type) → [inst : Ring R] → [inst : DecidableEq R] → [inst : DecidableEq X] → Type
FreeModuleAux 
R: Type ?u.68728
R 
X: Type ?u.68743
X → 
R: Type ?u.68728
R :=
  
Quot.lift: {α : Sort ?u.68844} →
  {r : α → α → Prop} → {β : Sort ?u.68843} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β
Quot.lift (fun 
s: ?m.68857
s => 
s: ?m.68857
s.
coords: {R : Type ?u.68860} → [inst : Ring R] → {X : Type ?u.68859} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀) (
coords_move_invariant: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₀ : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → coords s₁ x₀ = coords s₂ x₀
coords_move_invariant 
x₀: X
x₀)

namespace FormalSum

/-- Commutative diagram for coordinates. -/
theorem 
coeff_factors: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X) (s : FormalSum R X),
  FreeModuleAux.coeff x (sum s) = coords s x
coeff_factors (
x: X
x : 
X: Type ?u.69194
X) (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.69209) → Type ?u.69208 → [inst : Ring R] → Type (max?u.69208?u.69209)
FormalSum 
R: Type ?u.69179
R 
X: Type ?u.69194
X) : 
FreeModuleAux.coeff: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → X → FreeModuleAux R X → R
FreeModuleAux.coeff  
x: X
x (
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum 
s: FormalSum R X
s) = 
s: FormalSum R X
s.
coords: {R : Type ?u.69404} → [inst : Ring R] → {X : Type ?u.69403} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s: FormalSum R X

FreeModuleAux.coeff x (sum s) = coords s xsimp [
FreeModuleAux.coeff: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → X → FreeModuleAux R X → R
FreeModuleAux.coeff]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s: FormalSum R X

Quot.lift (fun s => coords s x) (_ : ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → coords s₁ x = coords s₂ x)
    (sum s) =   coords s x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s: FormalSum R X

FreeModuleAux.coeff x (sum s) = coords s xapply @
Quot.liftBeta: ∀ {α : Sort ?u.69869} {r : α → α → Prop} {β : Sort ?u.69868} (f : α → β) (c : ∀ (a b : α), r a b → f a = f b) (a : α),
  Quot.lift f c (Quot.mk r a) = f a
Quot.liftBeta (r := 
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 
X: Type
X) (f := fun 
s: ?m.69900
s => 
s: ?m.69900
s.
coords: {R : Type ?u.69903} → [inst : Ring R] → {X : Type ?u.69902} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s: FormalSum R X

c
∀ (a b : FormalSum R X), ElementaryMove R X a b → coords a x = coords b x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s: FormalSum R X

FreeModuleAux.coeff x (sum s) = coords s xapply 
coords_move_invariant: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₀ : X)
  (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → coords s₁ x₀ = coords s₂ x₀
coords_move_invariant
Goals accomplished! 🐙

/-- Coordinates well-defined under the equivalence generated by moves. -/
theorem 
coords_well_defined: ∀ (x : X) (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined  (
x: X
x : 
X: Type ?u.70025
X) (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.70040) → Type ?u.70039 → [inst : Ring R] → Type (max?u.70039?u.70040)
FormalSum 
R: Type ?u.70010
R 
X: Type ?u.70025
X) : 
s₁: FormalSum R X
s₁ ≃ 
s₂: FormalSum R X
s₂ → 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.71183} → [inst : Ring R] → {X : Type ?u.71182} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.71201} → [inst : Ring R] → {X : Type ?u.71200} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

s₁ ≃ s₂ → coords s₁ x = coords s₂ xintro 
hyp: s₁ ≃ s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

coords s₁ x = coords s₂ x
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

s₁ ≃ s₂ → coords s₁ x = coords s₂ xhave 
l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x
l : 
FreeModuleAux.coeff: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → X → FreeModuleAux R X → R
FreeModuleAux.coeff 
x: X
x (
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum 
s₂: FormalSum R X
s₂) = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.71342} → [inst : Ring R] → {X : Type ?u.71341} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

coords s₁ x = coords s₂ xby
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

FreeModuleAux.coeff x (sum s₂) = coords s₂ xsimp [
coeff_factors: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X) (s : FormalSum R X),
  FreeModuleAux.coeff x (sum s) = coords s x
coeff_factors, 
hyp: s₁ ≃ s₂
hyp]
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

s₁ ≃ s₂ → coords s₁ x = coords s₂ xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

coords s₁ x = coords s₂ x← 
l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

coords s₁ x = FreeModuleAux.coeff x (sum s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

coords s₁ x = FreeModuleAux.coeff x (sum s₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

s₁ ≃ s₂ → coords s₁ x = coords s₂ xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

coords s₁ x = FreeModuleAux.coeff x (sum s₂)← 
coeff_factors: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X) (s : FormalSum R X),
  FreeModuleAux.coeff x (sum s) = coords s x
coeff_factors
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

FreeModuleAux.coeff x (sum s₁) = FreeModuleAux.coeff x (sum s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

FreeModuleAux.coeff x (sum s₁) = FreeModuleAux.coeff x (sum s₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

s₁ ≃ s₂ → coords s₁ x = coords s₂ xrw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

FreeModuleAux.coeff x (sum s₁) = FreeModuleAux.coeff x (sum s₂)
hyp: s₁ ≃ s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: X

s₁, s₂: FormalSum R X

hyp: s₁ ≃ s₂

l: FreeModuleAux.coeff x (sum s₂) = coords s₂ x

FreeModuleAux.coeff x (sum s₂) = FreeModuleAux.coeff x (sum s₂)]
Goals accomplished! 🐙

/-!
### Equal coordinates implies related by elementary moves.
-/

/-- Cons respects equivalence. -/
theorem 
cons_equiv_of_equiv: ∀ (s₁ s₂ : FormalSum R X) (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.71955) → Type ?u.71954 → [inst : Ring R] → Type (max?u.71954?u.71955)
FormalSum 
R: Type ?u.71918
R 
X: Type ?u.71933
X) (
a: R
a : 
R: Type ?u.71918
R) (
x: X
x : 
X: Type ?u.71933
X) : 
s₁: FormalSum R X
s₁ ≃ 
s₂: FormalSum R X
s₂ → (
a: R
a, 
x: X
x) :: 
s₁: FormalSum R X
s₁ ≃ (
a: R
a, 
x: X
x) :: 
s₂: FormalSum R X
s₂ := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂intro 
h: s₁ ≃ s₂
h
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

(a, x) :: s₁ ≃ (a, x) :: s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂let 
f: FormalSum R X → FreeModuleAux R X
f : 
FormalSum: (R : Type ?u.74175) → Type ?u.74174 → [inst : Ring R] → Type (max?u.74174?u.74175)
FormalSum 
R: Type
R 
X: Type
X → 
FreeModuleAux: (R X : Type) → [inst : Ring R] → [inst : DecidableEq R] → [inst : DecidableEq X] → Type
FreeModuleAux 
R: Type
R 
X: Type
X := fun 
s: ?m.74190
s => 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum <| (
a: R
a, 
x: X
x) :: 
s: ?m.74190
s
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

(a, x) :: s₁ ≃ (a, x) :: s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂let 
wit: ∀ (s₁ : FormalSum R X) (s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
wit : (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.74303) → Type ?u.74302 → [inst : Ring R] → Type (max?u.74302?u.74303)
FormalSum 
R: Type
R 
X: Type
X) → (
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 
X: Type
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂) → 
f: FormalSum R X → FreeModuleAux R X
f 
s₁: FormalSum R X
s₁ = 
f: FormalSum R X → FreeModuleAux R X
f 
s₂: FormalSum R X
s₂ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

(a, x) :: s₁ ≃ (a, x) :: s₂by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
hyp: ElementaryMove R X s₁ s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁✝, s₂✝: FormalSum R X

a: R

x: X

h: s₁✝ ≃ s₂✝

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

s₁, s₂: FormalSum R X

hyp: ElementaryMove R X s₁ s₂

f s₁ = f s₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂apply 
Quot.sound: ∀ {α : Sort ?u.74336} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁✝, s₂✝: FormalSum R X

a: R

x: X

h: s₁✝ ≃ s₂✝

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

s₁, s₂: FormalSum R X

hyp: ElementaryMove R X s₁ s₂

a
ElementaryMove R X ((a, x) :: s₁) ((a, x) :: s₂)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f 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

X: Type

inst✝: DecidableEq X

s₁✝, s₂✝: FormalSum R X

a: R

x: X

h: s₁✝ ≃ s₂✝

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

s₁, s₂: FormalSum R X

hyp: ElementaryMove R X s₁ s₂

a.a
ElementaryMove R X s₁ s₂
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂assumption
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂let 
g: ?m.74430
g := 
Quot.lift: {α : Sort ?u.74432} →
  {r : α → α → Prop} → {β : Sort ?u.74431} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β
Quot.lift 
f: FormalSum R X → FreeModuleAux R X
f 
wit: ∀ (s₁ : FormalSum R X) (s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
wit
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

(a, x) :: s₁ ≃ (a, x) :: s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂let 
factorizes: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)
factorizes : (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.74473) → Type ?u.74472 → [inst : Ring R] → Type (max?u.74472?u.74473)
FormalSum 
R: Type
R 
X: Type
X) → 
g: ?m.74430
g (
s: FormalSum R X
s.
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum) = 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum ((
a: R
a, 
x: X
x) :: 
s: FormalSum R X
s) := 
Quot.liftBeta: ∀ {α : Sort ?u.74526} {r : α → α → Prop} {β : Sort ?u.74525} (f : α → β) (c : ∀ (a b : α), r a b → f a = f b) (a : α),
  Quot.lift f c (Quot.mk r a) = f a
Quot.liftBeta 
f: FormalSum R X → FreeModuleAux R X
f 
wit: ∀ (s₁ : FormalSum R X) (s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
wit
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

(a, x) :: s₁ ≃ (a, x) :: s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

(a, x) :: s₁ ≃ (a, x) :: s₂
equiv: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
equiv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

sum ((a, x) :: s₁) = sum ((a, x) :: s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

sum ((a, x) :: s₁) = sum ((a, x) :: s₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

sum ((a, x) :: s₁) = sum ((a, x) :: s₂)← 
factorizes: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)
factorizes
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = sum ((a, x) :: s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = sum ((a, x) :: s₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = sum ((a, x) :: s₂)← 
factorizes: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)
factorizes
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = g (sum s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = g (sum s₂)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₁) = g (sum s₂)
h: s₁ ≃ s₂
h
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

a: R

x: X

h: s₁ ≃ s₂

f:= fun s => sum ((a, x) :: s): FormalSum R X → FreeModuleAux R X

wit:= fun s₁ s₂ hyp => Quot.sound (ElementaryMove.cons a x s₁ s₂ hyp): ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

g:= Quot.lift f wit: (Quot fun a b => ElementaryMove R X a b) → FreeModuleAux R X

factorizes:= Quot.liftBeta f wit: ∀ (s : FormalSum R X), g (sum s) = sum ((a, x) :: s)

g (sum s₂) = g (sum s₂)]
Goals accomplished! 🐙

/-- If a coordinate `x` for a formal sum `s` is non-zero, `s` is related by moves to a formal sum with first term `x` with coefficient its coordinates, and the rest shorter than `s`. -/
theorem 
nonzero_coeff_has_complement: ∀ (x₀ : X) (s : FormalSum R X), 0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s
nonzero_coeff_has_complement  (
x₀: X
x₀ : 
X: Type ?u.74996
X)(
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.75011) → Type ?u.75010 → [inst : Ring R] → Type (max?u.75010?u.75011)
FormalSum 
R: Type ?u.74981
R 
X: Type ?u.74996
X) : 
0: ?m.75023
0 ≠ 
s: FormalSum R X
s.
coords: {R : Type ?u.75034} → [inst : Ring R] → {X : Type ?u.75033} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀ → (∃ 
ys: FormalSum R X
ys : 
FormalSum: (R : Type ?u.75094) → Type ?u.75093 → [inst : Ring R] → Type (max?u.75093?u.75094)
FormalSum 
R: Type ?u.74981
R 
X: Type ?u.74996
X, (((
s: FormalSum R X
s.
coords: {R : Type ?u.75114} → [inst : Ring R] → {X : Type ?u.75113} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys) ≃ 
s: FormalSum R X
s) ∧ (
List.length: {α : Type ?u.76259} → List α → ℕ
List.length 
ys: FormalSum R X
ys < 
s: FormalSum R X
s.
length: {α : Type ?u.76262} → List α → ℕ
length)) := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s: FormalSum R X

0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length sinduction 
s: FormalSum R X
s with
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s: FormalSum R X

0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s| 
nil: {α : Type u} → List α
nil =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

nil
0 ≠ coords [] x₀ → ∃ ys, (coords [] x₀, x₀) :: ys ≃ [] ∧ List.length ys < List.length []intro 
contra: 0 ≠ coords [] x₀
contra
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

contra: 0 ≠ coords [] x₀

nil
∃ ys, (coords [] x₀, x₀) :: ys ≃ [] ∧ List.length ys < List.length []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

nil
0 ≠ coords [] x₀ → ∃ ys, (coords [] x₀, x₀) :: ys ≃ [] ∧ List.length ys < List.length []contradiction
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

s: FormalSum R X

0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.76355
head 
tail: List ?m.76355
tail 
hyp: ?m.76356 tail
hyp =>
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

cons
0 ≠ coords (head :: tail) x₀ →
  ∃ ys, (coords (head :: tail) x₀, x₀) :: ys ≃ head :: tail ∧ List.length ys < List.length (head :: tail)let (
a: R
a, 
x: X
x) := 
head: ?m.76355
head
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

cons
0 ≠ coords ((a, x) :: tail) x₀ →
  ∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

cons
0 ≠ coords (head :: tail) x₀ →
  ∃ ys, (coords (head :: tail) x₀, x₀) :: ys ≃ head :: tail ∧ List.length ys < List.length (head :: tail)intro 
pos: 0 ≠ coords ((a, x) :: tail) x₀
pos
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

cons
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

cons
0 ≠ coords (head :: tail) x₀ →
  ∃ ys, (coords (head :: tail) x₀, x₀) :: ys ≃ head :: tail ∧ List.length ys < List.length (head :: tail)cases c : 
x: X
x == 
x₀: X
x₀ with
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

x✝: Bool

c: (x == x₀) = x✝

cons
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)| 
true: Bool
true =>
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)let 
k: ?m.76573
k := 
FormalSum.coords: {R : Type ?u.76575} → [inst : Ring R] → {X : Type ?u.76574} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
FormalSum.coords 
tail: List ?m.76355
tail 
x₀: X
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
lem: a + k = coords ((a, x) :: tail) x₀
lem : 
a: R
a + 
k: ?m.76573
k = 
coords: {R : Type ?u.76649} → [inst : Ring R] → {X : Type ?u.76648} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords ((
a: R
a, 
x: X
x) :: 
tail: List ?m.76355
tail) 
x₀: X
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k = coords ((a, x) :: tail) x₀rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k = coords ((a, x) :: tail) x₀
coords: {R : Type ?u.76938} → [inst : Ring R] → {X : Type ?u.76937} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k = monomCoeff R X x₀ (a, x) + coords tail x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k = coords ((a, x) :: tail) x₀
monomCoeff: (R : Type ?u.76975) → (X : Type ?u.76974) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k =   (match (a, x).snd == x₀ with
    | true => (a, x).fst
    | false => 0) +     coords tail x₀ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k = coords ((a, x) :: tail) x₀
c: (x == x₀) = true
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

a + k =   (match true with
    | true => (a, x).fst
    | false => 0) +     coords tail x₀]
Goals accomplished! 🐙
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
c'': x = x₀
c'' : 
x: X
x = 
x₀: X
x₀ := 
of_decide_eq_true: ∀ {p : Prop} [inst : Decidable p], decide p = true → p
of_decide_eq_true 
c: (x == x₀) = true
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
c'': x = x₀
c''
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
c'': x = x₀
c''
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail) at 
lem: a + k = coords ((a, x) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

cons.true
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)exact
        if 
c': ?m.77226
c' : (
0: ?m.77127
0 = 
k: ?m.76573
k) then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)have 
lIneq: List.length tail < List.length ((a, x) :: tail)
lIneq : 
tail: List (R × X)
tail.
length: {α : Type ?u.77235} → List α → ℕ
length < 
List.length: {α : Type ?u.77239} → List α → ℕ
List.length ((
a: R
a, 
x: X
x) :: 
tail: List (R × X)
tail) := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

List.length tail < List.length ((a, x) :: tail)simp [
List.length_cons: ∀ {α : Type ?u.77257} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
Goals accomplished! 🐙
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)← 
c': 0 = k
c',
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + 0 = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail) 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
add_zero: ∀ {M : Type ?u.77340} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail) at 
lem: a + k = coords ((a, x₀) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)← 
lem: a = coords ((a, x₀) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (a, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

lIneq: List.length tail < List.length ((a, x) :: tail)

∃ ys, (a, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': 0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)exact ⟨
tail: List (R × X)
tail, 
rfl: ∀ {α : Sort ?u.77504} {a : α}, a = a
rfl, 
lIneq: List.length tail < List.length ((a, x) :: tail)
lIneq⟩
Goals accomplished! 🐙
        else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

cons.true
∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)let ⟨
ys: FormalSum R X
ys, 
eqnStep: (coords tail x₀, x₀) :: ys ≃ tail
eqnStep, 
lIneqStep: List.length ys < List.length tail
lIneqStep⟩ := 
hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail
hyp 
c': ¬0 = k
c'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)have 
eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys
eqn₁ : (
a: R
a, 
x₀: X
x₀) :: (
k: R
k, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys ≃ (
a: R
a + 
k: R
k, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

(a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ysapply 
Quot.sound: ∀ {α : Sort ?u.78927} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

a
ElementaryMove R X ((a, x₀) :: (k, x₀) :: ys) ((a + k, x₀) :: ys)
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

(a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ysapply 
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

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)have 
eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail
eqn₂ : (
a: R
a, 
x₀: X
x₀) :: (
k: R
k, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys ≃ (
a: R
a, 
x₀: X
x₀) :: 
tail: List (R × X)
tail := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

(a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tailapply 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

a
(k, x₀) :: ys ≃ tail
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

(a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tailassumption
Goals accomplished! 🐙
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)have 
eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail
eqn : (
a: R
a + 
k: R
k, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys ≃ (
a: R
a, 
x₀: X
x₀) :: 
tail: List (R × X)
tail := 
Eq.trans: ∀ {α : Sort ?u.81317} {a b c : α}, a = b → b = c → a = c
Eq.trans (
Eq.symm: ∀ {α : Sort ?u.81322} {a b : α}, a = b → b = a
Eq.symm 
eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys
eqn₁) 
eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail
eqn₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)← 
lem: a + k = coords ((a, x₀) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

∃ ys, (a + k, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

∃ ys, (a + k, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)have 
lIneq: List.length ys < List.length ((a, x₀) :: tail)
lIneq : 
ys: FormalSum R X
ys.
length: {α : Type ?u.81347} → List α → ℕ
length < 
List.length: {α : Type ?u.81351} → List α → ℕ
List.length ((
a: R
a, 
x₀: X
x₀) :: 
tail: List (R × X)
tail) := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

∃ ys, (a + k, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

List.length ys < List.length ((a, x₀) :: tail)apply 
Nat.le_trans: ∀ {n m k : ℕ}, n ≤ m → m ≤ k → n ≤ k
Nat.le_trans 
lIneqStep: List.length ys < List.length tail
lIneqStep
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

List.length tail ≤ List.length ((a, x₀) :: tail)
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

ys: FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys ≃ tail

lIneqStep: List.length ys < List.length tail

eqn₁: (a, x₀) :: (k, x₀) :: ys ≃ (a + k, x₀) :: ys

eqn₂: (a, x₀) :: (k, x₀) :: ys ≃ (a, x₀) :: tail

eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail

List.length ys < List.length ((a, x₀) :: tail)simp [
List.length_cons: ∀ {α : Type ?u.81377} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons, 
Nat.le_succ: ∀ (n : ℕ), n ≤ Nat.succ n
Nat.le_succ]
Goals accomplished! 🐙
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = true

k:= coords tail x₀: R

lem: a + k = coords ((a, x₀) :: tail) x₀

c'': x = x₀

c': ¬0 = k

∃ ys, (coords ((a, x₀) :: tail) x₀, x₀) :: ys ≃ (a, x₀) :: tail ∧ List.length ys < List.length ((a, x₀) :: tail)exact ⟨
ys: FormalSum R X
ys, 
eqn: (a + k, x₀) :: ys ≃ (a, x₀) :: tail
eqn, 
lIneq: List.length ys < List.length ((a, x₀) :: tail)
lIneq⟩
Goals accomplished! 🐙
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

x✝: Bool

c: (x == x₀) = x✝

cons
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)| 
false: Bool
false =>
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)let 
k: ?m.81533
k := 
coords: {R : Type ?u.81535} → [inst : Ring R] → {X : Type ?u.81534} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
tail: List ?m.76355
tail 
x₀: X
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

k:= coords tail x₀: R

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
lem: k = coords ((a, x) :: tail) x₀
lem : 
k: ?m.81533
k = 
coords: {R : Type ?u.81616} → [inst : Ring R] → {X : Type ?u.81615} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords ((
a: R
a, 
x: X
x) :: 
tail: List ?m.76355
tail) 
x₀: X
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

k:= coords tail x₀: R

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

k:= coords tail x₀: R

k = coords ((a, x) :: tail) x₀simp [
coords: {R : Type ?u.81640} → [inst : Ring R] → {X : Type ?u.81639} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.81697) → (X : Type ?u.81696) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff, 
c: (x == x₀) = false
c, 
zero_add: ∀ {M : Type ?u.81738} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add]
Goals accomplished! 🐙
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

k:= coords tail x₀: R

lem: k = coords ((a, x) :: tail) x₀

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)← 
lem: k = coords ((a, x) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail) at 
pos: 0 ≠ coords ((a, x) :: tail) x₀
pos
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)let ⟨
ys': FormalSum R X
ys', 
eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail
eqnStep, 
lIneqStep: List.length ys' < List.length tail
lIneqStep⟩ := 
hyp: ?m.76356 tail
hyp 
pos: 0 ≠ k
pos
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)← 
lem: k = coords ((a, x) :: tail) x₀
lem
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)let 
ys: ?m.83037
ys := (
a: R
a, 
x: X
x) :: 
ys': FormalSum R X
ys'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
lIneq: List.length ys < List.length ((a, x) :: tail)
lIneq : 
ys: ?m.83037
ys.
length: {α : Type ?u.83053} → List α → ℕ
length < ((
a: R
a, 
x: X
x) :: 
tail: List ?m.76355
tail).
length: {α : Type ?u.83063} → List α → ℕ
length := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

List.length ys < List.length ((a, x) :: tail)simp [
List.length_cons: ∀ {α : Type ?u.83076} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

Nat.succ (List.length ys') < Nat.succ (List.length tail)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

List.length ys < List.length ((a, x) :: tail)apply 
Nat.succ_lt_succ: ∀ {n m : ℕ}, n < m → Nat.succ n < Nat.succ m
Nat.succ_lt_succ
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

a
List.length ys' < List.length tail
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

List.length ys < List.length ((a, x) :: tail)exact 
lIneqStep: List.length ys' < List.length tail
lIneqStep
Goals accomplished! 🐙
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'
eqn₁ : (
k: ?m.81533
k, 
x₀: X
x₀) :: 
ys: ?m.83037
ys ≃ (
a: R
a, 
x: X
x) :: (
k: ?m.81533
k, 
x₀: X
x₀) :: 
ys': FormalSum R X
ys' := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

(k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'apply 
Quot.sound: ∀ {α : Sort ?u.84281} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

a
ElementaryMove R X ((k, x₀) :: ys) ((a, x) :: (k, x₀) :: ys')
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

(k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'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

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
eqn₂: (a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tail
eqn₂ : (
a: R
a, 
x: X
x) :: (
k: ?m.81533
k, 
x₀: X
x₀) :: 
ys': FormalSum R X
ys' ≃ (
a: R
a, 
x: X
x) :: 
tail: List ?m.76355
tail := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

(a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tailapply 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

a
(k, x₀) :: ys' ≃ tail
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

(a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tailassumption
Goals accomplished! 🐙
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)have 
eqn: (k, x₀) :: ys ≃ (a, x) :: tail
eqn : (
k: ?m.81533
k, 
x₀: X
x₀) :: 
ys: ?m.83037
ys ≃ (
a: R
a, 
x: X
x) :: 
tail: List ?m.76355
tail := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

eqn₂: (a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tail

cons.false
∃ ys, (k, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

c: (x == x₀) = false

k:= coords tail x₀: R

pos: 0 ≠ k

lem: k = coords ((a, x) :: tail) x₀

ys': FormalSum R X

eqnStep: (coords tail x₀, x₀) :: ys' ≃ tail

lIneqStep: List.length ys' < List.length tail

ys:= (a, x) :: ys': List (R × X)

lIneq: List.length ys < List.length ((a, x) :: tail)

eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'

eqn₂: (a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tail

(k, x₀) :: ys ≃ (a, x) :: tailexact 
Eq.trans: ∀ {α : Sort ?u.86574} {a b c : α}, a = b → b = c → a = c
Eq.trans 
eqn₁: (k, x₀) :: ys ≃ (a, x) :: (k, x₀) :: ys'
eqn₁ 
eqn₂: (a, x) :: (k, x₀) :: ys' ≃ (a, x) :: tail
eqn₂
Goals accomplished! 🐙
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x₀: X

head: R × X

tail: List (R × X)

hyp: 0 ≠ coords tail x₀ → ∃ ys, (coords tail x₀, x₀) :: ys ≃ tail ∧ List.length ys < List.length tail

a: R

x: X

pos: 0 ≠ coords ((a, x) :: tail) x₀

c: (x == x₀) = false

cons.false
∃ ys, (coords ((a, x) :: tail) x₀, x₀) :: ys ≃ (a, x) :: tail ∧ List.length ys < List.length ((a, x) :: tail)exact ⟨
ys: ?m.83037
ys, 
eqn: (k, x₀) :: ys ≃ (a, x) :: tail
eqn, 
lIneq: List.length ys < List.length ((a, x) :: tail)
lIneq⟩
Goals accomplished! 🐙

/-- If all coordinates are zero, then moves relate to the empty sum. -/
theorem 
equiv_e_of_zero_coeffs: ∀ (s : FormalSum R X), (∀ (x : X), coords s x = 0) → s ≃ []
equiv_e_of_zero_coeffs  (
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.86726) → Type ?u.86725 → [inst : Ring R] → Type (max?u.86725?u.86726)
FormalSum 
R: Type ?u.86698
R 
X: Type ?u.86713
X) (
hyp: ∀ (x : X), coords s x = 0
hyp : ∀ 
x: X
x : 
X: Type ?u.86713
X, 
s: FormalSum R X
s.
coords: {R : Type ?u.86739} → [inst : Ring R] → {X : Type ?u.86738} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x = 
0: ?m.86795
0) : 
s: FormalSum R X
s ≃ 
[]: List ?m.86950
[] :=
  -- let canc : IsAddLeftCancel R :=
  --   ⟨fun a b c h => by
  --     rw [← neg_add_cancel_left a b, h, neg_add_cancel_left]⟩
  match 
mt: s = []
mt : 
s: FormalSum R X
s with
  | [] => 
rfl: ∀ {α : Sort ?u.88057} {a : α}, a = a
rfl
  | 
h: R × X
h :: 
t: List (R × X)
t => by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []let (
a₀: R
a₀, 
x₀: X
x₀) := 
h: R × X
h
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

(a₀, x₀) :: t ≃ []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []let 
hyp₀: ?m.88486
hyp₀ := 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0
hyp 
x₀: X
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀:= hyp x₀: coords ((a₀, x₀) :: t) x₀ = 0

(a₀, x₀) :: t ≃ []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀:= hyp x₀: coords ((a₀, x₀) :: t) x₀ = 0

(a₀, x₀) :: t ≃ []
coords: {R : Type ?u.88714} → [inst : Ring R] → {X : Type ?u.88713} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

(a₀, x₀) :: t ≃ []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

(a₀, x₀) :: t ≃ [] at 
hyp₀: ?m.88486
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

(a₀, x₀) :: t ≃ []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []have 
c₀: monomCoeff R X x₀ (a₀, x₀) = a₀
c₀ : 
monomCoeff: (R : Type ?u.88722) → (X : Type ?u.88721) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff 
R: Type
R 
X: Type
X 
x₀: X
x₀ (
a₀: R
a₀, 
x₀: X
x₀) = 
a₀: R
a₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

(a₀, x₀) :: t ≃ []by
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

monomCoeff R X x₀ (a₀, x₀) = a₀simp [
monomCoeff: (R : Type ?u.88737) → (X : Type ?u.88736) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff]
Goals accomplished! 🐙
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ []
c₀: monomCoeff R X x₀ (a₀, x₀) = a₀
c₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ [] at 
hyp₀: monomCoeff R X x₀ (a₀, x₀) + coords t x₀ = 0
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ []
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

hyp: ∀ (x : X), coords (h :: t) x = 0

mt: s = h :: t

h :: t ≃ []exact
      if 
hz: ?m.89571
hz : 
a₀: R
a₀ = 
0: ?m.89482
0 then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ []by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []
hz: a₀ = 0
hz
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: 0 + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: 0 + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ [] at 
hyp₀: a₀ + coords t x₀ = 0
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: 0 + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: 0 + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []
zero_add: ∀ {M : Type ?u.89609} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ [] at 
hyp₀: 0 + coords t x₀ = 0
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []have 
tail_coeffs: ∀ (x : X), coords t x = 0
tail_coeffs : ∀ 
x: X
x : 
X: Type
X, 
coords: {R : Type ?u.89749} → [inst : Ring R] → {X : Type ?u.89748} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x: X
x = 
0: ?m.89760
0 := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

∀ (x : X), coords t x = 0intro 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

coords t x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

∀ (x : X), coords t x = 0simp [
coords: {R : Type ?u.89784} → [inst : Ring R] → {X : Type ?u.89783} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

coords t x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

∀ (x : X), coords t x = 0exact
            if 
c: ?m.90008
c : (
x₀: X
x₀ = 
x: X
x) then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

coords t x = 0by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: x₀ = x

coords t x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: x₀ = x

coords t x = 0← 
c: x₀ = x
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: x₀ = x

coords t x₀ = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: x₀ = x

coords t x₀ = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: x₀ = x

coords t x = 0assumption
Goals accomplished! 🐙
            else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

coords t x = 0by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0let 
hx: ?m.90052
hx := 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0
hyp 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx:= hyp x: coords ((a₀, x₀) :: t) x = 0

coords t x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0simp [
coords: {R : Type ?u.90058} → [inst : Ring R] → {X : Type ?u.90057} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.90089) → (X : Type ?u.90088) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff] at 
hx: ?m.90052
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

coords t x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0have 
lf: (x₀ == x) = false
lf : (
x₀: X
x₀ == 
x: X
x) = 
false: Bool
false := 
decide_eq_false: ∀ {p : Prop} [inst : Decidable p], ¬p → decide p = false
decide_eq_false 
c: ¬x₀ = x
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords t x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords t x = 0
lf: (x₀ == x) = false
lf
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords t x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords t x = 0 at 
hx: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords t x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0simp [
zero_add: ∀ {M : Type ?u.91810} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add] at 
hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

coords t x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

x: X

c: ¬x₀ = x

coords t x = 0assumption
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []have _ : 
t: List (R × X)
t.
length: {α : Type ?u.92008} → List α → ℕ
length < (
h: R × X
h :: 
t: List (R × X)
t).
length: {α : Type ?u.92014} → List α → ℕ
length := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

List.length t < List.length (h :: t)simp [
List.length_cons: ∀ {α : Type ?u.92027} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []let 
step: t ≃ []
step : 
t: List (R × X)
t ≃ 
[]: List ?m.92148
[] := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

t ≃ []apply 
equiv_e_of_zero_coeffs: ∀ (s : FormalSum R X), (∀ (x : X), coords s x = 0) → s ≃ []
equiv_e_of_zero_coeffs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

hyp
∀ (x : X), coords t x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

t ≃ []exact 
tail_coeffs: ∀ (x : X), coords t x = 0
tail_coeffs
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(a₀, x₀) :: t ≃ []
hz: a₀ = 0
hz
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []have 
ls: (0, x₀) :: t ≃ t
ls : (
0: ?m.93266
0, 
x₀: X
x₀) :: 
t: List (R × X)
t ≃ 
t: List (R × X)
t := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ tapply 
Quot.sound: ∀ {α : Sort ?u.94264} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

a
ElementaryMove R X ((0, x₀) :: t) t
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ tapply 
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

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

a.h
0 = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

tail_coeffs: ∀ (x : X), coords t x = 0

x✝: List.length t < List.length (h :: t)

step:= equiv_e_of_zero_coeffs t tail_coeffs: t ≃ []

(0, x₀) :: t ≃ trfl
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: a₀ = 0

(a₀, x₀) :: t ≃ []exact 
Eq.trans: ∀ {α : Sort ?u.94357} {a b c : α}, a = b → b = c → a = c
Eq.trans 
ls: (0, x₀) :: t ≃ t
ls 
step: t ≃ []
step
Goals accomplished! 🐙
      else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

(a₀, x₀) :: t ≃ []by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []have 
non_zero: 0 ≠ coords t x₀
non_zero : 
0: ?m.94366
0 ≠ 
coords: {R : Type ?u.94377} → [inst : Ring R] → {X : Type ?u.94376} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

0 ≠ coords t x₀intro 
contra': 0 = coords t x₀
contra'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

0 ≠ coords t x₀let 
contra: ?m.94432
contra := 
Eq.symm: ∀ {α : Sort ?u.94433} {a b : α}, a = b → b = a
Eq.symm 
contra': 0 = coords t x₀
contra'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

0 ≠ coords t x₀rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False
contra: ?m.94432
contra,
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + 0 = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False
add_zero: ∀ {M : Type ?u.94466} [inst : AddZeroClass M] (a : M), a + 0 = a
add_zero
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False at 
hyp₀: a₀ + 0 = 0
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

contra': 0 = coords t x₀

contra:= Eq.symm contra': coords t x₀ = 0

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

0 ≠ coords t x₀contradiction
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []let ⟨
ys: FormalSum R X
ys, 
eqnStep: (coords t x₀, x₀) :: ys ≃ t
eqnStep, 
lIneqStep: List.length ys < List.length t
lIneqStep⟩ := 
nonzero_coeff_has_complement: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₀ : X) (s : FormalSum R X),
  0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s
nonzero_coeff_has_complement 
x₀: X
x₀ 
t: List (R × X)
t 
non_zero: 0 ≠ coords t x₀
non_zero
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []have 
tail_coeffs: ∀ (x : X), coords ys x = 0
tail_coeffs : ∀ 
x: X
x : 
X: Type
X, 
coords: {R : Type ?u.94786} → [inst : Ring R] → {X : Type ?u.94785} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
ys: FormalSum R X
ys 
x: X
x = 
0: ?m.94824
0 := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

∀ (x : X), coords ys x = 0intro 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

coords ys x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

∀ (x : X), coords ys x = 0simp [
coords: {R : Type ?u.94907} → [inst : Ring R] → {X : Type ?u.94906} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

coords ys x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

∀ (x : X), coords ys x = 0exact
            if 
c: ?m.95150
c : (
x₀: X
x₀ = 
x: X
x) then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

coords ys x = 0by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x = 0← 
c: x₀ = x
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x₀ = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x₀ = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x = 0let 
ceq: ?m.95177
ceq := 
coords_well_defined: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X)
  (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined 
x₀: X
x₀ 
_: FormalSum ?m.95178 ?m.95181
_ 
_: FormalSum ?m.95178 ?m.95181
_ 
eqnStep: (coords t x₀, x₀) :: ys ≃ t
eqnStep
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

ceq:= coords_well_defined x₀ ((coords t x₀, x₀) :: ys) t eqnStep: coords ((coords t x₀, x₀) :: ys) x₀ = coords t x₀

coords ys x₀ = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x = 0simp [
coords: {R : Type ?u.95277} → [inst : Ring R] → {X : Type ?u.95276} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.95308) → (X : Type ?u.95307) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff] at 
ceq: ?m.95177
ceq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

ceq: coords ys x₀ = 0

coords ys x₀ = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: x₀ = x

coords ys x = 0assumption
Goals accomplished! 🐙
            else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

coords ys x = 0by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0let 
hx: ?m.96432
hx := 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0
hyp 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx:= hyp x: coords ((a₀, x₀) :: t) x = 0

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0simp [
coords: {R : Type ?u.96438} → [inst : Ring R] → {X : Type ?u.96437} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.96469) → (X : Type ?u.96468) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff] at 
hx: ?m.96432
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0have 
lf: (x₀ == x) = false
lf : (
x₀: X
x₀ == 
x: X
x) = 
false: Bool
false := 
decide_eq_false: ∀ {p : Prop} [inst : Decidable p], ¬p → decide p = false
decide_eq_false 
c: ¬x₀ = x
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx:= hyp x: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords ys x = 0
lf: (x₀ == x) = false
lf
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords ys x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords ys x = 0 at 
hx: (match x₀ == x with
    | true => a₀
    | false => 0) +     coords t x =   0
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0

lf: (x₀ == x) = false

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0simp [
zero_add: ∀ {M : Type ?u.98105} [inst : AddZeroClass M] (a : M), 0 + a = a
zero_add] at 
hx: (match false with
    | true => a₀
    | false => 0) +     coords t x =   0
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0let 
ceq: ?m.98334
ceq := 
coords_well_defined: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X)
  (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined 
x: X
x 
_: FormalSum ?m.98335 ?m.98338
_ 
_: FormalSum ?m.98335 ?m.98338
_ 
eqnStep: (coords t x₀, x₀) :: ys ≃ t
eqnStep
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq:= coords_well_defined x ((coords t x₀, x₀) :: ys) t eqnStep: coords ((coords t x₀, x₀) :: ys) x = coords t x

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0simp [
coords: {R : Type ?u.98386} → [inst : Ring R] → {X : Type ?u.98385} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
monomCoeff: (R : Type ?u.98417) → (X : Type ?u.98416) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff, 
lf: (x₀ == x) = false
lf] at 
ceq: ?m.98334
ceq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq: coords ys x = coords t x

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq: coords ys x = coords t x

coords ys x = 0
hx: coords t x = 0
hx
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq: coords ys x = 0

coords ys x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq: coords ys x = 0

coords ys x = 0 at 
ceq: coords ys x = coords t x
ceq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

lf: (x₀ == x) = false

hx: coords t x = 0

ceq: coords ys x = 0

coords ys x = 0
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

x: X

c: ¬x₀ = x

coords ys x = 0exact 
ceq: coords ys x = 0
ceq
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []have _ : 
ys: FormalSum R X
ys.
length: {α : Type ?u.99237} → List α → ℕ
length < (
h: R × X
h :: 
t: List (R × X)
t).
length: {α : Type ?u.99244} → List α → ℕ
length := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

List.length ys < List.length (h :: t)simp [
List.length_cons: ∀ {α : Type ?u.99257} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

List.length ys < Nat.succ (List.length t)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

List.length ys < List.length (h :: t)apply 
Nat.le_trans: ∀ {n m k : ℕ}, n ≤ m → m ≤ k → n ≤ k
Nat.le_trans 
lIneqStep: List.length ys < List.length t
lIneqStep
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

List.length t ≤ Nat.succ (List.length t)
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

List.length ys < List.length (h :: t)apply 
Nat.le_succ: ∀ (n : ℕ), n ≤ Nat.succ n
Nat.le_succ
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []let 
step: ys ≃ []
step : 
ys: FormalSum R X
ys ≃ 
[]: List ?m.99400
[] := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

(a₀, x₀) :: t ≃ []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

ys ≃ []apply 
equiv_e_of_zero_coeffs: ∀ (s : FormalSum R X), (∀ (x : X), coords s x = 0) → s ≃ []
equiv_e_of_zero_coeffs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

hyp
∀ (x : X), coords ys x = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

ys ≃ []exact 
tail_coeffs: ∀ (x : X), coords ys x = 0
tail_coeffs
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []let 
eqn₁: ?m.100386
eqn₁ := 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv 
_: FormalSum ?m.100387 ?m.100390
_ 
_: FormalSum ?m.100387 ?m.100390
_ (
coords: {R : Type ?u.100395} → [inst : Ring R] → {X : Type ?u.100394} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀) 
x₀: X
x₀ 
step: ys ≃ []
step
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []let 
eqn₂: t ≃ [(coords t x₀, x₀)]
eqn₂ : 
t: List (R × X)
t ≃ (
coords: {R : Type ?u.100527} → [inst : Ring R] → {X : Type ?u.100526} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀, 
x₀: X
x₀) :: 
[]: List ?m.100575
[] := 
Eq.trans: ∀ {α : Sort ?u.101544} {a b c : α}, a = b → b = c → a = c
Eq.trans (
Eq.symm: ∀ {α : Sort ?u.101549} {a b : α}, a = b → b = a
Eq.symm 
eqnStep: (coords t x₀, x₀) :: ys ≃ t
eqnStep) 
eqn₁: ?m.100386
eqn₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []let 
eqn₃: ?m.101558
eqn₃ := 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv 
_: FormalSum ?m.101559 ?m.101562
_ 
_: FormalSum ?m.101559 ?m.101562
_ 
a₀: R
a₀ 
x₀: X
x₀ 
eqn₂: t ≃ [(coords t x₀, x₀)]
eqn₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

(a₀, x₀) :: t ≃ []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []apply 
Eq.trans: ∀ {α : Sort ?u.101574} {a b c : α}, a = b → b = c → a = c
Eq.trans 
eqn₃: ?m.101558
eqn₃
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

sum [(a₀, x₀), (coords t x₀, x₀)] = sum []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []have 
eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]
eqn₄ : 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum [(
a₀: R
a₀, 
x₀: X
x₀), (
coords: {R : Type ?u.101605} → [inst : Ring R] → {X : Type ?u.101604} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀, 
x₀: X
x₀)] = 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum [(
a₀: R
a₀ + 
coords: {R : Type ?u.102785} → [inst : Ring R] → {X : Type ?u.102784} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀, 
x₀: X
x₀)] := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

sum [(a₀, x₀), (coords t x₀, x₀)] = sum []by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]apply 
Quot.sound: ∀ {α : Sort ?u.102904} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

a
ElementaryMove R X [(a₀, x₀), (coords t x₀, x₀)] [(a₀ + coords t x₀, x₀)]
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]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

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []apply 
Eq.trans: ∀ {α : Sort ?u.102989} {a b c : α}, a = b → b = c → a = c
Eq.trans 
eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]
eqn₄
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

sum [(a₀ + coords t x₀, x₀)] = sum []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

sum [(a₀ + coords t x₀, x₀)] = sum []
hyp₀: a₀ + coords t x₀ = 0
hyp₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

sum [(0, x₀)] = sum []]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

sum [(0, x₀)] = sum []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []apply 
Quot.sound: ∀ {α : Sort ?u.103094} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

a
ElementaryMove R X [(0, x₀)] []
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []apply 
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

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

non_zero: 0 ≠ coords t x₀

ys: FormalSum R X

eqnStep: (coords t x₀, x₀) :: ys ≃ t

lIneqStep: List.length ys < List.length t

tail_coeffs: ∀ (x : X), coords ys x = 0

x✝: List.length ys < List.length (h :: t)

step:= equiv_e_of_zero_coeffs ys tail_coeffs: ys ≃ []

eqn₁:= cons_equiv_of_equiv ys [] (coords t x₀) x₀ step: (coords t x₀, x₀) :: ys ≃ [(coords t x₀, x₀)]

eqn₂:= Eq.trans (Eq.symm eqnStep) eqn₁: t ≃ [(coords t x₀, x₀)]

eqn₃:= cons_equiv_of_equiv t [(coords t x₀, x₀)] a₀ x₀ eqn₂: (a₀, x₀) :: t ≃ [(a₀, x₀), (coords t x₀, x₀)]

eqn₄: sum [(a₀, x₀), (coords t x₀, x₀)] = sum [(a₀ + coords t x₀, x₀)]

a.h
0 = 0
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = 0

mt: s = (a₀, x₀) :: t

hyp₀: a₀ + coords t x₀ = 0

c₀: monomCoeff R X x₀ (a₀, x₀) = a₀

hz: ¬a₀ = 0

(a₀, x₀) :: t ≃ []rfl
Goals accomplished! 🐙
  termination_by
  _ R X s h => 
s: FormalSum R✝ R
s.
length: {α : Type ?u.103706} → List α → ℕ
length decreasing_by
  assumption
Goals accomplished! 🐙

/-- If coordinates are equal, the sums are related by moves. -/
theorem 
equiv_of_equal_coeffs: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X),
  (∀ (x : X), coords s₁ x = coords s₂ x) → s₁ ≃ s₂
equiv_of_equal_coeffs  (
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.104030) → Type ?u.104029 → [inst : Ring R] → Type (max?u.104029?u.104030)
FormalSum 
R: Type ?u.104002
R 
X: Type ?u.104017
X) (
hyp: ∀ (x : X), coords s₁ x = coords s₂ x
hyp : ∀ 
x: X
x : 
X: Type ?u.104017
X, 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.104050} → [inst : Ring R] → {X : Type ?u.104049} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x = 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.104106} → [inst : Ring R] → {X : Type ?u.104105} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x) : 
s₁: FormalSum R X
s₁ ≃ 
s₂: FormalSum R X
s₂ :=
  match 
s₁: FormalSum R X
s₁ with
  | [] =>
    have 
coeffs: ∀ (x : X), coords s₂ x = 0
coeffs : ∀ 
x: X
x : 
X: Type ?u.104017
X, 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.105342} → [inst : Ring R] → {X : Type ?u.105341} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x: X
x = 
0: ?m.105360
0 := by
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

∀ (x : X), coords s₂ x = 0intro 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

x: X

coords s₂ x = 0
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

∀ (x : X), coords s₂ x = 0let 
h: ?m.105868
h := 
hyp: ∀ (x : X), coords [] x = coords s₂ x
hyp 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

x: X

h:= hyp x: coords [] x = coords s₂ x

coords s₂ x = 0
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

∀ (x : X), coords s₂ x = 0rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

x: X

h:= hyp x: coords [] x = coords s₂ x

coords s₂ x = 0← 
h: ?m.105868
h
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

x: X

h:= hyp x: coords [] x = coords s₂ x

coords [] x = 0]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

x: X

h:= hyp x: coords [] x = coords s₂ x

coords [] x = 0
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

hyp: ∀ (x : X), coords [] x = coords s₂ x

∀ (x : X), coords s₂ x = 0rfl
Goals accomplished! 🐙
    let 
zl: ?m.105437
zl := 
equiv_e_of_zero_coeffs: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s : FormalSum R X),
  (∀ (x : X), coords s x = 0) → s ≃ []
equiv_e_of_zero_coeffs 
s₂: FormalSum R X
s₂ 
coeffs: ∀ (x : X), coords s₂ x = 0
coeffs
    
Eq.symm: ∀ {α : Sort ?u.105474} {a b : α}, a = b → b = a
Eq.symm 
zl: ?m.105437
zl
  | 
h: R × X
h :: 
t: List (R × X)
t =>
    let (
a₀: R
a₀, 
x₀: X
x₀) := 
h: R × X
h
    by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂exact
      if 
p: ?m.106014
p : 
0: ?m.105908
0 = 
a₀: R
a₀ then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ s₂have 
eq₁: (a₀, x₀) :: t ≃ t
eq₁ : (
a₀: R
a₀, 
x₀: X
x₀) :: 
t: List (R × X)
t ≃ 
t: List (R × X)
t := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ s₂by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ tapply 
Quot.sound: ∀ {α : Sort ?u.107130} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

a
ElementaryMove R X ((a₀, x₀) :: t) t
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ tapply 
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

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

a.h
a₀ = 0
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ tapply 
Eq.symm: ∀ {α : Sort ?u.107220} {a b : α}, a = b → b = a
Eq.symm
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

a.h.h
0 = a₀
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ tassumption
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ s₂have _ : 
t: List (R × X)
t.
length: {α : Type ?u.107238} → List α → ℕ
length < (
h: R × X
h :: 
t: List (R × X)
t).
length: {α : Type ?u.107244} → List α → ℕ
length := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

(a₀, x₀) :: t ≃ s₂by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

List.length t < List.length (h :: t)simp [
List.length_cons: ∀ {α : Type ?u.107257} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ s₂have 
eq₂: t ≃ s₂
eq₂ : 
t: List (R × X)
t ≃ 
s₂: FormalSum R X
s₂ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

(a₀, x₀) :: t ≃ s₂by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

t ≃ s₂apply 
equiv_of_equal_coeffs: ∀ (s₁ s₂ : FormalSum R X), (∀ (x : X), coords s₁ x = coords s₂ x) → s₁ ≃ s₂
equiv_of_equal_coeffs 
t: List (R × X)
t 
s₂: FormalSum R X
s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

∀ (x : X), coords t x = coords s₂ x
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

t ≃ s₂intro 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

x: X

coords t x = coords s₂ x
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

t ≃ s₂let 
ceq: ?m.108362
ceq := 
coords_well_defined: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X)
  (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined 
x: X
x ((
a₀: R
a₀, 
x₀: X
x₀) :: 
t: List (R × X)
t) 
t: List (R × X)
t 
eq₁: (a₀, x₀) :: t ≃ t
eq₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

x: X

ceq:= coords_well_defined x ((a₀, x₀) :: t) t eq₁: coords ((a₀, x₀) :: t) x = coords t x

coords t x = coords s₂ x
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

eq₁: (a₀, x₀) :: t ≃ t

x✝: List.length t < List.length (h :: t)

t ≃ s₂simp [← 
ceq: ?m.108362
ceq, 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x
hyp]
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: 0 = a₀

(a₀, x₀) :: t ≃ s₂exact 
Eq.trans: ∀ {α : Sort ?u.108579} {a b c : α}, a = b → b = c → a = c
Eq.trans 
eq₁: (a₀, x₀) :: t ≃ t
eq₁ 
eq₂: t ≃ s₂
eq₂
Goals accomplished! 🐙
      else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

(a₀, x₀) :: t ≃ s₂let 
a₁: ?m.108585
a₁ := 
coords: {R : Type ?u.108587} → [inst : Ring R] → {X : Type ?u.108586} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
t: List (R × X)
t 
x₀: X
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

(a₀, x₀) :: t ≃ s₂
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

(a₀, x₀) :: t ≃ s₂exact
          if 
p₁: ?m.108681
p₁ : 
0: ?m.108640
0 = 
a₁: ?m.108585
a₁ then 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

(a₀, x₀) :: t ≃ s₂by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂have 
cf₂: coords s₂ x₀ = a₀
cf₂ : 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.108690} → [inst : Ring R] → {X : Type ?u.108689} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀ = 
a₀: R
a₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

coords s₂ x₀ = a₀rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

coords s₂ x₀ = a₀← 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

coords ((a₀, x₀) :: t) x₀ = a₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

coords ((a₀, x₀) :: t) x₀ = a₀
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

coords s₂ x₀ = a₀simp [
coords: {R : Type ?u.108732} → [inst : Ring R] → {X : Type ?u.108731} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, ← 
p₁: 0 = a₁
p₁, 
Nat.add_zero: ∀ (n : ℕ), n + 0 = n
Nat.add_zero, 
monomCoeff: (R : Type ?u.108802) → (X : Type ?u.108801) → [inst : Ring R] → [inst : DecidableEq X] → X → R × X → R
monomCoeff]
Goals accomplished! 🐙
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂let ⟨
ys: FormalSum R X
ys, 
eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂
eqn, _⟩ :=
              
nonzero_coeff_has_complement: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₀ : X) (s : FormalSum R X),
  0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s
nonzero_coeff_has_complement 
x₀: X
x₀ 
s₂: FormalSum R X
s₂
                (
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

(a₀, x₀) :: t ≃ s₂by
                  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

0 ≠ coords s₂ x₀rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

0 ≠ coords s₂ x₀
cf₂: coords s₂ x₀ = a₀
cf₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

0 ≠ a₀]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

0 ≠ a₀
                  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

0 ≠ coords s₂ x₀assumption
Goals accomplished! 🐙)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂let 
cfs: ?m.109927
cfs := fun 
x: ?m.109929
x => 
coords_well_defined: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X)
  (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined 
x: ?m.109929
x 
_: FormalSum ?m.109931 ?m.109934
_ 
_: FormalSum ?m.109931 ?m.109934
_ 
eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂
eqn
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs:= fun x => coords_well_defined x ((coords s₂ x₀, x₀) :: ys) s₂ eqn: ∀ (x : X), coords ((coords s₂ x₀, x₀) :: ys) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs:= fun x => coords_well_defined x ((coords s₂ x₀, x₀) :: ys) s₂ eqn: ∀ (x : X), coords ((coords s₂ x₀, x₀) :: ys) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂
cf₂: coords s₂ x₀ = a₀
cf₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂ at 
cfs: ?m.109927
cfs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂let 
cfs': ?m.110046
cfs' := fun (
x: X
x : 
X: Type
X) => 
Eq.trans: ∀ {α : Sort ?u.110049} {a b c : α}, a = b → b = c → a = c
Eq.trans (
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x
hyp 
x: X
x) (
Eq.symm: ∀ {α : Sort ?u.110060} {a b : α}, a = b → b = a
Eq.symm (
cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x
cfs 
x: X
x))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs':= fun x => Eq.trans (hyp x) (Eq.symm (cfs x)): ∀ (x : X), coords ((a₀, x₀) :: t) x = coords ((a₀, x₀) :: ys) x

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂simp [
coords: {R : Type ?u.110071} → [inst : Ring R] → {X : Type ?u.110070} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords] at 
cfs': ?m.110046
cfs'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂have _ : 
t: List (R × X)
t.
length: {α : Type ?u.111249} → List α → ℕ
length < (
h: R × X
h :: 
t: List (R × X)
t).
length: {α : Type ?u.111256} → List α → ℕ
length := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

(a₀, x₀) :: t ≃ s₂by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

List.length t < List.length (h :: t)simp [
List.length_cons: ∀ {α : Type ?u.111269} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_cons]
Goals accomplished! 🐙
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂let 
step: ?m.111323
step := 
equiv_of_equal_coeffs: ∀ (s₁ s₂ : FormalSum R X), (∀ (x : X), coords s₁ x = coords s₂ x) → s₁ ≃ s₂
equiv_of_equal_coeffs 
t: List (R × X)
t 
ys: FormalSum R X
ys 
cfs': ∀ (x : X), coords t x = coords ys x
cfs'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂let 
_step': ?m.111330
_step' := 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv 
t: List (R × X)
t 
ys: FormalSum R X
ys 
a₀: R
a₀ 
x₀: X
x₀ 
step: ?m.111323
step
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

_step':= cons_equiv_of_equiv t ys a₀ x₀ step: (a₀, x₀) :: t ≃ (a₀, x₀) :: ys

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

_step':= cons_equiv_of_equiv t ys a₀ x₀ step: (a₀, x₀) :: t ≃ (a₀, x₀) :: ys

(a₀, x₀) :: t ≃ s₂
cf₂: coords s₂ x₀ = a₀
cf₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (a₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

_step':= cons_equiv_of_equiv t ys a₀ x₀ step: (a₀, x₀) :: t ≃ (a₀, x₀) :: ys

(a₀, x₀) :: t ≃ s₂]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (a₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

_step':= cons_equiv_of_equiv t ys a₀ x₀ step: (a₀, x₀) :: t ≃ (a₀, x₀) :: ys

(a₀, x₀) :: t ≃ s₂ at 
eqn: (coords s₂ x₀, x₀) :: ys ≃ s₂
eqn
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

cf₂: coords s₂ x₀ = a₀

ys: FormalSum R X

eqn: (a₀, x₀) :: ys ≃ s₂

right✝: List.length ys < List.length s₂

cfs: ∀ (x : X), coords ((a₀, x₀) :: ys) x = coords s₂ x

cfs': ∀ (x : X), coords t x = coords ys x

x✝: List.length t < List.length (h :: t)

step:= equiv_of_equal_coeffs t ys cfs': t ≃ ys

_step':= cons_equiv_of_equiv t ys a₀ x₀ step: (a₀, x₀) :: t ≃ (a₀, x₀) :: ys

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: 0 = a₁

(a₀, x₀) :: t ≃ s₂exact 
Eq.trans: ∀ {α : Sort ?u.111379} {a b c : α}, a = b → b = c → a = c
Eq.trans 
_step': (a₀, x₀) :: t ≃ (a₀, x₀) :: ys
_step' 
eqn: (a₀, x₀) :: ys ≃ s₂
eqn
Goals accomplished! 🐙
          else 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

(a₀, x₀) :: t ≃ s₂by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂let ⟨
ys: FormalSum R X
ys, 
eqn: (coords t x₀, x₀) :: ys ≃ t
eqn, 
ineqn: List.length ys < List.length t
ineqn⟩ := 
nonzero_coeff_has_complement: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x₀ : X) (s : FormalSum R X),
  0 ≠ coords s x₀ → ∃ ys, (coords s x₀, x₀) :: ys ≃ s ∧ List.length ys < List.length s
nonzero_coeff_has_complement 
x₀: X
x₀ 
t: List (R × X)
t 
p₁: ¬0 = a₁
p₁
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂let 
s₃: ?m.111581
s₃ := (
a₀: R
a₀ + 
a₁: R
a₁, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

(a₀, x₀) :: t ≃ s₂
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂have 
eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃
eq₁ : (
a₀: R
a₀, 
x₀: X
x₀) :: (
a₁: R
a₁, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys ≃ 
s₃: ?m.111581
s₃ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

(a₀, x₀) :: t ≃ s₂by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

(a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃apply 
Quot.sound: ∀ {α : Sort ?u.112738} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b
Quot.sound
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

a
ElementaryMove R X ((a₀, x₀) :: (a₁, x₀) :: ys) s₃
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

(a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃let 
lem: ?m.112765
lem := 
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 
a₀: R
a₀ 
a₁: R
a₁ 
x₀: X
x₀ 
ys: FormalSum R X
ys
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

lem:= ElementaryMove.addCoeffs a₀ a₁ x₀ ys: ElementaryMove R X ((a₀, x₀) :: (a₁, x₀) :: ys) ((a₀ + a₁, x₀) :: ys)

a
ElementaryMove R X ((a₀, x₀) :: (a₁, x₀) :: ys) s₃
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

(a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃exact 
lem: ?m.112765
lem
Goals accomplished! 🐙
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂have 
eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t
eq₂ : (
a₀: R
a₀, 
x₀: X
x₀) :: (
a₁: R
a₁, 
x₀: X
x₀) :: 
ys: FormalSum R X
ys ≃ (
a₀: R
a₀, 
x₀: X
x₀) :: 
t: List (R × X)
t := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

(a₀, x₀) :: t ≃ s₂by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

(a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: tapply 
cons_equiv_of_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X)
  (a : R) (x : X), s₁ ≃ s₂ → (a, x) :: s₁ ≃ (a, x) :: s₂
cons_equiv_of_equiv
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

a
(a₁, x₀) :: ys ≃ t
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

(a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: tassumption
Goals accomplished! 🐙
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂have 
eq₃: s₃ ≃ s₂
eq₃ : 
s₃: ?m.111581
s₃ ≃ 
s₂: FormalSum R X
s₂ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

(a₀, x₀) :: t ≃ s₂by
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂have _ : 
ys: FormalSum R X
ys.
length: {α : Type ?u.114994} → List α → ℕ
length + 
1: ?m.114999
1 < 
t: List (R × X)
t.
length: {α : Type ?u.115017} → List α → ℕ
length + 
1: ?m.115022
1 := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂by
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

List.length ys + 1 < List.length t + 1apply 
Nat.succ_lt_succ: ∀ {n m : ℕ}, n < m → Nat.succ n < Nat.succ m
Nat.succ_lt_succ
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

a
List.length ys < List.length t
                
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

List.length ys + 1 < List.length t + 1exact 
ineqn: List.length ys < List.length t
ineqn
Goals accomplished! 🐙
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂apply 
equiv_of_equal_coeffs: ∀ (s₁ s₂ : FormalSum R X), (∀ (x : X), coords s₁ x = coords s₂ x) → s₁ ≃ s₂
equiv_of_equal_coeffs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

hyp
∀ (x : X), coords s₃ x = coords s₂ x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂intro 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

hyp
coords s₃ x = coords s₂ x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

hyp
coords s₃ x = coords s₂ x← 
hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x
hyp 
x: X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

hyp
coords s₃ x = coords ((a₀, x₀) :: t) x]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

hyp
coords s₃ x = coords ((a₀, x₀) :: t) x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂simp [
coords: {R : Type ?u.115146} → [inst : Ring R] → {X : Type ?u.115145} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂let 
d: ?m.115992
d := 
coords_well_defined: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (x : X)
  (s₁ s₂ : FormalSum R X), s₁ ≃ s₂ → coords s₁ x = coords s₂ x
coords_well_defined 
x: X
x 
_: FormalSum ?m.115993 ?m.115996
_ 
_: FormalSum ?m.115993 ?m.115996
_ 
eqn: (coords t x₀, x₀) :: ys ≃ t
eqn
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d:= coords_well_defined x ((coords t x₀, x₀) :: ys) t eqn: coords ((coords t x₀, x₀) :: ys) x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d:= coords_well_defined x ((coords t x₀, x₀) :: ys) t eqn: coords ((coords t x₀, x₀) :: ys) x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x
coords: {R : Type ?u.116221} → [inst : Ring R] → {X : Type ?u.116220} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x at 
d: ?m.115992
d
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x = monomCoeff R X x (a₀, x₀) + coords t x← 
d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x
d
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x =   monomCoeff R X x (a₀, x₀) + (monomCoeff R X x (coords t x₀, x₀) + coords ys x)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

x✝: List.length ys + 1 < List.length t + 1

x: X

d: monomCoeff R X x (coords t x₀, x₀) + coords ys x = coords t x

hyp
monomCoeff R X x (a₀ + coords t x₀, x₀) + coords ys x =   monomCoeff R X x (a₀, x₀) + (monomCoeff R X x (coords t x₀, x₀) + coords ys x)
              
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

ys: FormalSum R X

eqn: (coords t x₀, x₀) :: ys ≃ t

ineqn: List.length ys < List.length t

s₃:= (a₀ + a₁, x₀) :: ys: List (R × X)

eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃

eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t

s₃ ≃ s₂simp [
monom_coords_hom: ∀ {R : Type ?u.116237} [inst : Ring R] {X : Type ?u.116238} [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, 
coords: {R : Type ?u.116281} → [inst : Ring R] → {X : Type ?u.116280} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords, 
add_assoc: ∀ {G : Type ?u.116311} [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

X: Type

inst✝: DecidableEq X

s₁, s₂: FormalSum R X

h: R × X

t: List (R × X)

a₀: R

x₀: X

hyp: ∀ (x : X), coords ((a₀, x₀) :: t) x = coords s₂ x

p: ¬0 = a₀

a₁:= coords t x₀: R

p₁: ¬0 = a₁

(a₀, x₀) :: t ≃ s₂apply 
Eq.trans: ∀ {α : Sort ?u.116685} {a b c : α}, a = b → b = c → a = c
Eq.trans (
Eq.trans: ∀ {α : Sort ?u.116690} {a b c : α}, a = b → b = c → a = c
Eq.trans (
Eq.symm: ∀ {α : Sort ?u.116698} {a b : α}, a = b → b = a
Eq.symm 
eq₂: (a₀, x₀) :: (a₁, x₀) :: ys ≃ (a₀, x₀) :: t
eq₂) 
eq₁: (a₀, x₀) :: (a₁, x₀) :: ys ≃ s₃
eq₁) 
eq₃: s₃ ≃ s₂
eq₃
Goals accomplished! 🐙
  termination_by
  _ R X s _ _ => 
s: FormalSum R✝ R
s.
length: {α : Type ?u.117313} → List α → ℕ
length decreasing_by
  assumption
Goals accomplished! 🐙

/-!
## Functions invariant under moves pass to the quotient.
-/
/-- Lifting functions to the move induced quotient. -/
theorem 
func_eql_of_move_equiv: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] {β : Sort u}
  (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  {
β: Sort u
β : 
Sort u: Type u
Sort
Sort u: Type u
 u} (
f: FormalSum R X → β
f : 
FormalSum: (R : Type ?u.117790) → Type ?u.117789 → [inst : Ring R] → Type (max?u.117789?u.117790)
FormalSum 
R: Type ?u.117759
R 
X: Type ?u.117774
X → 
β: Sort u
β) : (∀ 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.117809) → Type ?u.117808 → [inst : Ring R] → Type (max?u.117808?u.117809)
FormalSum 
R: Type ?u.117759
R 
X: Type ?u.117774
X, 
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 ?u.117759
R 
X: Type ?u.117774
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ → 
f: FormalSum R X → β
f 
s₁: FormalSum R X
s₁ = 
f: FormalSum R X → β
f 
s₂: FormalSum R X
s₂) → (∀ 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ : 
FormalSum: (R : Type ?u.117912) → Type ?u.117911 → [inst : Ring R] → Type (max?u.117911?u.117912)
FormalSum 
R: Type ?u.117759
R 
X: Type ?u.117774
X, 
s₁: FormalSum R X
s₁ ≈ 
s₂: FormalSum R X
s₂ → 
f: FormalSum R X → β
f 
s₁: FormalSum R X
s₁ = 
f: FormalSum R X → β
f 
s₂: FormalSum R X
s₂) :=
  by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂intro 
hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (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₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂let 
fbar: FreeModuleAux R X → β
fbar : 
FreeModuleAux: (R X : Type) → [inst : Ring R] → [inst : DecidableEq R] → [inst : DecidableEq X] → Type
FreeModuleAux 
R: Type
R 
X: Type
X → 
β: Sort u
β := 
Quot.lift: {α : Sort ?u.117992} →
  {r : α → α → Prop} → {β : Sort ?u.117991} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β
Quot.lift 
f: FormalSum R X → β
f 
hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

∀ (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → f s₁ = f s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂let 
fct: ∀ (s : FormalSum R X), f s = fbar (sum s)
fct : ∀ 
s: FormalSum R X
s : 
FormalSum: (R : Type ?u.118056) → Type ?u.118055 → [inst : Ring R] → Type (max?u.118055?u.118056)
FormalSum 
R: Type
R 
X: Type
X, 
f: FormalSum R X → β
f 
s: FormalSum R X
s = 
fbar: FreeModuleAux R X → β
fbar (
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum 
s: FormalSum R X
s) := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

∀ (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → f s₁ = f s₂by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

∀ (s : FormalSum R X), f s = fbar (sum s)apply 
Quot.liftBeta: ∀ {α : Sort ?u.118161} {r : α → α → Prop} {β : Sort ?u.118160} (f : α → β) (c : ∀ (a b : α), r a b → f a = f b) (a : α),
  Quot.lift f c (Quot.mk r a) = f a
Quot.liftBeta
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

c
∀ (a b : FormalSum R X), ?r a b → f a = f b
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

r
FormalSum R X → FormalSum R X → Prop
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

∀ (s : FormalSum R X), f s = fbar (sum s)apply 
hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂
hyp
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂intro 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ 
sim: s₁ ≈ s₂
sim
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

f s₁ = f s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂have 
ec: eqlCoords R X s₁ s₂
ec : 
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords 
R: Type
R 
X: Type
X 
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂ := 
sim: s₁ ≈ s₂
sim
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: eqlCoords R X s₁ s₂

f s₁ = f s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: eqlCoords R X s₁ s₂

f s₁ = f s₂
eqlCoords: (R X : Type) → [inst : Ring R] → [inst_1 : DecidableEq X] → FormalSum R X → FormalSum R X → Prop
eqlCoords
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

f s₁ = f s₂]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

f s₁ = f s₂ at 
ec: eqlCoords R X s₁ s₂
ec
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

f s₁ = f s₂
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂have 
pullback: sum s₁ = sum s₂
pullback : 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum 
s₁: FormalSum R X
s₁ = 
sum: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → FormalSum R X → FreeModuleAux R X
sum 
s₂: FormalSum R X
s₂ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

f s₁ = f s₂by
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

sum s₁ = sum s₂apply 
equiv_of_equal_coeffs: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (s₁ s₂ : FormalSum R X),
  (∀ (x : X), coords s₁ x = coords s₂ x) → s₁ ≃ s₂
equiv_of_equal_coeffs
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

hyp
∀ (x : X), coords s₁ x = coords s₂ x
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

sum s₁ = sum s₂intro 
x: ?X
x
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

x: X

hyp
coords s₁ x = coords s₂ x
    
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

f: FormalSum R X → β

hyp: ∀ (s₁ s₂ : FormalSum R X), ElementaryMove R X s₁ s₂ → f s₁ = f s₂

fbar:= Quot.lift f hyp: FreeModuleAux R X → β

fct:= Quot.liftBeta (fun a => f a) hyp: ∀ (s : FormalSum R X), f s = fbar (sum s)

s₁, s₂: FormalSum R X

sim: s₁ ≈ s₂

ec: coords s₁ = coords s₂

sum s₁ = sum s₂exact 
congrFun: ∀ {α : Sort ?u.118411} {β : α → Sort ?u.118410} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
ec: coords s₁ = coords s₂
ec 
x: ?X
x
Goals accomplished! 🐙
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

β: Sort u

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₂simp [
fct: ∀ (s : FormalSum R X), f s = fbar (sum s)
fct, 
pullback: sum s₁ = sum s₂
pullback]
Goals accomplished! 🐙

end FormalSum
end ElementaryMoves

section NormRepr

/-! 
## Basic `Repr`

An instance of `Repr` on Free Modules, mainly for debugging (fairly crude). This is implemented by constructing a norm ball containing all the non-zero coordinates, and then making a list of non-zero coordinates
-/

theorem 
fst_le_max: ∀ (a b : ℕ), a ≤ max a b
fst_le_max (
a: ℕ
a 
b: ℕ
b : 
Nat: Type
Nat): 
a: ℕ
a ≤ 
max: {α : Type ?u.118732} → [self : Max α] → α → α → α
max 
a: ℕ
a 
b: ℕ
b  := by
    
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

a ≤ max a bsimp [
max: {α : Type ?u.118750} → [self : Max α] → α → α → α
max]
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

a ≤ max a b
    
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

a ≤ max a bexact if 
c: ?m.118848
c:
a: ℕ
a ≤ 
b: ℕ
b 
          then 
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

a ≤ max a bby
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ max a bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ Nat.instMaxNat.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ max a bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ maxOfLe.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ max a bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ { max := fun x y => if x ≤ y then y else x }.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ max a bsimp [
if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.118859} {t e : α}, (if c then t else e) = t
if_pos 
c: a ≤ b
c]
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

a ≤ max a bassumption
Goals accomplished! 🐙
          else 
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

a ≤ max a bby
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ max a bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ Nat.instMaxNat.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ max a bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ maxOfLe.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ max a bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ { max := fun x y => if x ≤ y then y else x }.1 a b
              
R: Type ?u.118700

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.118715

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

a ≤ max a bsimp [
if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.119347} {t e : α}, (if c then t else e) = e
if_neg 
c: ¬a ≤ b
c]
Goals accomplished! 🐙

            
theorem 
snd_le_max: ∀ (a b : ℕ), b ≤ max a b
snd_le_max (
a: ℕ
a 
b: ℕ
b : 
Nat: Type
Nat): 
b: ℕ
b ≤ 
max: {α : Type ?u.119824} → [self : Max α] → α → α → α
max 
a: ℕ
a 
b: ℕ
b  := by
    
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

b ≤ max a bsimp [
max: {α : Type ?u.119842} → [self : Max α] → α → α → α
max]
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

b ≤ max a b
    
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

b ≤ max a bexact if 
c: ?m.119940
c: 
a: ℕ
a ≤ 
b: ℕ
b
    then 
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

b ≤ max a bby
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ max a bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ Nat.instMaxNat.1 a b
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ max a bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ maxOfLe.1 a b
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ max a bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ { max := fun x y => if x ≤ y then y else x }.1 a b 
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

b ≤ max a bsimp [
if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.119951} {t e : α}, (if c then t else e) = t
if_pos 
c: a ≤ b
c]
Goals accomplished! 🐙
    else 
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

b ≤ max a bby 
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ Nat.instMaxNat.1 a b
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ maxOfLe.1 a b
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ { max := fun x y => if x ≤ y then y else x }.1 a b
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bsimp [
if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.120405} {t e : α}, (if c then t else e) = e
if_neg 
c: ¬a ≤ b
c]
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ a
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bapply 
Nat.le_of_lt: ∀ {n m : ℕ}, n < m → n ≤ m
Nat.le_of_lt
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

h
b < a
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a blet 
c': ?m.120870
c' := 
Nat.gt_of_not_le: ∀ {n m : ℕ}, ¬n ≤ m → n > m
Nat.gt_of_not_le 
c: ¬a ≤ b
c
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

c':= Nat.gt_of_not_le c: a > b

h
b < a
      
R: Type ?u.119792

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.119807

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

b ≤ max a bassumption
Goals accomplished! 🐙
      

theorem 
eq_fst_or_snd_of_max: ∀ (a b : ℕ), max a b = a ∨ max a b = b
eq_fst_or_snd_of_max (
a: ℕ
a 
b: ℕ
b : 
Nat: Type
Nat) : (
max: {α : Type ?u.120940} → [self : Max α] → α → α → α
max 
a: ℕ
a 
b: ℕ
b = 
a: ℕ
a) ∨ (
max: {α : Type ?u.120948} → [self : Max α] → α → α → α
max 
a: ℕ
a 
b: ℕ
b = 
b: ℕ
b) := by
      
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

max a b = a ∨ max a b = bsimp [
max: {α : Type ?u.120957} → [self : Max α] → α → α → α
max]
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

max a b = a ∨ max a b = b
      
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

max a b = a ∨ max a b = bexact if 
c: ?m.121076
c: 
a: ℕ
a ≤ 
b: ℕ
b 
        then 
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

max a b = a ∨ max a b = bby
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

max a b = a ∨ max a b = bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

Nat.instMaxNat.1 a b = a ∨ Nat.instMaxNat.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

max a b = a ∨ max a b = bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

maxOfLe.1 a b = a ∨ maxOfLe.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

max a b = a ∨ max a b = bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

{ max := fun x y => if x ≤ y then y else x }.1 a b = a ∨ { max := fun x y => if x ≤ y then y else x }.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: a ≤ b

max a b = a ∨ max a b = bsimp [
if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.121087} {t e : α}, (if c then t else e) = t
if_pos 
c: a ≤ b
c]
Goals accomplished! 🐙
        else 
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

max a b = a ∨ max a b = bby
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

max a b = a ∨ max a b = bunfold 
max: {α : Type u} → [self : Max α] → α → α → α
max
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

Nat.instMaxNat.1 a b = a ∨ Nat.instMaxNat.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

max a b = a ∨ max a b = bunfold 
Nat.instMaxNat: Max ℕ
Nat.instMaxNat
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

maxOfLe.1 a b = a ∨ maxOfLe.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

max a b = a ∨ max a b = bunfold 
maxOfLe: {α : Type u_1} → [inst : LE α] → [inst : DecidableRel LE.le] → Max α
maxOfLe
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

{ max := fun x y => if x ≤ y then y else x }.1 a b = a ∨ { max := fun x y => if x ≤ y then y else x }.1 a b = b
          
R: Type ?u.120908

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.120923

inst✝: DecidableEq X

a, b: ℕ

c: ¬a ≤ b

max a b = a ∨ max a b = bsimp [
if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.121575} {t e : α}, (if c then t else e) = e
if_neg 
c: ¬a ≤ b
c]
Goals accomplished! 🐙

def 
maxNormSuccOnSupp: {R : Type u_1} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type u_2} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp (
norm: X → ℕ
norm: 
X: Type ?u.122056
X → 
Nat: Type
Nat)(
crds: X → R
crds : 
X: Type ?u.122056
X → 
R: Type ?u.122041
R)(
s: List X
s: 
List: Type ?u.122076 → Type ?u.122076
List 
X: Type ?u.122056
X) : 
Nat: Type
Nat :=
  match 
s: List X
s with
  | [] => 
0: ?m.122094
0
  | 
head: X
head :: 
tail: List X
tail =>
      if 
crds: X → R
crds 
head: X
head ≠ 
0: ?m.122127
0 then 
        
max: {α : Type ?u.122224} → [self : Max α] → α → α → α
max (
norm: X → ℕ
norm 
head: X
head + 
1: ?m.122234
1) (
maxNormSuccOnSupp: (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
tail: List X
tail)
      else
        
maxNormSuccOnSupp: (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
tail: List X
tail        
    
theorem 
max_in_support: ∀ (norm : X → ℕ) (crds : X → R) (s : List X),
  maxNormSuccOnSupp norm crds s > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1
max_in_support (
norm: X → ℕ
norm: 
X: Type ?u.122795
X → 
Nat: Type
Nat)(
crds: X → R
crds : 
X: Type ?u.122795
X → 
R: Type ?u.122780
R)(
s: List X
s: 
List: Type ?u.122815 → Type ?u.122815
List 
X: Type ?u.122795
X) : 
maxNormSuccOnSupp: {R : Type ?u.122821} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.122820} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
s: List X
s > 
0: ?m.122881
0 → 
  ∃ 
x: X
x : 
X: Type ?u.122795
X, 
crds: X → R
crds 
x: X
x ≠ 
0: ?m.122917
0 ∧ 
maxNormSuccOnSupp: {R : Type ?u.122980} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.122979} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
s: List X
s = 
norm: X → ℕ
norm 
x: X
x + 
1: ?m.123031
1 := by
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

maxNormSuccOnSupp norm crds s > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1intro 
h: maxNormSuccOnSupp norm crds s > 0
h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

h: maxNormSuccOnSupp norm crds s > 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

maxNormSuccOnSupp norm crds s > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1induction 
s: List X
s with
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

h: maxNormSuccOnSupp norm crds s > 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1| 
nil: {α : Type u} → List α
nil => 
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

h: maxNormSuccOnSupp norm crds [] > 0

nil
∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds [] = norm x + 1simp [
maxNormSuccOnSupp: {R : Type ?u.123131} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.123130} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp] at 
h: maxNormSuccOnSupp norm crds [] > 0
h
Goals accomplished! 🐙
  
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

h: maxNormSuccOnSupp norm crds s > 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1| 
cons: {α : Type u} → α → List α → List α
cons 
head: ?m.123118
head 
tail: List ?m.123118
tail 
ih: ?m.123119 tail
ih => 
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

cons
∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1exact if 
c: ?m.123833
c : 
crds: X → R
crds 
head: ?m.123118
head =
0: ?m.123739
0 then
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

cons
∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1by 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1simp [
maxNormSuccOnSupp: {R : Type ?u.123848} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.123847} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp, 
c: crds head = 0
c]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: crds head = 0

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1simp [
maxNormSuccOnSupp: {R : Type ?u.125302} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.125301} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp, 
c: crds head = 0
c] at 
h: maxNormSuccOnSupp norm crds (head :: tail) > 0
h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: crds head = 0

h: maxNormSuccOnSupp norm crds tail > 0

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1exact  
ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
ih 
h: maxNormSuccOnSupp norm crds tail > 0
h
Goals accomplished! 🐙
        
    else 
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

cons
∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1by    
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1simp [
maxNormSuccOnSupp: {R : Type ?u.125593} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.125592} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp, 
c: ¬crds head = 0
c]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1simp [
maxNormSuccOnSupp: {R : Type ?u.126918} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.126917} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp, 
c: ¬crds head = 0
c] at 
h: maxNormSuccOnSupp norm crds (head :: tail) > 0
h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1let 
sl: ?m.127201
sl := 
eq_fst_or_snd_of_max: ∀ (a b : ℕ), max a b = a ∨ max a b = b
eq_fst_or_snd_of_max (
norm: X → ℕ
norm 
head: X
head + 
1: ?m.127206
1) (
maxNormSuccOnSupp: {R : Type ?u.127248} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.127247} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
tail: List X
tail)
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1cases 
sl: ?m.127201
sl
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

h✝: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

inl
∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

h✝: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

inr
∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1case inr 
p: ?m.127359
p =>
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
p: ?m.127359
p
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
p: ?m.127359
p
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: maxNormSuccOnSupp norm crds tail > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: maxNormSuccOnSupp norm crds tail > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1 at 
h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0
h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: maxNormSuccOnSupp norm crds tail > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1exact  
ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1
ih 
h: maxNormSuccOnSupp norm crds tail > 0
h
Goals accomplished! 🐙 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

h: maxNormSuccOnSupp norm crds (head :: tail) > 0

c: ¬crds head = 0

∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds (head :: tail) = norm x + 1case inl 
p: ?m.127358
p =>
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1
p: ?m.127358
p
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1
p: ?m.127358
p
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: norm head + 1 > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: norm head + 1 > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1 at 
h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0
h
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: norm head + 1 > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ norm head + 1 = norm x + 1
            
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

head: X

tail: List X

ih: maxNormSuccOnSupp norm crds tail > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds tail = norm x + 1

c: ¬crds head = 0

h: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) > 0

sl:= eq_fst_or_snd_of_max (norm head + 1) (maxNormSuccOnSupp norm crds tail): max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1 ∨   max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = maxNormSuccOnSupp norm crds tail

p: max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm head + 1

∃ x, ¬crds x = 0 ∧ max (norm head + 1) (maxNormSuccOnSupp norm crds tail) = norm x + 1exact ⟨
head: X
head, 
And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro 
c: ¬crds head = 0
c 
rfl: ∀ {α : Sort ?u.127488} {a : α}, a = a
rfl⟩
Goals accomplished! 🐙

theorem 
supp_below_max: ∀ (norm : X → ℕ) (crds : X → R) (s : List X) (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds s
supp_below_max(
norm: X → ℕ
norm: 
X: Type ?u.127570
X → 
Nat: Type
Nat)(
crds: X → R
crds : 
X: Type ?u.127570
X → 
R: Type ?u.127555
R)(
s: List X
s: 
List: Type ?u.127590 → Type ?u.127590
List 
X: Type ?u.127570
X) : (
x: X
x: 
X: Type ?u.127570
X) → 
x: X
x ∈ 
s: List X
s →  
crds: X → R
crds 
x: X
x ≠ 
0: ?m.127627
0 → 
norm: X → ℕ
norm 
x: X
x + 
1: ?m.127696
1 ≤ 
maxNormSuccOnSupp: {R : Type ?u.127712} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.127711} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
s: List X
s := by
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

∀ (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds sintro 
x: X
x 
h₁: x ∈ s
h₁ 
h₂: crds x ≠ 0
h₂
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

x: X

h₁: x ∈ s

h₂: crds x ≠ 0

norm x + 1 ≤ maxNormSuccOnSupp norm crds s
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

∀ (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds scases 
h₁: x ∈ s
h₁
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as✝: List X

head
norm x + 1 ≤ maxNormSuccOnSupp norm crds (x :: as✝)
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

b✝: X

as✝: List X

a✝: List.Mem x as✝

tail
norm x + 1 ≤ maxNormSuccOnSupp norm crds (b✝ :: as✝)
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

∀ (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds scase head 
as: List ?m.127869
as => 
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ maxNormSuccOnSupp norm crds (x :: as)rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ maxNormSuccOnSupp norm crds (x :: as)
maxNormSuccOnSupp: {R : Type ?u.128192} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.128191} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ if crds x ≠ 0 then max (norm x + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds as]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ if crds x ≠ 0 then max (norm x + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds as
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ maxNormSuccOnSupp norm crds (x :: as)simp [
h₂: crds x ≠ 0
h₂]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ max (norm x + 1) (maxNormSuccOnSupp norm crds as)
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

as: List X

norm x + 1 ≤ maxNormSuccOnSupp norm crds (x :: as)apply 
fst_le_max: ∀ (a b : ℕ), a ≤ max a b
fst_le_max
Goals accomplished! 🐙  
    
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

∀ (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds scase tail 
a: ?m.127869
a 
as: List ?m.127869
as 
th: List.Mem ?m.127870 as
th =>
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ maxNormSuccOnSupp norm crds (a :: as)rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ maxNormSuccOnSupp norm crds (a :: as)
maxNormSuccOnSupp: {R : Type ?u.128811} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.128810} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds as]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds as
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ maxNormSuccOnSupp norm crds (a :: as)let 
l: ?m.128849
l := 
supp_below_max: ∀ (norm : X → ℕ) (crds : X → R) (s : List X) (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds s
supp_below_max 
norm: X → ℕ
norm 
crds: X → R
crds 
as: List ?m.127869
as  
x: X
x  
th: List.Mem ?m.127870 as
th 
h₂: crds x ≠ 0
h₂
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds as 
      
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

norm x + 1 ≤ maxNormSuccOnSupp norm crds (a :: as)exact if 
c: ?m.128953
c:
crds: X → R
crds 
a: ?m.127869
a ≠ 
0: ?m.128860
0 then
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds asby
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: crds a ≠ 0

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds assimp [
c: crds a ≠ 0
c]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: crds a ≠ 0

norm x + 1 ≤ max (norm a + 1) (maxNormSuccOnSupp norm crds as)
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: crds a ≠ 0

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds asapply 
Nat.le_trans: ∀ {n m k : ℕ}, n ≤ m → m ≤ k → n ≤ k
Nat.le_trans 
l: norm x + 1 ≤ maxNormSuccOnSupp norm crds as
l
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: crds a ≠ 0

maxNormSuccOnSupp norm crds as ≤ max (norm a + 1) (maxNormSuccOnSupp norm crds as) 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: crds a ≠ 0

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds asapply 
snd_le_max: ∀ (a b : ℕ), b ≤ max a b
snd_le_max
Goals accomplished! 🐙
      else
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds asby 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: ¬crds a ≠ 0

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds assimp [
c: ¬crds a ≠ 0
c]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: ¬crds a ≠ 0

norm x + 1 ≤ maxNormSuccOnSupp norm crds as
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

x: X

h₂: crds x ≠ 0

a: X

as: List X

th: List.Mem x as

l:= supp_below_max norm crds as x th h₂: norm x + 1 ≤ maxNormSuccOnSupp norm crds as

c: ¬crds a ≠ 0

norm x + 1 ≤ if crds a ≠ 0 then max (norm a + 1) (maxNormSuccOnSupp norm crds as) else maxNormSuccOnSupp norm crds asexact 
l: norm x + 1 ≤ maxNormSuccOnSupp norm crds as
l
Goals accomplished! 🐙

theorem 
supp_zero_of_max_zero: ∀ (norm : X → ℕ) (crds : X → R) (s : List X), maxNormSuccOnSupp norm crds s = 0 → ∀ (x : X), x ∈ s → crds x = 0
supp_zero_of_max_zero(
norm: X → ℕ
norm: 
X: Type ?u.129879
X → 
Nat: Type
Nat)(
crds: X → R
crds : 
X: Type ?u.129879
X → 
R: Type ?u.129864
R)(
s: List X
s: 
List: Type ?u.129899 → Type ?u.129899
List 
X: Type ?u.129879
X) : 
maxNormSuccOnSupp: {R : Type ?u.129905} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.129904} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
crds: X → R
crds 
s: List X
s = 
0: ?m.129965
0 → 
    (
x: X
x: 
X: Type ?u.129879
X) → 
x: X
x ∈ 
s: List X
s →  
crds: X → R
crds 
x: X
x = 
0: ?m.130021
0 := fun 
hyp: ?m.130101
hyp 
x: ?m.130104
x 
hm: ?m.130107
hm =>
      if 
c: ?m.130204
c:
crds: X → R
crds 
x: ?m.130104
x = 
0: ?m.130111
0 then 
c: ?m.130204
c 
      else by 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

crds x = 0simp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

crds x = 0
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

crds x = 0let 
l: ?m.130256
l := 
supp_below_max: ∀ {R : Type ?u.130258} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type ?u.130257} (norm : X → ℕ) (crds : X → R)
  (s : List X) (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds s
supp_below_max 
norm: X → ℕ
norm 
crds: X → R
crds 
s: List X
s 
x: X
x 
hm: x ∈ s
hm 
c: ¬crds x = 0
c
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

l:= supp_below_max norm crds s x hm c: norm x + 1 ≤ maxNormSuccOnSupp norm crds s

crds x = 0 
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

crds x = 0rw [
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

l:= supp_below_max norm crds s x hm c: norm x + 1 ≤ maxNormSuccOnSupp norm crds s

crds x = 0
hyp: maxNormSuccOnSupp norm crds s = 0
hyp
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

l: norm x + 1 ≤ 0

crds x = 0]
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

l: norm x + 1 ≤ 0

crds x = 0 at 
l: ?m.130256
l
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

l: norm x + 1 ≤ 0

crds x = 0
        
R: Type u_2

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type u_1

inst✝: DecidableEq X

norm: X → ℕ

crds: X → R

s: List X

hyp: maxNormSuccOnSupp norm crds s = 0

x: X

hm: x ∈ s

c: ¬crds x = 0

crds x = 0contradiction
Goals accomplished! 🐙

def 
FormalSum.normSucc: {R : Type u_1} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type u_2} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
FormalSum.normSucc (
norm: X → ℕ
norm : 
X: Type ?u.130569
X → 
Nat: Type
Nat)(
s: FormalSum R X
s: 
FormalSum: (R : Type ?u.130586) → Type ?u.130585 → [inst : Ring R] → Type (max?u.130585?u.130586)
FormalSum 
R: Type ?u.130554
R 
X: Type ?u.130569
X) : 
Nat: Type
Nat :=
      
maxNormSuccOnSupp: {R : Type ?u.130598} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.130597} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm 
s: FormalSum R X
s.
coords: {R : Type ?u.130645} → [inst : Ring R] → {X : Type ?u.130644} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords (
s: FormalSum R X
s.
support: {R : Type ?u.130703} → [inst : Ring R] → {X : Type ?u.130702} → FormalSum R X → List X
support)

open FormalSum
theorem 
normsucc_le: ∀ (norm : X → ℕ) (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → normSucc norm s₁ ≤ normSucc norm s₂
normsucc_le(
norm: X → ℕ
norm : 
X: Type ?u.130903
X → 
Nat: Type
Nat)(
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂: 
FormalSum: (R : Type ?u.130920) → Type ?u.130919 → [inst : Ring R] → Type (max?u.130919?u.130920)
FormalSum 
R: Type ?u.130888
R 
X: Type ?u.130903
X)(
eql: s₁ ≈ s₂
eql : 
s₁: FormalSum R X
s₁ ≈ 
s₂: FormalSum R X
s₂): 
s₁: FormalSum R X
s₁.
normSucc: {R : Type ?u.131002} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.131001} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc 
norm: X → ℕ
norm ≤ 
s₂: FormalSum R X
s₂.
normSucc: {R : Type ?u.131096} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.131095} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc 
norm: X → ℕ
norm := 
      if 
c: ?m.131216
c:
s₁: FormalSum R X
s₁.
normSucc: {R : Type ?u.131140} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.131139} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc 
norm: X → ℕ
norm = 
0: ?m.131169
0 then 
      by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂
c: normSucc norm s₁ = 0
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: normSucc norm s₁ = 0

0 ≤ normSucc norm s₂]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: normSucc norm s₁ = 0

0 ≤ normSucc norm s₂
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂apply 
Nat.zero_le: ∀ (n : ℕ), 0 ≤ n
Nat.zero_le
Goals accomplished! 🐙 
      else by
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂simp [
FormalSum.normSucc: {R : Type ?u.131309} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.131308} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
FormalSum.normSucc]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂simp [
FormalSum.normSucc: {R : Type ?u.131707} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.131706} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
FormalSum.normSucc] at 
c: ¬normSucc norm s₁ = 0
c
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
c': maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0
c' : 
maxNormSuccOnSupp: {R : Type ?u.132034} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.132033} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm (
coords: {R : Type ?u.132043} → [inst : Ring R] → {X : Type ?u.132042} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₁: FormalSum R X
s₁) (
support: {R : Type ?u.132096} → [inst : Ring R] → {X : Type ?u.132095} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁) > 
0: ?m.132110
0 :=
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)by
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0cases 
Nat.eq_zero_or_pos: ∀ (n : ℕ), n = 0 ∨ n > 0
Nat.eq_zero_or_pos (
maxNormSuccOnSupp: {R : Type ?u.132135} → [inst : Ring R] → [inst : DecidableEq R] → {X : Type ?u.132134} → (X → ℕ) → (X → R) → List X → ℕ
maxNormSuccOnSupp 
norm: X → ℕ
norm (
coords: {R : Type ?u.132181} → [inst : Ring R] → {X : Type ?u.132180} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₁: FormalSum R X
s₁) (
support: {R : Type ?u.132234} → [inst : Ring R] → {X : Type ?u.132233} → FormalSum R X → List X
support 
s₁: FormalSum R X
s₁))
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

h✝: maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

inl
maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

h✝: maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

inr
maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0contradiction
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

h✝: maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

inr
maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0
            
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0assumption
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
l: ?m.132347
l := 
max_in_support: ∀ {R : Type ?u.132349} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type ?u.132348} (norm : X → ℕ) (crds : X → R)
  (s : List X), maxNormSuccOnSupp norm crds s > 0 → ∃ x, crds x ≠ 0 ∧ maxNormSuccOnSupp norm crds s = norm x + 1
max_in_support 
norm: X → ℕ
norm 
s₁: FormalSum R X
s₁.
coords: {R : Type ?u.132358} → [inst : Ring R] → {X : Type ?u.132357} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₁: FormalSum R X
s₁.
support: {R : Type ?u.132377} → [inst : Ring R] → {X : Type ?u.132376} → FormalSum R X → List X
support 
c': maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0
c'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let ⟨
x₀: X
x₀, 
p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1
p⟩:= 
l: ?m.132347
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
nonzr': ?m.132533
nonzr' := 
p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1
p.
left: ∀ {a b : Prop}, a ∧ b → a
left
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr':= p.left: coords s₁ x₀ ≠ 0

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
l: ?m.132544
l := 
congrFun: ∀ {α : Sort ?u.132546} {β : α → Sort ?u.132545} {f g : (x : α) → β x}, f = g → ∀ (a : α), f a = g a
congrFun 
eql: s₁ ≈ s₂
eql 
x₀: X
x₀
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr':= p.left: coords s₁ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr':= p.left: coords s₁ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
l: ?m.132544
l
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂) at 
nonzr': ?m.132533
nonzr'
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
nonzr: 0 ≠ coords s₂ x₀
nonzr : 
0: ?m.132609
0 ≠ 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.132620} → [inst : Ring R] → {X : Type ?u.132619} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
x₀: X
x₀ := 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)by
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

0 ≠ coords s₂ x₀intro 
hyp: 0 = coords s₂ x₀
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

hyp: 0 = coords s₂ x₀

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

0 ≠ coords s₂ x₀let 
l': ?m.132730
l' := 
Eq.symm: ∀ {α : Sort ?u.132731} {a b : α}, a = b → b = a
Eq.symm 
hyp: 0 = coords s₂ x₀
hyp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

hyp: 0 = coords s₂ x₀

l':= Eq.symm hyp: coords s₂ x₀ = 0

False
          
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

0 ≠ coords s₂ x₀contradiction
Goals accomplished! 🐙
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂let 
in_supp: ?m.132935
in_supp := 
nonzero_coord_in_support: ∀ {R : Type ?u.132936} [inst : Ring R] {X : Type ?u.132937} [inst_1 : DecidableEq X] (s : FormalSum R X) (x : X),
  0 ≠ coords s x → x ∈ support s
nonzero_coord_in_support 
s₂: FormalSum R X
s₂ 
x₀: X
x₀ 
nonzr: 0 ≠ coords s₂ x₀
nonzr
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

nonzr:= fun hyp =>
  let l' := Eq.symm hyp;
  absurd l' nonzr': 0 ≠ coords s₂ x₀

in_supp:= nonzero_coord_in_support s₂ x₀ nonzr: x₀ ∈ support s₂

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂rw [
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

nonzr:= fun hyp =>
  let l' := Eq.symm hyp;
  absurd l' nonzr': 0 ≠ coords s₂ x₀

in_supp:= nonzero_coord_in_support s₂ x₀ nonzr: x₀ ∈ support s₂

maxNormSuccOnSupp norm (coords s₁) (support s₁) ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1
p.
right: ∀ {a b : Prop}, a ∧ b → b
right
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

nonzr:= fun hyp =>
  let l' := Eq.symm hyp;
  absurd l' nonzr': 0 ≠ coords s₂ x₀

in_supp:= nonzero_coord_in_support s₂ x₀ nonzr: x₀ ∈ support s₂

norm x₀ + 1 ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)]
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

nonzr:= fun hyp =>
  let l' := Eq.symm hyp;
  absurd l' nonzr': 0 ≠ coords s₂ x₀

in_supp:= nonzero_coord_in_support s₂ x₀ nonzr: x₀ ∈ support s₂

norm x₀ + 1 ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂simp
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬maxNormSuccOnSupp norm (coords s₁) (support s₁) = 0

c':= Or.casesOn (motive := fun t =>
  Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)) = t →
    maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0)
  (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁))) (fun h h_1 => Eq.symm h_1 ▸ absurd h c)
  (fun h h_1 => Eq.symm h_1 ▸ h) (Eq.refl (Nat.eq_zero_or_pos (maxNormSuccOnSupp norm (coords s₁) (support s₁)))): maxNormSuccOnSupp norm (coords s₁) (support s₁) > 0

l✝:= max_in_support norm (coords s₁) (support s₁) c': ∃ x, coords s₁ x ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x + 1

x₀: X

p: coords s₁ x₀ ≠ 0 ∧ maxNormSuccOnSupp norm (coords s₁) (support s₁) = norm x₀ + 1

nonzr': coords s₂ x₀ ≠ 0

l:= congrFun eql x₀: coords s₁ x₀ = coords s₂ x₀

nonzr:= fun hyp =>
  let l' := Eq.symm hyp;
  absurd l' nonzr': 0 ≠ coords s₂ x₀

in_supp:= nonzero_coord_in_support s₂ x₀ nonzr: x₀ ∈ support s₂

norm x₀ + 1 ≤ maxNormSuccOnSupp norm (coords s₂) (support s₂)
        
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

c: ¬normSucc norm s₁ = 0

normSucc norm s₁ ≤ normSucc norm s₂apply 
supp_below_max: ∀ {R : Type ?u.133391} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type ?u.133390} (norm : X → ℕ) (crds : X → R)
  (s : List X) (x : X), x ∈ s → crds x ≠ 0 → norm x + 1 ≤ maxNormSuccOnSupp norm crds s
supp_below_max 
norm: X → ℕ
norm 
s₂: FormalSum R X
s₂.
coords: {R : Type ?u.133400} → [inst : Ring R] → {X : Type ?u.133399} → [inst_1 : DecidableEq X] → FormalSum R X → X → R
coords 
s₂: FormalSum R X
s₂.
support: {R : Type ?u.133419} → [inst : Ring R] → {X : Type ?u.133418} → FormalSum R X → List X
support 
x₀: X
x₀ 
in_supp: ?m.132935
in_supp 
nonzr': coords s₂ x₀ ≠ 0
nonzr'
Goals accomplished! 🐙

theorem 
norm_succ_eq: ∀ (norm : X → ℕ) (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → normSucc norm s₁ = normSucc norm s₂
norm_succ_eq(
norm: X → ℕ
norm : 
X: Type ?u.133553
X → 
Nat: Type
Nat)(
s₁: FormalSum R X
s₁ 
s₂: FormalSum R X
s₂: 
FormalSum: (R : Type ?u.133579) → Type ?u.133578 → [inst : Ring R] → Type (max?u.133578?u.133579)
FormalSum 
R: Type ?u.133538
R 
X: Type ?u.133553
X)(
eql: s₁ ≈ s₂
eql : 
s₁: FormalSum R X
s₁ ≈ 
s₂: FormalSum R X
s₂):
    
s₁: FormalSum R X
s₁.
normSucc: {R : Type ?u.133652} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.133651} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc 
norm: X → ℕ
norm = 
s₂: FormalSum R X
s₂.
normSucc: {R : Type ?u.133746} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.133745} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc 
norm: X → ℕ
norm := by
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂apply 
Nat.le_antisymm: ∀ {n m : ℕ}, n ≤ m → m ≤ n → n = m
Nat.le_antisymm
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₁
normSucc norm s₁ ≤ normSucc norm s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₂
normSucc norm s₂ ≤ normSucc norm s₁ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂<;>
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₁
normSucc norm s₁ ≤ normSucc norm s₂
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₂
normSucc norm s₂ ≤ normSucc norm s₁ 
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂apply 
normsucc_le: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (norm : X → ℕ)
  (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → normSucc norm s₁ ≤ normSucc norm s₂
normsucc_le
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₂.eql
s₂ ≈ s₁
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂assumption
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₂.eql
s₂ ≈ s₁
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂apply 
eqlCoords.symm: ∀ {R : Type} [inst : Ring R] {X : Type} [inst_1 : DecidableEq X] {s₁ s₂ : FormalSum R X},
  eqlCoords R X s₁ s₂ → eqlCoords R X s₂ s₁
eqlCoords.symm
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

h₂.eql.a
eqlCoords R X s₁ s₂
      
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

norm: X → ℕ

s₁, s₂: FormalSum R X

eql: s₁ ≈ s₂

normSucc norm s₁ = normSucc norm s₂assumption
Goals accomplished! 🐙

class 
NormCube: {α : Type} → (α → ℕ) → (ℕ → List α) → NormCube α
NormCube (
α: Type
α : 
Type: Type 1
Type) where
  
norm: {α : Type} → [self : NormCube α] → α → ℕ
norm : 
α: Type
α → 
Nat: Type
Nat
  
cube: {α : Type} → [self : NormCube α] → ℕ → List α
cube : 
Nat: Type
Nat → 
List: Type ?u.133977 → Type ?u.133977
List 
α: Type
α

def 
normCube: (α : Type) → [nc : NormCube α] → ℕ → List α
normCube (
α: Type
α : 
Type: Type 1
Type) [
nc: NormCube α
nc : 
NormCube: Type → Type
NormCube 
α: Type
α](
k: ℕ
k: 
Nat: Type
Nat)  := 
nc: NormCube α
nc.
cube: {α : Type} → [self : NormCube α] → ℕ → List α
cube 
k: ℕ
k

instance 
natCube: NormCube ℕ
natCube : 
NormCube: Type → Type
NormCube 
Nat: Type
Nat := ⟨
id: {α : Sort ?u.134123} → α → α
id, fun 
n: ?m.134129
n => (
List.range: ℕ → List ℕ
List.range 
n: ?m.134129
n).
reverse: {α : Type ?u.134131} → List α → List α
reverse⟩

instance 
finCube: {k : ℕ} → NormCube (Fin (Nat.succ k))
finCube {
k: ℕ
k: 
Nat: Type
Nat} : 
NormCube: Type → Type
NormCube (
Fin: ℕ → Type
Fin (
Nat.succ: ℕ → ℕ
Nat.succ 
k: ℕ
k)) := 
    let 
i: ℕ → Fin (Nat.succ k)
i : 
Nat: Type
Nat → 
Fin: ℕ → Type
Fin (
Nat.succ: ℕ → ℕ
Nat.succ 
k: ℕ
k) := fun 
n: ?m.134210
n => ⟨
n: ?m.134210
n % (
Nat.succ: ℕ → ℕ
Nat.succ 
k: ℕ
k), by 
          
R: Type ?u.134175

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.134190

inst✝: DecidableEq X

k, n: ℕ

n % Nat.succ k < Nat.succ kapply 
Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt
R: Type ?u.134175

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.134190

inst✝: DecidableEq X

k, n: ℕ

a
Nat.succ k > 0
          
R: Type ?u.134175

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type ?u.134190

inst✝: DecidableEq X

k, n: ℕ

n % Nat.succ k < Nat.succ kapply 
Nat.zero_lt_succ: ∀ (n : ℕ), 0 < Nat.succ n
Nat.zero_lt_succ
Goals accomplished! 🐙
          ⟩
    ⟨fun 
j: ?m.134261
j => 
j: ?m.134261
j.
val: {n : ℕ} → Fin n → ℕ
val, fun 
n: ?m.134267
n => (
List.range: ℕ → List ℕ
List.range (
min: {α : Type ?u.134269} → [self : Min α] → α → α → α
min (
k: ℕ
k + 
1: ?m.134279
1) 
n: ?m.134267
n)).
reverse: {α : Type ?u.134334} → List α → List α
reverse.
map: {α : Type ?u.134338} → {β : Type ?u.134337} → (α → β) → List α → List β
map 
i: ℕ → Fin (Nat.succ k)
i⟩


instance 
intCube: NormCube ℤ
intCube : 
NormCube: Type → Type
NormCube 
ℤ: Type
ℤ where
  norm := 
Int.natAbs: ℤ → ℕ
Int.natAbs
  cube : 
Nat: Type
Nat → 
List: Type ?u.134681 → Type ?u.134681
List 
ℤ: Type
ℤ := fun 
n: ?m.134683
n => 
      (
List.range: ℕ → List ℕ
List.range (
n: ?m.134683
n)).
reverse: {α : Type ?u.134688} → List α → List α
reverse.
map: {α : Type ?u.134692} → {β : Type ?u.134691} → (α → β) → List α → List β
map (
Int.ofNat: ℕ → ℤ
Int.ofNat) ++
      (
List.range: ℕ → List ℕ
List.range (
n: ?m.134683
n - 
1: ?m.134706
1)).
map: {α : Type ?u.134759} → {β : Type ?u.134758} → (α → β) → List α → List β
map (
Int.negSucc: ℕ → ℤ
Int.negSucc)

instance 
prodCube: {α β : Type} → [na : NormCube α] → [nb : NormCube β] → NormCube (α × β)
prodCube {
α: Type
α 
β: Type
β : 
Type: Type 1
Type} [
na: NormCube α
na: 
NormCube: Type → Type
NormCube 
α: Type
α] [
nb: NormCube β
nb :
NormCube: Type → Type
NormCube 
β: Type
β] :  
NormCube: Type → Type
NormCube (
α: Type
α × 
β: Type
β) where
  norm : (
α: Type
α × 
β: Type
β) → 
Nat: Type
Nat := 
    fun ⟨
a: α
a, 
b: β
b⟩ => 
max: {α : Type ?u.135012} → [self : Max α] → α → α → α
max (
na: NormCube α
na.
norm: {α : Type} → [self : NormCube α] → α → ℕ
norm 
a: α
a) (
nb: NormCube β
nb.
norm: {α : Type} → [self : NormCube α] → α → ℕ
norm 
b: β
b) 
  cube : 
Nat: Type
Nat → 
List: Type ?u.135096 → Type ?u.135096
List (
α: Type
α × 
β: Type
β) :=
    fun 
n: ?m.135100
n => 
      (
na: NormCube α
na.
cube: {α : Type} → [self : NormCube α] → ℕ → List α
cube 
n: ?m.135100
n).
bind: {α : Type ?u.135105} → {β : Type ?u.135104} → List α → (α → List β) → List β
bind (fun 
a: ?m.135114
a => 
        (
nb: NormCube β
nb.
cube: {α : Type} → [self : NormCube α] → ℕ → List α
cube 
n: ?m.135100
n).
map: {α : Type ?u.135118} → {β : Type ?u.135117} → (α → β) → List α → List β
map  (fun 
b: ?m.135126
b => 
          (
a: ?m.135114
a, 
b: ?m.135126
b)))

def 
FreeModule.normBound: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → [nx : NormCube X] → ℕ
FreeModule.normBound (
x: R[X]
x: 
R: Type ?u.135516
R[
X: Type ?u.135531
X])[
nx: NormCube X
nx : 
NormCube: Type → Type
NormCube 
X: Type ?u.135531
X] : 
Nat: Type
Nat := by
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

ℕlet 
f: FormalSum R X → ℕ
f : 
FormalSum: (R : Type ?u.135611) → Type ?u.135610 → [inst : Ring R] → Type (max?u.135610?u.135611)
FormalSum 
R: Type
R 
X: Type
X → 
Nat: Type
Nat := fun 
s: ?m.135617
s => 
s: ?m.135617
s.
normSucc: {R : Type ?u.135620} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type ?u.135619} → [inst_2 : DecidableEq X] → (X → ℕ) → FormalSum R X → ℕ
normSucc (
nx: NormCube X
nx.
norm: {α : Type} → [self : NormCube α] → α → ℕ
norm)
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

f:= fun s => normSucc NormCube.norm s: FormalSum R X → ℕ

ℕ
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

ℕapply 
Quotient.lift: {α : Sort ?u.135769} →
  {β : Sort ?u.135768} → {s : Setoid α} → (f : α → β) → (∀ (a b : α), a ≈ b → f a = f b) → Quotient s → β
Quotient.lift 
f: FormalSum R X → ℕ
f
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

f:= fun s => normSucc NormCube.norm s: FormalSum R X → ℕ

a
∀ (a b : FormalSum R X), a ≈ b → f a = f b
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

f:= fun s => normSucc NormCube.norm s: FormalSum R X → ℕ

a
Quotient ?m.135772
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

f:= fun s => normSucc NormCube.norm s: FormalSum R X → ℕ

Setoid (FormalSum R X)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

ℕapply 
norm_succ_eq: ∀ {R : Type} [inst : Ring R] [inst_1 : DecidableEq R] {X : Type} [inst_2 : DecidableEq X] (norm : X → ℕ)
  (s₁ s₂ : FormalSum R X), s₁ ≈ s₂ → normSucc norm s₁ = normSucc norm s₂
norm_succ_eq
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

f:= fun s => normSucc NormCube.norm s: FormalSum R X → ℕ

a
Quotient (formalSumSetoid R X)
  
R: Type

inst✝²: Ring R

inst✝¹: DecidableEq R

X: Type

inst✝: DecidableEq X

x: R[X]

nx: NormCube X

ℕexact 
x: R[X]
x
Goals accomplished! 🐙

-- this should be viewable directly if `R` and `X` are, as in our case
def 
FreeModule.coeffList: R[X] → [nx : NormCube X] → List (R × X)
FreeModule.coeffList (
x: R[X]
x: 
R: Type ?u.136041
R[
X: Type ?u.136056
X])[
nx: NormCube X
nx : 
NormCube: Type → Type
NormCube 
X: Type ?u.136056
X] : 
List: Type ?u.136128 → Type ?u.136128
List (
R: Type ?u.136041
R × 
X: Type ?u.136056
X) := 
   (
nx: NormCube X
nx.
cube: {α : Type} → [self : NormCube α] → ℕ → List α
cube (
x: R[X]
x.
normBound: {R : Type} →
  [inst : Ring R] → [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → [nx : NormCube X] → ℕ
normBound)).
filterMap: {α : Type ?u.136235} → {β : Type ?u.136234} → (α → Option β) → List α → List β
filterMap fun 
x₀: ?m.136244
x₀ => 
      let 
a: ?m.136247
a := 
x: R[X]
x.
coordinates: {R : Type} → [inst : Ring R] → {X : Type} → [inst_1 : DecidableEq X] → X → R[X] → R
coordinates 
x₀: ?m.136244
x₀
      if 
a: ?m.136247
a =
0: ?m.136302
0 then 
none: {α : Type ?u.136389} → Option α
none else 
some: {α : Type ?u.136392} → α → Option α
some (
a: ?m.136247
a, 
x₀: ?m.136244
x₀)

-- basic repr 
instance 
basicRepr: [inst : NormCube X] → [inst : Repr X] → [inst : Repr R] → Repr (R[X])
basicRepr [
NormCube: Type → Type
NormCube 
X: Type ?u.136620
X][
Repr: Type ?u.136634 → Type ?u.136634
Repr 
X: Type ?u.136620
X][
Repr: Type ?u.136637 → Type ?u.136637
Repr 
R: Type ?u.136605
R]: 
Repr: Type ?u.136640 → Type ?u.136640
Repr (
R: Type ?u.136605
R[
X: Type ?u.136620
X]) := 
  ⟨fun 
x: ?m.136707
x 
_: ?m.136710
_ => 
reprStr: {α : Type ?u.136712} → [inst : Repr α] → α → String
reprStr (
x: ?m.136707
x.
coeffList: {R : Type} →
  [inst : Ring R] →
    [inst_1 : DecidableEq R] → {X : Type} → [inst_2 : DecidableEq X] → R[X] → [nx : NormCube X] → List (R × X)
coeffList)⟩

end NormRepr