l3lab/ntp-mathlib huggingface dataset:
/-- Transfer `MulOneClass` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddZeroClass` across an `Equiv`"]
protected def mulOneClass [MulOneClass β] : MulOneClass α := by
  let one := e.one
  let mul := e.mul
  

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

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

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

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

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

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

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

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
  let one := e.one
  let mul := e.mul
  apply e.injective.mulOneClass _ <;> intros <;> 

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

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

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

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

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

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

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

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

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

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

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

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroOneClass β
zero : Zero α := Equiv.zero e
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
⊢ e 1 = 1

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

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

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

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

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : MulZeroOneClass β
zero : Zero α := Equiv.zero e
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
⊢ e 1 = 1

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

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

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

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

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

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

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

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

Next tactic:
let pow := e.pow ℕ
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ Monoid α

Next tactic:
apply e.injective.monoid _
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
intros
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> 

Proof state:
case npow
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x : α) (n : ℕ), e (x ^ n) = e x ^ n

Next tactic:
intros
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> intros <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.monoid _ <;> intros <;> 

Proof state:
case npow
α : Type u
β : Type v
e : α ≃ β
inst✝ : Monoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
x✝ : α
n✝ : ℕ
⊢ e (x✝ ^ n✝) = e x✝ ^ n✝

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

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

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

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

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

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

Next tactic:
let pow := e.pow ℕ
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ CommMonoid α

Next tactic:
apply e.injective.commMonoid _
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
intros
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> 

Proof state:
case npow
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x : α) (n : ℕ), e (x ^ n) = e x ^ n

Next tactic:
intros
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> intros <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α := by
  let one := e.one
  let mul := e.mul
  let pow := e.pow ℕ
  apply e.injective.commMonoid _ <;> intros <;> 

Proof state:
case npow
α : Type u
β : Type v
e : α ≃ β
inst✝ : CommMonoid β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
pow : Pow α ℕ := Equiv.pow e ℕ
x✝ : α
n✝ : ℕ
⊢ e (x✝ ^ n✝) = e x✝ ^ n✝

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

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

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

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

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

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

Next tactic:
let inv := e.Inv
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
⊢ Group α

Next tactic:
let div := e.div
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
⊢ Group α

Next tactic:
let npow := e.pow ℕ
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ Group α

Next tactic:
let zpow := e.pow ℤ
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ Group α

Next tactic:
apply e.injective.group _
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ e 1 = 1

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case inv
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ ∀ (x : α), e x⁻¹ = (e x)⁻¹

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case div
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ ∀ (x y : α), e (x / y) = e x / e y

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case npow
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ ∀ (x : α) (n : ℕ), e (x ^ n) = e x ^ n

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> 

Proof state:
case zpow
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ ∀ (x : α) (n : ℤ), e (x ^ n) = e x ^ n

Next tactic:
intros
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> intros <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
⊢ e 1 = 1

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> intros <;> 

Proof state:
case inv
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
x✝ : α
⊢ e x✝⁻¹ = (e x✝)⁻¹

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α := by
  let one := e.one
  let mul := e.mul
  let inv := e.Inv
  let div := e.div
  let npow := e.pow ℕ
  let zpow := e.pow ℤ
  apply e.injective.group _ <;> intros <;> 

Proof state:
case div
α : Type u
β : Type v
e : α ≃ β
inst✝ : Group β
one : One α := Equiv.one e
mul : Mul α := Equiv.mul e
inv : Inv α := Equiv.Inv e
div : Div α := Equiv.div e
npow : Pow α ℕ := Equiv.pow e ℕ
zpow : Pow α ℤ := Equiv.pow e ℤ
x✝ y✝ : α
⊢ e (x✝ / y✝) = e x✝ / e y✝

Next tactic:
exact e.apply_symm_apply _