File: Mathlib/Logic/Equiv/TransferInstance.lean

full_name: Equiv.zero
code: /-- Transfer `One` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Zero` across an `Equiv`"]
protected def one [One β] : One α 
goal: Zero α

full_name: Equiv.one
code: /-- Transfer `One` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Zero` across an `Equiv`"]
protected def one [One β] : One α 
goal: One α

full_name: Equiv.one_def
code: @[to_additive]
theorem one_def [One β] :
    letI := e.one
    1 = e.symm 1 
goal: 1 = e.symm 1

full_name: Equiv.zero_def
code: @[to_additive]
theorem one_def [One β] :
    letI := e.one
    1 = e.symm 1 
goal: 0 = e.symm 0

full_name: Equiv.instZeroShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [One α] : One (Shrink.{v} α) 
goal: Zero (Shrink.{v, u} α)

full_name: Equiv.instOneShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [One α] : One (Shrink.{v} α) 
goal: One (Shrink.{v, u} α)

full_name: Equiv.mul
code: /-- Transfer `Mul` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Add` across an `Equiv`"]
protected def mul [Mul β] : Mul α 
goal: Mul α

full_name: Equiv.add
code: /-- Transfer `Mul` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Add` across an `Equiv`"]
protected def mul [Mul β] : Mul α 
goal: Add α

full_name: Equiv.mul_def
code: @[to_additive]
theorem mul_def [Mul β] (x y : α) :
    letI := Equiv.mul e
    x * y = e.symm (e x * e y) 
goal: x * y = e.symm (e x * e y)

full_name: Equiv.add_def
code: @[to_additive]
theorem mul_def [Mul β] (x y : α) :
    letI := Equiv.mul e
    x * y = e.symm (e x * e y) 
goal: x + y = e.symm (e x + e y)

full_name: Equiv.instMulShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Mul α] : Mul (Shrink.{v} α) 
goal: Mul (Shrink.{v, u} α)

full_name: Equiv.instAddShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Mul α] : Mul (Shrink.{v} α) 
goal: Add (Shrink.{v, u} α)

full_name: Equiv.div
code: /-- Transfer `Div` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Sub` across an `Equiv`"]
protected def div [Div β] : Div α 
goal: Div α

full_name: Equiv.sub
code: /-- Transfer `Div` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Sub` across an `Equiv`"]
protected def div [Div β] : Div α 
goal: Sub α

full_name: Equiv.div_def
code: @[to_additive]
theorem div_def [Div β] (x y : α) :
    letI := Equiv.div e
    x / y = e.symm (e x / e y) 
goal: x / y = e.symm (e x / e y)

full_name: Equiv.sub_def
code: @[to_additive]
theorem div_def [Div β] (x y : α) :
    letI := Equiv.div e
    x / y = e.symm (e x / e y) 
goal: x - y = e.symm (e x - e y)

full_name: Equiv.instDivShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Div α] : Div (Shrink.{v} α) 
goal: Div (Shrink.{v, u} α)

full_name: Equiv.instSubShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Div α] : Div (Shrink.{v} α) 
goal: Sub (Shrink.{v, u} α)

full_name: Equiv.Neg
code: /-- Transfer `Inv` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Neg` across an `Equiv`"]
protected def Inv [Inv β] : Inv α 
goal: Neg α

full_name: Equiv.Inv
code: /-- Transfer `Inv` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `Neg` across an `Equiv`"]
protected def Inv [Inv β] : Inv α 
goal: Inv α

full_name: Equiv.neg_def
code: @[to_additive]
theorem inv_def [Inv β] (x : α) :
    letI := Equiv.Inv e
    x⁻¹ = e.symm (e x)⁻¹ 
goal: -x = e.symm (-e x)

full_name: Equiv.inv_def
code: @[to_additive]
theorem inv_def [Inv β] (x : α) :
    letI := Equiv.Inv e
    x⁻¹ = e.symm (e x)⁻¹ 
goal: x⁻¹ = e.symm (e x)⁻¹

full_name: Equiv.instInvShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Inv α] : Inv (Shrink.{v} α) 
goal: Inv (Shrink.{v, u} α)

full_name: Equiv.instNegShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Inv α] : Inv (Shrink.{v} α) 
goal: Neg (Shrink.{v, u} α)

full_name: Equiv.smul
code: /-- Transfer `SMul` across an `Equiv` -/
protected abbrev smul (R : Type*) [SMul R β] : SMul R α 
goal: SMul R α

full_name: Equiv.smul_def
code: theorem smul_def {R : Type*} [SMul R β] (r : R) (x : α) :
    letI := e.smul R
    r • x = e.symm (r • e x) 
goal: r • x = e.symm (r • e x)

full_name: Equiv.instSMulShrink
code: noncomputable instance [Small.{v} α] (R : Type*) [SMul R α] : SMul R (Shrink.{v} α) 
goal: SMul R (Shrink.{v, u} α)

full_name: Equiv.pow
code: /-- Transfer `Pow` across an `Equiv` -/
@[reducible, to_additive existing smul]
protected def pow (N : Type*) [Pow β N] : Pow α N 
goal: Pow α N

full_name: Equiv.pow_def
code: theorem pow_def {N : Type*} [Pow β N] (n : N) (x : α) :
    letI := e.pow N
    x ^ n = e.symm (e x ^ n) 
goal: x ^ n = e.symm (e x ^ n)

full_name: Equiv.instPowShrink
code: noncomputable instance [Small.{v} α] (N : Type*) [Pow α N] : Pow (Shrink.{v} α) N 
goal: Pow (Shrink.{v, u} α) N

full_name: Equiv.mulEquiv
code: /-- 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
    α ≃* β 
goal: let mul := e.mul;
α ≃* β

full_name: Equiv.addEquiv
code: /-- 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
    α ≃* β 
goal: let mul := e.add;
α ≃+ β

full_name: Equiv.addEquiv_apply
code: @[to_additive (attr := simp)]
theorem mulEquiv_apply (e : α ≃ β) [Mul β] (a : α) : (mulEquiv e) a = e a 
goal: e.addEquiv a = e a

full_name: Equiv.mulEquiv_apply
code: @[to_additive (attr := simp)]
theorem mulEquiv_apply (e : α ≃ β) [Mul β] (a : α) : (mulEquiv e) a = e a 
goal: e.mulEquiv a = e a

full_name: Equiv.mulEquiv_symm_apply
code: @[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b 
goal: (MulEquiv.symm e.mulEquiv) b = e.symm b

full_name: Equiv.addEquiv_symm_apply
code: @[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b 
goal: (AddEquiv.symm e.addEquiv) b = e.symm b

full_name: Shrink.mulEquiv
code: /-- Shrink `α` to a smaller universe preserves multiplication. -/
@[to_additive "Shrink `α` to a smaller universe preserves addition."]
noncomputable def _root_.Shrink.mulEquiv [Small.{v} α] [Mul α] : Shrink.{v} α ≃* α 
goal: Shrink.{v, u} α ≃* α

full_name: Shrink.addEquiv
code: /-- Shrink `α` to a smaller universe preserves multiplication. -/
@[to_additive "Shrink `α` to a smaller universe preserves addition."]
noncomputable def _root_.Shrink.mulEquiv [Small.{v} α] [Mul α] : Shrink.{v} α ≃* α 
goal: Shrink.{v, u} α ≃+ α

full_name: Equiv.ringEquiv
code: /-- 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 α ≃+* β 
goal: let add := e.add;
let mul := e.mul;
α ≃+* β

full_name: Equiv.ringEquiv_apply
code: @[simp]
theorem ringEquiv_apply (e : α ≃ β) [Add β] [Mul β] (a : α) : (ringEquiv e) a = e a 
goal: e.ringEquiv a = e a

full_name: Equiv.ringEquiv_symm_apply
code: 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 
goal: (RingEquiv.symm e.ringEquiv) b = e.symm b

full_name: Shrink.ringEquiv
code: /-- Shrink `α` to a smaller universe preserves ring structure. -/
noncomputable def _root_.Shrink.ringEquiv [Small.{v} α] [Ring α] : Shrink.{v} α ≃+* α 
goal: Shrink.{v, u} α ≃+* α

full_name: Equiv.addSemigroup
code: /-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α 
goal: AddSemigroup α

full_name: Equiv.semigroup
code: /-- Transfer `Semigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `add_semigroup` across an `Equiv`"]
protected def semigroup [Semigroup β] : Semigroup α 
goal: Semigroup α

full_name: Equiv.instSemigroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Semigroup α] : Semigroup (Shrink.{v} α) 
goal: Semigroup (Shrink.{v, u} α)

full_name: Equiv.instAddSemigroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Semigroup α] : Semigroup (Shrink.{v} α) 
goal: AddSemigroup (Shrink.{v, u} α)

full_name: Equiv.semigroupWithZero
code: /-- Transfer `SemigroupWithZero` across an `Equiv` -/
protected abbrev semigroupWithZero [SemigroupWithZero β] : SemigroupWithZero α 
goal: SemigroupWithZero α

full_name: Equiv.instSemigroupWithZeroShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [SemigroupWithZero α] : SemigroupWithZero (Shrink.{v} α) 
goal: SemigroupWithZero (Shrink.{v, u} α)

full_name: Equiv.instAddSemigroupWithZeroShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [SemigroupWithZero α] : SemigroupWithZero (Shrink.{v} α) 
goal: SemigroupWithZero (Shrink.{v, u} α)

full_name: Equiv.addCommSemigroup
code: /-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α 
goal: AddCommSemigroup α

full_name: Equiv.commSemigroup
code: /-- Transfer `CommSemigroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommSemigroup` across an `Equiv`"]
protected def commSemigroup [CommSemigroup β] : CommSemigroup α 
goal: CommSemigroup α

full_name: Equiv.instCommSemigroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommSemigroup α] : CommSemigroup (Shrink.{v} α) 
goal: CommSemigroup (Shrink.{v, u} α)

full_name: Equiv.instAddCommSemigroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommSemigroup α] : CommSemigroup (Shrink.{v} α) 
goal: AddCommSemigroup (Shrink.{v, u} α)

full_name: Equiv.mulZeroClass
code: /-- Transfer `MulZeroClass` across an `Equiv` -/
protected abbrev mulZeroClass [MulZeroClass β] : MulZeroClass α 
goal: MulZeroClass α

full_name: Equiv.instMulZeroClassShrink
code: noncomputable instance [Small.{v} α] [MulZeroClass α] : MulZeroClass (Shrink.{v} α) 
goal: MulZeroClass (Shrink.{v, u} α)

full_name: Equiv.mulOneClass
code: /-- Transfer `MulOneClass` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddZeroClass` across an `Equiv`"]
protected def mulOneClass [MulOneClass β] : MulOneClass α 
goal: MulOneClass α

full_name: Equiv.addZeroClass
code: /-- Transfer `MulOneClass` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddZeroClass` across an `Equiv`"]
protected def mulOneClass [MulOneClass β] : MulOneClass α 
goal: AddZeroClass α

full_name: Equiv.instMulOneClassShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [MulOneClass α] : MulOneClass (Shrink.{v} α) 
goal: MulOneClass (Shrink.{v, u} α)

full_name: Equiv.instAddZeroClassShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [MulOneClass α] : MulOneClass (Shrink.{v} α) 
goal: AddZeroClass (Shrink.{v, u} α)

full_name: Equiv.mulZeroOneClass
code: /-- Transfer `MulZeroOneClass` across an `Equiv` -/
protected abbrev mulZeroOneClass [MulZeroOneClass β] : MulZeroOneClass α 
goal: MulZeroOneClass α

full_name: Equiv.instMulZeroOneClassShrink
code: noncomputable instance [Small.{v} α] [MulZeroOneClass α] : MulZeroOneClass (Shrink.{v} α) 
goal: MulZeroOneClass (Shrink.{v, u} α)

full_name: Equiv.monoid
code: /-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α 
goal: Monoid α

full_name: Equiv.addMonoid
code: /-- Transfer `Monoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddMonoid` across an `Equiv`"]
protected def monoid [Monoid β] : Monoid α 
goal: AddMonoid α

full_name: Equiv.instAddMonoidShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Monoid α] : Monoid (Shrink.{v} α) 
goal: AddMonoid (Shrink.{v, u} α)

full_name: Equiv.instMonoidShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Monoid α] : Monoid (Shrink.{v} α) 
goal: Monoid (Shrink.{v, u} α)

full_name: Equiv.addCommMonoid
code: /-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α 
goal: AddCommMonoid α

full_name: Equiv.commMonoid
code: /-- Transfer `CommMonoid` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommMonoid` across an `Equiv`"]
protected def commMonoid [CommMonoid β] : CommMonoid α 
goal: CommMonoid α

full_name: Equiv.instCommMonoidShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommMonoid α] : CommMonoid (Shrink.{v} α) 
goal: CommMonoid (Shrink.{v, u} α)

full_name: Equiv.instAddCommMonoidShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommMonoid α] : CommMonoid (Shrink.{v} α) 
goal: AddCommMonoid (Shrink.{v, u} α)

full_name: Equiv.addGroup
code: /-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α 
goal: AddGroup α

full_name: Equiv.group
code: /-- Transfer `Group` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddGroup` across an `Equiv`"]
protected def group [Group β] : Group α 
goal: Group α

full_name: Equiv.instGroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Group α] : Group (Shrink.{v} α) 
goal: Group (Shrink.{v, u} α)

full_name: Equiv.instAddGroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [Group α] : Group (Shrink.{v} α) 
goal: AddGroup (Shrink.{v, u} α)

full_name: Equiv.addCommGroup
code: /-- Transfer `CommGroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommGroup` across an `Equiv`"]
protected def commGroup [CommGroup β] : CommGroup α 
goal: AddCommGroup α

full_name: Equiv.commGroup
code: /-- Transfer `CommGroup` across an `Equiv` -/
@[to_additive (attr := reducible) "Transfer `AddCommGroup` across an `Equiv`"]
protected def commGroup [CommGroup β] : CommGroup α 
goal: CommGroup α

full_name: Equiv.instCommGroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommGroup α] : CommGroup (Shrink.{v} α) 
goal: CommGroup (Shrink.{v, u} α)

full_name: Equiv.instAddCommGroupShrink
code: @[to_additive]
noncomputable instance [Small.{v} α] [CommGroup α] : CommGroup (Shrink.{v} α) 
goal: AddCommGroup (Shrink.{v, u} α)

full_name: Equiv.nonUnitalNonAssocSemiring
code: /-- Transfer `NonUnitalNonAssocSemiring` across an `Equiv` -/
protected abbrev nonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring β] :
    NonUnitalNonAssocSemiring α 
goal: NonUnitalNonAssocSemiring α

full_name: Equiv.instNonUnitalNonAssocSemiringShrink
code: noncomputable instance [Small.{v} α] [NonUnitalNonAssocSemiring α] :
    NonUnitalNonAssocSemiring (Shrink.{v} α) 
goal: NonUnitalNonAssocSemiring (Shrink.{v, u} α)

full_name: Equiv.nonUnitalSemiring
code: /-- Transfer `NonUnitalSemiring` across an `Equiv` -/
protected abbrev nonUnitalSemiring [NonUnitalSemiring β] : NonUnitalSemiring α 
goal: NonUnitalSemiring α

full_name: Equiv.instNonUnitalSemiringShrink
code: noncomputable instance [Small.{v} α] [NonUnitalSemiring α] : NonUnitalSemiring (Shrink.{v} α) 
goal: NonUnitalSemiring (Shrink.{v, u} α)

full_name: Equiv.addMonoidWithOne
code: /-- Transfer `AddMonoidWithOne` across an `Equiv` -/
protected abbrev addMonoidWithOne [AddMonoidWithOne β] : AddMonoidWithOne α 
goal: AddMonoidWithOne α

full_name: Equiv.instAddMonoidWithOneShrink
code: noncomputable instance [Small.{v} α] [AddMonoidWithOne α] : AddMonoidWithOne (Shrink.{v} α) 
goal: AddMonoidWithOne (Shrink.{v, u} α)

full_name: Equiv.addGroupWithOne
code: /-- Transfer `AddGroupWithOne` across an `Equiv` -/
protected abbrev addGroupWithOne [AddGroupWithOne β] : AddGroupWithOne α 
goal: AddGroupWithOne α

full_name: Equiv.instAddGroupWithOneShrink
code: noncomputable instance [Small.{v} α] [AddGroupWithOne α] : AddGroupWithOne (Shrink.{v} α) 
goal: AddGroupWithOne (Shrink.{v, u} α)

full_name: Equiv.nonAssocSemiring
code: /-- Transfer `NonAssocSemiring` across an `Equiv` -/
protected abbrev nonAssocSemiring [NonAssocSemiring β] : NonAssocSemiring α 
goal: NonAssocSemiring α

full_name: Equiv.instNonAssocSemiringShrink
code: noncomputable instance [Small.{v} α] [NonAssocSemiring α] : NonAssocSemiring (Shrink.{v} α) 
goal: NonAssocSemiring (Shrink.{v, u} α)

full_name: Equiv.semiring
code: /-- Transfer `Semiring` across an `Equiv` -/
protected abbrev semiring [Semiring β] : Semiring α 
goal: Semiring α

full_name: Equiv.instSemiringShrink
code: noncomputable instance [Small.{v} α] [Semiring α] : Semiring (Shrink.{v} α) 
goal: Semiring (Shrink.{v, u} α)

full_name: Equiv.nonUnitalCommSemiring
code: /-- Transfer `NonUnitalCommSemiring` across an `Equiv` -/
protected abbrev nonUnitalCommSemiring [NonUnitalCommSemiring β] : NonUnitalCommSemiring α 
goal: NonUnitalCommSemiring α

full_name: Equiv.instNonUnitalCommSemiringShrink
code: noncomputable instance [Small.{v} α] [NonUnitalCommSemiring α] :
    NonUnitalCommSemiring (Shrink.{v} α) 
goal: NonUnitalCommSemiring (Shrink.{v, u} α)

full_name: Equiv.commSemiring
code: /-- Transfer `CommSemiring` across an `Equiv` -/
protected abbrev commSemiring [CommSemiring β] : CommSemiring α 
goal: CommSemiring α

full_name: Equiv.instCommSemiringShrink
code: noncomputable instance [Small.{v} α] [CommSemiring α] : CommSemiring (Shrink.{v} α) 
goal: CommSemiring (Shrink.{v, u} α)

full_name: Equiv.nonUnitalNonAssocRing
code: /-- Transfer `NonUnitalNonAssocRing` across an `Equiv` -/
protected abbrev nonUnitalNonAssocRing [NonUnitalNonAssocRing β] : NonUnitalNonAssocRing α 
goal: NonUnitalNonAssocRing α

full_name: Equiv.instNonUnitalNonAssocRingShrink
code: noncomputable instance [Small.{v} α] [NonUnitalNonAssocRing α] :
    NonUnitalNonAssocRing (Shrink.{v} α) 
goal: NonUnitalNonAssocRing (Shrink.{v, u} α)

full_name: Equiv.nonUnitalRing
code: /-- Transfer `NonUnitalRing` across an `Equiv` -/
protected abbrev nonUnitalRing [NonUnitalRing β] : NonUnitalRing α 
goal: NonUnitalRing α

full_name: Equiv.instNonUnitalRingShrink
code: noncomputable instance [Small.{v} α] [NonUnitalRing α] : NonUnitalRing (Shrink.{v} α) 
goal: NonUnitalRing (Shrink.{v, u} α)

full_name: Equiv.nonAssocRing
code: /-- Transfer `NonAssocRing` across an `Equiv` -/
protected abbrev nonAssocRing [NonAssocRing β] : NonAssocRing α 
goal: NonAssocRing α

full_name: Equiv.instNonAssocRingShrink
code: noncomputable instance [Small.{v} α] [NonAssocRing α] : NonAssocRing (Shrink.{v} α) 
goal: NonAssocRing (Shrink.{v, u} α)

full_name: Equiv.ring
code: /-- Transfer `Ring` across an `Equiv` -/
protected abbrev ring [Ring β] : Ring α 
goal: Ring α

full_name: Equiv.instRingShrink
code: noncomputable instance [Small.{v} α] [Ring α] : Ring (Shrink.{v} α) 
goal: Ring (Shrink.{v, u} α)

full_name: Equiv.nonUnitalCommRing
code: /-- Transfer `NonUnitalCommRing` across an `Equiv` -/
protected abbrev nonUnitalCommRing [NonUnitalCommRing β] : NonUnitalCommRing α 
goal: NonUnitalCommRing α

full_name: Equiv.instNonUnitalCommRingShrink
code: noncomputable instance [Small.{v} α] [NonUnitalCommRing α] : NonUnitalCommRing (Shrink.{v} α) 
goal: NonUnitalCommRing (Shrink.{v, u} α)

full_name: Equiv.commRing
code: /-- Transfer `CommRing` across an `Equiv` -/
protected abbrev commRing [CommRing β] : CommRing α 
goal: CommRing α

full_name: Equiv.instCommRingShrink
code: noncomputable instance [Small.{v} α] [CommRing α] : CommRing (Shrink.{v} α) 
goal: CommRing (Shrink.{v, u} α)

full_name: Equiv.nontrivial
code: /-- Transfer `Nontrivial` across an `Equiv` -/
protected theorem nontrivial [Nontrivial β] : Nontrivial α 
goal: Nontrivial α

full_name: Equiv.instNontrivialShrink
code: noncomputable instance [Small.{v} α] [Nontrivial α] : Nontrivial (Shrink.{v} α) 
goal: Nontrivial (Shrink.{v, u} α)

full_name: Equiv.isDomain
code: /-- Transfer `IsDomain` across an `Equiv` -/
protected theorem isDomain [Ring α] [Ring β] [IsDomain β] (e : α ≃+* β) : IsDomain α 
goal: IsDomain α

full_name: Equiv.instIsDomainShrink
code: noncomputable instance [Small.{v} α] [Ring α] [IsDomain α] : IsDomain (Shrink.{v} α) 
goal: IsDomain (Shrink.{v, u} α)

full_name: Equiv.nnratCast
code: /-- Transfer `NNRatCast` across an `Equiv` -/
protected abbrev nnratCast [NNRatCast β] : NNRatCast α 
goal: NNRatCast α

full_name: Equiv.ratCast
code: /-- Transfer `RatCast` across an `Equiv` -/
protected abbrev ratCast [RatCast β] : RatCast α 
goal: RatCast α

full_name: Shrink.instNNRatCast
code: noncomputable instance _root_.Shrink.instNNRatCast [Small.{v} α] [NNRatCast α] :
    NNRatCast (Shrink.{v} α) 
goal: NNRatCast (Shrink.{v, u} α)

full_name: Shrink.instRatCast
code: noncomputable instance _root_.Shrink.instRatCast [Small.{v} α] [RatCast α] :
    RatCast (Shrink.{v} α) 
goal: RatCast (Shrink.{v, u} α)

full_name: Equiv.divisionRing
code: /-- Transfer `DivisionRing` across an `Equiv` -/
protected abbrev divisionRing [DivisionRing β] : DivisionRing α 
goal: DivisionRing α

full_name: Equiv.instDivisionRingShrink
code: noncomputable instance [Small.{v} α] [DivisionRing α] : DivisionRing (Shrink.{v} α) 
goal: DivisionRing (Shrink.{v, u} α)

full_name: Equiv.field
code: /-- Transfer `Field` across an `Equiv` -/
protected abbrev field [Field β] : Field α 
goal: Field α

full_name: Equiv.instFieldShrink
code: noncomputable instance [Small.{v} α] [Field α] : Field (Shrink.{v} α) 
goal: Field (Shrink.{v, u} α)

full_name: Equiv.mulAction
code: /-- Transfer `MulAction` across an `Equiv` -/
protected abbrev mulAction (e : α ≃ β) [MulAction R β] : MulAction R α 
goal: MulAction R α

full_name: Equiv.instMulActionShrink
code: noncomputable instance [Small.{v} α] [MulAction R α] : MulAction R (Shrink.{v} α) 
goal: MulAction R (Shrink.{v, u} α)

full_name: Equiv.distribMulAction
code: /-- Transfer `DistribMulAction` across an `Equiv` -/
protected abbrev distribMulAction (e : α ≃ β) [AddCommMonoid β] :
    letI := Equiv.addCommMonoid e
    ∀ [DistribMulAction R β], DistribMulAction R α 
goal: DistribMulAction R α

full_name: Equiv.instDistribMulActionShrink
code: noncomputable instance [Small.{v} α] [AddCommMonoid α] [DistribMulAction R α] :
    DistribMulAction R (Shrink.{v} α) 
goal: DistribMulAction R (Shrink.{v, u} α)

full_name: Equiv.module
code: /-- Transfer `Module` across an `Equiv` -/
protected abbrev module (e : α ≃ β) [AddCommMonoid β] :
    let addCommMonoid := Equiv.addCommMonoid e
    ∀ [Module R β], Module R α 
goal: let addCommMonoid := e.addCommMonoid;
[inst : Module R β] → Module R α

full_name: Equiv.instModuleShrink
code: noncomputable instance [Small.{v} α] [AddCommMonoid α] [Module R α] : Module R (Shrink.{v} α) 
goal: Module R (Shrink.{v, u} α)

full_name: Equiv.linearEquiv
code: /-- An equivalence `e : α ≃ β` gives a linear equivalence `α ≃ₗ[R] β`
where the `R`-module structure on `α` is
the one obtained by transporting an `R`-module structure on `β` back along `e`.
-/
def linearEquiv (e : α ≃ β) [AddCommMonoid β] [Module R β] : by
    let addCommMonoid := Equiv.addCommMonoid e
    let module := Equiv.module R e
    exact α ≃ₗ[R] β 
goal: let addCommMonoid := e.addCommMonoid;
let module := Equiv.module R e;
α ≃ₗ[R] β

full_name: Shrink.linearEquiv_symm_apply
code: /-- Shrink `α` to a smaller universe preserves module structure. -/
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α 
goal: ∀ (a : α), (Shrink.linearEquiv α R).symm a = (AddEquiv.symm (equivShrink α).symm.addEquiv) a

full_name: Shrink.linearEquiv_apply
code: /-- Shrink `α` to a smaller universe preserves module structure. -/
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α 
goal: ∀ (a : Shrink.{v, u} α), (Shrink.linearEquiv α R) a = (equivShrink α).symm a

full_name: Shrink.linearEquiv
code: /-- Shrink `α` to a smaller universe preserves module structure. -/
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α 
goal: Shrink.{v, u} α ≃ₗ[R] α

full_name: Equiv.algebra
code: /-- Transfer `Algebra` across an `Equiv` -/
protected abbrev algebra (e : α ≃ β) [Semiring β] :
    let semiring := Equiv.semiring e
    ∀ [Algebra R β], Algebra R α 
goal: let semiring := e.semiring;
[inst : Algebra R β] → Algebra R α

full_name: Equiv.algebraMap_def
code: lemma algebraMap_def (e : α ≃ β) [Semiring β] [Algebra R β] (r : R) :
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    (algebraMap R α) r = e.symm ((algebraMap R β) r) 
goal: let semiring := e.semiring;
let algebra := Equiv.algebra R e;
(algebraMap R α) r = e.symm ((algebraMap R β) r)

full_name: Equiv.instAlgebraShrink
code: noncomputable instance [Small.{v} α] [Semiring α] [Algebra R α] :
    Algebra R (Shrink.{v} α) 
goal: Algebra R (Shrink.{v, u} α)

full_name: Equiv.algEquiv
code: /-- An equivalence `e : α ≃ β` gives an algebra equivalence `α ≃ₐ[R] β`
where the `R`-algebra structure on `α` is
the one obtained by transporting an `R`-algebra structure on `β` back along `e`.
-/
def algEquiv (e : α ≃ β) [Semiring β] [Algebra R β] : by
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    exact α ≃ₐ[R] β 
goal: let semiring := e.semiring;
let algebra := Equiv.algebra R e;
α ≃ₐ[R] β

full_name: Equiv.algEquiv_apply
code: @[simp]
theorem algEquiv_apply (e : α ≃ β) [Semiring β] [Algebra R β] (a : α) : (algEquiv R e) a = e a 
goal: (Equiv.algEquiv R e) a = e a

full_name: Equiv.algEquiv_symm_apply
code: theorem algEquiv_symm_apply (e : α ≃ β) [Semiring β] [Algebra R β] (b : β) : by
    letI := Equiv.semiring e
    letI := Equiv.algebra R e
    exact (algEquiv R e).symm b = e.symm b 
goal: (AlgEquiv.symm (Equiv.algEquiv R e)) b = e.symm b

full_name: Shrink.algEquiv_apply
code: /-- Shrink `α` to a smaller universe preserves algebra structure. -/
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α 
goal: ∀ (a : Shrink.{v, u} α), (Shrink.algEquiv α R) a = (equivShrink α).symm a

full_name: Shrink.algEquiv
code: /-- Shrink `α` to a smaller universe preserves algebra structure. -/
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α 
goal: Shrink.{v, u} α ≃ₐ[R] α

full_name: Shrink.algEquiv_symm_apply
code: /-- Shrink `α` to a smaller universe preserves algebra structure. -/
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α 
goal: ∀ (a : α), (Shrink.algEquiv α R).symm a = (equivShrink α) a

full_name: Finite.exists_type_zero_nonempty_mulEquiv
code: /-- Any finite group in universe `u` is equivalent to some finite group in universe `0`. -/
lemma exists_type_zero_nonempty_mulEquiv (G : Type u) [Group G] [Finite G] :
    ∃ (G' : Type) (_ : Group G') (_ : Fintype G'), Nonempty (G ≃* G') 
goal: ∃ G' x x_1, Nonempty (G ≃* G')