ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Group/Commute/Hom.lean

full_name: SemiconjBy.map
code: @[to_additive (attr := simp)]
protected theorem SemiconjBy.map [MulHomClass F M N] (h : SemiconjBy a x y) (f : F) :
    SemiconjBy (f a) (f x) (f y) 
goal: SemiconjBy (f a) (f x) (f y)

full_name: AddSemiconjBy.map
code: @[to_additive (attr := simp)]
protected theorem SemiconjBy.map [MulHomClass F M N] (h : SemiconjBy a x y) (f : F) :
    SemiconjBy (f a) (f x) (f y) 
goal: AddSemiconjBy (f a) (f x) (f y)

full_name: Commute.map
code: @[to_additive (attr := simp)]
protected theorem Commute.map [MulHomClass F M N] (h : Commute x y) (f : F) : Commute (f x) (f y) 
goal: Commute (f x) (f y)

full_name: AddCommute.map
code: @[to_additive (attr := simp)]
protected theorem Commute.map [MulHomClass F M N] (h : Commute x y) (f : F) : Commute (f x) (f y) 
goal: AddCommute (f x) (f y)

full_name: SemiconjBy.of_map
code: @[to_additive (attr := simp)]
protected theorem SemiconjBy.of_map [MulHomClass F M N] (f : F) (hf : Function.Injective f)
    (h : SemiconjBy (f a) (f x) (f y)) : SemiconjBy a x y 
goal: SemiconjBy a x y

full_name: AddSemiconjBy.of_map
code: @[to_additive (attr := simp)]
protected theorem SemiconjBy.of_map [MulHomClass F M N] (f : F) (hf : Function.Injective f)
    (h : SemiconjBy (f a) (f x) (f y)) : SemiconjBy a x y 
goal: AddSemiconjBy a x y

full_name: AddCommute.of_map
code: @[to_additive (attr := simp)]
theorem Commute.of_map [MulHomClass F M N] {f : F} (hf : Function.Injective f)
    (h : Commute (f x) (f y)) : Commute x y 
goal: AddCommute x y

full_name: Commute.of_map
code: @[to_additive (attr := simp)]
theorem Commute.of_map [MulHomClass F M N] {f : F} (hf : Function.Injective f)
    (h : Commute (f x) (f y)) : Commute x y 
goal: Commute x y
File: Mathlib/Algebra/Group/Action/Option.lean

full_name: Option.VAdd
code: @[to_additive Option.VAdd]
instance : SMul M (Option α) 
goal: VAdd M (Option α)

full_name: Option.instSMul
code: @[to_additive Option.VAdd]
instance : SMul M (Option α) 
goal: SMul M (Option α)

full_name: Option.smul_def
code: @[to_additive]
theorem smul_def : a • x = x.map (a • ·) 
goal: a • x = Option.map (fun x => a • x) x

full_name: Option.vadd_def
code: @[to_additive]
theorem smul_def : a • x = x.map (a • ·) 
goal: a +ᵥ x = Option.map (fun x => a +ᵥ x) x

full_name: Option.smul_none
code: @[to_additive (attr := simp)]
theorem smul_none : a • (none : Option α) = none 
goal: a • none = none

full_name: Option.vadd_none
code: @[to_additive (attr := simp)]
theorem smul_none : a • (none : Option α) = none 
goal: a +ᵥ none = none

full_name: Option.vadd_some
code: @[to_additive (attr := simp)]
theorem smul_some : a • some b = some (a • b) 
goal: a +ᵥ some b = some (a +ᵥ b)

full_name: Option.smul_some
code: @[to_additive (attr := simp)]
theorem smul_some : a • some b = some (a • b) 
goal: a • some b = some (a • b)

full_name: Option.instIsScalarTowerOfVAdd
code: @[to_additive]
instance instIsScalarTowerOfSMul [SMul M N] [IsScalarTower M N α] : IsScalarTower M N (Option α) 
goal: VAddAssocClass M N (Option α)

full_name: Option.instIsScalarTowerOfSMul
code: @[to_additive]
instance instIsScalarTowerOfSMul [SMul M N] [IsScalarTower M N α] : IsScalarTower M N (Option α) 
goal: IsScalarTower M N (Option α)

full_name: Option.instVAddCommClass
code: @[to_additive]
instance [SMulCommClass M N α] : SMulCommClass M N (Option α) 
goal: VAddCommClass M N (Option α)

full_name: Option.instSMulCommClass
code: @[to_additive]
instance [SMulCommClass M N α] : SMulCommClass M N (Option α) 
goal: SMulCommClass M N (Option α)

full_name: Option.instIsCentralScalar
code: @[to_additive]
instance [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M (Option α) 
goal: IsCentralScalar M (Option α)

full_name: Option.instIsCentralVAdd
code: @[to_additive]
instance [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M (Option α) 
goal: IsCentralVAdd M (Option α)

full_name: Option.instFaithfulVAdd
code: @[to_additive]
instance [FaithfulSMul M α] : FaithfulSMul M (Option α) 
goal: FaithfulVAdd M (Option α)

full_name: Option.instFaithfulSMul
code: @[to_additive]
instance [FaithfulSMul M α] : FaithfulSMul M (Option α) 
goal: FaithfulSMul M (Option α)

full_name: Option.instMulAction
code: instance [Monoid M] [MulAction M α] :
    MulAction M (Option α) 
goal: MulAction M (Option α)
File: Mathlib/Algebra/Group/FiniteSupport.lean

full_name: Function.mulSupport_along_fiber_finite_of_finite
code: @[to_additive (attr := simp)]
lemma mulSupport_along_fiber_finite_of_finite (f : α × β → γ) (a : α) (h : (mulSupport f).Finite) :
    (mulSupport fun b ↦ f (a, b)).Finite 
goal: (Function.mulSupport fun b => f (a, b)).Finite

full_name: Function.support_along_fiber_finite_of_finite
code: @[to_additive (attr := simp)]
lemma mulSupport_along_fiber_finite_of_finite (f : α × β → γ) (a : α) (h : (mulSupport f).Finite) :
    (mulSupport fun b ↦ f (a, b)).Finite 
goal: (Function.support fun b => f (a, b)).Finite
File: Mathlib/Algebra/Group/MinimalAxioms.lean

full_name: Group.ofLeftAxioms
code: /-- Define a `Group` structure on a Type by proving `∀ a, 1 * a = a` and
`∀ a, a⁻¹ * a = 1`.
Note that this uses the default definitions for `npow`, `zpow` and `div`.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible)
"Define an `AddGroup` structure on a Type by proving `∀ a, 0 + a = a` and
`∀ a, -a + a = 0`.
Note that this uses the default definitions for `nsmul`, `zsmul` and `sub`.
See note [reducible non-instances]."]
def Group.ofLeftAxioms {G : Type u} [Mul G] [Inv G] [One G]
    (assoc : ∀ a b c : G, (a * b) * c = a * (b * c))
    (one_mul : ∀ a : G, 1 * a = a)
    (mul_left_inv : ∀ a : G, a⁻¹ * a = 1) : Group G 
goal: Group G

full_name: AddGroup.ofLeftAxioms
code: /-- Define a `Group` structure on a Type by proving `∀ a, 1 * a = a` and
`∀ a, a⁻¹ * a = 1`.
Note that this uses the default definitions for `npow`, `zpow` and `div`.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible)
"Define an `AddGroup` structure on a Type by proving `∀ a, 0 + a = a` and
`∀ a, -a + a = 0`.
Note that this uses the default definitions for `nsmul`, `zsmul` and `sub`.
See note [reducible non-instances]."]
def Group.ofLeftAxioms {G : Type u} [Mul G] [Inv G] [One G]
    (assoc : ∀ a b c : G, (a * b) * c = a * (b * c))
    (one_mul : ∀ a : G, 1 * a = a)
    (mul_left_inv : ∀ a : G, a⁻¹ * a = 1) : Group G 
goal: AddGroup G

full_name: Group.ofRightAxioms
code: /-- Define a `Group` structure on a Type by proving `∀ a, a * 1 = a` and
`∀ a, a * a⁻¹ = 1`.
Note that this uses the default definitions for `npow`, `zpow` and `div`.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible)
"Define an `AddGroup` structure on a Type by proving `∀ a, a + 0 = a` and
`∀ a, a + -a = 0`.
Note that this uses the default definitions for `nsmul`, `zsmul` and `sub`.
See note [reducible non-instances]."]
def Group.ofRightAxioms {G : Type u} [Mul G] [Inv G] [One G]
    (assoc : ∀ a b c : G, (a * b) * c = a * (b * c))
    (mul_one : ∀ a : G, a * 1 = a)
    (mul_right_inv : ∀ a : G, a * a⁻¹ = 1) : Group G 
goal: Group G

full_name: AddGroup.ofRightAxioms
code: /-- Define a `Group` structure on a Type by proving `∀ a, a * 1 = a` and
`∀ a, a * a⁻¹ = 1`.
Note that this uses the default definitions for `npow`, `zpow` and `div`.
See note [reducible non-instances]. -/
@[to_additive (attr := reducible)
"Define an `AddGroup` structure on a Type by proving `∀ a, a + 0 = a` and
`∀ a, a + -a = 0`.
Note that this uses the default definitions for `nsmul`, `zsmul` and `sub`.
See note [reducible non-instances]."]
def Group.ofRightAxioms {G : Type u} [Mul G] [Inv G] [One G]
    (assoc : ∀ a b c : G, (a * b) * c = a * (b * c))
    (mul_one : ∀ a : G, a * 1 = a)
    (mul_right_inv : ∀ a : G, a * a⁻¹ = 1) : Group G 
goal: AddGroup G
File: Mathlib/Algebra/Group/ZeroOne.lean

full_name: Zero.zero
code: class Zero.{u} (α : Type u) where
  zero : α
goal: α

full_name: Zero.toOfNat0
code: instance (priority := 300) Zero.toOfNat0 {α} [Zero α] : OfNat α (nat_lit 0) 
goal: OfNat α 0

full_name: Zero.ofOfNat0
code: instance (priority := 200) Zero.ofOfNat0 {α} [OfNat α (nat_lit 0)] : Zero α 
goal: Zero α

full_name: One.one
code: @[to_additive]
class One (α : Type u) where
  one : α
goal: α

full_name: One
code: @[to_additive]
class One (α : Type u) where
  one : α
goal: Type u

full_name: One.toOfNat1
code: @[to_additive existing Zero.toOfNat0]
instance (priority := 300) One.toOfNat1 {α} [One α] : OfNat α (nat_lit 1) 
goal: OfNat α 1

full_name: One.ofOfNat1
code: @[to_additive existing Zero.ofOfNat0, to_additive_change_numeral 2]
instance (priority := 200) One.ofOfNat1 {α} [OfNat α (nat_lit 1)] : One α 
goal: One α
File: Mathlib/Algebra/Group/PNatPowAssoc.lean

full_name: PNatPowAssoc.ppow_one
code: /-- A `Prop`-valued mixin for power-associative multiplication in the non-unital setting. -/
class PNatPowAssoc (M : Type*) [Mul M] [Pow M ℕ+] : Prop where
  /-- Multiplication is power-associative. -/
  protected ppow_add : ∀ (k n : ℕ+) (x : M), x ^ (k + n) = x ^ k * x ^ n
  /-- Exponent one is identity. -/
  protected ppow_one : ∀ (x : M), x ^ (1 : ℕ+) = x
goal: x ^ 1 = x

full_name: PNatPowAssoc.ppow_add
code: /-- A `Prop`-valued mixin for power-associative multiplication in the non-unital setting. -/
class PNatPowAssoc (M : Type*) [Mul M] [Pow M ℕ+] : Prop where
  /-- Multiplication is power-associative. -/
  protected ppow_add : ∀ (k n : ℕ+) (x : M), x ^ (k + n) = x ^ k * x ^ n
  /-- Exponent one is identity. -/
  protected ppow_one : ∀ (x : M), x ^ (1 : ℕ+) = x
goal: x ^ (k + n) = x ^ k * x ^ n

full_name: PNatPowAssoc
code: /-- A `Prop`-valued mixin for power-associative multiplication in the non-unital setting. -/
class PNatPowAssoc (M : Type*) [Mul M] [Pow M ℕ+] : Prop where
  /-- Multiplication is power-associative. -/
  protected ppow_add : ∀ (k n : ℕ+) (x : M), x ^ (k + n) = x ^ k * x ^ n
  /-- Exponent one is identity. -/
  protected ppow_one : ∀ (x : M), x ^ (1 : ℕ+) = x
goal: Prop

full_name: ppow_add
code: theorem ppow_add (k n : ℕ+) (x : M) : x ^ (k + n) = x ^ k * x ^ n 
goal: x ^ (k + n) = x ^ k * x ^ n

full_name: ppow_one
code: @[simp]
theorem ppow_one (x : M) : x ^ (1 : ℕ+) = x 
goal: x ^ 1 = x

full_name: ppow_mul_assoc
code: theorem ppow_mul_assoc (k m n : ℕ+) (x : M) :
    (x ^ k * x ^ m) * x ^ n = x ^ k * (x ^ m * x ^ n) 
goal: x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)

full_name: ppow_mul_comm
code: theorem ppow_mul_comm (m n : ℕ+) (x : M) :
    x ^ m * x ^ n = x ^ n * x ^ m 
goal: x ^ m * x ^ n = x ^ n * x ^ m

full_name: ppow_mul
code: theorem ppow_mul (x : M) (m n : ℕ+) : x ^ (m * n) = (x ^ m) ^ n 
goal: x ^ (m * n) = (x ^ m) ^ n

full_name: ppow_mul'
code: theorem ppow_mul' (x : M) (m n : ℕ+) : x ^ (m * n) = (x ^ n) ^ m 
goal: x ^ (m * n) = (x ^ n) ^ m

full_name: Pi.instPNatPowAssoc
code: instance Pi.instPNatPowAssoc {ι : Type*} {α : ι → Type*} [∀ i, Mul <| α i] [∀ i, Pow (α i) ℕ+]
    [∀ i, PNatPowAssoc <| α i] : PNatPowAssoc (∀ i, α i) 
goal: PNatPowAssoc ((i : ι) → α i)

full_name: Prod.instPNatPowAssoc
code: instance Prod.instPNatPowAssoc {N : Type*} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] [Mul N] [Pow N ℕ+]
    [PNatPowAssoc N] : PNatPowAssoc (M × N) 
goal: PNatPowAssoc (M × N)

full_name: ppow_eq_pow
code: theorem ppow_eq_pow [Monoid M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (n : ℕ+) :
    x ^ n = x ^ (n : ℕ) 
goal: x ^ n = x ^ ↑n
File: Mathlib/Algebra/Group/Commutator.lean

full_name: commutatorElement
code: /-- The commutator of two elements `g₁` and `g₂`. -/
instance commutatorElement {G : Type*} [Group G] : Bracket G G 
goal: Bracket G G

full_name: commutatorElement_def
code: theorem commutatorElement_def {G : Type*} [Group G] (g₁ g₂ : G) :
    ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹ 
goal: ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹
File: Mathlib/Algebra/Group/Fin/Basic.lean

full_name: Fin.addCommSemigroup
code: instance addCommSemigroup (n : ℕ) : AddCommSemigroup (Fin n) 
goal: AddCommSemigroup (Fin n)

full_name: Fin.instAddCommSemigroup
code: instance (n) : AddCommSemigroup (Fin n) 
goal: AddCommSemigroup (Fin n)

full_name: Fin.addCommMonoid
code: instance addCommMonoid (n : ℕ) [NeZero n] : AddCommMonoid (Fin n) 
goal: AddCommMonoid (Fin n)

full_name: Fin.instAddMonoidWithOne
code: instance instAddMonoidWithOne (n) [NeZero n] : AddMonoidWithOne (Fin n) 
goal: AddMonoidWithOne (Fin n)

full_name: Fin.addCommGroup
code: instance addCommGroup (n : ℕ) [NeZero n] : AddCommGroup (Fin n) 
goal: AddCommGroup (Fin n)

full_name: Fin.instInvolutiveNeg
code: /-- Note this is more general than `Fin.addCommGroup` as it applies (vacuously) to `Fin 0` too. -/
instance instInvolutiveNeg (n : ℕ) : InvolutiveNeg (Fin n) 
goal: InvolutiveNeg (Fin n)

full_name: Fin.instIsCancelAdd
code: /-- Note this is more general than `Fin.addCommGroup` as it applies (vacuously) to `Fin 0` too. -/
instance instIsCancelAdd (n : ℕ) : IsCancelAdd (Fin n) 
goal: IsCancelAdd (Fin n)

full_name: Fin.instAddLeftCancelSemigroup
code: /-- Note this is more general than `Fin.addCommGroup` as it applies (vacuously) to `Fin 0` too. -/
instance instAddLeftCancelSemigroup (n : ℕ) : AddLeftCancelSemigroup (Fin n) 
goal: AddLeftCancelSemigroup (Fin n)

full_name: Fin.instAddRightCancelSemigroup
code: /-- Note this is more general than `Fin.addCommGroup` as it applies (vacuously) to `Fin 0` too. -/
instance instAddRightCancelSemigroup (n : ℕ) : AddRightCancelSemigroup (Fin n) 
goal: AddRightCancelSemigroup (Fin n)

full_name: Fin.coe_sub_one
code: lemma coe_sub_one (a : Fin (n + 1)) : ↑(a - 1) = if a = 0 then n else a - 1 
goal: ↑(a - 1) = if a = 0 then n else ↑a - 1

full_name: Fin.lt_sub_one_iff
code: @[simp]
lemma lt_sub_one_iff {k : Fin (n + 2)} : k < k - 1 ↔ k = 0 
goal: k < k - 1 ↔ k = 0

full_name: Fin.le_sub_one_iff
code: @[simp] lemma le_sub_one_iff {k : Fin (n + 1)} : k ≤ k - 1 ↔ k = 0 
goal: k ≤ k - 1 ↔ k = 0

full_name: Fin.sub_one_lt_iff
code: lemma sub_one_lt_iff {k : Fin (n + 1)} : k - 1 < k ↔ 0 < k 
goal: k - 1 < k ↔ 0 < k

full_name: Fin.neg_last
code: @[simp] lemma neg_last (n : ℕ) : -Fin.last n = 1 
goal: -Fin.last n = 1

full_name: Fin.neg_natCast_eq_one
code: lemma neg_natCast_eq_one (n : ℕ) : -(n : Fin (n + 1)) = 1 
goal: -↑n = 1
File: Mathlib/Algebra/Group/ConjFinite.lean

full_name: instFintypeConjClassesOfDecidableRelIsConj
code: instance [Fintype α] [DecidableRel (IsConj : α → α → Prop)] : Fintype (ConjClasses α) 
goal: Fintype (ConjClasses α)

full_name: instFiniteConjClasses
code: instance [Finite α] : Finite (ConjClasses α) 
goal: Finite (ConjClasses α)

full_name: instDecidableRelIsConjOfDecidableEqOfFintype
code: instance [DecidableEq α] [Fintype α] : DecidableRel (IsConj : α → α → Prop) 
goal: DecidableRel IsConj

full_name: conjugatesOf.fintype
code: instance conjugatesOf.fintype [Fintype α] [DecidableRel (IsConj : α → α → Prop)] {a : α} :
  Fintype (conjugatesOf a) 
goal: Fintype ↑(conjugatesOf a)

full_name: ConjClasses.instFintypeElemCarrier
code: instance {x : ConjClasses α} : Fintype (carrier x) 
goal: Fintype ↑x.carrier
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

full_name: SemiconjBy.inv_inv_symm_iff
code: @[to_additive (attr := simp)]
theorem inv_inv_symm_iff : SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x 
goal: SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x

full_name: AddSemiconjBy.neg_neg_symm_iff
code: @[to_additive (attr := simp)]
theorem inv_inv_symm_iff : SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x 
goal: AddSemiconjBy (-a) (-x) (-y) ↔ AddSemiconjBy a y x

full_name: SemiconjBy.inv_symm_left_iff
code: @[to_additive (attr := simp)] lemma inv_symm_left_iff : SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y 
goal: SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y

full_name: AddSemiconjBy.neg_symm_left_iff
code: @[to_additive (attr := simp)] lemma inv_symm_left_iff : SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y 
goal: AddSemiconjBy (-a) y x ↔ AddSemiconjBy a x y

full_name: AddSemiconjBy.neg_right_iff
code: @[to_additive (attr := simp)] lemma inv_right_iff : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
goal: AddSemiconjBy a (-x) (-y) ↔ AddSemiconjBy a x y

full_name: SemiconjBy.inv_right_iff
code: @[to_additive (attr := simp)] lemma inv_right_iff : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
goal: SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y

full_name: SemiconjBy.zpow_right
code: @[to_additive (attr := simp)] lemma zpow_right (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
goal: SemiconjBy a (x ^ m) (y ^ m)

full_name: AddSemiconjBy.zsmul_right
code: @[to_additive (attr := simp)] lemma zpow_right (h : SemiconjBy a x y) :
    ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
goal: AddSemiconjBy a (m • x) (m • y)

full_name: AddSemiconjBy.eq_zero_iff
code: @[to_additive] lemma eq_one_iff (h : SemiconjBy a x y): x = 1 ↔ y = 1 
goal: x = 0 ↔ y = 0

full_name: SemiconjBy.eq_one_iff
code: @[to_additive] lemma eq_one_iff (h : SemiconjBy a x y): x = 1 ↔ y = 1 
goal: x = 1 ↔ y = 1
File: Mathlib/Algebra/Algebra/Hom/Rat.lean

full_name: RingHom.toRatAlgHom
code: /-- Reinterpret a `RingHom` as a `ℚ`-algebra homomorphism. This actually yields an equivalence,
see `RingHom.equivRatAlgHom`. -/
def toRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S) : R →ₐ[ℚ] S 
goal: R →ₐ[ℚ] S

full_name: RingHom.toRatAlgHom_toRingHom
code: @[simp]
theorem toRatAlgHom_toRingHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S) :
    ↑f.toRatAlgHom = f 
goal: ↑f.toRatAlgHom = f

full_name: AlgHom.toRingHom_toRatAlgHom
code: @[simp]
theorem AlgHom.toRingHom_toRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S]
    (f : R →ₐ[ℚ] S) : (f : R →+* S).toRatAlgHom = f 
goal: (↑f).toRatAlgHom = f

full_name: RingHom.equivRatAlgHom_symm_apply
code: /-- The equivalence between `RingHom` and `ℚ`-algebra homomorphisms. -/
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S) 
goal: RingHom.equivRatAlgHom.symm self = self.toRingHom

full_name: RingHom.equivRatAlgHom
code: /-- The equivalence between `RingHom` and `ℚ`-algebra homomorphisms. -/
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S) 
goal: (R →+* S) ≃ (R →ₐ[ℚ] S)

full_name: RingHom.equivRatAlgHom_apply
code: /-- The equivalence between `RingHom` and `ℚ`-algebra homomorphisms. -/
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S) 
goal: RingHom.equivRatAlgHom f = f.toRatAlgHom
File: Mathlib/Algebra/Algebra/Field.lean

full_name: algebraMap.coe_inj
code: @[norm_cast, simp]
theorem coe_inj {a b : R} : (↑a : A) = ↑b ↔ a = b 
goal: ↑a = ↑b ↔ a = b

full_name: algebraMap.lift_map_eq_zero_iff
code: @[norm_cast]
theorem lift_map_eq_zero_iff (a : R) : (↑a : A) = 0 ↔ a = 0 
goal: ↑a = 0 ↔ a = 0

full_name: algebraMap.coe_inv
code: @[norm_cast]
theorem coe_inv (r : R) : ↑r⁻¹ = ((↑r)⁻¹ : A) 
goal: ↑r⁻¹ = (↑r)⁻¹

full_name: algebraMap.coe_div
code: @[norm_cast]
theorem coe_div (r s : R) : ↑(r / s) = (↑r / ↑s : A) 
goal: ↑(r / s) = ↑r / ↑s

full_name: algebraMap.coe_zpow
code: @[norm_cast]
theorem coe_zpow (r : R) (z : ℤ) : ↑(r ^ z) = (r : A) ^ z 
goal: ↑(r ^ z) = ↑r ^ z

full_name: algebraMap.coe_ratCast
code: @[norm_cast]
theorem coe_ratCast (q : ℚ) : ↑(q : R) = (q : A) 
goal: ↑↑q = ↑q
File: Mathlib/Algebra/Algebra/Rat.lean

full_name: RingHom.map_rat_algebraMap
code: @[simp]
theorem map_rat_algebraMap [Semiring R] [Semiring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S)
    (r : ℚ) : f (algebraMap ℚ R r) = algebraMap ℚ S r 
goal: f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r

full_name: algebraRat
code: instance algebraRat {α} [DivisionRing α] [CharZero α] : Algebra ℚ α 
goal: Algebra ℚ α

full_name: instAlgebraNNRatRat
code: /-- The rational numbers are an algebra over the non-negative rationals. -/
instance : Algebra NNRat ℚ 
goal: Algebra ℚ≥0 ℚ

full_name: algebraMap_rat_rat
code: @[simp] theorem algebraMap_rat_rat : algebraMap ℚ ℚ = RingHom.id ℚ 
goal: algebraMap ℚ ℚ = RingHom.id ℚ

full_name: algebra_rat_subsingleton
code: instance algebra_rat_subsingleton {α} [Semiring α] : Subsingleton (Algebra ℚ α) 
goal: Subsingleton (Algebra ℚ α)
File: Mathlib/Algebra/Algebra/Subalgebra/Order.lean

full_name: Subalgebra.toOrderedSemiring
code: instance toOrderedSemiring [CommSemiring R] [OrderedSemiring A] [Algebra R A]
    (S : Subalgebra R A) : OrderedSemiring S 
goal: OrderedSemiring ↥S

full_name: Subalgebra.toStrictOrderedSemiring
code: instance toStrictOrderedSemiring [CommSemiring R] [StrictOrderedSemiring A] [Algebra R A]
    (S : Subalgebra R A) : StrictOrderedSemiring S 
goal: StrictOrderedSemiring ↥S

full_name: Subalgebra.toOrderedCommSemiring
code: instance toOrderedCommSemiring [CommSemiring R] [OrderedCommSemiring A] [Algebra R A]
    (S : Subalgebra R A) : OrderedCommSemiring S 
goal: OrderedCommSemiring ↥S

full_name: Subalgebra.toStrictOrderedCommSemiring
code: instance toStrictOrderedCommSemiring [CommSemiring R] [StrictOrderedCommSemiring A]
    [Algebra R A] (S : Subalgebra R A) : StrictOrderedCommSemiring S 
goal: StrictOrderedCommSemiring ↥S

full_name: Subalgebra.toOrderedRing
code: instance toOrderedRing [CommRing R] [OrderedRing A] [Algebra R A] (S : Subalgebra R A) :
    OrderedRing S 
goal: OrderedRing ↥S

full_name: Subalgebra.toOrderedCommRing
code: instance toOrderedCommRing [CommRing R] [OrderedCommRing A] [Algebra R A]
    (S : Subalgebra R A) : OrderedCommRing S 
goal: OrderedCommRing ↥S

full_name: Subalgebra.toLinearOrderedSemiring
code: instance toLinearOrderedSemiring [CommSemiring R] [LinearOrderedSemiring A] [Algebra R A]
    (S : Subalgebra R A) : LinearOrderedSemiring S 
goal: LinearOrderedSemiring ↥S

full_name: Subalgebra.toLinearOrderedCommSemiring
code: instance toLinearOrderedCommSemiring [CommSemiring R] [LinearOrderedCommSemiring A]
    [Algebra R A] (S : Subalgebra R A) : LinearOrderedCommSemiring S 
goal: LinearOrderedCommSemiring ↥S

full_name: Subalgebra.toLinearOrderedRing
code: instance toLinearOrderedRing [CommRing R] [LinearOrderedRing A] [Algebra R A]
    (S : Subalgebra R A) : LinearOrderedRing S 
goal: LinearOrderedRing ↥S

full_name: Subalgebra.toLinearOrderedCommRing
code: instance toLinearOrderedCommRing [CommRing R] [LinearOrderedCommRing A] [Algebra R A]
    (S : Subalgebra R A) : LinearOrderedCommRing S 
goal: LinearOrderedCommRing ↥S