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

full_name: LinearEquiv
code: /-- A linear equivalence is an invertible linear map. -/
-- Porting note (#11215): TODO @[nolint has_nonempty_instance]
structure LinearEquiv {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
  {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) (M₂ : Type*)
  [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂] extends LinearMap σ M M₂, M ≃+ M₂
goal: Type (max u_19 u_20)

full_name: _aux_Mathlib_Algebra_Module_Equiv_Defs___unexpand_LinearEquiv_1
code: /-- The notation `M ≃ₛₗ[σ] M₂` denotes the type of linear equivalences between `M` and `M₂` over a
ring homomorphism `σ`. -/
notation:50 M " ≃ₛₗ[" σ "] " M₂ => LinearEquiv σ M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Module_Equiv_Defs___macroRules_term_≃ₛₗ[_]__1»
code: /-- The notation `M ≃ₛₗ[σ] M₂` denotes the type of linear equivalences between `M` and `M₂` over a
ring homomorphism `σ`. -/
notation:50 M " ≃ₛₗ[" σ "] " M₂ => LinearEquiv σ M M₂
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Module_Equiv_Defs___unexpand_LinearEquiv_2
code: /-- The notation `M ≃ₗ [R] M₂` denotes the type of linear equivalences between `M` and `M₂` over
a plain linear map `M →ₗ M₂`. -/
notation:50 M " ≃ₗ[" R "] " M₂ => LinearEquiv (RingHom.id R) M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Module_Equiv_Defs___macroRules_term_≃ₗ[_]__1»
code: /-- The notation `M ≃ₗ [R] M₂` denotes the type of linear equivalences between `M` and `M₂` over
a plain linear map `M →ₗ M₂`. -/
notation:50 M " ≃ₗ[" R "] " M₂ => LinearEquiv (RingHom.id R) M M₂
goal: Lean.Macro

full_name: SemilinearEquivClass.map_smulₛₗ
code: /-- `SemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled `σ`-semilinear equivs
`M → M₂`.

See also `LinearEquivClass F R M M₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearEquivClass (F : Type*) {R S : outParam Type*} [Semiring R] [Semiring S]
  (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
  (M M₂ : outParam Type*) [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂]
  [EquivLike F M M₂]
  extends AddEquivClass F M M₂ : Prop where
  /-- Applying a semilinear equivalence `f` over `σ` to `r • x` equals `σ r • f x`. -/
  map_smulₛₗ : ∀ (f : F) (r : R) (x : M), f (r • x) = σ r • f x
goal: f (r • x) = σ r • f x

full_name: SemilinearEquivClass
code: /-- `SemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled `σ`-semilinear equivs
`M → M₂`.

See also `LinearEquivClass F R M M₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearEquivClass (F : Type*) {R S : outParam Type*} [Semiring R] [Semiring S]
  (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
  (M M₂ : outParam Type*) [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂]
  [EquivLike F M M₂]
  extends AddEquivClass F M M₂ : Prop where
  /-- Applying a semilinear equivalence `f` over `σ` to `r • x` equals `σ r • f x`. -/
  map_smulₛₗ : ∀ (f : F) (r : R) (x : M), f (r • x) = σ r • f x
goal: Prop

full_name: LinearEquivClass
code: /-- `LinearEquivClass F R M M₂` asserts `F` is a type of bundled `R`-linear equivs `M → M₂`.
This is an abbreviation for `SemilinearEquivClass F (RingHom.id R) M M₂`.
-/
abbrev LinearEquivClass (F : Type*) (R M M₂ : outParam Type*) [Semiring R] [AddCommMonoid M]
    [AddCommMonoid M₂] [Module R M] [Module R M₂] [EquivLike F M M₂] 
goal: Prop

full_name: SemilinearEquivClass.instSemilinearMapClass
code: instance (priority := 100) [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
  [EquivLike F M M₂] [s : SemilinearEquivClass F σ M M₂] : SemilinearMapClass F σ M M₂ 
goal: SemilinearMapClass F σ M M₂

full_name: SemilinearEquivClass.semilinearEquiv
code: /-- Reinterpret an element of a type of semilinear equivalences as a semilinear equivalence. -/
@[coe]
def semilinearEquiv [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    [EquivLike F M M₂] [SemilinearEquivClass F σ M M₂] (f : F) : M ≃ₛₗ[σ] M₂ 
goal: M ≃ₛₗ[σ] M₂

full_name: SemilinearEquivClass.instCoeToSemilinearEquiv
code: /-- Reinterpret an element of a type of semilinear equivalences as a semilinear equivalence. -/
instance instCoeToSemilinearEquiv [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    [EquivLike F M M₂] [SemilinearEquivClass F σ M M₂] : CoeHead F (M ≃ₛₗ[σ] M₂) 
goal: CoeHead F (M ≃ₛₗ[σ] M₂)

full_name: LinearEquiv.instCoeLinearMap
code: instance : Coe (M ≃ₛₗ[σ] M₂) (M →ₛₗ[σ] M₂) 
goal: Coe (M ≃ₛₗ[σ] M₂) (M →ₛₗ[σ] M₂)

full_name: LinearEquiv.toEquiv
code: /-- The equivalence of types underlying a linear equivalence. -/
def toEquiv : (M ≃ₛₗ[σ] M₂) → M ≃ M₂ 
goal: (M ≃ₛₗ[σ] M₂) → M ≃ M₂

full_name: LinearEquiv.toEquiv_injective
code: theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₛₗ[σ] M₂) → M ≃ M₂) 
goal: Function.Injective LinearEquiv.toEquiv

full_name: LinearEquiv.toEquiv_inj
code: @[simp]
theorem toEquiv_inj {e₁ e₂ : M ≃ₛₗ[σ] M₂} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂ 
goal: e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂

full_name: LinearEquiv.toLinearMap_injective
code: theorem toLinearMap_injective : Injective (toLinearMap : (M ≃ₛₗ[σ] M₂) → M →ₛₗ[σ] M₂) 
goal: Function.Injective LinearEquiv.toLinearMap

full_name: LinearEquiv.toLinearMap_inj
code: @[simp, norm_cast]
theorem toLinearMap_inj {e₁ e₂ : M ≃ₛₗ[σ] M₂} : (↑e₁ : M →ₛₗ[σ] M₂) = e₂ ↔ e₁ = e₂ 
goal: ↑e₁ = ↑e₂ ↔ e₁ = e₂

full_name: LinearEquiv.instEquivLike
code: instance : EquivLike (M ≃ₛₗ[σ] M₂) M M₂ 
goal: EquivLike (M ≃ₛₗ[σ] M₂) M M₂

full_name: LinearEquiv.instFunLike
code: /-- Helper instance for when inference gets stuck on following the normal chain
`EquivLike → FunLike`.

TODO: this instance doesn't appear to be necessary: remove it (after benchmarking?)
-/
instance : FunLike (M ≃ₛₗ[σ] M₂) M M₂ 
goal: FunLike (M ≃ₛₗ[σ] M₂) M M₂

full_name: LinearEquiv.instSemilinearEquivClass
code: instance : SemilinearEquivClass (M ≃ₛₗ[σ] M₂) σ M M₂ 
goal: SemilinearEquivClass (M ≃ₛₗ[σ] M₂) σ M M₂

full_name: LinearEquiv.coe_mk
code: @[simp]
theorem coe_mk {to_fun inv_fun map_add map_smul left_inv right_inv} :
    (⟨⟨⟨to_fun, map_add⟩, map_smul⟩, inv_fun, left_inv, right_inv⟩ : M ≃ₛₗ[σ] M₂) = to_fun 
goal: ⇑{ toFun := to_fun, map_add' := map_add, map_smul' := map_smul, invFun := inv_fun, left_inv := left_inv,
      right_inv := right_inv } =
  to_fun

full_name: LinearEquiv.coe_injective
code: theorem coe_injective : @Injective (M ≃ₛₗ[σ] M₂) (M → M₂) CoeFun.coe 
goal: Function.Injective CoeFun.coe

full_name: LinearEquiv.coe_coe
code: @[simp, norm_cast]
theorem coe_coe : ⇑(e : M →ₛₗ[σ] M₂) = e 
goal: ⇑↑e = ⇑e

full_name: LinearEquiv.coe_toEquiv
code: @[simp]
theorem coe_toEquiv : ⇑(e.toEquiv) = e 
goal: ⇑e.toEquiv = ⇑e

full_name: LinearEquiv.coe_toLinearMap
code: @[simp]
theorem coe_toLinearMap : ⇑e.toLinearMap = e 
goal: ⇑↑e = ⇑e

full_name: LinearEquiv.toFun_eq_coe
code: theorem toFun_eq_coe : e.toFun = e 
goal: (↑e).toFun = ⇑e

full_name: LinearEquiv.ext
code: @[ext]
theorem ext (h : ∀ x, e x = e' x) : e = e' 
goal: e = e'

full_name: LinearEquiv.ext_iff
code: theorem ext_iff : e = e' ↔ ∀ x, e x = e' x 
goal: e = e' ↔ ∀ (x : M), e x = e' x

full_name: LinearEquiv.congr_arg
code: protected theorem congr_arg {x x'} : x = x' → e x = e x' 
goal: x = x' → e x = e x'

full_name: LinearEquiv.congr_fun
code: protected theorem congr_fun (h : e = e') (x : M) : e x = e' x 
goal: e x = e' x

full_name: LinearEquiv.refl
code: /-- The identity map is a linear equivalence. -/
@[refl]
def refl [Module R M] : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: LinearEquiv.refl_apply
code: @[simp]
theorem refl_apply [Module R M] (x : M) : refl R M x = x 
goal: (LinearEquiv.refl R M) x = x

full_name: LinearEquiv.symm
code: /-- Linear equivalences are symmetric. -/
@[symm]
def symm (e : M ≃ₛₗ[σ] M₂) : M₂ ≃ₛₗ[σ'] M 
goal: M₂ ≃ₛₗ[σ'] M

full_name: LinearEquiv.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply {R : Type*} {S : Type*} [Semiring R] [Semiring S]
    {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    {M : Type*} {M₂ : Type*} [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂]
    (e : M ≃ₛₗ[σ] M₂) : M → M₂ 
goal: M → M₂

full_name: LinearEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply {R : Type*} {S : Type*} [Semiring R] [Semiring S]
    {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    {M : Type*} {M₂ : Type*} [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂]
    (e : M ≃ₛₗ[σ] M₂) : M₂ → M 
goal: M₂ → M

full_name: LinearEquiv.invFun_eq_symm
code: @[simp]
theorem invFun_eq_symm : e.invFun = e.symm 
goal: e.invFun = ⇑e.symm

full_name: LinearEquiv.coe_toEquiv_symm
code: @[simp]
theorem coe_toEquiv_symm : e.toEquiv.symm = e.symm 
goal: e.toEquiv.symm = ↑e.symm

full_name: LinearEquiv.trans
code: /-- Linear equivalences are transitive. -/
-- Note: the `RingHomCompTriple σ₃₂ σ₂₁ σ₃₁` is unused, but is convenient to carry around
-- implicitly for lemmas like `LinearEquiv.self_trans_symm`.
@[trans, nolint unusedArguments]
def trans
    [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [RingHomCompTriple σ₃₂ σ₂₁ σ₃₁]
    {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₃ : RingHomInvPair σ₂₃ σ₃₂}
    [RingHomInvPair σ₁₃ σ₃₁] {re₂₁ : RingHomInvPair σ₂₁ σ₁₂}
    {re₃₂ : RingHomInvPair σ₃₂ σ₂₃} [RingHomInvPair σ₃₁ σ₁₃]
    (e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂) (e₂₃ : M₂ ≃ₛₗ[σ₂₃] M₃) : M₁ ≃ₛₗ[σ₁₃] M₃ 
goal: M₁ ≃ₛₗ[σ₁₃] M₃

full_name: LinearEquiv._aux_Mathlib_Algebra_Module_Equiv_Defs___macroRules_LinearEquiv_transNotation_1
code: /-- The notation `e₁ ≪≫ₗ e₂` denotes the composition of the linear equivalences `e₁` and `e₂`. -/
notation3:80 (name := transNotation) e₁:80 " ≪≫ₗ " e₂:81 =>
  @LinearEquiv.trans _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (RingHom.id _) (RingHom.id _) (RingHom.id _)
    (RingHom.id _) (RingHom.id _) (RingHom.id _) RingHomCompTriple.ids RingHomCompTriple.ids
    RingHomInvPair.ids RingHomInvPair.ids RingHomInvPair.ids RingHomInvPair.ids RingHomInvPair.ids
    RingHomInvPair.ids e₁ e₂
goal: Lean.Macro

full_name: LinearEquiv.coe_toAddEquiv
code: @[simp]
theorem coe_toAddEquiv : e.toAddEquiv = e 
goal: e.toAddEquiv = ↑e

full_name: LinearEquiv.toAddMonoidHom_commutes
code: /-- The two paths coercion can take to an `AddMonoidHom` are equivalent -/
theorem toAddMonoidHom_commutes : e.toLinearMap.toAddMonoidHom = e.toAddEquiv.toAddMonoidHom 
goal: (↑e).toAddMonoidHom = e.toAddEquiv.toAddMonoidHom

full_name: LinearEquiv.trans_apply
code: @[simp]
theorem trans_apply (c : M₁) : (e₁₂.trans e₂₃ : M₁ ≃ₛₗ[σ₁₃] M₃) c = e₂₃ (e₁₂ c) 
goal: (e₁₂.trans e₂₃) c = e₂₃ (e₁₂ c)

full_name: LinearEquiv.coe_trans
code: theorem coe_trans :
    (e₁₂.trans e₂₃ : M₁ →ₛₗ[σ₁₃] M₃) = (e₂₃ : M₂ →ₛₗ[σ₂₃] M₃).comp (e₁₂ : M₁ →ₛₗ[σ₁₂] M₂) 
goal: ↑(e₁₂.trans e₂₃) = (↑e₂₃).comp ↑e₁₂

full_name: LinearEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (c : M₂) : e (e.symm c) = c 
goal: e (e.symm c) = c

full_name: LinearEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (b : M) : e.symm (e b) = b 
goal: e.symm (e b) = b

full_name: LinearEquiv.trans_symm
code: @[simp]
theorem trans_symm : (e₁₂.trans e₂₃ : M₁ ≃ₛₗ[σ₁₃] M₃).symm = e₂₃.symm.trans e₁₂.symm 
goal: (e₁₂.trans e₂₃).symm = e₂₃.symm.trans e₁₂.symm

full_name: LinearEquiv.symm_trans_apply
code: theorem symm_trans_apply (c : M₃) :
    (e₁₂.trans e₂₃ : M₁ ≃ₛₗ[σ₁₃] M₃).symm c = e₁₂.symm (e₂₃.symm c) 
goal: (e₁₂.trans e₂₃).symm c = e₁₂.symm (e₂₃.symm c)

full_name: LinearEquiv.trans_refl
code: @[simp]
theorem trans_refl : e.trans (refl S M₂) = e 
goal: e.trans (LinearEquiv.refl S M₂) = e

full_name: LinearEquiv.refl_trans
code: @[simp]
theorem refl_trans : (refl R M).trans e = e 
goal: (LinearEquiv.refl R M).trans e = e

full_name: LinearEquiv.symm_apply_eq
code: theorem symm_apply_eq {x y} : e.symm x = y ↔ x = e y 
goal: e.symm x = y ↔ x = e y

full_name: LinearEquiv.eq_symm_apply
code: theorem eq_symm_apply {x y} : y = e.symm x ↔ e y = x 
goal: y = e.symm x ↔ e y = x

full_name: LinearEquiv.eq_comp_symm
code: theorem eq_comp_symm {α : Type*} (f : M₂ → α) (g : M₁ → α) : f = g ∘ e₁₂.symm ↔ f ∘ e₁₂ = g 
goal: f = g ∘ ⇑e₁₂.symm ↔ f ∘ ⇑e₁₂ = g

full_name: LinearEquiv.comp_symm_eq
code: theorem comp_symm_eq {α : Type*} (f : M₂ → α) (g : M₁ → α) : g ∘ e₁₂.symm = f ↔ g = f ∘ e₁₂ 
goal: g ∘ ⇑e₁₂.symm = f ↔ g = f ∘ ⇑e₁₂

full_name: LinearEquiv.eq_symm_comp
code: theorem eq_symm_comp {α : Type*} (f : α → M₁) (g : α → M₂) : f = e₁₂.symm ∘ g ↔ e₁₂ ∘ f = g 
goal: f = ⇑e₁₂.symm ∘ g ↔ ⇑e₁₂ ∘ f = g

full_name: LinearEquiv.symm_comp_eq
code: theorem symm_comp_eq {α : Type*} (f : α → M₁) (g : α → M₂) : e₁₂.symm ∘ g = f ↔ g = e₁₂ ∘ f 
goal: ⇑e₁₂.symm ∘ g = f ↔ g = ⇑e₁₂ ∘ f

full_name: LinearEquiv.eq_comp_toLinearMap_symm
code: theorem eq_comp_toLinearMap_symm (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₃] M₃) :
    f = g.comp e₁₂.symm.toLinearMap ↔ f.comp e₁₂.toLinearMap = g 
goal: f = g.comp ↑e₁₂.symm ↔ f.comp ↑e₁₂ = g

full_name: LinearEquiv.comp_toLinearMap_symm_eq
code: theorem comp_toLinearMap_symm_eq (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₃] M₃) :
    g.comp e₁₂.symm.toLinearMap = f ↔ g = f.comp e₁₂.toLinearMap 
goal: g.comp ↑e₁₂.symm = f ↔ g = f.comp ↑e₁₂

full_name: LinearEquiv.eq_toLinearMap_symm_comp
code: theorem eq_toLinearMap_symm_comp (f : M₃ →ₛₗ[σ₃₁] M₁) (g : M₃ →ₛₗ[σ₃₂] M₂) :
    f = e₁₂.symm.toLinearMap.comp g ↔ e₁₂.toLinearMap.comp f = g 
goal: f = (↑e₁₂.symm).comp g ↔ (↑e₁₂).comp f = g

full_name: LinearEquiv.toLinearMap_symm_comp_eq
code: theorem toLinearMap_symm_comp_eq (f : M₃ →ₛₗ[σ₃₁] M₁) (g : M₃ →ₛₗ[σ₃₂] M₂) :
    e₁₂.symm.toLinearMap.comp g = f ↔ g = e₁₂.toLinearMap.comp f 
goal: (↑e₁₂.symm).comp g = f ↔ g = (↑e₁₂).comp f

full_name: LinearEquiv.refl_symm
code: @[simp]
theorem refl_symm [Module R M] : (refl R M).symm = LinearEquiv.refl R M 
goal: (LinearEquiv.refl R M).symm = LinearEquiv.refl R M

full_name: LinearEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (f : M₁ ≃ₛₗ[σ₁₂] M₂) : f.trans f.symm = LinearEquiv.refl R₁ M₁ 
goal: f.trans f.symm = LinearEquiv.refl R₁ M₁

full_name: LinearEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (f : M₁ ≃ₛₗ[σ₁₂] M₂) : f.symm.trans f = LinearEquiv.refl R₂ M₂ 
goal: f.symm.trans f = LinearEquiv.refl R₂ M₂

full_name: LinearEquiv.refl_toLinearMap
code: @[simp]  -- Porting note: norm_cast
theorem refl_toLinearMap [Module R M] : (LinearEquiv.refl R M : M →ₗ[R] M) = LinearMap.id 
goal: ↑(LinearEquiv.refl R M) = LinearMap.id

full_name: LinearEquiv.comp_coe
code: @[simp]  -- Porting note: norm_cast
theorem comp_coe [Module R M] [Module R M₂] [Module R M₃] (f : M ≃ₗ[R] M₂) (f' : M₂ ≃ₗ[R] M₃) :
    (f' : M₂ →ₗ[R] M₃).comp (f : M →ₗ[R] M₂) = (f.trans f' : M ≃ₗ[R] M₃) 
goal: ↑f' ∘ₗ ↑f = ↑(f ≪≫ₗ f')

full_name: LinearEquiv.mk_coe
code: @[simp]
theorem mk_coe (f h₁ h₂) : (LinearEquiv.mk e f h₁ h₂ : M ≃ₛₗ[σ] M₂) = e 
goal: { toLinearMap := ↑e, invFun := f, left_inv := h₁, right_inv := h₂ } = e

full_name: LinearEquiv.map_add
code: protected theorem map_add (a b : M) : e (a + b) = e a + e b 
goal: e (a + b) = e a + e b

full_name: LinearEquiv.map_zero
code: protected theorem map_zero : e 0 = 0 
goal: e 0 = 0

full_name: LinearEquiv.map_smulₛₗ
code: protected theorem map_smulₛₗ (c : R) (x : M) : e (c • x) = (σ : R → S) c • e x 
goal: e (c • x) = σ c • e x

full_name: LinearEquiv.map_smul
code: theorem map_smul (e : N₁ ≃ₗ[R₁] N₂) (c : R₁) (x : N₁) : e (c • x) = c • e x 
goal: e (c • x) = c • e x

full_name: LinearEquiv.map_eq_zero_iff
code: theorem map_eq_zero_iff {x : M} : e x = 0 ↔ x = 0 
goal: e x = 0 ↔ x = 0

full_name: LinearEquiv.map_ne_zero_iff
code: theorem map_ne_zero_iff {x : M} : e x ≠ 0 ↔ x ≠ 0 
goal: e x ≠ 0 ↔ x ≠ 0

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

full_name: LinearEquiv.symm_bijective
code: theorem symm_bijective [Module R M] [Module S M₂] [RingHomInvPair σ' σ] [RingHomInvPair σ σ'] :
    Function.Bijective (symm : (M ≃ₛₗ[σ] M₂) → M₂ ≃ₛₗ[σ'] M) 
goal: Function.Bijective LinearEquiv.symm

full_name: LinearEquiv.mk_coe'
code: @[simp]
theorem mk_coe' (f h₁ h₂ h₃ h₄) :
    (LinearEquiv.mk ⟨⟨f, h₁⟩, h₂⟩ (⇑e) h₃ h₄ : M₂ ≃ₛₗ[σ'] M) = e.symm 
goal: { toFun := f, map_add' := h₁, map_smul' := h₂, invFun := ⇑e, left_inv := h₃, right_inv := h₄ } = e.symm

full_name: LinearEquiv.symm_mk.aux
code: /-- Auxilliary definition to avoid looping in `dsimp` with `LinearEquiv.symm_mk`. -/
protected def symm_mk.aux (f h₁ h₂ h₃ h₄) 
goal: M₂ ≃ₛₗ[σ'] M

full_name: LinearEquiv.symm_mk
code: @[simp]
theorem symm_mk (f h₁ h₂ h₃ h₄) :
    (⟨⟨⟨e, h₁⟩, h₂⟩, f, h₃, h₄⟩ : M ≃ₛₗ[σ] M₂).symm =
      { symm_mk.aux e f h₁ h₂ h₃ h₄ with
        toFun := f
        invFun := e } 
goal: { toFun := ⇑e, map_add' := h₁, map_smul' := h₂, invFun := f, left_inv := h₃, right_inv := h₄ }.symm =
  let __src := LinearEquiv.symm_mk.aux e f h₁ h₂ h₃ h₄;
  { toFun := f, map_add' := ⋯, map_smul' := ⋯, invFun := ⇑e, left_inv := ⋯, right_inv := ⋯ }

full_name: LinearEquiv.coe_symm_mk
code: @[simp]
theorem coe_symm_mk [Module R M] [Module R M₂]
    {to_fun inv_fun map_add map_smul left_inv right_inv} :
    ⇑(⟨⟨⟨to_fun, map_add⟩, map_smul⟩, inv_fun, left_inv, right_inv⟩ : M ≃ₗ[R] M₂).symm = inv_fun 
goal: ⇑{ toFun := to_fun, map_add' := map_add, map_smul' := map_smul, invFun := inv_fun, left_inv := left_inv,
        right_inv := right_inv }.symm =
  inv_fun

full_name: LinearEquiv.bijective
code: protected theorem bijective : Function.Bijective e 
goal: Function.Bijective ⇑e

full_name: LinearEquiv.injective
code: protected theorem injective : Function.Injective e 
goal: Function.Injective ⇑e

full_name: LinearEquiv.surjective
code: protected theorem surjective : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: LinearEquiv.image_eq_preimage
code: protected theorem image_eq_preimage (s : Set M) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: LinearEquiv.image_symm_eq_preimage
code: protected theorem image_symm_eq_preimage (s : Set M₂) : e.symm '' s = e ⁻¹' s 
goal: ⇑e.symm '' s = ⇑e ⁻¹' s

full_name: RingEquiv.toSemilinearEquiv_apply
code: /-- Interpret a `RingEquiv` `f` as an `f`-semilinear equiv. -/
@[simps]
def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
    haveI := RingHomInvPair.of_ringEquiv f
    haveI := RingHomInvPair.symm (↑f : R →+* S) (f.symm : S →+* R)
    R ≃ₛₗ[(↑f : R →+* S)] S 
goal: f.toSemilinearEquiv a = f a

full_name: RingEquiv.toSemilinearEquiv
code: /-- Interpret a `RingEquiv` `f` as an `f`-semilinear equiv. -/
@[simps]
def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
    haveI := RingHomInvPair.of_ringEquiv f
    haveI := RingHomInvPair.symm (↑f : R →+* S) (f.symm : S →+* R)
    R ≃ₛₗ[(↑f : R →+* S)] S 
goal: R ≃ₛₗ[↑f] S

full_name: RingEquiv.toSemilinearEquiv_symm_apply
code: /-- Interpret a `RingEquiv` `f` as an `f`-semilinear equiv. -/
@[simps]
def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
    haveI := RingHomInvPair.of_ringEquiv f
    haveI := RingHomInvPair.symm (↑f : R →+* S) (f.symm : S →+* R)
    R ≃ₛₗ[(↑f : R →+* S)] S 
goal: ∀ (a : S), f.toSemilinearEquiv.symm a = f.invFun a

full_name: LinearEquiv.ofInvolutive
code: /-- An involutive linear map is a linear equivalence. -/
def ofInvolutive {σ σ' : R →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    {_ : Module R M} (f : M →ₛₗ[σ] M) (hf : Involutive f) : M ≃ₛₗ[σ] M 
goal: {x : Module R M} → (f : M →ₛₗ[σ] M) → Function.Involutive ⇑f → M ≃ₛₗ[σ] M

full_name: LinearEquiv.coe_ofInvolutive
code: @[simp]
theorem coe_ofInvolutive {σ σ' : R →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    {_ : Module R M} (f : M →ₛₗ[σ] M) (hf : Involutive f) : ⇑(ofInvolutive f hf) = f 
goal: ∀ {x : Module R M} (f : M →ₛₗ[σ] M) (hf : Function.Involutive ⇑f), ⇑(LinearEquiv.ofInvolutive f hf) = ⇑f