l3lab/ntp-mathlib huggingface dataset:
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  

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

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

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

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

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

Next tactic:
let neg := e.Neg
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
⊢ NonUnitalRing α

Next tactic:
let sub := e.sub
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
⊢ NonUnitalRing α

Next tactic:
let nsmul := e.smul ℕ
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
⊢ NonUnitalRing α

Next tactic:
let zsmul := e.smul ℤ
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ NonUnitalRing α

Next tactic:
apply e.injective.nonUnitalRing _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ e 0 = 0

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x y : α), e (x + y) = e x + e y

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case neg
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x : α), e (-x) = -e x

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case sub
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x y : α), e (x - y) = e x - e y

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x : α) (n : ℕ), e (n • x) = n • e x

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> 

Proof state:
case gsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ ∀ (x : α) (n : ℤ), e (n • x) = n • e x

Next tactic:
intros
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
⊢ e 0 = 0

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ y✝ : α
⊢ e (x✝ + y✝) = e x✝ + e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case neg
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ : α
⊢ e (-x✝) = -e x✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case sub
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ y✝ : α
⊢ e (x✝ - y✝) = e x✝ - e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ : α
n✝ : ℕ
⊢ e (n✝ • x✝) = n✝ • e x✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `NonUnitalRing` across an `Equiv` -/
@[reducible]
protected def nonUnitalRing [NonUnitalRing β] : NonUnitalRing α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let neg := e.Neg
  let sub := e.sub
  let nsmul := e.smul ℕ
  let zsmul := e.smul ℤ
  apply e.injective.nonUnitalRing _ <;> intros <;> 

Proof state:
case gsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalRing β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
neg : Neg α := Equiv.Neg e
sub : Sub α := Equiv.sub e
nsmul : SMul ℕ α := Equiv.smul e ℕ
zsmul : SMul ℤ α := Equiv.smul e ℤ
x✝ : α
n✝ : ℤ
⊢ e (n✝ • x✝) = n✝ • e x✝

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

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

Next tactic:
let add_group_with_one := e.addGroupWithOne
/-- Transfer `NonAssocRing` across an `Equiv` -/
@[reducible]
protected def nonAssocRing [NonAssocRing β] : NonAssocRing α := by
  let add_group_with_one := e.addGroupWithOne
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
⊢ NonAssocRing α

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

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ NonAssocRing α

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

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ e 0 = 0

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ e 1 = 1

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

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (x y : α), e (x + y) = e x + e y

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

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

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

Proof state:
case neg
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (x : α), e (-x) = -e x

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

Proof state:
case sub
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (x y : α), e (x - y) = e x - e y

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

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (x : α) (n : ℕ), e (n • x) = n • e x

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

Proof state:
case gsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (x : α) (n : ℤ), e (n • x) = n • e x

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

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (n : ℕ), e ↑n = ↑n

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

Proof state:
case int_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ ∀ (n : ℤ), e ↑n = ↑n

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

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ e 0 = 0

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
⊢ e 1 = 1

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

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ y✝ : α
⊢ e (x✝ + y✝) = e x✝ + e y✝

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

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

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

Proof state:
case neg
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ : α
⊢ e (-x✝) = -e x✝

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

Proof state:
case sub
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ y✝ : α
⊢ e (x✝ - y✝) = e x✝ - e y✝

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

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ : α
n✝ : ℕ
⊢ e (n✝ • x✝) = n✝ • e x✝

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

Proof state:
case gsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
x✝ : α
n✝ : ℤ
⊢ e (n✝ • x✝) = n✝ • e x✝

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

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
n✝ : ℕ
⊢ e ↑n✝ = ↑n✝

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

Proof state:
case int_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocRing β
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
mul : Mul α := Equiv.mul e
n✝ : ℤ
⊢ e ↑n✝ = ↑n✝

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

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

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

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

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

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Ring β
mul : Mul α := Equiv.mul e
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
⊢ Ring α

Next tactic:
let npow := e.pow ℕ
/-- Transfer `Ring` across an `Equiv` -/
@[reducible]
protected def ring [Ring β] : Ring α := by
  let mul := e.mul
  let add_group_with_one := e.addGroupWithOne
  let npow := e.pow ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Ring β
mul : Mul α := Equiv.mul e
add_group_with_one : AddGroupWithOne α := Equiv.addGroupWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ Ring α

Next tactic:
apply e.injective.ring _