l3lab/ntp-mathlib huggingface dataset:
/-- Transfer `NonUnitalSemiring` across an `Equiv` -/
@[reducible]
protected def nonUnitalSemiring [NonUnitalSemiring β] : NonUnitalSemiring α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let nsmul := e.smul ℕ
  apply e.injective.nonUnitalSemiring _ <;> intros <;> 

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

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

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

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `AddMonoidWithOne` across an `Equiv` -/
@[reducible]
protected def addMonoidWithOne [AddMonoidWithOne β] : AddMonoidWithOne α :=
  { e.addMonoid, e.one with
    natCast := fun n => e.symm n
    natCast_zero := e.injective (by 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : AddMonoidWithOne β
src✝¹ : AddMonoid α := Equiv.addMonoid e
src✝ : One α := Equiv.one e
⊢ e (NatCast.natCast 0) = e 0

Next tactic:
simp [zero_def]
/-- Transfer `AddMonoidWithOne` across an `Equiv` -/
@[reducible]
protected def addMonoidWithOne [AddMonoidWithOne β] : AddMonoidWithOne α :=
  { e.addMonoid, e.one with
    natCast := fun n => e.symm n
    natCast_zero := e.injective (by simp [zero_def])
    natCast_succ := fun n => e.injective (by 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : AddMonoidWithOne β
src✝¹ : AddMonoid α := Equiv.addMonoid e
src✝ : One α := Equiv.one e
n : ℕ
⊢ e (NatCast.natCast (n + 1)) = e (NatCast.natCast n + 1)

Next tactic:
simp [add_def, one_def]
/-- Transfer `AddGroupWithOne` across an `Equiv` -/
@[reducible]
protected def addGroupWithOne [AddGroupWithOne β] : AddGroupWithOne α :=
  { e.addMonoidWithOne,
    e.addGroup with
    intCast := fun n => e.symm n
    intCast_ofNat := fun n => by 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne α := Equiv.addMonoidWithOne e
src✝ : AddGroup α := Equiv.addGroup e
n : ℕ
⊢ IntCast.intCast ↑n = ↑n

Next tactic:
simp only [Int.cast_ofNat]
/-- Transfer `AddGroupWithOne` across an `Equiv` -/
@[reducible]
protected def addGroupWithOne [AddGroupWithOne β] : AddGroupWithOne α :=
  { e.addMonoidWithOne,
    e.addGroup with
    intCast := fun n => e.symm n
    intCast_ofNat := fun n => by simp only [Int.cast_ofNat]; 

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne α := Equiv.addMonoidWithOne e
src✝ : AddGroup α := Equiv.addGroup e
n : ℕ
⊢ e.symm ↑n = ↑n

Next tactic:
rfl
/-- Transfer `NonAssocSemiring` across an `Equiv` -/
@[reducible]
protected def nonAssocSemiring [NonAssocSemiring β] : NonAssocSemiring α := by
  

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

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

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

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

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ NonAssocSemiring α

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

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ e 0 = 0

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ e 1 = 1

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

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ ∀ (x y : α), e (x + y) = e x + e y

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

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

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

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ ∀ (x : α) (n : ℕ), e (n • x) = n • e x

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

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ ∀ (n : ℕ), e ↑n = ↑n

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

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ e 0 = 0

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

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ e 1 = 1

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

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
x✝ y✝ : α
⊢ e (x✝ + y✝) = e x✝ + e y✝

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

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

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

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
x✝ : α
n✝ : ℕ
⊢ e (n✝ • x✝) = n✝ • e x✝

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

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonAssocSemiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
n✝ : ℕ
⊢ e ↑n✝ = ↑n✝

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

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

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

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

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

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
⊢ Semiring α

Next tactic:
let npow := e.pow ℕ
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  

Proof state:
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ Semiring α

Next tactic:
apply e.injective.semiring _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 0 = 0

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x y : α), e (x + y) = e x + e y

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x y : α), e (x * y) = e x * e y

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (x : α) (n : ℕ), e (n • x) = n • e x

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

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

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> 

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ ∀ (n : ℕ), e ↑n = ↑n

Next tactic:
intros
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 0 = 0

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case one
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
⊢ e 1 = 1

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case add
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
x✝ y✝ : α
⊢ e (x✝ + y✝) = e x✝ + e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case mul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
x✝ y✝ : α
⊢ e (x✝ * y✝) = e x✝ * e y✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case nsmul
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
x✝ : α
n✝ : ℕ
⊢ e (n✝ • x✝) = n✝ • e x✝

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

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

Next tactic:
exact e.apply_symm_apply _
/-- Transfer `Semiring` across an `Equiv` -/
@[reducible]
protected def semiring [Semiring β] : Semiring α := by
  let mul := e.mul
  let add_monoid_with_one := e.addMonoidWithOne
  let npow := e.pow ℕ
  apply e.injective.semiring _ <;> intros <;> 

Proof state:
case nat_cast
α : Type u
β : Type v
e : α ≃ β
inst✝ : Semiring β
mul : Mul α := Equiv.mul e
add_monoid_with_one : AddMonoidWithOne α := Equiv.addMonoidWithOne e
npow : Pow α ℕ := Equiv.pow e ℕ
n✝ : ℕ
⊢ e ↑n✝ = ↑n✝

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

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

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

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

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

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

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

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

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

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

Next tactic:
apply e.injective.nonUnitalCommSemiring _
/-- Transfer `NonUnitalCommSemiring` across an `Equiv` -/
@[reducible]
protected def nonUnitalCommSemiring [NonUnitalCommSemiring β] : NonUnitalCommSemiring α := by
  let zero := e.zero
  let add := e.add
  let mul := e.mul
  let nsmul := e.smul ℕ
  apply e.injective.nonUnitalCommSemiring _ <;> 

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalCommSemiring β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
nsmul : SMul ℕ α := Equiv.smul e ℕ
⊢ e 0 = 0

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

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

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

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

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

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

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

Proof state:
case zero
α : Type u
β : Type v
e : α ≃ β
inst✝ : NonUnitalCommSemiring β
zero : Zero α := Equiv.zero e
add : Add α := Equiv.add e
mul : Mul α := Equiv.mul e
nsmul : SMul ℕ α := Equiv.smul e ℕ
⊢ e 0 = 0

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

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

Next tactic:
exact e.apply_symm_apply _