internlm/Lean-Github huggingface dataset:
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ coords (mulMonom b h ((0, g) :: tail)) x₀ = coords (mulMonom b h tail) x₀
Tactic:
simp [mulMonom, coords,monom_coords_at_zero]
Proof state after:
no goals
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case addCoeffs
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail)) x₀ = coords (mulMonom b h ((a₁ + a₂, x) :: tail)) x₀
Tactic:
simp [mulMonom, coords, right_distrib, monom_coords_hom, add_assoc]
Proof state after:
no goals
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case cons
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a : R
x : G
t₁ t₂ : FormalSum R G
a✝ : ElementaryMove R G t₁ t₂
step : coords (mulMonom b h t₁) x₀ = coords (mulMonom b h t₂) x₀
⊢ coords (mulMonom b h ((a, x) :: t₁)) x₀ = coords (mulMonom b h ((a, x) :: t₂)) x₀
Tactic:
simp [mulMonom, coords, step]
Proof state after:
no goals
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case swap
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x₁ x₂ : G
tail : FormalSum R G
⊢ coords (mulMonom b h ((a₁, x₁) :: (a₂, x₂) :: tail)) x₀ = coords (mulMonom b h ((a₂, x₂) :: (a₁, x₁) :: tail)) x₀
Tactic:
simp [mulMonom, coords]
Proof state after:
case swap
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x₁ x₂ : G
tail : FormalSum R G
⊢ monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =
    monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case swap
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x₁ x₂ : G
tail : FormalSum R G
⊢ monomCoeff R G x₀ (a₁ * b, x₁ * h) + (monomCoeff R G x₀ (a₂ * b, x₂ * h) + coords (mulMonom b h tail) x₀) =
    monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
Tactic:
conv =>
  lhs
  rw [← add_assoc]
  arg 1
  rw [add_comm]
Proof state after:
case swap
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x₁ x₂ : G
tail : FormalSum R G
⊢ monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀ =
    monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
Theorem: GroupRing.mul_monom_invariant
Proof state before:
case swap
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
b : R
h x₀ : G
s₁ s₂ : FormalSum R G
a₁ a₂ : R
x₁ x₂ : G
tail : FormalSum R G
⊢ monomCoeff R G x₀ (a₂ * b, x₂ * h) + monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀ =
    monomCoeff R G x₀ (a₂ * b, x₂ * h) + (monomCoeff R G x₀ (a₁ * b, x₁ * h) + coords (mulMonom b h tail) x₀)
Tactic:
rw [← add_assoc]
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ t : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ mul s₁ t ≈ mul s₂ t
Tactic:
cases t
Proof state after:
case nil
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ mul s₁ [] ≈ mul s₂ []

case cons
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
head✝ : R × G
tail✝ : List (R × G)
⊢ mul s₁ (head✝ :: tail✝) ≈ mul s₂ (head✝ :: tail✝)
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ mul s₁ [] ≈ mul s₂ []
Tactic:
case nil => 
  simp [mul]
  rfl
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
head' : R × G
tail' : List (R × G)
⊢ mul s₁ (head' :: tail') ≈ mul s₂ (head' :: tail')
Tactic:
case cons head' tail' =>
  let (b, h) := head'
  induction rel with
  | zeroCoeff tail g a hyp => 
    rw [hyp]
    simp [mul, mulMonom]
    apply funext; intro x₀
    rw [← append_coords]
    simp [coords, monom_coords_at_zero]
    rw [← append_coords]
    simp  
    let rel' : ElementaryMove R G ((0, g) :: tail)  tail := by 
      apply ElementaryMove.zeroCoeff
      rfl
    let prev  := first_arg_invariant  _ _ tail' rel' 
    let pl := congrFun prev x₀
    rw [pl]  
  | addCoeffs a₁ a₂ x tail => 
    simp [mul]
    apply funext; intro x₀
    rw [← append_coords]
    rw [← append_coords]
    simp [coords]
    rw [right_distrib]
    simp [monom_coords_hom]
    let rel' : ElementaryMove R G 
      ((a₁, x) :: (a₂, x) :: tail)
        ((a₁ + a₂, x) :: tail) := by 
        apply ElementaryMove.addCoeffs
    let prev  := first_arg_invariant  _ _ tail' rel' 
    let pl := congrFun prev x₀
    rw [pl]
    simp [add_assoc] 
  | cons a x s₁ s₂ r _ => 
    simp [mul]
    apply funext; intro x₀
    rw [← append_coords]
    rw [← append_coords]
    simp [coords]
    let rel' : ElementaryMove R G 
      ((a, x) :: s₁)
        ((a, x) :: s₂) := by 
        apply ElementaryMove.cons
        assumption 
    let prev  := first_arg_invariant  _ _ tail' rel' 
    let pl := congrFun prev x₀
    rw [pl]
    let ps := mul_monom_invariant b h x₀ s₁ s₂ r
    rw [ps]       
  | swap a₁ a₂ x₁ x₂ tail => 
    simp [mul]
    apply funext; intro x₀
    rw [← append_coords]
    rw [← append_coords]
    rw [mulMonom]
    rw [mulMonom]
    rw [coords]
    rw [coords]
    rw [mulMonom]
    rw [mulMonom]
    rw [coords]
    rw [coords]
    let rel' : ElementaryMove R G 
      ((a₁, x₁) :: (a₂, x₂) :: tail)
        ((a₂, x₂) :: (a₁, x₁) :: tail) := by 
        apply ElementaryMove.swap
    let prev  := first_arg_invariant  _ _ tail' rel' 
    let pl := congrFun prev x₀
    rw [pl]
    simp 
    rw [← add_assoc]
    rw [← add_assoc]
    simp
    conv =>
      lhs 
      rw [add_comm]
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ mul s₁ [] ≈ mul s₂ []
Tactic:
simp [mul]
Proof state after:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ [] ≈ []
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
⊢ [] ≈ []
Tactic:
rfl
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
head' : R × G
tail' : List (R × G)
⊢ mul s₁ (head' :: tail') ≈ mul s₂ (head' :: tail')
Tactic:
let (b, h) := head'
Proof state after:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
head' : R × G
tail' : List (R × G)
b : R
h : G
⊢ mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
rel : ElementaryMove R G s₁ s₂
head' : R × G
tail' : List (R × G)
b : R
h : G
⊢ mul s₁ ((b, h) :: tail') ≈ mul s₂ ((b, h) :: tail')
Tactic:
induction rel with
| zeroCoeff tail g a hyp => 
  rw [hyp]
  simp [mul, mulMonom]
  apply funext; intro x₀
  rw [← append_coords]
  simp [coords, monom_coords_at_zero]
  rw [← append_coords]
  simp  
  let rel' : ElementaryMove R G ((0, g) :: tail)  tail := by 
    apply ElementaryMove.zeroCoeff
    rfl
  let prev  := first_arg_invariant  _ _ tail' rel' 
  let pl := congrFun prev x₀
  rw [pl]  
| addCoeffs a₁ a₂ x tail => 
  simp [mul]
  apply funext; intro x₀
  rw [← append_coords]
  rw [← append_coords]
  simp [coords]
  rw [right_distrib]
  simp [monom_coords_hom]
  let rel' : ElementaryMove R G 
    ((a₁, x) :: (a₂, x) :: tail)
      ((a₁ + a₂, x) :: tail) := by 
      apply ElementaryMove.addCoeffs
  let prev  := first_arg_invariant  _ _ tail' rel' 
  let pl := congrFun prev x₀
  rw [pl]
  simp [add_assoc] 
| cons a x s₁ s₂ r _ => 
  simp [mul]
  apply funext; intro x₀
  rw [← append_coords]
  rw [← append_coords]
  simp [coords]
  let rel' : ElementaryMove R G 
    ((a, x) :: s₁)
      ((a, x) :: s₂) := by 
      apply ElementaryMove.cons
      assumption 
  let prev  := first_arg_invariant  _ _ tail' rel' 
  let pl := congrFun prev x₀
  rw [pl]
  let ps := mul_monom_invariant b h x₀ s₁ s₂ r
  rw [ps]       
| swap a₁ a₂ x₁ x₂ tail => 
  simp [mul]
  apply funext; intro x₀
  rw [← append_coords]
  rw [← append_coords]
  rw [mulMonom]
  rw [mulMonom]
  rw [coords]
  rw [coords]
  rw [mulMonom]
  rw [mulMonom]
  rw [coords]
  rw [coords]
  let rel' : ElementaryMove R G 
    ((a₁, x₁) :: (a₂, x₂) :: tail)
      ((a₂, x₂) :: (a₁, x₁) :: tail) := by 
      apply ElementaryMove.swap
  let prev  := first_arg_invariant  _ _ tail' rel' 
  let pl := congrFun prev x₀
  rw [pl]
  simp 
  rw [← add_assoc]
  rw [← add_assoc]
  simp
  conv =>
    lhs 
    rw [add_comm]
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ mul ((a, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')
Tactic:
rw [hyp]
Proof state after:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ mul ((0, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ mul ((0, g) :: tail) ((b, h) :: tail') ≈ mul tail ((b, h) :: tail')
Tactic:
simp [mul, mulMonom]
Proof state after:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ (0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail') ≈ mulMonom b h tail ++ mul tail tail'
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ (0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail') ≈ mulMonom b h tail ++ mul tail tail'
Tactic:
apply funext
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ ∀ (x : G),
    coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x =
      coords (mulMonom b h tail ++ mul tail tail') x
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
⊢ ∀ (x : G),
    coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x =
      coords (mulMonom b h tail ++ mul tail tail') x
Tactic:
intro x₀
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =
    coords (mulMonom b h tail ++ mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =
    coords (mulMonom b h tail ++ mul tail tail') x₀
Tactic:
rw [← append_coords]
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords ((0, g * h) :: (mulMonom b h tail ++ mul ((0, g) :: tail) tail')) x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Tactic:
simp [coords, monom_coords_at_zero]
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mulMonom b h tail ++ mul ((0, g) :: tail) tail') x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mulMonom b h tail ++ mul ((0, g) :: tail) tail') x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Tactic:
rw [← append_coords]
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mulMonom b h tail) x₀ + coords (mul ((0, g) :: tail) tail') x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mulMonom b h tail) x₀ + coords (mul ((0, g) :: tail) tail') x₀ =
    coords (mulMonom b h tail) x₀ + coords (mul tail tail') x₀
Tactic:
simp
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Tactic:
let rel' : ElementaryMove R G ((0, g) :: tail)  tail := by 
  apply ElementaryMove.zeroCoeff
  rfl
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Tactic:
let prev  := first_arg_invariant  _ _ tail' rel'
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
prev : mul ((0, g) :: tail) tail' ≈ mul tail tail' := first_arg_invariant ((0, g) :: tail) tail tail' rel'
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
prev : mul ((0, g) :: tail) tail' ≈ mul tail tail' := first_arg_invariant ((0, g) :: tail) tail tail' rel'
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Tactic:
let pl := congrFun prev x₀
Proof state after:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
prev : mul ((0, g) :: tail) tail' ≈ mul tail tail' := first_arg_invariant ((0, g) :: tail) tail tail' rel'
pl : coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀ := congrFun prev x₀
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Theorem: GroupRing.first_arg_invariant
Proof state before:
case zeroCoeff.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
rel' : ElementaryMove R G ((0, g) :: tail) tail := zeroCoeff tail g 0 (Eq.refl 0)
prev : mul ((0, g) :: tail) tail' ≈ mul tail tail' := first_arg_invariant ((0, g) :: tail) tail tail' rel'
pl : coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀ := congrFun prev x₀
⊢ coords (mul ((0, g) :: tail) tail') x₀ = coords (mul tail tail') x₀
Tactic:
rw [pl]
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ ElementaryMove R G ((0, g) :: tail) tail
Tactic:
apply ElementaryMove.zeroCoeff
Proof state after:
case h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ 0 = 0
Theorem: GroupRing.first_arg_invariant
Proof state before:
case h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
tail : FormalSum R G
g : G
a : R
hyp : a = 0
x₀ : G
⊢ 0 = 0
Tactic:
rfl
Proof state after:
no goals
Theorem: GroupRing.first_arg_invariant
Proof state before:
case addCoeffs
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ mul ((a₁, x) :: (a₂, x) :: tail) ((b, h) :: tail') ≈ mul ((a₁ + a₂, x) :: tail) ((b, h) :: tail')
Tactic:
simp [mul]
Proof state after:
case addCoeffs
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈
    mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail'
Theorem: GroupRing.first_arg_invariant
Proof state before:
case addCoeffs
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail' ≈
    mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail'
Tactic:
apply funext
Proof state after:
case addCoeffs.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ ∀ (x_1 : G),
    coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x_1 =
      coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x_1
Theorem: GroupRing.first_arg_invariant
Proof state before:
case addCoeffs.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
⊢ ∀ (x_1 : G),
    coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x_1 =
      coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x_1
Tactic:
intro x₀
Proof state after:
case addCoeffs.h
R : Type
inst✝³ : Ring R
inst✝² : DecidableEq R
G : Type
inst✝¹ : Group G
inst✝ : DecidableEq G
s₁ s₂ : FormalSum R G
head' : R × G
tail' : List (R × G)
b : R
h : G
a₁ a₂ : R
x : G
tail : FormalSum R G
x₀ : G
⊢ coords (mulMonom b h ((a₁, x) :: (a₂, x) :: tail) ++ mul ((a₁, x) :: (a₂, x) :: tail) tail') x₀ =
    coords (mulMonom b h ((a₁ + a₂, x) :: tail) ++ mul ((a₁ + a₂, x) :: tail) tail') x₀