File: Mathlib/Algebra/Algebra/Bilinear.lean

full_name: LinearMap.mul
code: /-- The multiplication in a non-unital non-associative algebra is a bilinear map.

A weaker version of this for semirings exists as `AddMonoidHom.mul`. -/
def mul : A →ₗ[R] A →ₗ[R] A 
goal: A →ₗ[R] A →ₗ[R] A

full_name: LinearMap.mul'
code: /-- The multiplication map on a non-unital algebra, as an `R`-linear map from `A ⊗[R] A` to `A`. -/
noncomputable def mul' : A ⊗[R] A →ₗ[R] A 
goal: A ⊗[R] A →ₗ[R] A

full_name: LinearMap.mulLeft
code: /-- The multiplication on the left in a non-unital algebra is a linear map. -/
def mulLeft (a : A) : A →ₗ[R] A 
goal: A →ₗ[R] A

full_name: LinearMap.mulRight
code: /-- The multiplication on the right in an algebra is a linear map. -/
def mulRight (a : A) : A →ₗ[R] A 
goal: A →ₗ[R] A

full_name: LinearMap.mulLeftRight
code: /-- Simultaneous multiplication on the left and right is a linear map. -/
def mulLeftRight (ab : A × A) : A →ₗ[R] A 
goal: A →ₗ[R] A

full_name: LinearMap.mulLeft_toAddMonoidHom
code: @[simp]
theorem mulLeft_toAddMonoidHom (a : A) : (mulLeft R a : A →+ A) = AddMonoidHom.mulLeft a 
goal: ↑(LinearMap.mulLeft R a) = AddMonoidHom.mulLeft a

full_name: LinearMap.mulRight_toAddMonoidHom
code: @[simp]
theorem mulRight_toAddMonoidHom (a : A) : (mulRight R a : A →+ A) = AddMonoidHom.mulRight a 
goal: ↑(LinearMap.mulRight R a) = AddMonoidHom.mulRight a

full_name: LinearMap.mul_apply'
code: @[simp]
theorem mul_apply' (a b : A) : mul R A a b = a * b 
goal: ((LinearMap.mul R A) a) b = a * b

full_name: LinearMap.mulLeft_apply
code: @[simp]
theorem mulLeft_apply (a b : A) : mulLeft R a b = a * b 
goal: (LinearMap.mulLeft R a) b = a * b

full_name: LinearMap.mulRight_apply
code: @[simp]
theorem mulRight_apply (a b : A) : mulRight R a b = b * a 
goal: (LinearMap.mulRight R a) b = b * a

full_name: LinearMap.mulLeftRight_apply
code: @[simp]
theorem mulLeftRight_apply (a b x : A) : mulLeftRight R (a, b) x = a * x * b 
goal: (LinearMap.mulLeftRight R (a, b)) x = a * x * b

full_name: LinearMap.mul'_apply
code: @[simp]
theorem mul'_apply {a b : A} : mul' R A (a ⊗ₜ b) = a * b 
goal: (LinearMap.mul' R A) (a ⊗ₜ[R] b) = a * b

full_name: LinearMap.mulLeft_zero_eq_zero
code: @[simp]
theorem mulLeft_zero_eq_zero : mulLeft R (0 : A) = 0 
goal: LinearMap.mulLeft R 0 = 0

full_name: LinearMap.mulRight_zero_eq_zero
code: @[simp]
theorem mulRight_zero_eq_zero : mulRight R (0 : A) = 0 
goal: LinearMap.mulRight R 0 = 0

full_name: NonUnitalAlgHom.lmul
code: /-- The multiplication in a non-unital algebra is a bilinear map.

A weaker version of this for non-unital non-associative algebras exists as `LinearMap.mul`. -/
def _root_.NonUnitalAlgHom.lmul : A →ₙₐ[R] End R A 
goal: A →ₙₐ[R] Module.End R A

full_name: NonUnitalAlgHom.coe_lmul_eq_mul
code: @[simp]
theorem _root_.NonUnitalAlgHom.coe_lmul_eq_mul : ⇑(NonUnitalAlgHom.lmul R A) = mul R A 
goal: ⇑(NonUnitalAlgHom.lmul R A) = ⇑(LinearMap.mul R A)

full_name: LinearMap.commute_mulLeft_right
code: theorem commute_mulLeft_right (a b : A) : Commute (mulLeft R a) (mulRight R b) 
goal: Commute (LinearMap.mulLeft R a) (LinearMap.mulRight R b)

full_name: LinearMap.mulLeft_mul
code: @[simp]
theorem mulLeft_mul (a b : A) : mulLeft R (a * b) = (mulLeft R a).comp (mulLeft R b) 
goal: LinearMap.mulLeft R (a * b) = LinearMap.mulLeft R a ∘ₗ LinearMap.mulLeft R b

full_name: LinearMap.mulRight_mul
code: @[simp]
theorem mulRight_mul (a b : A) : mulRight R (a * b) = (mulRight R b).comp (mulRight R a) 
goal: LinearMap.mulRight R (a * b) = LinearMap.mulRight R b ∘ₗ LinearMap.mulRight R a

full_name: LinearMap.map_mul_iff
code: /-- A `LinearMap` preserves multiplication if pre- and post- composition with `LinearMap.mul` are
equivalent. By converting the statement into an equality of `LinearMap`s, this lemma allows various
specialized `ext` lemmas about `→ₗ[R]` to then be applied.

This is the `LinearMap` version of `AddMonoidHom.map_mul_iff`. -/
theorem map_mul_iff (f : A →ₗ[R] B) :
    (∀ x y, f (x * y) = f x * f y) ↔
      (LinearMap.mul R A).compr₂ f = (LinearMap.mul R B ∘ₗ f).compl₂ f 
goal: (∀ (x y : A), f (x * y) = f x * f y) ↔ (LinearMap.mul R A).compr₂ f = (LinearMap.mul R B ∘ₗ f).compl₂ f

full_name: Algebra.lmul
code: /-- The multiplication in an algebra is an algebra homomorphism into the endomorphisms on
the algebra.

A weaker version of this for non-unital algebras exists as `NonUnitalAlgHom.mul`. -/
def _root_.Algebra.lmul : A →ₐ[R] End R A 
goal: A →ₐ[R] Module.End R A

full_name: Algebra.coe_lmul_eq_mul
code: @[simp]
theorem _root_.Algebra.coe_lmul_eq_mul : ⇑(Algebra.lmul R A) = mul R A 
goal: ⇑(Algebra.lmul R A) = ⇑(LinearMap.mul R A)

full_name: Algebra.lmul_injective
code: theorem _root_.Algebra.lmul_injective : Function.Injective (Algebra.lmul R A) 
goal: Function.Injective ⇑(Algebra.lmul R A)

full_name: Algebra.lmul_isUnit_iff
code: theorem _root_.Algebra.lmul_isUnit_iff {x : A} :
    IsUnit (Algebra.lmul R A x) ↔ IsUnit x 
goal: IsUnit ((Algebra.lmul R A) x) ↔ IsUnit x

full_name: LinearMap.mulLeft_eq_zero_iff
code: @[simp]
theorem mulLeft_eq_zero_iff (a : A) : mulLeft R a = 0 ↔ a = 0 
goal: LinearMap.mulLeft R a = 0 ↔ a = 0

full_name: LinearMap.mulRight_eq_zero_iff
code: @[simp]
theorem mulRight_eq_zero_iff (a : A) : mulRight R a = 0 ↔ a = 0 
goal: LinearMap.mulRight R a = 0 ↔ a = 0

full_name: LinearMap.mulLeft_one
code: @[simp]
theorem mulLeft_one : mulLeft R (1 : A) = LinearMap.id 
goal: LinearMap.mulLeft R 1 = LinearMap.id

full_name: LinearMap.mulRight_one
code: @[simp]
theorem mulRight_one : mulRight R (1 : A) = LinearMap.id 
goal: LinearMap.mulRight R 1 = LinearMap.id

full_name: LinearMap.pow_mulLeft
code: @[simp]
theorem pow_mulLeft (a : A) (n : ℕ) : mulLeft R a ^ n = mulLeft R (a ^ n) 
goal: LinearMap.mulLeft R a ^ n = LinearMap.mulLeft R (a ^ n)

full_name: LinearMap.pow_mulRight
code: @[simp]
theorem pow_mulRight (a : A) (n : ℕ) : mulRight R a ^ n = mulRight R (a ^ n) 
goal: LinearMap.mulRight R a ^ n = LinearMap.mulRight R (a ^ n)

full_name: LinearMap.mulLeft_injective
code: theorem mulLeft_injective [NoZeroDivisors A] {x : A} (hx : x ≠ 0) :
    Function.Injective (mulLeft R x) 
goal: Function.Injective ⇑(LinearMap.mulLeft R x)

full_name: LinearMap.mulRight_injective
code: theorem mulRight_injective [NoZeroDivisors A] {x : A} (hx : x ≠ 0) :
    Function.Injective (mulRight R x) 
goal: Function.Injective ⇑(LinearMap.mulRight R x)

full_name: LinearMap.mul_injective
code: theorem mul_injective [NoZeroDivisors A] {x : A} (hx : x ≠ 0) : Function.Injective (mul R A x) 
goal: Function.Injective ⇑((LinearMap.mul R A) x)