File: Mathlib/Algebra/Module/Equiv/Basic.lean

full_name: LinearEquiv.restrictScalars_apply
code: /-- If `M` and `M₂` are both `R`-semimodules and `S`-semimodules and `R`-semimodule structures
are defined by an action of `R` on `S` (formally, we have two scalar towers), then any `S`-linear
equivalence from `M` to `M₂` is also an `R`-linear equivalence.

See also `LinearMap.restrictScalars`. -/
@[simps]
def restrictScalars (f : M ≃ₗ[S] M₂) : M ≃ₗ[R] M₂ 
goal: (LinearEquiv.restrictScalars R f) a = f a

full_name: LinearEquiv.restrictScalars
code: /-- If `M` and `M₂` are both `R`-semimodules and `S`-semimodules and `R`-semimodule structures
are defined by an action of `R` on `S` (formally, we have two scalar towers), then any `S`-linear
equivalence from `M` to `M₂` is also an `R`-linear equivalence.

See also `LinearMap.restrictScalars`. -/
@[simps]
def restrictScalars (f : M ≃ₗ[S] M₂) : M ≃ₗ[R] M₂ 
goal: M ≃ₗ[R] M₂

full_name: LinearEquiv.restrictScalars_symm_apply
code: /-- If `M` and `M₂` are both `R`-semimodules and `S`-semimodules and `R`-semimodule structures
are defined by an action of `R` on `S` (formally, we have two scalar towers), then any `S`-linear
equivalence from `M` to `M₂` is also an `R`-linear equivalence.

See also `LinearMap.restrictScalars`. -/
@[simps]
def restrictScalars (f : M ≃ₗ[S] M₂) : M ≃ₗ[R] M₂ 
goal: (LinearEquiv.restrictScalars R f).symm a = f.symm a

full_name: LinearEquiv.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (M ≃ₗ[S] M₂) → M ≃ₗ[R] M₂) 
goal: Function.Injective (LinearEquiv.restrictScalars R)

full_name: LinearEquiv.restrictScalars_inj
code: @[simp]
theorem restrictScalars_inj (f g : M ≃ₗ[S] M₂) :
    f.restrictScalars R = g.restrictScalars R ↔ f = g 
goal: LinearEquiv.restrictScalars R f = LinearEquiv.restrictScalars R g ↔ f = g

full_name: Module.End_isUnit_iff
code: theorem _root_.Module.End_isUnit_iff [Module R M] (f : Module.End R M) :
    IsUnit f ↔ Function.Bijective f 
goal: IsUnit f ↔ Function.Bijective ⇑f

full_name: LinearEquiv.automorphismGroup
code: instance automorphismGroup : Group (M ≃ₗ[R] M) 
goal: Group (M ≃ₗ[R] M)

full_name: LinearEquiv.coe_one
code: @[simp]
lemma coe_one : ↑(1 : M ≃ₗ[R] M) = id 
goal: ⇑1 = id

full_name: LinearEquiv.coe_toLinearMap_one
code: @[simp]
lemma coe_toLinearMap_one : (↑(1 : M ≃ₗ[R] M) : M →ₗ[R] M) = LinearMap.id 
goal: ↑1 = LinearMap.id

full_name: LinearEquiv.coe_toLinearMap_mul
code: @[simp]
lemma coe_toLinearMap_mul {e₁ e₂ : M ≃ₗ[R] M} :
    (↑(e₁ * e₂) : M →ₗ[R] M) = (e₁ : M →ₗ[R] M) * (e₂ : M →ₗ[R] M) 
goal: ↑(e₁ * e₂) = ↑e₁ * ↑e₂

full_name: LinearEquiv.coe_pow
code: theorem coe_pow (e : M ≃ₗ[R] M) (n : ℕ) : ⇑(e ^ n) = e^[n] 
goal: ⇑(e ^ n) = (⇑e)^[n]

full_name: LinearEquiv.pow_apply
code: theorem pow_apply (e : M ≃ₗ[R] M) (n : ℕ) (m : M) : (e ^ n) m = e^[n] m 
goal: (e ^ n) m = (⇑e)^[n] m

full_name: LinearEquiv.automorphismGroup.toLinearMapMonoidHom
code: /-- Restriction from `R`-linear automorphisms of `M` to `R`-linear endomorphisms of `M`,
promoted to a monoid hom. -/
@[simps]
def automorphismGroup.toLinearMapMonoidHom : (M ≃ₗ[R] M) →* M →ₗ[R] M 
goal: (M ≃ₗ[R] M) →* M →ₗ[R] M

full_name: LinearEquiv.automorphismGroup.toLinearMapMonoidHom_apply
code: /-- Restriction from `R`-linear automorphisms of `M` to `R`-linear endomorphisms of `M`,
promoted to a monoid hom. -/
@[simps]
def automorphismGroup.toLinearMapMonoidHom : (M ≃ₗ[R] M) →* M →ₗ[R] M 
goal: LinearEquiv.automorphismGroup.toLinearMapMonoidHom e = ↑e

full_name: LinearEquiv.applyDistribMulAction
code: /-- The tautological action by `M ≃ₗ[R] M` on `M`.

This generalizes `Function.End.applyMulAction`. -/
instance applyDistribMulAction : DistribMulAction (M ≃ₗ[R] M) M 
goal: DistribMulAction (M ≃ₗ[R] M) M

full_name: LinearEquiv.smul_def
code: @[simp]
protected theorem smul_def (f : M ≃ₗ[R] M) (a : M) : f • a = f a 
goal: f • a = f a

full_name: LinearEquiv.apply_faithfulSMul
code: /-- `LinearEquiv.applyDistribMulAction` is faithful. -/
instance apply_faithfulSMul : FaithfulSMul (M ≃ₗ[R] M) M 
goal: FaithfulSMul (M ≃ₗ[R] M) M

full_name: LinearEquiv.apply_smulCommClass
code: instance apply_smulCommClass : SMulCommClass R (M ≃ₗ[R] M) M 
goal: SMulCommClass R (M ≃ₗ[R] M) M

full_name: LinearEquiv.apply_smulCommClass'
code: instance apply_smulCommClass' : SMulCommClass (M ≃ₗ[R] M) R M 
goal: SMulCommClass (M ≃ₗ[R] M) R M

full_name: LinearEquiv.ofSubsingleton_symm_apply
code: /-- Any two modules that are subsingletons are isomorphic. -/
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂ 
goal: ∀ (x : M₂), (LinearEquiv.ofSubsingleton M M₂).symm x = 0

full_name: LinearEquiv.ofSubsingleton_apply
code: /-- Any two modules that are subsingletons are isomorphic. -/
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂ 
goal: ∀ (x : M), (LinearEquiv.ofSubsingleton M M₂) x = 0

full_name: LinearEquiv.ofSubsingleton
code: /-- Any two modules that are subsingletons are isomorphic. -/
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂ 
goal: M ≃ₗ[R] M₂

full_name: LinearEquiv.ofSubsingleton_self
code: @[simp]
theorem ofSubsingleton_self : ofSubsingleton M M = refl R M 
goal: LinearEquiv.ofSubsingleton M M = LinearEquiv.refl R M

full_name: Module.compHom.toLinearEquiv_apply
code: /-- `g : R ≃+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S 
goal: (Module.compHom.toLinearEquiv g) a = g a

full_name: Module.compHom.toLinearEquiv
code: /-- `g : R ≃+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S 
goal: R ≃ₗ[R] S

full_name: Module.compHom.toLinearEquiv_symm_apply
code: /-- `g : R ≃+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S 
goal: (Module.compHom.toLinearEquiv g).symm a = g.symm a

full_name: DistribMulAction.toLinearEquiv
code: /-- Each element of the group defines a linear equivalence.

This is a stronger version of `DistribMulAction.toAddEquiv`. -/
@[simps!]
def toLinearEquiv (s : S) : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: DistribMulAction.toLinearEquiv_symm_apply
code: /-- Each element of the group defines a linear equivalence.

This is a stronger version of `DistribMulAction.toAddEquiv`. -/
@[simps!]
def toLinearEquiv (s : S) : M ≃ₗ[R] M 
goal: ∀ (a : M), (DistribMulAction.toLinearEquiv R M s).symm a = s⁻¹ • a

full_name: DistribMulAction.toLinearEquiv_apply
code: /-- Each element of the group defines a linear equivalence.

This is a stronger version of `DistribMulAction.toAddEquiv`. -/
@[simps!]
def toLinearEquiv (s : S) : M ≃ₗ[R] M 
goal: ∀ (a : M), (DistribMulAction.toLinearEquiv R M s) a = s • a

full_name: DistribMulAction.toModuleAut
code: /-- Each element of the group defines a module automorphism.

This is a stronger version of `DistribMulAction.toAddAut`. -/
@[simps]
def toModuleAut : S →* M ≃ₗ[R] M 
goal: S →* M ≃ₗ[R] M

full_name: DistribMulAction.toModuleAut_apply
code: /-- Each element of the group defines a module automorphism.

This is a stronger version of `DistribMulAction.toAddAut`. -/
@[simps]
def toModuleAut : S →* M ≃ₗ[R] M 
goal: (DistribMulAction.toModuleAut R M) s = DistribMulAction.toLinearEquiv R M s

full_name: AddEquiv.toLinearEquiv
code: /-- An additive equivalence whose underlying function preserves `smul` is a linear equivalence. -/
def toLinearEquiv (h : ∀ (c : R) (x), e (c • x) = c • e x) : M ≃ₗ[R] M₂ 
goal: M ≃ₗ[R] M₂

full_name: AddEquiv.coe_toLinearEquiv
code: @[simp]
theorem coe_toLinearEquiv (h : ∀ (c : R) (x), e (c • x) = c • e x) : ⇑(e.toLinearEquiv h) = e 
goal: ⇑(e.toLinearEquiv h) = ⇑e

full_name: AddEquiv.coe_toLinearEquiv_symm
code: @[simp]
theorem coe_toLinearEquiv_symm (h : ∀ (c : R) (x), e (c • x) = c • e x) :
    ⇑(e.toLinearEquiv h).symm = e.symm 
goal: ⇑(e.toLinearEquiv h).symm = ⇑e.symm

full_name: AddEquiv.toNatLinearEquiv
code: /-- An additive equivalence between commutative additive monoids is a linear equivalence between
ℕ-modules -/
def toNatLinearEquiv : M ≃ₗ[ℕ] M₂ 
goal: M ≃ₗ[ℕ] M₂

full_name: AddEquiv.coe_toNatLinearEquiv
code: @[simp]
theorem coe_toNatLinearEquiv : ⇑e.toNatLinearEquiv = e 
goal: ⇑e.toNatLinearEquiv = ⇑e

full_name: AddEquiv.toNatLinearEquiv_toAddEquiv
code: @[simp]
theorem toNatLinearEquiv_toAddEquiv : ↑e.toNatLinearEquiv = e 
goal: ↑e.toNatLinearEquiv = e

full_name: LinearEquiv.toAddEquiv_toNatLinearEquiv
code: @[simp]
theorem _root_.LinearEquiv.toAddEquiv_toNatLinearEquiv (e : M ≃ₗ[ℕ] M₂) :
    AddEquiv.toNatLinearEquiv ↑e = e 
goal: (↑e).toNatLinearEquiv = e

full_name: AddEquiv.toNatLinearEquiv_symm
code: @[simp]
theorem toNatLinearEquiv_symm : e.toNatLinearEquiv.symm = e.symm.toNatLinearEquiv 
goal: e.toNatLinearEquiv.symm = e.symm.toNatLinearEquiv

full_name: AddEquiv.toNatLinearEquiv_refl
code: @[simp]
theorem toNatLinearEquiv_refl : (AddEquiv.refl M).toNatLinearEquiv = LinearEquiv.refl ℕ M 
goal: (AddEquiv.refl M).toNatLinearEquiv = LinearEquiv.refl ℕ M

full_name: AddEquiv.toNatLinearEquiv_trans
code: @[simp]
theorem toNatLinearEquiv_trans (e₂ : M₂ ≃+ M₃) :
    e.toNatLinearEquiv.trans e₂.toNatLinearEquiv = (e.trans e₂).toNatLinearEquiv 
goal: e.toNatLinearEquiv ≪≫ₗ e₂.toNatLinearEquiv = (e.trans e₂).toNatLinearEquiv

full_name: AddEquiv.toIntLinearEquiv
code: /-- An additive equivalence between commutative additive groups is a linear
equivalence between ℤ-modules -/
def toIntLinearEquiv : M ≃ₗ[ℤ] M₂ 
goal: M ≃ₗ[ℤ] M₂

full_name: AddEquiv.coe_toIntLinearEquiv
code: @[simp]
theorem coe_toIntLinearEquiv : ⇑e.toIntLinearEquiv = e 
goal: ⇑e.toIntLinearEquiv = ⇑e

full_name: AddEquiv.toIntLinearEquiv_toAddEquiv
code: @[simp]
theorem toIntLinearEquiv_toAddEquiv : ↑e.toIntLinearEquiv = e 
goal: ↑e.toIntLinearEquiv = e

full_name: LinearEquiv.toAddEquiv_toIntLinearEquiv
code: @[simp]
theorem _root_.LinearEquiv.toAddEquiv_toIntLinearEquiv (e : M ≃ₗ[ℤ] M₂) :
    AddEquiv.toIntLinearEquiv (e : M ≃+ M₂) = e 
goal: (↑e).toIntLinearEquiv = e

full_name: AddEquiv.toIntLinearEquiv_symm
code: @[simp]
theorem toIntLinearEquiv_symm : e.toIntLinearEquiv.symm = e.symm.toIntLinearEquiv 
goal: e.toIntLinearEquiv.symm = e.symm.toIntLinearEquiv

full_name: AddEquiv.toIntLinearEquiv_refl
code: @[simp]
theorem toIntLinearEquiv_refl : (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M 
goal: (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M

full_name: AddEquiv.toIntLinearEquiv_trans
code: @[simp]
theorem toIntLinearEquiv_trans (e₂ : M₂ ≃+ M₃) :
    e.toIntLinearEquiv.trans e₂.toIntLinearEquiv = (e.trans e₂).toIntLinearEquiv 
goal: e.toIntLinearEquiv ≪≫ₗ e₂.toIntLinearEquiv = (e.trans e₂).toIntLinearEquiv

full_name: LinearMap.ringLmapEquivSelf_apply
code: /-- The equivalence between R-linear maps from `R` to `M`, and points of `M` itself.
This says that the forgetful functor from `R`-modules to types is representable, by `R`.

This is an `S`-linear equivalence, under the assumption that `S` acts on `M` commuting with `R`.
When `R` is commutative, we can take this to be the usual action with `S = R`.
Otherwise, `S = ℕ` shows that the equivalence is additive.
See note [bundled maps over different rings].
-/
@[simps]
def ringLmapEquivSelf [Module S M] [SMulCommClass R S M] : (R →ₗ[R] M) ≃ₗ[S] M 
goal: (LinearMap.ringLmapEquivSelf R S M) f = f 1

full_name: LinearMap.ringLmapEquivSelf
code: /-- The equivalence between R-linear maps from `R` to `M`, and points of `M` itself.
This says that the forgetful functor from `R`-modules to types is representable, by `R`.

This is an `S`-linear equivalence, under the assumption that `S` acts on `M` commuting with `R`.
When `R` is commutative, we can take this to be the usual action with `S = R`.
Otherwise, `S = ℕ` shows that the equivalence is additive.
See note [bundled maps over different rings].
-/
@[simps]
def ringLmapEquivSelf [Module S M] [SMulCommClass R S M] : (R →ₗ[R] M) ≃ₗ[S] M 
goal: (R →ₗ[R] M) ≃ₗ[S] M

full_name: LinearMap.ringLmapEquivSelf_symm_apply
code: /-- The equivalence between R-linear maps from `R` to `M`, and points of `M` itself.
This says that the forgetful functor from `R`-modules to types is representable, by `R`.

This is an `S`-linear equivalence, under the assumption that `S` acts on `M` commuting with `R`.
When `R` is commutative, we can take this to be the usual action with `S = R`.
Otherwise, `S = ℕ` shows that the equivalence is additive.
See note [bundled maps over different rings].
-/
@[simps]
def ringLmapEquivSelf [Module S M] [SMulCommClass R S M] : (R →ₗ[R] M) ≃ₗ[S] M 
goal: (LinearMap.ringLmapEquivSelf R S M).symm x = LinearMap.smulRight 1 x

full_name: addMonoidHomLequivNat
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℕ`-linear morphisms `A →ₗ[ℕ] B`.
-/
@[simps]
def addMonoidHomLequivNat {A B : Type*} (R : Type*) [Semiring R] [AddCommMonoid A]
    [AddCommMonoid B] [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B
    
goal: (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B

full_name: addMonoidHomLequivNat_apply
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℕ`-linear morphisms `A →ₗ[ℕ] B`.
-/
@[simps]
def addMonoidHomLequivNat {A B : Type*} (R : Type*) [Semiring R] [AddCommMonoid A]
    [AddCommMonoid B] [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B
    
goal: (addMonoidHomLequivNat R) f = f.toNatLinearMap

full_name: addMonoidHomLequivNat_symm_apply
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℕ`-linear morphisms `A →ₗ[ℕ] B`.
-/
@[simps]
def addMonoidHomLequivNat {A B : Type*} (R : Type*) [Semiring R] [AddCommMonoid A]
    [AddCommMonoid B] [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B
    
goal: (addMonoidHomLequivNat R).symm f = f.toAddMonoidHom

full_name: addMonoidHomLequivInt_symm_apply
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    
goal: (addMonoidHomLequivInt R).symm f = f.toAddMonoidHom

full_name: addMonoidHomLequivInt
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    
goal: (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B

full_name: addMonoidHomLequivInt_apply
code: /--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    
goal: (addMonoidHomLequivInt R) f = f.toIntLinearMap

full_name: addMonoidEndRingEquivInt
code: /-- Ring equivalence between additive group endomorphisms of an `AddCommGroup` `A` and
`ℤ`-module endomorphisms of `A.` -/
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A 
goal: AddMonoid.End A ≃+* Module.End ℤ A

full_name: addMonoidEndRingEquivInt_apply
code: /-- Ring equivalence between additive group endomorphisms of an `AddCommGroup` `A` and
`ℤ`-module endomorphisms of `A.` -/
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A 
goal: ∀ (a : A →+ A), (addMonoidEndRingEquivInt A) a = (↑(addMonoidHomLequivInt ℤ)).toFun a

full_name: addMonoidEndRingEquivInt_symm_apply
code: /-- Ring equivalence between additive group endomorphisms of an `AddCommGroup` `A` and
`ℤ`-module endomorphisms of `A.` -/
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A 
goal: ∀ (a : A →ₗ[ℤ] A), (addMonoidEndRingEquivInt A).symm a = (addMonoidHomLequivInt ℤ).invFun a

full_name: LinearEquiv.instZero
code: /-- Between two zero modules, the zero map is an equivalence. -/
instance : Zero (M ≃ₛₗ[σ₁₂] M₂) 
goal: Zero (M ≃ₛₗ[σ₁₂] M₂)

full_name: LinearEquiv.zero_symm
code: @[simp]
theorem zero_symm : (0 : M ≃ₛₗ[σ₁₂] M₂).symm = 0 
goal: LinearEquiv.symm 0 = 0

full_name: LinearEquiv.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : M ≃ₛₗ[σ₁₂] M₂) = 0 
goal: ⇑0 = 0

full_name: LinearEquiv.zero_apply
code: theorem zero_apply (x : M) : (0 : M ≃ₛₗ[σ₁₂] M₂) x = 0 
goal: 0 x = 0

full_name: LinearEquiv.instUnique
code: /-- Between two zero modules, the zero map is the only equivalence. -/
instance : Unique (M ≃ₛₗ[σ₁₂] M₂) 
goal: Unique (M ≃ₛₗ[σ₁₂] M₂)

full_name: LinearEquiv.uniqueOfSubsingleton
code: instance uniqueOfSubsingleton [Subsingleton R] [Subsingleton R₂] : Unique (M ≃ₛₗ[σ₁₂] M₂) 
goal: Unique (M ≃ₛₗ[σ₁₂] M₂)

full_name: LinearEquiv.curry
code: /-- Linear equivalence between a curried and uncurried function.
  Differs from `TensorProduct.curry`. -/
protected def curry : (V × V₂ → R) ≃ₗ[R] V → V₂ → R 
goal: (V × V₂ → R) ≃ₗ[R] V → V₂ → R

full_name: LinearEquiv.coe_curry
code: @[simp]
theorem coe_curry : ⇑(LinearEquiv.curry R V V₂) = curry 
goal: ⇑(LinearEquiv.curry R V V₂) = Function.curry

full_name: LinearEquiv.coe_curry_symm
code: @[simp]
theorem coe_curry_symm : ⇑(LinearEquiv.curry R V V₂).symm = uncurry 
goal: ⇑(LinearEquiv.curry R V V₂).symm = Function.uncurry

full_name: LinearEquiv.ofLinear
code: /-- If a linear map has an inverse, it is a linear equivalence. -/
def ofLinear (h₁ : f.comp g = LinearMap.id) (h₂ : g.comp f = LinearMap.id) : M ≃ₛₗ[σ₁₂] M₂ 
goal: M ≃ₛₗ[σ₁₂] M₂

full_name: LinearEquiv.ofLinear_apply
code: @[simp]
theorem ofLinear_apply {h₁ h₂} (x : M) : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂) x = f x 
goal: (LinearEquiv.ofLinear f g h₁ h₂) x = f x

full_name: LinearEquiv.ofLinear_symm_apply
code: @[simp]
theorem ofLinear_symm_apply {h₁ h₂} (x : M₂) : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂).symm x = g x 
goal: (LinearEquiv.ofLinear f g h₁ h₂).symm x = g x

full_name: LinearEquiv.ofLinear_toLinearMap
code: @[simp]
theorem ofLinear_toLinearMap {h₁ h₂} : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂) = f 
goal: ↑(LinearEquiv.ofLinear f g h₁ h₂) = f

full_name: LinearEquiv.ofLinear_symm_toLinearMap
code: @[simp]
theorem ofLinear_symm_toLinearMap {h₁ h₂} : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂).symm = g 
goal: ↑(LinearEquiv.ofLinear f g h₁ h₂).symm = g

full_name: LinearEquiv.neg
code: /-- `x ↦ -x` as a `LinearEquiv` -/
def neg : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: LinearEquiv.coe_neg
code: @[simp]
theorem coe_neg : ⇑(neg R : M ≃ₗ[R] M) = -id 
goal: ⇑(LinearEquiv.neg R) = -id

full_name: LinearEquiv.neg_apply
code: theorem neg_apply (x : M) : neg R x = -x 
goal: (LinearEquiv.neg R) x = -x

full_name: LinearEquiv.symm_neg
code: @[simp]
theorem symm_neg : (neg R : M ≃ₗ[R] M).symm = neg R 
goal: (LinearEquiv.neg R).symm = LinearEquiv.neg R

full_name: LinearEquiv.smulOfUnit
code: /-- Multiplying by a unit `a` of the ring `R` is a linear equivalence. -/
def smulOfUnit (a : Rˣ) : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: LinearEquiv.arrowCongr
code: /-- A linear isomorphism between the domains and codomains of two spaces of linear maps gives a
linear isomorphism between the two function spaces. -/
def arrowCongr {R M₁ M₂ M₂₁ M₂₂ : Sort _} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂]
    [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂] [Module R M₂₁]
    [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) : (M₁ →ₗ[R] M₂₁) ≃ₗ[R] M₂ →ₗ[R] M₂₂ 
goal: (M₁ →ₗ[R] M₂₁) ≃ₗ[R] M₂ →ₗ[R] M₂₂

full_name: LinearEquiv.arrowCongr_apply
code: @[simp]
theorem arrowCongr_apply {R M₁ M₂ M₂₁ M₂₂ : Sort _} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂]
    [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₁ →ₗ[R] M₂₁)
    (x : M₂) : arrowCongr e₁ e₂ f x = e₂ (f (e₁.symm x)) 
goal: ((e₁.arrowCongr e₂) f) x = e₂ (f (e₁.symm x))

full_name: LinearEquiv.arrowCongr_symm_apply
code: @[simp]
theorem arrowCongr_symm_apply {R M₁ M₂ M₂₁ M₂₂ : Sort _} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂]
    [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₂ →ₗ[R] M₂₂)
    (x : M₁) : (arrowCongr e₁ e₂).symm f x = e₂.symm (f (e₁ x)) 
goal: ((e₁.arrowCongr e₂).symm f) x = e₂.symm (f (e₁ x))

full_name: LinearEquiv.arrowCongr_comp
code: theorem arrowCongr_comp {N N₂ N₃ : Sort _} [AddCommMonoid N] [AddCommMonoid N₂] [AddCommMonoid N₃]
    [Module R N] [Module R N₂] [Module R N₃] (e₁ : M ≃ₗ[R] N) (e₂ : M₂ ≃ₗ[R] N₂) (e₃ : M₃ ≃ₗ[R] N₃)
    (f : M →ₗ[R] M₂) (g : M₂ →ₗ[R] M₃) :
    arrowCongr e₁ e₃ (g.comp f) = (arrowCongr e₂ e₃ g).comp (arrowCongr e₁ e₂ f) 
goal: (e₁.arrowCongr e₃) (g ∘ₗ f) = (e₂.arrowCongr e₃) g ∘ₗ (e₁.arrowCongr e₂) f

full_name: LinearEquiv.arrowCongr_trans
code: theorem arrowCongr_trans {M₁ M₂ M₃ N₁ N₂ N₃ : Sort _} [AddCommMonoid M₁] [Module R M₁]
    [AddCommMonoid M₂] [Module R M₂] [AddCommMonoid M₃] [Module R M₃] [AddCommMonoid N₁]
    [Module R N₁] [AddCommMonoid N₂] [Module R N₂] [AddCommMonoid N₃] [Module R N₃]
    (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : N₁ ≃ₗ[R] N₂) (e₃ : M₂ ≃ₗ[R] M₃) (e₄ : N₂ ≃ₗ[R] N₃) :
    (arrowCongr e₁ e₂).trans (arrowCongr e₃ e₄) = arrowCongr (e₁.trans e₃) (e₂.trans e₄) 
goal: e₁.arrowCongr e₂ ≪≫ₗ e₃.arrowCongr e₄ = (e₁ ≪≫ₗ e₃).arrowCongr (e₂ ≪≫ₗ e₄)

full_name: LinearEquiv.congrRight
code: /-- If `M₂` and `M₃` are linearly isomorphic then the two spaces of linear maps from `M` into `M₂`
and `M` into `M₃` are linearly isomorphic. -/
def congrRight (f : M₂ ≃ₗ[R] M₃) : (M →ₗ[R] M₂) ≃ₗ[R] M →ₗ[R] M₃ 
goal: (M →ₗ[R] M₂) ≃ₗ[R] M →ₗ[R] M₃

full_name: LinearEquiv.conj
code: /-- If `M` and `M₂` are linearly isomorphic then the two spaces of linear maps from `M` and `M₂` to
themselves are linearly isomorphic. -/
def conj (e : M ≃ₗ[R] M₂) : Module.End R M ≃ₗ[R] Module.End R M₂ 
goal: Module.End R M ≃ₗ[R] Module.End R M₂

full_name: LinearEquiv.conj_apply
code: theorem conj_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M) :
    e.conj f = ((↑e : M →ₗ[R] M₂).comp f).comp (e.symm : M₂ →ₗ[R] M) 
goal: e.conj f = (↑e ∘ₗ f) ∘ₗ ↑e.symm

full_name: LinearEquiv.conj_apply_apply
code: theorem conj_apply_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M) (x : M₂) :
    e.conj f x = e (f (e.symm x)) 
goal: (e.conj f) x = e (f (e.symm x))

full_name: LinearEquiv.symm_conj_apply
code: theorem symm_conj_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M₂) :
    e.symm.conj f = ((↑e.symm : M₂ →ₗ[R] M).comp f).comp (e : M →ₗ[R] M₂) 
goal: e.symm.conj f = (↑e.symm ∘ₗ f) ∘ₗ ↑e

full_name: LinearEquiv.conj_comp
code: theorem conj_comp (e : M ≃ₗ[R] M₂) (f g : Module.End R M) :
    e.conj (g.comp f) = (e.conj g).comp (e.conj f) 
goal: e.conj (g ∘ₗ f) = e.conj g ∘ₗ e.conj f

full_name: LinearEquiv.conj_trans
code: theorem conj_trans (e₁ : M ≃ₗ[R] M₂) (e₂ : M₂ ≃ₗ[R] M₃) :
    e₁.conj.trans e₂.conj = (e₁.trans e₂).conj 
goal: e₁.conj ≪≫ₗ e₂.conj = (e₁ ≪≫ₗ e₂).conj

full_name: LinearEquiv.conj_id
code: @[simp]
theorem conj_id (e : M ≃ₗ[R] M₂) : e.conj LinearMap.id = LinearMap.id 
goal: e.conj LinearMap.id = LinearMap.id

full_name: LinearEquiv.congrLeft
code: /-- An `R`-linear isomorphism between two `R`-modules `M₂` and `M₃` induces an `S`-linear
isomorphism between `M₂ →ₗ[R] M` and `M₃ →ₗ[R] M`, if `M` is both an `R`-module and an
`S`-module and their actions commute. -/
def congrLeft {R} (S) [Semiring R] [Semiring S] [Module R M₂] [Module R M₃] [Module R M]
    [Module S M] [SMulCommClass R S M] (e : M₂ ≃ₗ[R] M₃) : (M₂ →ₗ[R] M) ≃ₗ[S] (M₃ →ₗ[R] M) 
goal: (M₂ →ₗ[R] M) ≃ₗ[S] M₃ →ₗ[R] M

full_name: LinearEquiv.smulOfNeZero_symm_apply
code: /-- Multiplying by a nonzero element `a` of the field `K` is a linear equivalence. -/
@[simps!]
def smulOfNeZero (a : K) (ha : a ≠ 0) : M ≃ₗ[K] M 
goal: ∀ (a_1 : M), (LinearEquiv.smulOfNeZero K M a ha).symm a_1 = (Units.mk0 a ha)⁻¹ • a_1

full_name: LinearEquiv.smulOfNeZero
code: /-- Multiplying by a nonzero element `a` of the field `K` is a linear equivalence. -/
@[simps!]
def smulOfNeZero (a : K) (ha : a ≠ 0) : M ≃ₗ[K] M 
goal: M ≃ₗ[K] M

full_name: LinearEquiv.smulOfNeZero_apply
code: /-- Multiplying by a nonzero element `a` of the field `K` is a linear equivalence. -/
@[simps!]
def smulOfNeZero (a : K) (ha : a ≠ 0) : M ≃ₗ[K] M 
goal: ∀ (a_1 : M), (LinearEquiv.smulOfNeZero K M a ha) a_1 = Units.mk0 a ha • a_1

full_name: Equiv.toLinearEquiv
code: /-- An equivalence whose underlying function is linear is a linear equivalence. -/
def toLinearEquiv (e : M ≃ M₂) (h : IsLinearMap R (e : M → M₂)) : M ≃ₗ[R] M₂ 
goal: M ≃ₗ[R] M₂

full_name: LinearMap.funLeft
code: /-- Given an `R`-module `M` and a function `m → n` between arbitrary types,
construct a linear map `(n → M) →ₗ[R] (m → M)` -/
def funLeft (f : m → n) : (n → M) →ₗ[R] m → M 
goal: (n → M) →ₗ[R] m → M

full_name: LinearMap.funLeft_apply
code: @[simp]
theorem funLeft_apply (f : m → n) (g : n → M) (i : m) : funLeft R M f g i = g (f i) 
goal: (LinearMap.funLeft R M f) g i = g (f i)

full_name: LinearMap.funLeft_id
code: @[simp]
theorem funLeft_id (g : n → M) : funLeft R M _root_.id g = g 
goal: (LinearMap.funLeft R M id) g = g

full_name: LinearMap.funLeft_comp
code: theorem funLeft_comp (f₁ : n → p) (f₂ : m → n) :
    funLeft R M (f₁ ∘ f₂) = (funLeft R M f₂).comp (funLeft R M f₁) 
goal: LinearMap.funLeft R M (f₁ ∘ f₂) = LinearMap.funLeft R M f₂ ∘ₗ LinearMap.funLeft R M f₁

full_name: LinearMap.funLeft_surjective_of_injective
code: theorem funLeft_surjective_of_injective (f : m → n) (hf : Injective f) :
    Surjective (funLeft R M f) 
goal: Function.Surjective ⇑(LinearMap.funLeft R M f)

full_name: LinearMap.funLeft_injective_of_surjective
code: theorem funLeft_injective_of_surjective (f : m → n) (hf : Surjective f) :
    Injective (funLeft R M f) 
goal: Function.Injective ⇑(LinearMap.funLeft R M f)

full_name: LinearEquiv.funCongrLeft
code: /-- Given an `R`-module `M` and an equivalence `m ≃ n` between arbitrary types,
construct a linear equivalence `(n → M) ≃ₗ[R] (m → M)` -/
def funCongrLeft (e : m ≃ n) : (n → M) ≃ₗ[R] m → M 
goal: (n → M) ≃ₗ[R] m → M

full_name: LinearEquiv.funCongrLeft_apply
code: @[simp]
theorem funCongrLeft_apply (e : m ≃ n) (x : n → M) : funCongrLeft R M e x = funLeft R M e x 
goal: (LinearEquiv.funCongrLeft R M e) x = (LinearMap.funLeft R M ⇑e) x

full_name: LinearEquiv.funCongrLeft_id
code: @[simp]
theorem funCongrLeft_id : funCongrLeft R M (Equiv.refl n) = LinearEquiv.refl R (n → M) 
goal: LinearEquiv.funCongrLeft R M (Equiv.refl n) = LinearEquiv.refl R (n → M)

full_name: LinearEquiv.funCongrLeft_comp
code: @[simp]
theorem funCongrLeft_comp (e₁ : m ≃ n) (e₂ : n ≃ p) :
    funCongrLeft R M (Equiv.trans e₁ e₂) =
      LinearEquiv.trans (funCongrLeft R M e₂) (funCongrLeft R M e₁) 
goal: LinearEquiv.funCongrLeft R M (e₁.trans e₂) = LinearEquiv.funCongrLeft R M e₂ ≪≫ₗ LinearEquiv.funCongrLeft R M e₁

full_name: LinearEquiv.funCongrLeft_symm
code: @[simp]
theorem funCongrLeft_symm (e : m ≃ n) : (funCongrLeft R M e).symm = funCongrLeft R M e.symm 
goal: (LinearEquiv.funCongrLeft R M e).symm = LinearEquiv.funCongrLeft R M e.symm