File: Mathlib/Algebra/Module/Submodule/Map.lean

full_name: Submodule.map
code: /-- The pushforward of a submodule `p ⊆ M` by `f : M → M₂` -/
def map (f : F) (p : Submodule R M) : Submodule R₂ M₂ 
goal: Submodule R₂ M₂

full_name: Submodule.map_coe
code: @[simp]
theorem map_coe (f : F) (p : Submodule R M) : (map f p : Set M₂) = f '' p 
goal: ↑(Submodule.map f p) = ⇑f '' ↑p

full_name: Submodule.map_toAddSubmonoid
code: theorem map_toAddSubmonoid (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) :
    (p.map f).toAddSubmonoid = p.toAddSubmonoid.map (f : M →+ M₂) 
goal: (Submodule.map f p).toAddSubmonoid = AddSubmonoid.map (↑f) p.toAddSubmonoid

full_name: Submodule.map_toAddSubmonoid'
code: theorem map_toAddSubmonoid' (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) :
    (p.map f).toAddSubmonoid = p.toAddSubmonoid.map f 
goal: (Submodule.map f p).toAddSubmonoid = AddSubmonoid.map f p.toAddSubmonoid

full_name: AddMonoidHom.coe_toIntLinearMap_map
code: @[simp]
theorem _root_.AddMonoidHom.coe_toIntLinearMap_map {A A₂ : Type*} [AddCommGroup A] [AddCommGroup A₂]
    (f : A →+ A₂) (s : AddSubgroup A) :
    (AddSubgroup.toIntSubmodule s).map f.toIntLinearMap =
      AddSubgroup.toIntSubmodule (s.map f) 
goal: Submodule.map f.toIntLinearMap (AddSubgroup.toIntSubmodule s) = AddSubgroup.toIntSubmodule (AddSubgroup.map f s)

full_name: MonoidHom.coe_toAdditive_map
code: @[simp]
theorem _root_.MonoidHom.coe_toAdditive_map {G G₂ : Type*} [Group G] [Group G₂] (f : G →* G₂)
    (s : Subgroup G) :
    s.toAddSubgroup.map (MonoidHom.toAdditive f) = Subgroup.toAddSubgroup (s.map f) 
goal: AddSubgroup.map (MonoidHom.toAdditive f) (Subgroup.toAddSubgroup s) = Subgroup.toAddSubgroup (Subgroup.map f s)

full_name: AddMonoidHom.coe_toMultiplicative_map
code: @[simp]
theorem _root_.AddMonoidHom.coe_toMultiplicative_map {G G₂ : Type*} [AddGroup G] [AddGroup G₂]
    (f : G →+ G₂) (s : AddSubgroup G) :
    s.toSubgroup.map (AddMonoidHom.toMultiplicative f) = AddSubgroup.toSubgroup (s.map f) 
goal: Subgroup.map (AddMonoidHom.toMultiplicative f) (AddSubgroup.toSubgroup s) = AddSubgroup.toSubgroup (AddSubgroup.map f s)

full_name: Submodule.mem_map
code: @[simp]
theorem mem_map {f : F} {p : Submodule R M} {x : M₂} : x ∈ map f p ↔ ∃ y, y ∈ p ∧ f y = x 
goal: x ∈ Submodule.map f p ↔ ∃ y ∈ p, f y = x

full_name: Submodule.mem_map_of_mem
code: theorem mem_map_of_mem {f : F} {p : Submodule R M} {r} (h : r ∈ p) : f r ∈ map f p 
goal: f r ∈ Submodule.map f p

full_name: Submodule.apply_coe_mem_map
code: theorem apply_coe_mem_map (f : F) {p : Submodule R M} (r : p) : f r ∈ map f p 
goal: f ↑r ∈ Submodule.map f p

full_name: Submodule.map_id
code: @[simp]
theorem map_id : map (LinearMap.id : M →ₗ[R] M) p = p 
goal: Submodule.map LinearMap.id p = p

full_name: Submodule.map_comp
code: theorem map_comp [RingHomSurjective σ₂₃] [RingHomSurjective σ₁₃] (f : M →ₛₗ[σ₁₂] M₂)
    (g : M₂ →ₛₗ[σ₂₃] M₃) (p : Submodule R M) : map (g.comp f : M →ₛₗ[σ₁₃] M₃) p = map g (map f p) 
goal: Submodule.map (g.comp f) p = Submodule.map g (Submodule.map f p)

full_name: Submodule.map_mono
code: theorem map_mono {f : F} {p p' : Submodule R M} : p ≤ p' → map f p ≤ map f p' 
goal: p ≤ p' → Submodule.map f p ≤ Submodule.map f p'

full_name: Submodule.map_zero
code: @[simp]
theorem map_zero : map (0 : M →ₛₗ[σ₁₂] M₂) p = ⊥ 
goal: Submodule.map 0 p = ⊥

full_name: Submodule.map_add_le
code: theorem map_add_le (f g : M →ₛₗ[σ₁₂] M₂) : map (f + g) p ≤ map f p ⊔ map g p 
goal: Submodule.map (f + g) p ≤ Submodule.map f p ⊔ Submodule.map g p

full_name: Submodule.map_inf_le
code: theorem map_inf_le (f : F) {p q : Submodule R M} :
    (p ⊓ q).map f ≤ p.map f ⊓ q.map f 
goal: Submodule.map f (p ⊓ q) ≤ Submodule.map f p ⊓ Submodule.map f q

full_name: Submodule.map_inf
code: theorem map_inf (f : F) {p q : Submodule R M} (hf : Injective f) :
    (p ⊓ q).map f = p.map f ⊓ q.map f 
goal: Submodule.map f (p ⊓ q) = Submodule.map f p ⊓ Submodule.map f q

full_name: Submodule.range_map_nonempty
code: theorem range_map_nonempty (N : Submodule R M) :
    (Set.range (fun ϕ => Submodule.map ϕ N : (M →ₛₗ[σ₁₂] M₂) → Submodule R₂ M₂)).Nonempty 
goal: (Set.range fun ϕ => Submodule.map ϕ N).Nonempty

full_name: Submodule.equivMapOfInjective
code: /-- The pushforward of a submodule by an injective linear map is
linearly equivalent to the original submodule. See also `LinearEquiv.submoduleMap` for a
computable version when `f` has an explicit inverse. -/
noncomputable def equivMapOfInjective (f : F) (i : Injective f) (p : Submodule R M) :
    p ≃ₛₗ[σ₁₂] p.map f 
goal: ↥p ≃ₛₗ[σ₁₂] ↥(Submodule.map f p)

full_name: Submodule.coe_equivMapOfInjective_apply
code: @[simp]
theorem coe_equivMapOfInjective_apply (f : F) (i : Injective f) (p : Submodule R M) (x : p) :
    (equivMapOfInjective f i p x : M₂) = f x 
goal: ↑((Submodule.equivMapOfInjective f i p) x) = f ↑x

full_name: Submodule.map_equivMapOfInjective_symm_apply
code: @[simp]
theorem map_equivMapOfInjective_symm_apply (f : F) (i : Injective f) (p : Submodule R M)
    (x : p.map f) : f ((equivMapOfInjective f i p).symm x) = x 
goal: f ↑((Submodule.equivMapOfInjective f i p).symm x) = ↑x

full_name: Submodule.comap
code: /-- The pullback of a submodule `p ⊆ M₂` along `f : M → M₂` -/
def comap [SemilinearMapClass F σ₁₂ M M₂] (f : F) (p : Submodule R₂ M₂) : Submodule R M 
goal: Submodule R M

full_name: Submodule.comap_coe
code: @[simp]
theorem comap_coe (f : F) (p : Submodule R₂ M₂) : (comap f p : Set M) = f ⁻¹' p 
goal: ↑(Submodule.comap f p) = ⇑f ⁻¹' ↑p

full_name: Submodule.AddMonoidHom.coe_toIntLinearMap_comap
code: @[simp]
theorem AddMonoidHom.coe_toIntLinearMap_comap {A A₂ : Type*} [AddCommGroup A] [AddCommGroup A₂]
    (f : A →+ A₂) (s : AddSubgroup A₂) :
    (AddSubgroup.toIntSubmodule s).comap f.toIntLinearMap =
      AddSubgroup.toIntSubmodule (s.comap f) 
goal: Submodule.comap f.toIntLinearMap (AddSubgroup.toIntSubmodule s) = AddSubgroup.toIntSubmodule (AddSubgroup.comap f s)

full_name: Submodule.mem_comap
code: @[simp]
theorem mem_comap {f : F} {p : Submodule R₂ M₂} : x ∈ comap f p ↔ f x ∈ p 
goal: x ∈ Submodule.comap f p ↔ f x ∈ p

full_name: Submodule.comap_id
code: @[simp]
theorem comap_id : comap (LinearMap.id : M →ₗ[R] M) p = p 
goal: Submodule.comap LinearMap.id p = p

full_name: Submodule.comap_comp
code: theorem comap_comp (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₃] M₃) (p : Submodule R₃ M₃) :
    comap (g.comp f : M →ₛₗ[σ₁₃] M₃) p = comap f (comap g p) 
goal: Submodule.comap (g.comp f) p = Submodule.comap f (Submodule.comap g p)

full_name: Submodule.comap_mono
code: theorem comap_mono {f : F} {q q' : Submodule R₂ M₂} : q ≤ q' → comap f q ≤ comap f q' 
goal: q ≤ q' → Submodule.comap f q ≤ Submodule.comap f q'

full_name: Submodule.le_comap_pow_of_le_comap
code: theorem le_comap_pow_of_le_comap (p : Submodule R M) {f : M →ₗ[R] M} (h : p ≤ p.comap f) (k : ℕ) :
    p ≤ p.comap (f ^ k) 
goal: p ≤ Submodule.comap (f ^ k) p

full_name: Submodule.map_le_iff_le_comap
code: theorem map_le_iff_le_comap {f : F} {p : Submodule R M} {q : Submodule R₂ M₂} :
    map f p ≤ q ↔ p ≤ comap f q 
goal: Submodule.map f p ≤ q ↔ p ≤ Submodule.comap f q

full_name: Submodule.gc_map_comap
code: theorem gc_map_comap (f : F) : GaloisConnection (map f) (comap f)
  
goal: GaloisConnection (Submodule.map f) (Submodule.comap f)

full_name: Submodule.map_bot
code: @[simp]
theorem map_bot (f : F) : map f ⊥ = ⊥ 
goal: Submodule.map f ⊥ = ⊥

full_name: Submodule.map_sup
code: @[simp]
theorem map_sup (f : F) : map f (p ⊔ p') = map f p ⊔ map f p' 
goal: Submodule.map f (p ⊔ p') = Submodule.map f p ⊔ Submodule.map f p'

full_name: Submodule.map_iSup
code: @[simp]
theorem map_iSup {ι : Sort*} (f : F) (p : ι → Submodule R M) :
    map f (⨆ i, p i) = ⨆ i, map f (p i) 
goal: Submodule.map f (⨆ i, p i) = ⨆ i, Submodule.map f (p i)

full_name: Submodule.comap_top
code: @[simp]
theorem comap_top (f : F) : comap f ⊤ = ⊤ 
goal: Submodule.comap f ⊤ = ⊤

full_name: Submodule.comap_inf
code: @[simp]
theorem comap_inf (f : F) : comap f (q ⊓ q') = comap f q ⊓ comap f q' 
goal: Submodule.comap f (q ⊓ q') = Submodule.comap f q ⊓ Submodule.comap f q'

full_name: Submodule.comap_iInf
code: @[simp]
theorem comap_iInf [RingHomSurjective σ₁₂] {ι : Sort*} (f : F) (p : ι → Submodule R₂ M₂) :
    comap f (⨅ i, p i) = ⨅ i, comap f (p i) 
goal: Submodule.comap f (⨅ i, p i) = ⨅ i, Submodule.comap f (p i)

full_name: Submodule.comap_zero
code: @[simp]
theorem comap_zero : comap (0 : M →ₛₗ[σ₁₂] M₂) q = ⊤ 
goal: Submodule.comap 0 q = ⊤

full_name: Submodule.map_comap_le
code: theorem map_comap_le [RingHomSurjective σ₁₂] (f : F) (q : Submodule R₂ M₂) :
    map f (comap f q) ≤ q 
goal: Submodule.map f (Submodule.comap f q) ≤ q

full_name: Submodule.le_comap_map
code: theorem le_comap_map [RingHomSurjective σ₁₂] (f : F) (p : Submodule R M) : p ≤ comap f (map f p) 
goal: p ≤ Submodule.comap f (Submodule.map f p)

full_name: Submodule.giMapComap
code: /-- `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. -/
def giMapComap (hf : Surjective f) : GaloisInsertion (map f) (comap f) 
goal: GaloisInsertion (Submodule.map f) (Submodule.comap f)

full_name: Submodule.map_comap_eq_of_surjective
code: theorem map_comap_eq_of_surjective (p : Submodule R₂ M₂) : (p.comap f).map f = p 
goal: Submodule.map f (Submodule.comap f p) = p

full_name: Submodule.map_surjective_of_surjective
code: theorem map_surjective_of_surjective : Function.Surjective (map f) 
goal: Function.Surjective (Submodule.map f)

full_name: Submodule.comap_injective_of_surjective
code: theorem comap_injective_of_surjective : Function.Injective (comap f) 
goal: Function.Injective (Submodule.comap f)

full_name: Submodule.map_sup_comap_of_surjective
code: theorem map_sup_comap_of_surjective (p q : Submodule R₂ M₂) :
    (p.comap f ⊔ q.comap f).map f = p ⊔ q 
goal: Submodule.map f (Submodule.comap f p ⊔ Submodule.comap f q) = p ⊔ q

full_name: Submodule.map_iSup_comap_of_sujective
code: theorem map_iSup_comap_of_sujective {ι : Sort*} (S : ι → Submodule R₂ M₂) :
    (⨆ i, (S i).comap f).map f = iSup S 
goal: Submodule.map f (⨆ i, Submodule.comap f (S i)) = iSup S

full_name: Submodule.map_inf_comap_of_surjective
code: theorem map_inf_comap_of_surjective (p q : Submodule R₂ M₂) :
    (p.comap f ⊓ q.comap f).map f = p ⊓ q 
goal: Submodule.map f (Submodule.comap f p ⊓ Submodule.comap f q) = p ⊓ q

full_name: Submodule.map_iInf_comap_of_surjective
code: theorem map_iInf_comap_of_surjective {ι : Sort*} (S : ι → Submodule R₂ M₂) :
    (⨅ i, (S i).comap f).map f = iInf S 
goal: Submodule.map f (⨅ i, Submodule.comap f (S i)) = iInf S

full_name: Submodule.comap_le_comap_iff_of_surjective
code: theorem comap_le_comap_iff_of_surjective (p q : Submodule R₂ M₂) : p.comap f ≤ q.comap f ↔ p ≤ q 
goal: Submodule.comap f p ≤ Submodule.comap f q ↔ p ≤ q

full_name: Submodule.comap_strictMono_of_surjective
code: theorem comap_strictMono_of_surjective : StrictMono (comap f) 
goal: StrictMono (Submodule.comap f)

full_name: Submodule.gciMapComap
code: /-- `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. -/
def gciMapComap (hf : Injective f) : GaloisCoinsertion (map f) (comap f) 
goal: GaloisCoinsertion (Submodule.map f) (Submodule.comap f)

full_name: Submodule.comap_map_eq_of_injective
code: theorem comap_map_eq_of_injective (p : Submodule R M) : (p.map f).comap f = p 
goal: Submodule.comap f (Submodule.map f p) = p

full_name: Submodule.comap_surjective_of_injective
code: theorem comap_surjective_of_injective : Function.Surjective (comap f) 
goal: Function.Surjective (Submodule.comap f)

full_name: Submodule.map_injective_of_injective
code: theorem map_injective_of_injective : Function.Injective (map f) 
goal: Function.Injective (Submodule.map f)

full_name: Submodule.comap_inf_map_of_injective
code: theorem comap_inf_map_of_injective (p q : Submodule R M) : (p.map f ⊓ q.map f).comap f = p ⊓ q 
goal: Submodule.comap f (Submodule.map f p ⊓ Submodule.map f q) = p ⊓ q

full_name: Submodule.comap_iInf_map_of_injective
code: theorem comap_iInf_map_of_injective {ι : Sort*} (S : ι → Submodule R M) :
    (⨅ i, (S i).map f).comap f = iInf S 
goal: Submodule.comap f (⨅ i, Submodule.map f (S i)) = iInf S

full_name: Submodule.comap_sup_map_of_injective
code: theorem comap_sup_map_of_injective (p q : Submodule R M) : (p.map f ⊔ q.map f).comap f = p ⊔ q 
goal: Submodule.comap f (Submodule.map f p ⊔ Submodule.map f q) = p ⊔ q

full_name: Submodule.comap_iSup_map_of_injective
code: theorem comap_iSup_map_of_injective {ι : Sort*} (S : ι → Submodule R M) :
    (⨆ i, (S i).map f).comap f = iSup S 
goal: Submodule.comap f (⨆ i, Submodule.map f (S i)) = iSup S

full_name: Submodule.map_le_map_iff_of_injective
code: theorem map_le_map_iff_of_injective (p q : Submodule R M) : p.map f ≤ q.map f ↔ p ≤ q 
goal: Submodule.map f p ≤ Submodule.map f q ↔ p ≤ q

full_name: Submodule.map_strictMono_of_injective
code: theorem map_strictMono_of_injective : StrictMono (map f) 
goal: StrictMono (Submodule.map f)

full_name: Submodule.orderIsoMapComapOfBijective_symm_apply
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps symm_apply apply]
def orderIsoMapComapOfBijective [FunLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂]
    (f : F) (hf : Bijective f) : Submodule R M ≃o Submodule R₂ M₂ 
goal: (RelIso.symm (Submodule.orderIsoMapComapOfBijective f hf)) p = Submodule.comap f p

full_name: Submodule.orderIsoMapComapOfBijective
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps symm_apply apply]
def orderIsoMapComapOfBijective [FunLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂]
    (f : F) (hf : Bijective f) : Submodule R M ≃o Submodule R₂ M₂ 
goal: Submodule R M ≃o Submodule R₂ M₂

full_name: Submodule.orderIsoMapComapOfBijective_apply
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps symm_apply apply]
def orderIsoMapComapOfBijective [FunLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂]
    (f : F) (hf : Bijective f) : Submodule R M ≃o Submodule R₂ M₂ 
goal: (Submodule.orderIsoMapComapOfBijective f hf) p = Submodule.map f p

full_name: Submodule.orderIsoMapComap
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps! symm_apply apply]
def orderIsoMapComap [EquivLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂] (f : F) :
    Submodule R M ≃o Submodule R₂ M₂ 
goal: Submodule R M ≃o Submodule R₂ M₂

full_name: Submodule.orderIsoMapComap_symm_apply
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps! symm_apply apply]
def orderIsoMapComap [EquivLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂] (f : F) :
    Submodule R M ≃o Submodule R₂ M₂ 
goal: (RelIso.symm (Submodule.orderIsoMapComap f)) p = Submodule.comap f p

full_name: Submodule.orderIsoMapComap_apply
code: /-- A linear isomorphism induces an order isomorphism of submodules. -/
@[simps! symm_apply apply]
def orderIsoMapComap [EquivLike F M M₂] [SemilinearMapClass F σ₁₂ M M₂] (f : F) :
    Submodule R M ≃o Submodule R₂ M₂ 
goal: (Submodule.orderIsoMapComap f) p = Submodule.map f p

full_name: Submodule.map_inf_eq_map_inf_comap
code: theorem map_inf_eq_map_inf_comap [RingHomSurjective σ₁₂] {f : F} {p : Submodule R M}
    {p' : Submodule R₂ M₂} : map f p ⊓ p' = map f (p ⊓ comap f p') 
goal: Submodule.map f p ⊓ p' = Submodule.map f (p ⊓ Submodule.comap f p')

full_name: Submodule.map_comap_subtype
code: @[simp]
theorem map_comap_subtype : map p.subtype (comap p.subtype p') = p ⊓ p' 
goal: Submodule.map p.subtype (Submodule.comap p.subtype p') = p ⊓ p'

full_name: Submodule.eq_zero_of_bot_submodule
code: theorem eq_zero_of_bot_submodule : ∀ b : (⊥ : Submodule R M), b = 0
  
goal: b = 0

full_name: LinearMap.iInf_invariant
code: /-- The infimum of a family of invariant submodule of an endomorphism is also an invariant
submodule. -/
theorem _root_.LinearMap.iInf_invariant {σ : R →+* R} [RingHomSurjective σ] {ι : Sort*}
    (f : M →ₛₗ[σ] M) {p : ι → Submodule R M} (hf : ∀ i, ∀ v ∈ p i, f v ∈ p i) :
    ∀ v ∈ iInf p, f v ∈ iInf p 
goal: v ∈ iInf p → f v ∈ iInf p

full_name: Submodule.disjoint_iff_comap_eq_bot
code: theorem disjoint_iff_comap_eq_bot {p q : Submodule R M} : Disjoint p q ↔ comap p.subtype q = ⊥ 
goal: Disjoint p q ↔ Submodule.comap p.subtype q = ⊥

full_name: Submodule.map_neg
code: @[simp]
protected theorem map_neg (f : M →ₗ[R] M₂) : map (-f) p = map f p 
goal: Submodule.map (-f) p = Submodule.map f p

full_name: Submodule.comap_neg
code: @[simp]
lemma comap_neg {f : M →ₗ[R] M₂} {p : Submodule R M₂} :
    p.comap (-f) = p.comap f 
goal: Submodule.comap (-f) p = Submodule.comap f p

full_name: Submodule.comap_smul
code: theorem comap_smul (f : V →ₗ[K] V₂) (p : Submodule K V₂) (a : K) (h : a ≠ 0) :
    p.comap (a • f) = p.comap f 
goal: Submodule.comap (a • f) p = Submodule.comap f p

full_name: Submodule.map_smul
code: protected theorem map_smul (f : V →ₗ[K] V₂) (p : Submodule K V) (a : K) (h : a ≠ 0) :
    p.map (a • f) = p.map f 
goal: Submodule.map (a • f) p = Submodule.map f p

full_name: Submodule.comap_smul'
code: theorem comap_smul' (f : V →ₗ[K] V₂) (p : Submodule K V₂) (a : K) :
    p.comap (a • f) = ⨅ _ : a ≠ 0, p.comap f 
goal: Submodule.comap (a • f) p = ⨅ (_ : a ≠ 0), Submodule.comap f p

full_name: Submodule.map_smul'
code: theorem map_smul' (f : V →ₗ[K] V₂) (p : Submodule K V) (a : K) :
    p.map (a • f) = ⨆ _ : a ≠ 0, map f p 
goal: Submodule.map (a • f) p = ⨆ (_ : a ≠ 0), Submodule.map f p

full_name: Submodule.comapSubtypeEquivOfLe
code: /-- If `s ≤ t`, then we can view `s` as a submodule of `t` by taking the comap
of `t.subtype`. -/
@[simps symm_apply]
def comapSubtypeEquivOfLe {p q : Submodule R M} (hpq : p ≤ q) : comap q.subtype p ≃ₗ[R] p 
goal: ↥(Submodule.comap q.subtype p) ≃ₗ[R] ↥p

full_name: Submodule.comapSubtypeEquivOfLe_symm_apply
code: /-- If `s ≤ t`, then we can view `s` as a submodule of `t` by taking the comap
of `t.subtype`. -/
@[simps symm_apply]
def comapSubtypeEquivOfLe {p q : Submodule R M} (hpq : p ≤ q) : comap q.subtype p ≃ₗ[R] p 
goal: (Submodule.comapSubtypeEquivOfLe hpq).symm x = ⟨⟨↑x, ⋯⟩, ⋯⟩

full_name: Submodule.comapSubtypeEquivOfLe_apply_coe
code: @[simp]
theorem comapSubtypeEquivOfLe_apply_coe {p q : Submodule R M} (hpq : p ≤ q)
    (x : comap q.subtype p) :
    (comapSubtypeEquivOfLe hpq x : M) = (x : M) 
goal: ↑((Submodule.comapSubtypeEquivOfLe hpq) x) = ↑↑x

full_name: Submodule.mem_map_equiv
code: @[simp high]
theorem mem_map_equiv {e : M ≃ₛₗ[τ₁₂] M₂} {x : M₂} :
    x ∈ p.map (e : M →ₛₗ[τ₁₂] M₂) ↔ e.symm x ∈ p 
goal: x ∈ Submodule.map (↑e) p ↔ e.symm x ∈ p

full_name: Submodule.map_equiv_eq_comap_symm
code: theorem map_equiv_eq_comap_symm (e : M ≃ₛₗ[τ₁₂] M₂) (K : Submodule R M) :
    K.map (e : M →ₛₗ[τ₁₂] M₂) = K.comap (e.symm : M₂ →ₛₗ[τ₂₁] M) 
goal: Submodule.map (↑e) K = Submodule.comap (↑e.symm) K

full_name: Submodule.comap_equiv_eq_map_symm
code: theorem comap_equiv_eq_map_symm (e : M ≃ₛₗ[τ₁₂] M₂) (K : Submodule R₂ M₂) :
    K.comap (e : M →ₛₗ[τ₁₂] M₂) = K.map (e.symm : M₂ →ₛₗ[τ₂₁] M) 
goal: Submodule.comap (↑e) K = Submodule.map (↑e.symm) K

full_name: Submodule.map_symm_eq_iff
code: theorem map_symm_eq_iff (e : M ≃ₛₗ[τ₁₂] M₂) {K : Submodule R₂ M₂} :
    K.map e.symm = p ↔ p.map e = K 
goal: Submodule.map e.symm K = p ↔ Submodule.map e p = K

full_name: Submodule.orderIsoMapComap_apply'
code: theorem orderIsoMapComap_apply' (e : M ≃ₛₗ[τ₁₂] M₂) (p : Submodule R M) :
    orderIsoMapComap e p = comap e.symm p 
goal: (Submodule.orderIsoMapComap e) p = Submodule.comap e.symm p

full_name: Submodule.orderIsoMapComap_symm_apply'
code: theorem orderIsoMapComap_symm_apply' (e : M ≃ₛₗ[τ₁₂] M₂) (p : Submodule R₂ M₂) :
    (orderIsoMapComap e).symm p = map e.symm p 
goal: (Submodule.orderIsoMapComap e).symm p = Submodule.map e.symm p

full_name: Submodule.inf_comap_le_comap_add
code: theorem inf_comap_le_comap_add (f₁ f₂ : M →ₛₗ[τ₁₂] M₂) :
    comap f₁ q ⊓ comap f₂ q ≤ comap (f₁ + f₂) q 
goal: Submodule.comap f₁ q ⊓ Submodule.comap f₂ q ≤ Submodule.comap (f₁ + f₂) q

full_name: Submodule.comap_le_comap_smul
code: theorem comap_le_comap_smul (fₗ : N →ₗ[R] N₂) (c : R) : comap fₗ qₗ ≤ comap (c • fₗ) qₗ 
goal: Submodule.comap fₗ qₗ ≤ Submodule.comap (c • fₗ) qₗ

full_name: Submodule.compatibleMaps
code: /-- Given modules `M`, `M₂` over a commutative ring, together with submodules `p ⊆ M`, `q ⊆ M₂`,
the set of maps $\{f ∈ Hom(M, M₂) | f(p) ⊆ q \}$ is a submodule of `Hom(M, M₂)`. -/
def compatibleMaps : Submodule R (N →ₗ[R] N₂) 
goal: Submodule R (N →ₗ[R] N₂)

full_name: LinearMap.submoduleMap
code: /-- A linear map between two modules restricts to a linear map from any submodule p of the
domain onto the image of that submodule.

This is the linear version of `AddMonoidHom.addSubmonoidMap` and `AddMonoidHom.addSubgroupMap`. -/
def submoduleMap (f : M →ₗ[R] M₁) (p : Submodule R M) : p →ₗ[R] p.map f 
goal: ↥p →ₗ[R] ↥(Submodule.map f p)

full_name: LinearMap.submoduleMap_coe_apply
code: @[simp]
theorem submoduleMap_coe_apply (f : M →ₗ[R] M₁) {p : Submodule R M} (x : p) :
    ↑(f.submoduleMap p x) = f x 
goal: ↑((f.submoduleMap p) x) = f ↑x

full_name: LinearMap.submoduleMap_surjective
code: theorem submoduleMap_surjective (f : M →ₗ[R] M₁) (p : Submodule R M) :
    Function.Surjective (f.submoduleMap p) 
goal: Function.Surjective ⇑(f.submoduleMap p)

full_name: LinearMap.map_codRestrict
code: theorem map_codRestrict [RingHomSurjective σ₂₁] (p : Submodule R M) (f : M₂ →ₛₗ[σ₂₁] M) (h p') :
    Submodule.map (codRestrict p f h) p' = comap p.subtype (p'.map f) 
goal: Submodule.map (LinearMap.codRestrict p f h) p' = Submodule.comap p.subtype (Submodule.map f p')

full_name: LinearMap.comap_codRestrict
code: theorem comap_codRestrict (p : Submodule R M) (f : M₂ →ₛₗ[σ₂₁] M) (hf p') :
    Submodule.comap (codRestrict p f hf) p' = Submodule.comap f (map p.subtype p') 
goal: Submodule.comap (LinearMap.codRestrict p f hf) p' = Submodule.comap f (Submodule.map p.subtype p')

full_name: LinearEquiv.map_eq_comap
code: theorem map_eq_comap {p : Submodule R M} :
    (p.map (e : M →ₛₗ[σ₁₂] M₂) : Submodule R₂ M₂) = p.comap (e.symm : M₂ →ₛₗ[σ₂₁] M) 
goal: Submodule.map (↑e) p = Submodule.comap (↑e.symm) p

full_name: LinearEquiv.submoduleMap
code: /-- A linear equivalence of two modules restricts to a linear equivalence from any submodule
`p` of the domain onto the image of that submodule.

This is the linear version of `AddEquiv.submonoidMap` and `AddEquiv.subgroupMap`.

This is `LinearEquiv.ofSubmodule'` but with `map` on the right instead of `comap` on the left. -/
def submoduleMap (p : Submodule R M) : p ≃ₛₗ[σ₁₂] ↥(p.map (e : M →ₛₗ[σ₁₂] M₂) : Submodule R₂ M₂) 
goal: ↥p ≃ₛₗ[σ₁₂] ↥(Submodule.map (↑e) p)

full_name: LinearEquiv.submoduleMap_apply
code: @[simp]
theorem submoduleMap_apply (p : Submodule R M) (x : p) : ↑(e.submoduleMap p x) = e x 
goal: ↑((e.submoduleMap p) x) = e ↑x

full_name: LinearEquiv.submoduleMap_symm_apply
code: @[simp]
theorem submoduleMap_symm_apply (p : Submodule R M)
    (x : (p.map (e : M →ₛₗ[σ₁₂] M₂) : Submodule R₂ M₂)) : ↑((e.submoduleMap p).symm x) = e.symm x 
goal: ↑((e.submoduleMap p).symm x) = e.symm ↑x