ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Ring/Subring/Order.lean

full_name: SubringClass.toOrderedRing
code: /-- A subring of an `OrderedRing` is an `OrderedRing`. -/
instance (priority := 75) toOrderedRing [OrderedRing R] [SubringClass S R] :
    OrderedRing s 
goal: OrderedRing ↥s

full_name: SubringClass.toOrderedCommRing
code: /-- A subring of an `OrderedCommRing` is an `OrderedCommRing`. -/
instance (priority := 75) toOrderedCommRing [OrderedCommRing R] [SubringClass S R] :
    OrderedCommRing s 
goal: OrderedCommRing ↥s

full_name: SubringClass.toLinearOrderedRing
code: /-- A subring of a `LinearOrderedRing` is a `LinearOrderedRing`. -/
instance (priority := 75) toLinearOrderedRing [LinearOrderedRing R] [SubringClass S R] :
    LinearOrderedRing s 
goal: LinearOrderedRing ↥s

full_name: SubringClass.toLinearOrderedCommRing
code: /-- A subring of a `LinearOrderedCommRing` is a `LinearOrderedCommRing`. -/
instance (priority := 75) toLinearOrderedCommRing [LinearOrderedCommRing R] [SubringClass S R] :
    LinearOrderedCommRing s 
goal: LinearOrderedCommRing ↥s

full_name: Subring.toOrderedRing
code: /-- A subring of an `OrderedRing` is an `OrderedRing`. -/
instance toOrderedRing [OrderedRing R] (s : Subring R) : OrderedRing s 
goal: OrderedRing ↥s

full_name: Subring.toOrderedCommRing
code: /-- A subring of an `OrderedCommRing` is an `OrderedCommRing`. -/
instance toOrderedCommRing [OrderedCommRing R] (s : Subring R) : OrderedCommRing s 
goal: OrderedCommRing ↥s

full_name: Subring.toLinearOrderedRing
code: /-- A subring of a `LinearOrderedRing` is a `LinearOrderedRing`. -/
instance toLinearOrderedRing [LinearOrderedRing R] (s : Subring R) : LinearOrderedRing s 
goal: LinearOrderedRing ↥s

full_name: Subring.toLinearOrderedCommRing
code: /-- A subring of a `LinearOrderedCommRing` is a `LinearOrderedCommRing`. -/
instance toLinearOrderedCommRing [LinearOrderedCommRing R] (s : Subring R) :
    LinearOrderedCommRing s 
goal: LinearOrderedCommRing ↥s

full_name: Subring.orderedSubtype
code: /-- The inclusion `S → R` of a subring, as an ordered ring homomorphism. -/
def orderedSubtype {R : Type*} [OrderedRing R] (s : Subring R) : s →+*o R 
goal: ↥s →+*o R

full_name: Subring.orderedSubtype_coe
code: lemma orderedSubtype_coe (s : Subring R) : Subring.orderedSubtype s = Subring.subtype s 
goal: ↑s.orderedSubtype = s.subtype
File: Mathlib/Algebra/Ring/Action/Group.lean

full_name: MulSemiringAction.toRingEquiv
code: /-- Each element of the group defines a semiring isomorphism. -/
@[simps!]
def MulSemiringAction.toRingEquiv [MulSemiringAction G R] (x : G) : R ≃+* R 
goal: R ≃+* R

full_name: MulSemiringAction.toRingEquiv_apply
code: /-- Each element of the group defines a semiring isomorphism. -/
@[simps!]
def MulSemiringAction.toRingEquiv [MulSemiringAction G R] (x : G) : R ≃+* R 
goal: ∀ (a : R), (MulSemiringAction.toRingEquiv G R x) a = x • a

full_name: MulSemiringAction.toRingEquiv_symm_apply
code: /-- Each element of the group defines a semiring isomorphism. -/
@[simps!]
def MulSemiringAction.toRingEquiv [MulSemiringAction G R] (x : G) : R ≃+* R 
goal: ∀ (a : R), (MulSemiringAction.toRingEquiv G R x).symm a = x⁻¹ • a
File: Mathlib/Algebra/Ring/MinimalAxioms.lean

full_name: Ring.ofMinimalAxioms
code: /-- Define a `Ring` structure on a Type by proving a minimized set of axioms.
Note that this uses the default definitions for `npow`, `nsmul`, `zsmul` and `sub`
See note [reducible non-instances]. -/
abbrev Ring.ofMinimalAxioms {R : Type u}
    [Add R] [Mul R] [Neg R] [Zero R] [One R]
    (add_assoc : ∀ a b c : R, a + b + c = a + (b + c))
    (zero_add : ∀ a : R, 0 + a = a)
    (add_left_neg : ∀ a : R, -a + a = 0)
    (mul_assoc : ∀ a b c : R, a * b * c = a * (b * c))
    (one_mul : ∀ a : R, 1 * a = a)
    (mul_one : ∀ a : R, a * 1 = a)
    (left_distrib : ∀ a b c : R, a * (b + c) = a * b + a * c)
    (right_distrib : ∀ a b c : R, (a + b) * c = a * c + b * c) : Ring R 
goal: Ring R

full_name: CommRing.ofMinimalAxioms
code: /-- Define a `CommRing` structure on a Type by proving a minimized set of axioms.
Note that this uses the default definitions for `npow`, `nsmul`, `zsmul` and `sub`
See note [reducible non-instances]. -/
abbrev CommRing.ofMinimalAxioms {R : Type u}
    [Add R] [Mul R] [Neg R] [Zero R] [One R]
    (add_assoc : ∀ a b c : R, a + b + c = a + (b + c))
    (zero_add : ∀ a : R, 0 + a = a)
    (add_left_neg : ∀ a : R, -a + a = 0)
    (mul_assoc : ∀ a b c : R, a * b * c = a * (b * c))
    (mul_comm : ∀ a b : R, a * b = b * a)
    (one_mul : ∀ a : R, 1 * a = a)
    (left_distrib : ∀ a b c : R, a * (b + c) = a * b + a * c) : CommRing R 
goal: CommRing R
File: Mathlib/Algebra/Ring/Regular.lean

full_name: isLeftRegular_of_non_zero_divisor
code: /-- Left `Mul` by a `k : α` over `[Ring α]` is injective, if `k` is not a zero divisor.
The typeclass that restricts all terms of `α` to have this property is `NoZeroDivisors`. -/
theorem isLeftRegular_of_non_zero_divisor [NonUnitalNonAssocRing α] (k : α)
    (h : ∀ x : α, k * x = 0 → x = 0) : IsLeftRegular k 
goal: IsLeftRegular k

full_name: isRightRegular_of_non_zero_divisor
code: /-- Right `Mul` by a `k : α` over `[Ring α]` is injective, if `k` is not a zero divisor.
The typeclass that restricts all terms of `α` to have this property is `NoZeroDivisors`. -/
theorem isRightRegular_of_non_zero_divisor [NonUnitalNonAssocRing α] (k : α)
    (h : ∀ x : α, x * k = 0 → x = 0) : IsRightRegular k 
goal: IsRightRegular k

full_name: isRegular_of_ne_zero'
code: theorem isRegular_of_ne_zero' [NonUnitalNonAssocRing α] [NoZeroDivisors α] {k : α} (hk : k ≠ 0) :
    IsRegular k 
goal: IsRegular k

full_name: isRegular_iff_ne_zero'
code: theorem isRegular_iff_ne_zero' [Nontrivial α] [NonUnitalNonAssocRing α] [NoZeroDivisors α]
    {k : α} : IsRegular k ↔ k ≠ 0 
goal: IsRegular k ↔ k ≠ 0

full_name: NoZeroDivisors.toCancelMonoidWithZero
code: /-- A ring with no zero divisors is a `CancelMonoidWithZero`.

Note this is not an instance as it forms a typeclass loop. -/
abbrev NoZeroDivisors.toCancelMonoidWithZero [Ring α] [NoZeroDivisors α] : CancelMonoidWithZero α 
goal: CancelMonoidWithZero α

full_name: NoZeroDivisors.toCancelCommMonoidWithZero
code: /-- A commutative ring with no zero divisors is a `CancelCommMonoidWithZero`.

Note this is not an instance as it forms a typeclass loop. -/
abbrev NoZeroDivisors.toCancelCommMonoidWithZero [CommRing α] [NoZeroDivisors α] :
    CancelCommMonoidWithZero α 
goal: CancelCommMonoidWithZero α

full_name: IsDomain.toCancelMonoidWithZero
code: instance (priority := 100) IsDomain.toCancelMonoidWithZero [Semiring α] [IsDomain α] :
    CancelMonoidWithZero α 
goal: CancelMonoidWithZero α

full_name: IsDomain.toCancelCommMonoidWithZero
code: instance (priority := 100) IsDomain.toCancelCommMonoidWithZero : CancelCommMonoidWithZero α 
goal: CancelCommMonoidWithZero α
File: Mathlib/Algebra/Ring/NegOnePow.lean

full_name: Int.negOnePow
code: /-- The map `ℤ → ℤˣ` which sends `n` to `(-1 : ℤˣ) ^ n`. -/
def negOnePow (n : ℤ) : ℤˣ 
goal: ℤˣ

full_name: Int.negOnePow_def
code: lemma negOnePow_def (n : ℤ) : n.negOnePow = (-1 : ℤˣ) ^ n 
goal: n.negOnePow = (-1) ^ n

full_name: Int.negOnePow_add
code: lemma negOnePow_add (n₁ n₂ : ℤ) :
    (n₁ + n₂).negOnePow =  n₁.negOnePow * n₂.negOnePow 
goal: (n₁ + n₂).negOnePow = n₁.negOnePow * n₂.negOnePow

full_name: Int.negOnePow_zero
code: @[simp]
lemma negOnePow_zero : negOnePow 0 = 1 
goal: Int.negOnePow 0 = 1

full_name: Int.negOnePow_one
code: @[simp]
lemma negOnePow_one : negOnePow 1 = -1 
goal: Int.negOnePow 1 = -1

full_name: Int.negOnePow_succ
code: lemma negOnePow_succ (n : ℤ) : (n + 1).negOnePow = - n.negOnePow 
goal: (n + 1).negOnePow = -n.negOnePow

full_name: Int.negOnePow_even
code: lemma negOnePow_even (n : ℤ) (hn : Even n) : n.negOnePow = 1 
goal: n.negOnePow = 1

full_name: Int.negOnePow_two_mul
code: @[simp]
lemma negOnePow_two_mul (n : ℤ) : (2 * n).negOnePow = 1 
goal: (2 * n).negOnePow = 1

full_name: Int.negOnePow_odd
code: lemma negOnePow_odd (n : ℤ) (hn : Odd n) : n.negOnePow = -1 
goal: n.negOnePow = -1

full_name: Int.negOnePow_two_mul_add_one
code: @[simp]
lemma negOnePow_two_mul_add_one (n : ℤ) : (2 * n + 1).negOnePow = -1 
goal: (2 * n + 1).negOnePow = -1

full_name: Int.negOnePow_eq_one_iff
code: lemma negOnePow_eq_one_iff (n : ℤ) : n.negOnePow = 1 ↔ Even n 
goal: n.negOnePow = 1 ↔ Even n

full_name: Int.negOnePow_eq_neg_one_iff
code: lemma negOnePow_eq_neg_one_iff (n : ℤ) : n.negOnePow = -1 ↔ Odd n 
goal: n.negOnePow = -1 ↔ Odd n

full_name: Int.abs_negOnePow
code: @[simp]
theorem abs_negOnePow (n : ℤ) : |(n.negOnePow : ℤ)| = 1 
goal: |↑n.negOnePow| = 1

full_name: Int.negOnePow_neg
code: @[simp]
lemma negOnePow_neg (n : ℤ) : (-n).negOnePow = n.negOnePow 
goal: (-n).negOnePow = n.negOnePow

full_name: Int.negOnePow_abs
code: @[simp]
lemma negOnePow_abs (n : ℤ) : |n|.negOnePow = n.negOnePow 
goal: |n|.negOnePow = n.negOnePow

full_name: Int.negOnePow_sub
code: lemma negOnePow_sub (n₁ n₂ : ℤ) :
    (n₁ - n₂).negOnePow = n₁.negOnePow * n₂.negOnePow 
goal: (n₁ - n₂).negOnePow = n₁.negOnePow * n₂.negOnePow

full_name: Int.negOnePow_eq_iff
code: lemma negOnePow_eq_iff (n₁ n₂ : ℤ) :
    n₁.negOnePow = n₂.negOnePow ↔ Even (n₁ - n₂) 
goal: n₁.negOnePow = n₂.negOnePow ↔ Even (n₁ - n₂)

full_name: Int.negOnePow_mul_self
code: @[simp]
lemma negOnePow_mul_self (n : ℤ) : (n * n).negOnePow = n.negOnePow 
goal: (n * n).negOnePow = n.negOnePow

full_name: Int.coe_negOnePow
code: lemma coe_negOnePow (K : Type*) (n : ℤ) [Field K] : n.negOnePow = (-1 : K) ^ n 
goal: ↑↑n.negOnePow = (-1) ^ n
File: Mathlib/Algebra/Ring/Center.lean

full_name: Set.natCast_mem_center
code: @[simp]
theorem natCast_mem_center [NonAssocSemiring M] (n : ℕ) : (n : M) ∈ Set.center M 
goal: ↑n ∈ Set.center M

full_name: Set.ofNat_mem_center
code: @[simp]
theorem ofNat_mem_center [NonAssocSemiring M] (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n)) ∈ Set.center M 
goal: OfNat.ofNat n ∈ Set.center M

full_name: Set.intCast_mem_center
code: @[simp]
theorem intCast_mem_center [NonAssocRing M] (n : ℤ) : (n : M) ∈ Set.center M 
goal: ↑n ∈ Set.center M

full_name: Set.add_mem_center
code: @[simp]
theorem add_mem_center [Distrib M] {a b : M} (ha : a ∈ Set.center M) (hb : b ∈ Set.center M) :
    a + b ∈ Set.center M  
goal: a + b ∈ Set.center M

full_name: Set.neg_mem_center
code: @[simp]
theorem neg_mem_center [NonUnitalNonAssocRing M] {a : M} (ha : a ∈ Set.center M) :
    -a ∈ Set.center M 
goal: -a ∈ Set.center M
File: Mathlib/Algebra/Ring/Nat.lean

full_name: Nat.instCommSemiring
code: instance instCommSemiring : CommSemiring ℕ 
goal: CommSemiring ℕ

full_name: Nat.instCancelCommMonoidWithZero
code: instance instCancelCommMonoidWithZero : CancelCommMonoidWithZero ℕ 
goal: CancelCommMonoidWithZero ℕ

full_name: Nat.instMulDivCancelClass
code: instance instMulDivCancelClass : MulDivCancelClass ℕ 
goal: MulDivCancelClass ℕ

full_name: Nat.instCharZero
code: instance instCharZero : CharZero ℕ 
goal: CharZero ℕ

full_name: Nat.instAddCommMonoidWithOne
code: instance instAddCommMonoidWithOne : AddCommMonoidWithOne ℕ 
goal: AddCommMonoidWithOne ℕ

full_name: Nat.instDistrib
code: instance instDistrib              : Distrib ℕ              
goal: Distrib ℕ

full_name: Nat.instSemiring
code: instance instSemiring             : Semiring ℕ             
goal: Semiring ℕ
File: Mathlib/Algebra/Ring/WithZero.lean

full_name: WithZero.instLeftDistribClass
code: instance instLeftDistribClass [Mul α] [Add α] [LeftDistribClass α] :
    LeftDistribClass (WithZero α) 
goal: LeftDistribClass (WithZero α)

full_name: WithZero.instRightDistribClass
code: instance instRightDistribClass [Mul α] [Add α] [RightDistribClass α] :
    RightDistribClass (WithZero α) 
goal: RightDistribClass (WithZero α)

full_name: WithZero.instDistrib
code: instance instDistrib [Distrib α] : Distrib (WithZero α) 
goal: Distrib (WithZero α)

full_name: WithZero.instSemiring
code: instance instSemiring [Semiring α] : Semiring (WithZero α) 
goal: Semiring (WithZero α)
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

full_name: dvd_smul_of_dvd
code: lemma dvd_smul_of_dvd {M : Type*} [SMul M R] [Semigroup R] [SMulCommClass M R R] {x y : R}
    (m : M) (h : x ∣ y) : x ∣ m • y 
goal: x ∣ m • y

full_name: dvd_nsmul_of_dvd
code: lemma dvd_nsmul_of_dvd [NonUnitalSemiring R] {x y : R} (n : ℕ) (h : x ∣ y) : x ∣ n • y 
goal: x ∣ n • y

full_name: dvd_zsmul_of_dvd
code: lemma dvd_zsmul_of_dvd [NonUnitalRing R] {x y : R} (z : ℤ) (h : x ∣ y) : x ∣ z • y 
goal: x ∣ z • y

full_name: Commute.pow_dvd_add_pow_of_pow_eq_zero_right
code: lemma pow_dvd_add_pow_of_pow_eq_zero_right (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hy : y ^ n = 0) : x ^ m ∣ (x + y) ^ p 
goal: x ^ m ∣ (x + y) ^ p

full_name: Commute.pow_dvd_add_pow_of_pow_eq_zero_left
code: lemma pow_dvd_add_pow_of_pow_eq_zero_left (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hx : x ^ n = 0) : y ^ m ∣ (x + y) ^ p 
goal: y ^ m ∣ (x + y) ^ p

full_name: Commute.pow_dvd_pow_of_sub_pow_eq_zero
code: lemma pow_dvd_pow_of_sub_pow_eq_zero (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (h : (x - y) ^ n = 0) : x ^ m ∣ y ^ p 
goal: x ^ m ∣ y ^ p

full_name: Commute.pow_dvd_pow_of_add_pow_eq_zero
code: lemma pow_dvd_pow_of_add_pow_eq_zero (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (h : (x + y) ^ n = 0) : x ^ m ∣ y ^ p 
goal: x ^ m ∣ y ^ p

full_name: Commute.pow_dvd_sub_pow_of_pow_eq_zero_right
code: lemma pow_dvd_sub_pow_of_pow_eq_zero_right (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hy : y ^ n = 0) : x ^ m ∣ (x - y) ^ p 
goal: x ^ m ∣ (x - y) ^ p

full_name: Commute.pow_dvd_sub_pow_of_pow_eq_zero_left
code: lemma pow_dvd_sub_pow_of_pow_eq_zero_left (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hx : x ^ n = 0) : y ^ m ∣ (x - y) ^ p 
goal: y ^ m ∣ (x - y) ^ p

full_name: Commute.add_pow_dvd_pow_of_pow_eq_zero_right
code: lemma add_pow_dvd_pow_of_pow_eq_zero_right (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hx : x ^ n = 0) : (x + y) ^ m ∣ y ^ p 
goal: (x + y) ^ m ∣ y ^ p

full_name: Commute.add_pow_dvd_pow_of_pow_eq_zero_left
code: lemma add_pow_dvd_pow_of_pow_eq_zero_left (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hy : y ^ n = 0) : (x + y) ^ m ∣ x ^ p 
goal: (x + y) ^ m ∣ x ^ p

full_name: dvd_mul_sub_mul_mul_left_of_dvd
code: lemma dvd_mul_sub_mul_mul_left_of_dvd {p a b c d x y : R}
    (h1 : p ∣ a * x + b * y) (h2 : p ∣ c * x + d * y) : p ∣ (a * d - b * c) * x 
goal: p ∣ (a * d - b * c) * x

full_name: dvd_mul_sub_mul_mul_right_of_dvd
code: lemma dvd_mul_sub_mul_mul_right_of_dvd {p a b c d x y : R}
    (h1 : p ∣ a * x + b * y) (h2 : p ∣ c * x + d * y) : p ∣ (a * d - b * c) * y 
goal: p ∣ (a * d - b * c) * y

full_name: dvd_mul_sub_mul_mul_gcd_of_dvd
code: lemma dvd_mul_sub_mul_mul_gcd_of_dvd {p a b c d x y : R} [IsDomain R] [GCDMonoid R]
    (h1 : p ∣ a * x + b * y) (h2 : p ∣ c * x + d * y) : p ∣ (a * d - b * c) * gcd x y 
goal: p ∣ (a * d - b * c) * gcd x y
File: Mathlib/Algebra/Ring/Invertible.lean

full_name: invertibleNeg
code: /-- `-⅟a` is the inverse of `-a` -/
def invertibleNeg [Mul α] [One α] [HasDistribNeg α] (a : α) [Invertible a] : Invertible (-a) 
goal: Invertible (-a)

full_name: invOf_neg
code: @[simp]
theorem invOf_neg [Monoid α] [HasDistribNeg α] (a : α) [Invertible a] [Invertible (-a)] :
    ⅟ (-a) = -⅟ a 
goal: ⅟(-a) = -⅟a

full_name: one_sub_invOf_two
code: @[simp]
theorem one_sub_invOf_two [Ring α] [Invertible (2 : α)] : 1 - (⅟ 2 : α) = ⅟ 2 
goal: 1 - ⅟2 = ⅟2

full_name: invOf_two_add_invOf_two
code: @[simp]
theorem invOf_two_add_invOf_two [NonAssocSemiring α] [Invertible (2 : α)] :
    (⅟ 2 : α) + (⅟ 2 : α) = 1 
goal: ⅟2 + ⅟2 = 1

full_name: pos_of_invertible_cast
code: theorem pos_of_invertible_cast [Semiring α] [Nontrivial α] (n : ℕ) [Invertible (n : α)] : 0 < n 
goal: 0 < n

full_name: invOf_add_invOf
code: theorem invOf_add_invOf [Semiring α] (a b : α) [Invertible a] [Invertible b] :
    ⅟a + ⅟b = ⅟a * (a + b) * ⅟b 
goal: ⅟a + ⅟b = ⅟a * (a + b) * ⅟b

full_name: invOf_sub_invOf
code: /-- A version of `inv_sub_inv'` for `invOf`. -/
theorem invOf_sub_invOf [Ring α] (a b : α) [Invertible a] [Invertible b] :
    ⅟a - ⅟b = ⅟a * (b - a) * ⅟b 
goal: ⅟a - ⅟b = ⅟a * (b - a) * ⅟b

full_name: Ring.inverse_add_inverse
code: /-- A version of `inv_add_inv'` for `Ring.inverse`. -/
theorem Ring.inverse_add_inverse [Semiring α] {a b : α} (h : IsUnit a ↔ IsUnit b) :
    Ring.inverse a + Ring.inverse b = Ring.inverse a * (a + b) * Ring.inverse b 
goal: Ring.inverse a + Ring.inverse b = Ring.inverse a * (a + b) * Ring.inverse b

full_name: Ring.inverse_sub_inverse
code: /-- A version of `inv_sub_inv'` for `Ring.inverse`. -/
theorem Ring.inverse_sub_inverse [Ring α] {a b : α} (h : IsUnit a ↔ IsUnit b) :
    Ring.inverse a - Ring.inverse b = Ring.inverse a * (b - a) * Ring.inverse b 
goal: Ring.inverse a - Ring.inverse b = Ring.inverse a * (b - a) * Ring.inverse b
File: Mathlib/Algebra/Ring/Centralizer.lean

full_name: Set.add_mem_centralizer
code: @[simp]
theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a + b ∈ centralizer S 
goal: a + b ∈ S.centralizer

full_name: Set.neg_mem_centralizer
code: @[simp]
theorem neg_mem_centralizer [Mul M] [HasDistribNeg M] (ha : a ∈ centralizer S) :
    -a ∈ centralizer S 
goal: -a ∈ S.centralizer
File: Mathlib/Algebra/Ring/ULift.lean

full_name: ULift.mulZeroClass
code: instance mulZeroClass [MulZeroClass α] : MulZeroClass (ULift α) 
goal: MulZeroClass (ULift.{u_1, u} α)

full_name: ULift.distrib
code: instance distrib [Distrib α] : Distrib (ULift α) 
goal: Distrib (ULift.{u_1, u} α)

full_name: ULift.nonUnitalNonAssocSemiring
code: instance nonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring α] :
    NonUnitalNonAssocSemiring (ULift α) 
goal: NonUnitalNonAssocSemiring (ULift.{u_1, u} α)

full_name: ULift.nonAssocSemiring
code: instance nonAssocSemiring [NonAssocSemiring α] : NonAssocSemiring (ULift α) 
goal: NonAssocSemiring (ULift.{u_1, u} α)

full_name: ULift.nonUnitalSemiring
code: instance nonUnitalSemiring [NonUnitalSemiring α] : NonUnitalSemiring (ULift α) 
goal: NonUnitalSemiring (ULift.{u_1, u} α)

full_name: ULift.semiring
code: instance semiring [Semiring α] : Semiring (ULift α) 
goal: Semiring (ULift.{u_1, u} α)

full_name: ULift.ringEquiv
code: /-- The ring equivalence between `ULift α` and `α`. -/
def ringEquiv [NonUnitalNonAssocSemiring α] : ULift α ≃+* α 
goal: ULift.{u_1, u} α ≃+* α

full_name: ULift.nonUnitalCommSemiring
code: instance nonUnitalCommSemiring [NonUnitalCommSemiring α] : NonUnitalCommSemiring (ULift α) 
goal: NonUnitalCommSemiring (ULift.{u_1, u} α)

full_name: ULift.commSemiring
code: instance commSemiring [CommSemiring α] : CommSemiring (ULift α) 
goal: CommSemiring (ULift.{u_1, u} α)

full_name: ULift.nonUnitalNonAssocRing
code: instance nonUnitalNonAssocRing [NonUnitalNonAssocRing α] : NonUnitalNonAssocRing (ULift α) 
goal: NonUnitalNonAssocRing (ULift.{u_1, u} α)

full_name: ULift.nonUnitalRing
code: instance nonUnitalRing [NonUnitalRing α] : NonUnitalRing (ULift α) 
goal: NonUnitalRing (ULift.{u_1, u} α)

full_name: ULift.nonAssocRing
code: instance nonAssocRing [NonAssocRing α] : NonAssocRing (ULift α) 
goal: NonAssocRing (ULift.{u_1, u} α)

full_name: ULift.ring
code: instance ring [Ring α] : Ring (ULift α) 
goal: Ring (ULift.{u_1, u} α)

full_name: ULift.nonUnitalCommRing
code: instance nonUnitalCommRing [NonUnitalCommRing α] : NonUnitalCommRing (ULift α) 
goal: NonUnitalCommRing (ULift.{u_1, u} α)

full_name: ULift.commRing
code: instance commRing [CommRing α] : CommRing (ULift α) 
goal: CommRing (ULift.{u_1, u} α)
File: Mathlib/Algebra/Algebra/Subalgebra/Rank.lean

full_name: Subalgebra.rank_sup_eq_rank_left_mul_rank_of_free
code: theorem rank_sup_eq_rank_left_mul_rank_of_free :
    Module.rank R ↥(A ⊔ B) = Module.rank R A * Module.rank A (Algebra.adjoin A (B : Set S)) 
goal: Module.rank R ↥(A ⊔ B) = Module.rank R ↥A * Module.rank ↥A ↥(Algebra.adjoin ↥A ↑B)

full_name: Subalgebra.rank_sup_eq_rank_right_mul_rank_of_free
code: theorem rank_sup_eq_rank_right_mul_rank_of_free :
    Module.rank R ↥(A ⊔ B) = Module.rank R B * Module.rank B (Algebra.adjoin B (A : Set S)) 
goal: Module.rank R ↥(A ⊔ B) = Module.rank R ↥B * Module.rank ↥B ↥(Algebra.adjoin ↥B ↑A)

full_name: Subalgebra.finrank_sup_eq_finrank_left_mul_finrank_of_free
code: theorem finrank_sup_eq_finrank_left_mul_finrank_of_free :
    finrank R ↥(A ⊔ B) = finrank R A * finrank A (Algebra.adjoin A (B : Set S)) 
goal: FiniteDimensional.finrank R ↥(A ⊔ B) =
  FiniteDimensional.finrank R ↥A * FiniteDimensional.finrank ↥A ↥(Algebra.adjoin ↥A ↑B)

full_name: Subalgebra.finrank_sup_eq_finrank_right_mul_finrank_of_free
code: theorem finrank_sup_eq_finrank_right_mul_finrank_of_free :
    finrank R ↥(A ⊔ B) = finrank R B * finrank B (Algebra.adjoin B (A : Set S)) 
goal: FiniteDimensional.finrank R ↥(A ⊔ B) =
  FiniteDimensional.finrank R ↥B * FiniteDimensional.finrank ↥B ↥(Algebra.adjoin ↥B ↑A)

full_name: Subalgebra.finrank_left_dvd_finrank_sup_of_free
code: theorem finrank_left_dvd_finrank_sup_of_free :
    finrank R A ∣ finrank R ↥(A ⊔ B) 
goal: FiniteDimensional.finrank R ↥A ∣ FiniteDimensional.finrank R ↥(A ⊔ B)

full_name: Subalgebra.finrank_right_dvd_finrank_sup_of_free
code: theorem finrank_right_dvd_finrank_sup_of_free :
    finrank R B ∣ finrank R ↥(A ⊔ B) 
goal: FiniteDimensional.finrank R ↥B ∣ FiniteDimensional.finrank R ↥(A ⊔ B)
File: Mathlib/Algebra/Ring/AddAut.lean

full_name: AddAut.mulLeft_apply_apply
code: /-- Left multiplication by a unit of a semiring as an additive automorphism. -/
@[simps! (config := { simpRhs := true })]
def mulLeft : Rˣ →* AddAut R 
goal: ∀ (a : R), (AddAut.mulLeft x) a = x • a

full_name: AddAut.mulLeft
code: /-- Left multiplication by a unit of a semiring as an additive automorphism. -/
@[simps! (config := { simpRhs := true })]
def mulLeft : Rˣ →* AddAut R 
goal: Rˣ →* AddAut R

full_name: AddAut.mulLeft_apply_symm_apply
code: /-- Left multiplication by a unit of a semiring as an additive automorphism. -/
@[simps! (config := { simpRhs := true })]
def mulLeft : Rˣ →* AddAut R 
goal: ∀ (a : R), (AddEquiv.symm (AddAut.mulLeft x)) a = x⁻¹ • a

full_name: AddAut.mulRight
code: /-- Right multiplication by a unit of a semiring as an additive automorphism. -/
def mulRight (u : Rˣ) : AddAut R 
goal: AddAut R

full_name: AddAut.mulRight_apply
code: @[simp]
theorem mulRight_apply (u : Rˣ) (x : R) : mulRight u x = x * u 
goal: (AddAut.mulRight u) x = x * ↑u

full_name: AddAut.mulRight_symm_apply
code: @[simp]
theorem mulRight_symm_apply (u : Rˣ) (x : R) : (mulRight u).symm x = x * u⁻¹ 
goal: (AddEquiv.symm (AddAut.mulRight u)) x = x * ↑u⁻¹