l3lab/ntp-mathlib huggingface dataset:
theorem comp_tensorLId_eq (Q₂ : QuadraticForm R M₂) :
    Q₂.comp (TensorProduct.lid R M₂) = (sq (R := R)).tmul Q₂ := by
  refine (QuadraticForm.associated_rightInverse R).injective ?_
  apply BilinForm.toLin.injective
  ext m₂ m₂'
  dsimp [-associated_apply]
  

Proof state:
case a.a.h.h.a.h.h
R : Type uR
M₁ : Type uM₁
M₂ : Type uM₂
M₃ : Type uM₃
M₄ : Type uM₄
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : Invertible 2
Q₂ : QuadraticForm R M₂
m₂ m₂' : M₂
⊢ BilinForm.bilin ((associatedHom R) (comp Q₂ ↑(TensorProduct.lid R M₂))) (1 ⊗ₜ[R] m₂) (1 ⊗ₜ[R] m₂') =
    BilinForm.bilin ((associatedHom R) (QuadraticForm.tmul sq Q₂)) (1 ⊗ₜ[R] m₂) (1 ⊗ₜ[R] m₂')

Next tactic:
simp only [associated_tmul, QuadraticForm.associated_comp]
theorem comp_tensorLId_eq (Q₂ : QuadraticForm R M₂) :
    Q₂.comp (TensorProduct.lid R M₂) = (sq (R := R)).tmul Q₂ := by
  refine (QuadraticForm.associated_rightInverse R).injective ?_
  apply BilinForm.toLin.injective
  ext m₂ m₂'
  dsimp [-associated_apply]
  simp only [associated_tmul, QuadraticForm.associated_comp]
  

Proof state:
case a.a.h.h.a.h.h
R : Type uR
M₁ : Type uM₁
M₂ : Type uM₂
M₃ : Type uM₃
M₄ : Type uM₄
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : Invertible 2
Q₂ : QuadraticForm R M₂
m₂ m₂' : M₂
⊢ BilinForm.bilin (BilinForm.comp ((associatedHom R) Q₂) ↑(TensorProduct.lid R M₂) ↑(TensorProduct.lid R M₂))
      (1 ⊗ₜ[R] m₂) (1 ⊗ₜ[R] m₂') =
    BilinForm.bilin (BilinForm.tmul (associated sq) (associated Q₂)) (1 ⊗ₜ[R] m₂) (1 ⊗ₜ[R] m₂')

Next tactic:
simp [-associated_apply, mul_one]
/-- An equivalence `e : α ≃ β` gives a multiplicative equivalence `α ≃* β` where
the multiplicative structure on `α` is the one obtained by transporting a multiplicative structure
on `β` back along `e`. -/
@[to_additive "An equivalence `e : α ≃ β` gives an additive equivalence `α ≃+ β` where
the additive structure on `α` is the one obtained by transporting an additive structure
on `β` back along `e`."]
def mulEquiv (e : α ≃ β) [Mul β] :
    let mul := Equiv.mul e
    α ≃* β := by
  

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
⊢ let mul := Equiv.mul e;
  α ≃* β

Next tactic:
intros
/-- An equivalence `e : α ≃ β` gives a multiplicative equivalence `α ≃* β` where
the multiplicative structure on `α` is the one obtained by transporting a multiplicative structure
on `β` back along `e`. -/
@[to_additive "An equivalence `e : α ≃ β` gives an additive equivalence `α ≃+ β` where
the additive structure on `α` is the one obtained by transporting an additive structure
on `β` back along `e`."]
def mulEquiv (e : α ≃ β) [Mul β] :
    let mul := Equiv.mul e
    α ≃* β := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
mul✝ : Mul α := Equiv.mul e
⊢ α ≃* β

Next tactic:
exact
    { e with
      map_mul' := fun x y => by
        apply e.symm.injective
        simp [mul_def] }
/-- An equivalence `e : α ≃ β` gives a multiplicative equivalence `α ≃* β` where
the multiplicative structure on `α` is the one obtained by transporting a multiplicative structure
on `β` back along `e`. -/
@[to_additive "An equivalence `e : α ≃ β` gives an additive equivalence `α ≃+ β` where
the additive structure on `α` is the one obtained by transporting an additive structure
on `β` back along `e`."]
def mulEquiv (e : α ≃ β) [Mul β] :
    let mul := Equiv.mul e
    α ≃* β := by
  intros
  exact
    { e with
      map_mul' := fun x y => by
        

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ Equiv.toFun
      { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
        right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
      (x * y) =
    Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        x *
      Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        y

Next tactic:
apply e.symm.injective
/-- An equivalence `e : α ≃ β` gives a multiplicative equivalence `α ≃* β` where
the multiplicative structure on `α` is the one obtained by transporting a multiplicative structure
on `β` back along `e`. -/
@[to_additive "An equivalence `e : α ≃ β` gives an additive equivalence `α ≃+ β` where
the additive structure on `α` is the one obtained by transporting an additive structure
on `β` back along `e`."]
def mulEquiv (e : α ≃ β) [Mul β] :
    let mul := Equiv.mul e
    α ≃* β := by
  intros
  exact
    { e with
      map_mul' := fun x y => by
        apply e.symm.injective
        

Proof state:
case a
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ e.symm
      (Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        (x * y)) =
    e.symm
      (Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          x *
        Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          y)

Next tactic:
simp [mul_def]
@[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b :=
  by 

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
b : β
⊢ (MulEquiv.symm (mulEquiv e)) b = e.symm b

Next tactic:
intros
@[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b :=
  by intros; 

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
b : β
⊢ (MulEquiv.symm (mulEquiv e)) b = e.symm b

Next tactic:
rfl
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
⊢ Sort ?u.20848

Next tactic:
let add := Equiv.add e
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add : Add α := Equiv.add e
⊢ Sort ?u.20848

Next tactic:
let mul := Equiv.mul e
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
⊢ Sort ?u.20848

Next tactic:
exact α ≃+* β
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
⊢ let add := Equiv.add e;
  let mul := Equiv.mul e;
  α ≃+* β

Next tactic:
intros
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  intros
  

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add✝ : Add α := Equiv.add e
mul✝ : Mul α := Equiv.mul e
⊢ α ≃+* β

Next tactic:
exact
    { e with
      map_add' := fun x y => by
        apply e.symm.injective
        simp [add_def]
      map_mul' := fun x y => by
        apply e.symm.injective
        simp [mul_def] }
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  intros
  exact
    { e with
      map_add' := fun x y => by
        apply e.symm.injective
        simp [add_def]
      map_mul' := fun x y => by
        

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add✝ : Add α := Equiv.add e
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ Equiv.toFun
      { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
        right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
      (x * y) =
    Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        x *
      Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        y

Next tactic:
apply e.symm.injective
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  intros
  exact
    { e with
      map_add' := fun x y => by
        apply e.symm.injective
        simp [add_def]
      map_mul' := fun x y => by
        apply e.symm.injective
        

Proof state:
case a
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add✝ : Add α := Equiv.add e
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ e.symm
      (Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        (x * y)) =
    e.symm
      (Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          x *
        Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          y)

Next tactic:
simp [mul_def]
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  intros
  exact
    { e with
      map_add' := fun x y => by
        

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add✝ : Add α := Equiv.add e
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ Equiv.toFun
      { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
        right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
      (x + y) =
    Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        x +
      Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        y

Next tactic:
apply e.symm.injective
/-- An equivalence `e : α ≃ β` gives a ring equivalence `α ≃+* β`
where the ring structure on `α` is
the one obtained by transporting a ring structure on `β` back along `e`.
-/
def ringEquiv (e : α ≃ β) [Add β] [Mul β] : by
    let add := Equiv.add e
    let mul := Equiv.mul e
    exact α ≃+* β := by
  intros
  exact
    { e with
      map_add' := fun x y => by
        apply e.symm.injective
        

Proof state:
case a
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
add✝ : Add α := Equiv.add e
mul✝ : Mul α := Equiv.mul e
x y : α
⊢ e.symm
      (Equiv.toFun
        { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
          right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
        (x + y)) =
    e.symm
      (Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          x +
        Equiv.toFun
          { toFun := e.toFun, invFun := e.invFun, left_inv := (_ : Function.LeftInverse e.invFun e.toFun),
            right_inv := (_ : Function.RightInverse e.invFun e.toFun) }
          y)

Next tactic:
simp [add_def]
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ Sort ?u.77860

Next tactic:
letI := Equiv.add e
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    letI := Equiv.add e
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
this : Add α := Equiv.add e
⊢ Sort ?u.77860

Next tactic:
letI := Equiv.mul e
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    letI := Equiv.add e
    letI := Equiv.mul e
    

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
this✝ : Add α := Equiv.add e
this : Mul α := Equiv.mul e
⊢ Sort ?u.77860

Next tactic:
exact (ringEquiv e).symm b = e.symm b
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    letI := Equiv.add e
    letI := Equiv.mul e
    exact (ringEquiv e).symm b = e.symm b := by 

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ (RingEquiv.symm (ringEquiv e)) b = e.symm b

Next tactic:
intros
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    letI := Equiv.add e
    letI := Equiv.mul e
    exact (ringEquiv e).symm b = e.symm b := by intros; 

Proof state:
α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ (RingEquiv.symm (ringEquiv e)) b = e.symm b

Next tactic:
rfl
/-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α := by
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semigroup β
⊢ Semigroup α

Next tactic:
let mul := e.mul
/-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α := by
  let mul := e.mul
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semigroup β
mul : Mul α := Equiv.mul e
⊢ Semigroup α

Next tactic:
apply e.injective.semigroup _
/-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α := by
  let mul := e.mul
  apply e.injective.semigroup _; 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semigroup β
mul : Mul α := Equiv.mul e
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α := by
  let mul := e.mul
  apply e.injective.semigroup _; intros; 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semigroup β
mul : Mul α := Equiv.mul e
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
⊢ SemigroupWithZero α

Next tactic:
let mul := e.mul
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
⊢ SemigroupWithZero α

Next tactic:
let zero := e.zero
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  let zero := e.zero
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
zero : Zero α := Equiv.zero e
⊢ SemigroupWithZero α

Next tactic:
apply e.injective.semigroupWithZero _
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  let zero := e.zero
  apply e.injective.semigroupWithZero _ <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
zero : Zero α := Equiv.zero e
⊢ e 0 = 0

Next tactic:
intros
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  let zero := e.zero
  apply e.injective.semigroupWithZero _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
zero : Zero α := Equiv.zero e
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  let zero := e.zero
  apply e.injective.semigroupWithZero _ <;> intros <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
zero : Zero α := Equiv.zero e
⊢ e 0 = 0

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `SemigroupWithZero` across an `Equiv` -/
@[reducible]
protected def semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α := by
  let mul := e.mul
  let zero := e.zero
  apply e.injective.semigroupWithZero _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : SemigroupWithZero β
mul : Mul α := Equiv.mul e
zero : Zero α := Equiv.zero e
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α := by
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommSemigroup β
⊢ CommSemigroup α

Next tactic:
let mul := e.mul
/-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α := by
  let mul := e.mul
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommSemigroup β
mul : Mul α := Equiv.mul e
⊢ CommSemigroup α

Next tactic:
apply e.injective.commSemigroup _
/-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α := by
  let mul := e.mul
  apply e.injective.commSemigroup _; 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommSemigroup β
mul : Mul α := Equiv.mul e
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α := by
  let mul := e.mul
  apply e.injective.commSemigroup _; intros; 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommSemigroup β
mul : Mul α := Equiv.mul e
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
⊢ MulZeroClass α

Next tactic:
let zero := e.zero
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
⊢ MulZeroClass α

Next tactic:
let mul := e.mul
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  let mul := e.mul
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
mul : Mul α := Equiv.mul e
⊢ MulZeroClass α

Next tactic:
apply e.injective.mulZeroClass _
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  let mul := e.mul
  apply e.injective.mulZeroClass _ <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
mul : Mul α := Equiv.mul e
⊢ e 0 = 0

Next tactic:
intros
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  let mul := e.mul
  apply e.injective.mulZeroClass _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
mul : Mul α := Equiv.mul e
⊢ ∀ (a b : α), e (a * b) = e a * e b

Next tactic:
intros
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  let mul := e.mul
  apply e.injective.mulZeroClass _ <;> intros <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
mul : Mul α := Equiv.mul e
⊢ e 0 = 0

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `MulZeroClass` across an `Equiv` -/
@[reducible]
protected def mulZeroClass [MulZeroClass β] : MulZeroClass α := by
  let zero := e.zero
  let mul := e.mul
  apply e.injective.mulZeroClass _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroClass β
zero : Zero α := Equiv.zero e
mul : Mul α := Equiv.mul e
a✝ b✝ : α
⊢ e (a✝ * b✝) = e a✝ * e b✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `MulOneClass` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddZeroClass` across an `Equiv`"]
protected def mulOneClass [MulOneClass β] : MulOneClass α := by
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulOneClass β
⊢ MulOneClass α

Next tactic:
let one := e.one
/-- Transfer `MulOneClass` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddZeroClass` across an `Equiv`"]
protected def mulOneClass [MulOneClass β] : MulOneClass α := by
  let one := e.one
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulOneClass β
one : One α := Equiv.one e
⊢ MulOneClass α

Next tactic:
let mul := e.mul