ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/GroupWithZero/Pi.lean

full_name: Pi.mulZeroClass
code: instance mulZeroClass : MulZeroClass (∀ i, α i) 
goal: MulZeroClass ((i : ι) → α i)

full_name: MulHom.single
code: /-- The multiplicative homomorphism including a single `MulZeroClass`
into a dependent family of `MulZeroClass`es, as functions supported at a point.

This is the `MulHom` version of `Pi.single`. -/
@[simps]
def _root_.MulHom.single (i : ι) : α i →ₙ* ∀ i, α i 
goal: α i →ₙ* (i : ι) → α i

full_name: MulHom.single_apply
code: /-- The multiplicative homomorphism including a single `MulZeroClass`
into a dependent family of `MulZeroClass`es, as functions supported at a point.

This is the `MulHom` version of `Pi.single`. -/
@[simps]
def _root_.MulHom.single (i : ι) : α i →ₙ* ∀ i, α i 
goal: (MulHom.single i) x j = Pi.single i x j

full_name: Pi.single_mul
code: lemma single_mul (i : ι) (x y : α i) : single i (x * y) = single i x * single i y 
goal: Pi.single i (x * y) = Pi.single i x * Pi.single i y

full_name: Pi.single_mul_left_apply
code: lemma single_mul_left_apply (i j : ι) (a : α i) (f : ∀ i, α i) :
    single i (a * f i) j = single i a j * f j 
goal: Pi.single i (a * f i) j = Pi.single i a j * f j

full_name: Pi.single_mul_right_apply
code: lemma single_mul_right_apply (i j : ι) (f : ∀ i, α i) (a : α i) :
    single i (f i * a) j = f j * single i a j 
goal: Pi.single i (f i * a) j = f j * Pi.single i a j

full_name: Pi.single_mul_left
code: lemma single_mul_left (a : α i) : single i (a * f i) = single i a * f 
goal: Pi.single i (a * f i) = Pi.single i a * f

full_name: Pi.single_mul_right
code: lemma single_mul_right (a : α i) : single i (f i * a) = f * single i a 
goal: Pi.single i (f i * a) = f * Pi.single i a

full_name: Pi.mulZeroOneClass
code: instance mulZeroOneClass [∀ i, MulZeroOneClass (α i)] : MulZeroOneClass (∀ i, α i) 
goal: MulZeroOneClass ((i : ι) → α i)

full_name: Pi.monoidWithZero
code: instance monoidWithZero [∀ i, MonoidWithZero (α i)] : MonoidWithZero (∀ i, α i) 
goal: MonoidWithZero ((i : ι) → α i)

full_name: Pi.commMonoidWithZero
code: instance commMonoidWithZero [∀ i, CommMonoidWithZero (α i)] : CommMonoidWithZero (∀ i, α i) 
goal: CommMonoidWithZero ((i : ι) → α i)

full_name: Pi.semigroupWithZero
code: instance semigroupWithZero [∀ i, SemigroupWithZero (α i)] : SemigroupWithZero (∀ i, α i) 
goal: SemigroupWithZero ((i : ι) → α i)
File: Mathlib/Algebra/GroupWithZero/Action/Prod.lean

full_name: Prod.smul_zero_mk
code: theorem smul_zero_mk {α : Type*} [Monoid M] [AddMonoid α] [DistribMulAction M α] (a : M) (c : β) :
    a • ((0 : α), c) = (0, a • c) 
goal: a • (0, c) = (0, a • c)

full_name: Prod.smul_mk_zero
code: theorem smul_mk_zero {β : Type*} [Monoid M] [AddMonoid β] [DistribMulAction M β] (a : M) (b : α) :
    a • (b, (0 : β)) = (a • b, 0) 
goal: a • (b, 0) = (a • b, 0)

full_name: Prod.smulZeroClass
code: instance smulZeroClass {R M N : Type*} [Zero M] [Zero N] [SMulZeroClass R M] [SMulZeroClass R N] :
    SMulZeroClass R (M × N) 
goal: SMulZeroClass R (M × N)

full_name: Prod.distribSMul
code: instance distribSMul {R M N : Type*} [AddZeroClass M] [AddZeroClass N] [DistribSMul R M]
    [DistribSMul R N] : DistribSMul R (M × N) 
goal: DistribSMul R (M × N)

full_name: Prod.distribMulAction
code: instance distribMulAction {R : Type*} [Monoid R] [AddMonoid M] [AddMonoid N]
    [DistribMulAction R M] [DistribMulAction R N] : DistribMulAction R (M × N) 
goal: DistribMulAction R (M × N)

full_name: Prod.mulDistribMulAction
code: instance mulDistribMulAction {R : Type*} [Monoid R] [Monoid M] [Monoid N]
    [MulDistribMulAction R M] [MulDistribMulAction R N] : MulDistribMulAction R (M × N) 
goal: MulDistribMulAction R (M × N)

full_name: DistribMulAction.prodOfSMulCommClass
code: /-- Construct a `DistribMulAction` by a product monoid from `DistribMulAction`s by the factors. -/
abbrev DistribMulAction.prodOfSMulCommClass [DistribMulAction M α] [DistribMulAction N α]
    [SMulCommClass M N α] : DistribMulAction (M × N) α 
goal: DistribMulAction (M × N) α

full_name: DistribMulAction.prodEquiv
code: /-- A `DistribMulAction` by a product monoid is equivalent to
  commuting `DistribMulAction`s by the factors. -/
def DistribMulAction.prodEquiv : DistribMulAction (M × N) α ≃
    Σ' (_ : DistribMulAction M α) (_ : DistribMulAction N α), SMulCommClass M N α 
goal: DistribMulAction (M × N) α ≃ (x : DistribMulAction M α) ×' (x_1 : DistribMulAction N α) ×' SMulCommClass M N α
File: Mathlib/Algebra/GroupWithZero/Center.lean

full_name: Set.zero_mem_center
code: @[simp] lemma zero_mem_center : (0 : M₀) ∈ center M₀ 
goal: 0 ∈ Set.center M₀

full_name: Set.zero_mem_centralizer
code: @[simp] lemma zero_mem_centralizer : (0 : M₀) ∈ centralizer s 
goal: 0 ∈ s.centralizer

full_name: Set.center_units_subset
code: lemma center_units_subset : center G₀ˣ ⊆ ((↑) : G₀ˣ → G₀) ⁻¹' center G₀ 
goal: Set.center G₀ˣ ⊆ Units.val ⁻¹' Set.center G₀

full_name: Set.center_units_eq
code: /-- In a group with zero, the center of the units is the preimage of the center. -/
lemma center_units_eq : center G₀ˣ = ((↑) : G₀ˣ → G₀) ⁻¹' center G₀ 
goal: Set.center G₀ˣ = Units.val ⁻¹' Set.center G₀

full_name: Set.inv_mem_centralizer₀
code: @[simp] lemma inv_mem_centralizer₀ (ha : a ∈ centralizer s) : a⁻¹ ∈ centralizer s 
goal: a⁻¹ ∈ s.centralizer

full_name: Set.div_mem_centralizer₀
code: @[simp] lemma div_mem_centralizer₀ (ha : a ∈ centralizer s) (hb : b ∈ centralizer s) :
    a / b ∈ centralizer s 
goal: a / b ∈ s.centralizer

full_name: Set.inv_mem_center₀
code: @[deprecated inv_mem_center (since := "2024-06-17")]
theorem inv_mem_center₀ (ha : a ∈ Set.center G₀) : a⁻¹ ∈ Set.center G₀ 
goal: a⁻¹ ∈ Set.center G₀

full_name: Set.div_mem_center₀
code: @[deprecated div_mem_center (since := "2024-06-17")]
theorem div_mem_center₀ (ha : a ∈ Set.center G₀) (hb : b ∈ Set.center G₀) : a / b ∈ Set.center G₀ 
goal: a / b ∈ Set.center G₀
File: Mathlib/Algebra/GroupWithZero/Prod.lean

full_name: Prod.instMulZeroClass
code: instance instMulZeroClass [MulZeroClass M₀] [MulZeroClass N₀] : MulZeroClass (M₀ × N₀) 
goal: MulZeroClass (M₀ × N₀)

full_name: Prod.instSemigroupWithZero
code: instance instSemigroupWithZero [SemigroupWithZero M₀] [SemigroupWithZero N₀] :
    SemigroupWithZero (M₀ × N₀) 
goal: SemigroupWithZero (M₀ × N₀)

full_name: Prod.instMulZeroOneClass
code: instance instMulZeroOneClass [MulZeroOneClass M₀] [MulZeroOneClass N₀] :
    MulZeroOneClass (M₀ × N₀) 
goal: MulZeroOneClass (M₀ × N₀)

full_name: Prod.instMonoidWithZero
code: instance instMonoidWithZero [MonoidWithZero M₀] [MonoidWithZero N₀] : MonoidWithZero (M₀ × N₀) 
goal: MonoidWithZero (M₀ × N₀)

full_name: Prod.instCommMonoidWithZero
code: instance instCommMonoidWithZero [CommMonoidWithZero M₀] [CommMonoidWithZero N₀] :
    CommMonoidWithZero (M₀ × N₀) 
goal: CommMonoidWithZero (M₀ × N₀)

full_name: mulMonoidWithZeroHom_apply
code: /-- Multiplication as a multiplicative homomorphism with zero. -/
@[simps]
def mulMonoidWithZeroHom [CommMonoidWithZero M₀] : M₀ × M₀ →*₀ M₀ 
goal: ∀ (a : M₀ × M₀), mulMonoidWithZeroHom a = (↑mulMonoidHom).toFun a

full_name: mulMonoidWithZeroHom
code: /-- Multiplication as a multiplicative homomorphism with zero. -/
@[simps]
def mulMonoidWithZeroHom [CommMonoidWithZero M₀] : M₀ × M₀ →*₀ M₀ 
goal: M₀ × M₀ →*₀ M₀

full_name: divMonoidWithZeroHom_apply
code: /-- Division as a multiplicative homomorphism with zero. -/
@[simps]
def divMonoidWithZeroHom [CommGroupWithZero M₀] : M₀ × M₀ →*₀ M₀ 
goal: ∀ (a : M₀ × M₀), divMonoidWithZeroHom a = (↑divMonoidHom).toFun a

full_name: divMonoidWithZeroHom
code: /-- Division as a multiplicative homomorphism with zero. -/
@[simps]
def divMonoidWithZeroHom [CommGroupWithZero M₀] : M₀ × M₀ →*₀ M₀ 
goal: M₀ × M₀ →*₀ M₀
File: Mathlib/Algebra/GroupWithZero/NeZero.lean

full_name: NeZero.one
code: /-- In a nontrivial monoid with zero, zero and one are different. -/
instance NeZero.one : NeZero (1 : M₀) 
goal: NeZero 1

full_name: pullback_nonzero
code: /-- Pullback a `Nontrivial` instance along a function sending `0` to `0` and `1` to `1`. -/
theorem pullback_nonzero [Zero M₀'] [One M₀'] (f : M₀' → M₀) (zero : f 0 = 0) (one : f 1 = 1) :
    Nontrivial M₀' 
goal: Nontrivial M₀'

full_name: inv_ne_zero
code: theorem inv_ne_zero (h : a ≠ 0) : a⁻¹ ≠ 0 
goal: a⁻¹ ≠ 0

full_name: inv_mul_cancel
code: @[simp]
theorem inv_mul_cancel (h : a ≠ 0) : a⁻¹ * a = 1 
goal: a⁻¹ * a = 1
File: Mathlib/Algebra/GroupWithZero/Commute.lean

full_name: Ring.mul_inverse_rev'
code: theorem mul_inverse_rev' {a b : M₀} (h : Commute a b) :
    inverse (a * b) = inverse b * inverse a 
goal: Ring.inverse (a * b) = Ring.inverse b * Ring.inverse a

full_name: Ring.mul_inverse_rev
code: theorem mul_inverse_rev {M₀} [CommMonoidWithZero M₀] (a b : M₀) :
    Ring.inverse (a * b) = inverse b * inverse a 
goal: Ring.inverse (a * b) = Ring.inverse b * Ring.inverse a

full_name: Ring.inverse_pow
code: lemma inverse_pow (r : M₀) : ∀ n : ℕ, Ring.inverse r ^ n = Ring.inverse (r ^ n)
  
goal: Ring.inverse r ^ n = Ring.inverse (r ^ n)

full_name: Commute.ring_inverse_ring_inverse
code: theorem Commute.ring_inverse_ring_inverse {a b : M₀} (h : Commute a b) :
    Commute (Ring.inverse a) (Ring.inverse b) 
goal: Commute (Ring.inverse a) (Ring.inverse b)

full_name: Commute.zero_right
code: @[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : Commute a 0 
goal: Commute a 0

full_name: Commute.zero_left
code: @[simp]
theorem zero_left [MulZeroClass G₀] (a : G₀) : Commute 0 a 
goal: Commute 0 a

full_name: Commute.inv_left_iff₀
code: @[simp]
theorem inv_left_iff₀ : Commute a⁻¹ b ↔ Commute a b 
goal: Commute a⁻¹ b ↔ Commute a b

full_name: Commute.inv_left₀
code: theorem inv_left₀ (h : Commute a b) : Commute a⁻¹ b 
goal: Commute a⁻¹ b

full_name: Commute.inv_right_iff₀
code: @[simp]
theorem inv_right_iff₀ : Commute a b⁻¹ ↔ Commute a b 
goal: Commute a b⁻¹ ↔ Commute a b

full_name: Commute.inv_right₀
code: theorem inv_right₀ (h : Commute a b) : Commute a b⁻¹ 
goal: Commute a b⁻¹

full_name: Commute.div_right
code: @[simp]
theorem div_right (hab : Commute a b) (hac : Commute a c) : Commute a (b / c) 
goal: Commute a (b / c)

full_name: Commute.div_left
code: @[simp]
theorem div_left (hac : Commute a c) (hbc : Commute b c) : Commute (a / b) c 
goal: Commute (a / b) c

full_name: pow_inv_comm₀
code: theorem pow_inv_comm₀ (a : G₀) (m n : ℕ) : a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m 
goal: a⁻¹ ^ m * a ^ n = a ^ n * a⁻¹ ^ m
File: Mathlib/Algebra/GroupWithZero/ULift.lean

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

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

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

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

full_name: ULift.commGroupWithZero
code: instance commGroupWithZero [CommGroupWithZero α] : CommGroupWithZero (ULift α) 
goal: CommGroupWithZero (ULift.{u_1, u} α)
File: Mathlib/Algebra/GroupWithZero/Invertible.lean

full_name: nonzero_of_invertible
code: theorem nonzero_of_invertible [MulZeroOneClass α] (a : α) [Nontrivial α] [Invertible a] : a ≠ 0 
goal: a ≠ 0

full_name: Invertible.ne_zero
code: instance (priority := 100) Invertible.ne_zero [MulZeroOneClass α] [Nontrivial α] (a : α)
    [Invertible a] : NeZero a 
goal: NeZero a

full_name: Ring.inverse_invertible
code: /-- A variant of `Ring.inverse_unit`. -/
@[simp]
theorem Ring.inverse_invertible (x : α) [Invertible x] : Ring.inverse x = ⅟ x 
goal: Ring.inverse x = ⅟x

full_name: invertibleOfNonzero
code: /-- `a⁻¹` is an inverse of `a` if `a ≠ 0` -/
def invertibleOfNonzero {a : α} (h : a ≠ 0) : Invertible a 
goal: Invertible a

full_name: invOf_eq_inv
code: @[simp]
theorem invOf_eq_inv (a : α) [Invertible a] : ⅟ a = a⁻¹ 
goal: ⅟a = a⁻¹

full_name: inv_mul_cancel_of_invertible
code: @[simp]
theorem inv_mul_cancel_of_invertible (a : α) [Invertible a] : a⁻¹ * a = 1 
goal: a⁻¹ * a = 1

full_name: mul_inv_cancel_of_invertible
code: @[simp]
theorem mul_inv_cancel_of_invertible (a : α) [Invertible a] : a * a⁻¹ = 1 
goal: a * a⁻¹ = 1

full_name: invertibleInv
code: /-- `a` is the inverse of `a⁻¹` -/
def invertibleInv {a : α} [Invertible a] : Invertible a⁻¹ 
goal: Invertible a⁻¹

full_name: div_mul_cancel_of_invertible
code: @[simp]
theorem div_mul_cancel_of_invertible (a b : α) [Invertible b] : a / b * b = a 
goal: a / b * b = a

full_name: mul_div_cancel_of_invertible
code: @[simp]
theorem mul_div_cancel_of_invertible (a b : α) [Invertible b] : a * b / b = a 
goal: a * b / b = a

full_name: div_self_of_invertible
code: @[simp]
theorem div_self_of_invertible (a : α) [Invertible a] : a / a = 1 
goal: a / a = 1

full_name: invertibleDiv
code: /-- `b / a` is the inverse of `a / b` -/
def invertibleDiv (a b : α) [Invertible a] [Invertible b] : Invertible (a / b) 
goal: Invertible (a / b)

full_name: invOf_div
code: theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
    ⅟ (a / b) = b / a 
goal: ⅟(a / b) = b / a
File: Mathlib/Algebra/Lie/CartanExists.lean

full_name: LieAlgebra.engel_isBot_of_isMin._aux_Mathlib_Algebra_Lie_CartanExists___macroRules_LieAlgebra_engel_isBot_of_isMin_termφ_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.Macro

full_name: LieAlgebra.engel_isBot_of_isMin._aux_Mathlib_Algebra_Lie_CartanExists___unexpand_LieModule_toEnd_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.PrettyPrinter.Unexpander

full_name: _private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin.lieCharpoly
code: /-- Let `x` and `y` be elements of a Lie `R`-algebra `L`, and `M` a Lie module over `M`.
Then the characteristic polynomials of the family of endomorphisms `⁅r • y + x, _⁆` of `M`
have coefficients that are polynomial in `r : R`.
In other words, we obtain a polynomial over `R[X]`
that specializes to the characteristic polynomial of `⁅r • y + x, _⁆` under the map `X ↦ r`.
This polynomial is captured in `lieCharpoly R M x y`. -/
private noncomputable
def lieCharpoly : Polynomial R[X] 
goal: Polynomial (Polynomial R)

full_name: LieAlgebra.engel_isBot_of_isMin.lieCharpoly_monic
code: lemma lieCharpoly_monic : (lieCharpoly R M x y).Monic 
goal: (LieAlgebra.engel_isBot_of_isMin.lieCharpoly R M x y).Monic

full_name: LieAlgebra.engel_isBot_of_isMin.lieCharpoly_natDegree
code: lemma lieCharpoly_natDegree : (lieCharpoly R M x y).natDegree = finrank R M 
goal: (LieAlgebra.engel_isBot_of_isMin.lieCharpoly R M x y).natDegree = FiniteDimensional.finrank R M

full_name: LieAlgebra.engel_isBot_of_isMin.lieCharpoly_map_eval
code: lemma lieCharpoly_map_eval (r : R) :
    (lieCharpoly R M x y).map (evalRingHom r) = (φ (r • y + x)).charpoly 
goal: Polynomial.map (Polynomial.evalRingHom r) (LieAlgebra.engel_isBot_of_isMin.lieCharpoly R M x y) =
  LinearMap.charpoly ((LieModule.toEnd R L M) (r • y + x))

full_name: LieAlgebra.engel_isBot_of_isMin.lieCharpoly_coeff_natDegree
code: lemma lieCharpoly_coeff_natDegree (i j : ℕ) (hij : i + j = finrank R M) :
    ((lieCharpoly R M x y).coeff i).natDegree ≤ j 
goal: ((LieAlgebra.engel_isBot_of_isMin.lieCharpoly R M x y).coeff i).natDegree ≤ j

full_name: LieAlgebra.engel_isBot_of_isMin
code: /-- Let `L` be a Lie algebra of dimension `n` over a field `K` with at least `n` elements.
Given a Lie subalgebra `U` of `L`, and an element `x ∈ U` such that `U ≤ engel K x`.
Suppose that `engel K x` is minimal amongst the Engel subalgebras `engel K y` for `y ∈ U`.
Then `engel K x ≤ engel K y` for all `y ∈ U`.

Lemma 2 in [barnes1967]. -/
lemma engel_isBot_of_isMin (hLK : finrank K L ≤ #K) (U : LieSubalgebra K L)
    (E : {engel K x | x ∈ U}) (hUle : U ≤ E) (hmin : IsMin E) :
    IsBot E 
goal: IsBot E

full_name: LieAlgebra.exists_isCartanSubalgebra_engel_of_finrank_le_card
code: lemma exists_isCartanSubalgebra_engel_of_finrank_le_card (h : finrank K L ≤ #K) :
    ∃ x : L, IsCartanSubalgebra (engel K x) 
goal: ∃ x, (LieSubalgebra.engel K x).IsCartanSubalgebra

full_name: LieAlgebra.exists_isCartanSubalgebra_engel
code: lemma exists_isCartanSubalgebra_engel [Infinite K] :
    ∃ x : L, IsCartanSubalgebra (engel K x) 
goal: ∃ x, (LieSubalgebra.engel K x).IsCartanSubalgebra
File: Mathlib/Algebra/Divisibility/Prod.lean

full_name: prod_dvd_iff
code: theorem prod_dvd_iff {x y : G₁ × G₂} :
    x ∣ y ↔ x.1 ∣ y.1 ∧ x.2 ∣ y.2 
goal: x ∣ y ↔ x.1 ∣ y.1 ∧ x.2 ∣ y.2

full_name: Prod.mk_dvd_mk
code: @[simp]
theorem Prod.mk_dvd_mk {x₁ y₁ : G₁} {x₂ y₂ : G₂} :
    (x₁, x₂) ∣ (y₁, y₂) ↔ x₁ ∣ y₁ ∧ x₂ ∣ y₂ 
goal: (x₁, x₂) ∣ (y₁, y₂) ↔ x₁ ∣ y₁ ∧ x₂ ∣ y₂

full_name: instDecompositionMonoidProd
code: instance [DecompositionMonoid G₁] [DecompositionMonoid G₂] : DecompositionMonoid (G₁ × G₂) 
goal: DecompositionMonoid (G₁ × G₂)

full_name: pi_dvd_iff
code: theorem pi_dvd_iff {x y : ∀ i, G i} : x ∣ y ↔ ∀ i, x i ∣ y i 
goal: x ∣ y ↔ ∀ (i : ι), x i ∣ y i

full_name: instDecompositionMonoidForall
code: instance [∀ i, DecompositionMonoid (G i)] : DecompositionMonoid (∀ i, G i) 
goal: DecompositionMonoid ((i : ι) → G i)
File: Mathlib/Algebra/Module/LinearMap/Rat.lean

full_name: AddMonoidHom.toRatLinearMap
code: /-- Reinterpret an additive homomorphism as a `ℚ`-linear map. -/
def AddMonoidHom.toRatLinearMap [AddCommGroup M] [Module ℚ M] [AddCommGroup M₂] [Module ℚ M₂]
    (f : M →+ M₂) : M →ₗ[ℚ] M₂ 
goal: M →ₗ[ℚ] M₂

full_name: AddMonoidHom.toRatLinearMap_injective
code: theorem AddMonoidHom.toRatLinearMap_injective [AddCommGroup M] [Module ℚ M] [AddCommGroup M₂]
    [Module ℚ M₂] : Function.Injective (@AddMonoidHom.toRatLinearMap M M₂ _ _ _ _) 
goal: Function.Injective AddMonoidHom.toRatLinearMap

full_name: AddMonoidHom.coe_toRatLinearMap
code: @[simp]
theorem AddMonoidHom.coe_toRatLinearMap [AddCommGroup M] [Module ℚ M] [AddCommGroup M₂]
    [Module ℚ M₂] (f : M →+ M₂) : ⇑f.toRatLinearMap = f 
goal: ⇑f.toRatLinearMap = ⇑f
File: Mathlib/Algebra/Module/LinearMap/Prod.lean

full_name: IsLinearMap.isLinearMap_add
code: theorem isLinearMap_add [AddCommMonoid M] [Module R M] :
    IsLinearMap R fun x : M × M => x.1 + x.2 
goal: IsLinearMap R fun x => x.1 + x.2

full_name: IsLinearMap.isLinearMap_sub
code: theorem isLinearMap_sub [AddCommGroup M] [Module R M] :
    IsLinearMap R fun x : M × M => x.1 - x.2 
goal: IsLinearMap R fun x => x.1 - x.2
File: Mathlib/Algebra/Module/LinearMap/Basic.lean

full_name: LinearMap.instSMulDomMulAct
code: instance : SMul S'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂) 
goal: SMul S'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂)

full_name: DomMulAct.smul_linearMap_apply
code: theorem _root_.DomMulAct.smul_linearMap_apply (a : S'ᵈᵐᵃ) (f : M →ₛₗ[σ₁₂] M₂) (x : M) :
    (a • f) x = f (DomMulAct.mk.symm a • x) 
goal: (a • f) x = f (DomMulAct.mk.symm a • x)

full_name: DomMulAct.mk_smul_linearMap_apply
code: @[simp]
theorem _root_.DomMulAct.mk_smul_linearMap_apply (a : S') (f : M →ₛₗ[σ₁₂] M₂) (x : M) :
    (DomMulAct.mk a • f) x = f (a • x) 
goal: (DomMulAct.mk a • f) x = f (a • x)

full_name: DomMulAct.coe_smul_linearMap
code: theorem  _root_.DomMulAct.coe_smul_linearMap (a : S'ᵈᵐᵃ) (f : M →ₛₗ[σ₁₂] M₂) :
    (a • f : M →ₛₗ[σ₁₂] M₂) = a • (f : M → M₂) 
goal: ⇑(a • f) = a • ⇑f

full_name: LinearMap.instSMulCommClassDomMulAct
code: instance [SMulCommClass S' T' M] : SMulCommClass S'ᵈᵐᵃ T'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂) 
goal: SMulCommClass S'ᵈᵐᵃ T'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂)

full_name: LinearMap.instDistribMulActionDomMulActOfSMulCommClass
code: instance {S'} [Monoid S'] [DistribMulAction S' M] [SMulCommClass R S' M] :
    DistribMulAction S'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂) 
goal: DistribMulAction S'ᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂)

full_name: LinearMap.instNoZeroSMulDivisors
code: instance [NoZeroSMulDivisors S M₂] : NoZeroSMulDivisors S (M →ₛₗ[σ₁₂] M₂) 
goal: NoZeroSMulDivisors S (M →ₛₗ[σ₁₂] M₂)

full_name: LinearMap.instModuleDomMulActOfSMulCommClass
code: instance [SMulCommClass R S M] : Module Sᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂) 
goal: Module Sᵈᵐᵃ (M →ₛₗ[σ₁₂] M₂)
File: Mathlib/Algebra/Module/LinearMap/Star.lean

full_name: _aux_Mathlib_Algebra_Module_LinearMap_Star___unexpand_LinearMap_1
code: /-- `M →ₗ⋆[R] N` is the type of `R`-conjugate-linear maps from `M` to `N`. -/
notation:25 M " →ₗ⋆[" R:25 "] " M₂:0 => LinearMap (starRingEnd R) M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Module_LinearMap_Star___macroRules_term_→ₗ⋆[_]__1»
code: /-- `M →ₗ⋆[R] N` is the type of `R`-conjugate-linear maps from `M` to `N`. -/
notation:25 M " →ₗ⋆[" R:25 "] " M₂:0 => LinearMap (starRingEnd R) M M₂
goal: Lean.Macro

full_name: «_aux_Mathlib_Algebra_Module_LinearMap_Star___macroRules_term_≃ₗ⋆[_]__1»
code: /-- The notation `M ≃ₗ⋆[R] M₂` denotes the type of star-linear equivalences between `M` and `M₂`
over the `⋆` endomorphism of the underlying starred ring `R`. -/
notation:50 M " ≃ₗ⋆[" R "] " M₂ => LinearEquiv (starRingEnd R) M M₂
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Module_LinearMap_Star___unexpand_LinearEquiv_1
code: /-- The notation `M ≃ₗ⋆[R] M₂` denotes the type of star-linear equivalences between `M` and `M₂`
over the `⋆` endomorphism of the underlying starred ring `R`. -/
notation:50 M " ≃ₗ⋆[" R "] " M₂ => LinearEquiv (starRingEnd R) M M₂
goal: Lean.PrettyPrinter.Unexpander
File: Mathlib/Algebra/Module/Opposites.lean

full_name: MulOpposite.instModule
code: /-- `MulOpposite.distribMulAction` extends to a `Module` -/
instance instModule : Module R Mᵐᵒᵖ 
goal: Module R Mᵐᵒᵖ

full_name: MulOpposite.opLinearEquiv
code: /-- The function `op` is a linear equivalence. -/
def opLinearEquiv : M ≃ₗ[R] Mᵐᵒᵖ 
goal: M ≃ₗ[R] Mᵐᵒᵖ

full_name: MulOpposite.coe_opLinearEquiv
code: @[simp]
theorem coe_opLinearEquiv : (opLinearEquiv R : M → Mᵐᵒᵖ) = op 
goal: ⇑(MulOpposite.opLinearEquiv R) = MulOpposite.op

full_name: MulOpposite.coe_opLinearEquiv_symm
code: @[simp]
theorem coe_opLinearEquiv_symm : ((opLinearEquiv R).symm : Mᵐᵒᵖ → M) = unop 
goal: ⇑(MulOpposite.opLinearEquiv R).symm = MulOpposite.unop

full_name: MulOpposite.coe_opLinearEquiv_toLinearMap
code: @[simp]
theorem coe_opLinearEquiv_toLinearMap : ((opLinearEquiv R).toLinearMap : M → Mᵐᵒᵖ) = op 
goal: ⇑↑(MulOpposite.opLinearEquiv R) = MulOpposite.op

full_name: MulOpposite.coe_opLinearEquiv_symm_toLinearMap
code: @[simp]
theorem coe_opLinearEquiv_symm_toLinearMap :
    ((opLinearEquiv R).symm.toLinearMap : Mᵐᵒᵖ → M) = unop 
goal: ⇑↑(MulOpposite.opLinearEquiv R).symm = MulOpposite.unop

full_name: MulOpposite.opLinearEquiv_toAddEquiv
code: theorem opLinearEquiv_toAddEquiv : (opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).toAddEquiv = opAddEquiv 
goal: (MulOpposite.opLinearEquiv R).toAddEquiv = MulOpposite.opAddEquiv

full_name: MulOpposite.coe_opLinearEquiv_addEquiv
code: @[simp]
theorem coe_opLinearEquiv_addEquiv : ((opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ) : M ≃+ Mᵐᵒᵖ) = opAddEquiv 
goal: ↑(MulOpposite.opLinearEquiv R) = MulOpposite.opAddEquiv

full_name: MulOpposite.opLinearEquiv_symm_toAddEquiv
code: theorem opLinearEquiv_symm_toAddEquiv :
    (opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).symm.toAddEquiv = opAddEquiv.symm 
goal: (MulOpposite.opLinearEquiv R).symm.toAddEquiv = MulOpposite.opAddEquiv.symm

full_name: MulOpposite.coe_opLinearEquiv_symm_addEquiv
code: @[simp]
theorem coe_opLinearEquiv_symm_addEquiv :
    ((opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).symm : Mᵐᵒᵖ ≃+ M) = opAddEquiv.symm 
goal: ↑(MulOpposite.opLinearEquiv R).symm = MulOpposite.opAddEquiv.symm