File: Mathlib/Algebra/Algebra/Operations.lean

full_name: SubMulAction.algebraMap_mem
code: theorem algebraMap_mem (r : R) : algebraMap R A r ∈ (1 : SubMulAction R A) 
goal: (algebraMap R A) r ∈ 1

full_name: SubMulAction.mem_one'
code: theorem mem_one' {x : A} : x ∈ (1 : SubMulAction R A) ↔ ∃ y, algebraMap R A y = x 
goal: x ∈ 1 ↔ ∃ y, (algebraMap R A) y = x

full_name: Submodule.one
code: /-- `1 : Submodule R A` is the submodule R of A. -/
instance one : One (Submodule R A) 
goal: One (Submodule R A)

full_name: Submodule.one_eq_range
code: theorem one_eq_range : (1 : Submodule R A) = LinearMap.range (Algebra.linearMap R A) 
goal: 1 = LinearMap.range (Algebra.linearMap R A)

full_name: Submodule.le_one_toAddSubmonoid
code: theorem le_one_toAddSubmonoid : 1 ≤ (1 : Submodule R A).toAddSubmonoid 
goal: 1 ≤ Submodule.toAddSubmonoid 1

full_name: Submodule.algebraMap_mem
code: theorem algebraMap_mem (r : R) : algebraMap R A r ∈ (1 : Submodule R A) 
goal: (algebraMap R A) r ∈ 1

full_name: Submodule.mem_one
code: @[simp]
theorem mem_one {x : A} : x ∈ (1 : Submodule R A) ↔ ∃ y, algebraMap R A y = x 
goal: x ∈ 1 ↔ ∃ y, (algebraMap R A) y = x

full_name: Submodule.toSubMulAction_one
code: @[simp]
theorem toSubMulAction_one : (1 : Submodule R A).toSubMulAction = 1 
goal: Submodule.toSubMulAction 1 = 1

full_name: Submodule.one_eq_span
code: theorem one_eq_span : (1 : Submodule R A) = R ∙ 1 
goal: 1 = Submodule.span R {1}

full_name: Submodule.one_eq_span_one_set
code: theorem one_eq_span_one_set : (1 : Submodule R A) = span R 1 
goal: 1 = Submodule.span R 1

full_name: Submodule.one_le
code: theorem one_le : (1 : Submodule R A) ≤ P ↔ (1 : A) ∈ P 
goal: 1 ≤ P ↔ 1 ∈ P

full_name: Submodule.map_one
code: protected theorem map_one {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    map f.toLinearMap (1 : Submodule R A) = 1 
goal: Submodule.map f.toLinearMap 1 = 1

full_name: Submodule.map_op_one
code: @[simp]
theorem map_op_one :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (1 : Submodule R A) = 1 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R)) 1 = 1

full_name: Submodule.comap_op_one
code: @[simp]
theorem comap_op_one :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (1 : Submodule R Aᵐᵒᵖ) = 1 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R)) 1 = 1

full_name: Submodule.map_unop_one
code: @[simp]
theorem map_unop_one :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (1 : Submodule R Aᵐᵒᵖ) = 1 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) 1 = 1

full_name: Submodule.comap_unop_one
code: @[simp]
theorem comap_unop_one :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (1 : Submodule R A) = 1 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) 1 = 1

full_name: Submodule.mul
code: /-- Multiplication of sub-R-modules of an R-algebra A. The submodule `M * N` is the
smallest R-submodule of `A` containing the elements `m * n` for `m ∈ M` and `n ∈ N`. -/
instance mul : Mul (Submodule R A) 
goal: Mul (Submodule R A)

full_name: Submodule.mul_mem_mul
code: theorem mul_mem_mul (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N 
goal: m * n ∈ M * N

full_name: Submodule.mul_le
code: theorem mul_le : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P 
goal: M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P

full_name: Submodule.mul_toAddSubmonoid
code: theorem mul_toAddSubmonoid (M N : Submodule R A) :
    (M * N).toAddSubmonoid = M.toAddSubmonoid * N.toAddSubmonoid 
goal: (M * N).toAddSubmonoid = M.toAddSubmonoid * N.toAddSubmonoid

full_name: Submodule.mul_induction_on
code: @[elab_as_elim]
protected theorem mul_induction_on {C : A → Prop} {r : A} (hr : r ∈ M * N)
    (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r 
goal: C r

full_name: Submodule.mul_induction_on'
code: /-- A dependent version of `mul_induction_on`. -/
@[elab_as_elim]
protected theorem mul_induction_on' {C : ∀ r, r ∈ M * N → Prop}
    (mem_mul_mem : ∀ m (hm : m ∈ M) n (hn : n ∈ N), C (m * n) (mul_mem_mul hm hn))
    (add : ∀ x hx y hy, C x hx → C y hy → C (x + y) (add_mem hx hy)) {r : A} (hr : r ∈ M * N) :
    C r hr 
goal: C r hr

full_name: Submodule.span_mul_span
code: theorem span_mul_span : span R S * span R T = span R (S * T) 
goal: Submodule.span R S * Submodule.span R T = Submodule.span R (S * T)

full_name: Submodule.mul_bot
code: @[simp]
theorem mul_bot : M * ⊥ = ⊥ 
goal: M * ⊥ = ⊥

full_name: Submodule.bot_mul
code: @[simp]
theorem bot_mul : ⊥ * M = ⊥ 
goal: ⊥ * M = ⊥

full_name: Submodule.one_mul
code: protected theorem one_mul : (1 : Submodule R A) * M = M 
goal: 1 * M = M

full_name: Submodule.mul_one
code: protected theorem mul_one : M * 1 = M 
goal: M * 1 = M

full_name: Submodule.mul_le_mul
code: @[mono]
theorem mul_le_mul (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q 
goal: M * N ≤ P * Q

full_name: Submodule.mul_le_mul_left
code: theorem mul_le_mul_left (h : M ≤ N) : M * P ≤ N * P 
goal: M * P ≤ N * P

full_name: Submodule.mul_le_mul_right
code: theorem mul_le_mul_right (h : N ≤ P) : M * N ≤ M * P 
goal: M * N ≤ M * P

full_name: Submodule.mul_sup
code: theorem mul_sup : M * (N ⊔ P) = M * N ⊔ M * P 
goal: M * (N ⊔ P) = M * N ⊔ M * P

full_name: Submodule.sup_mul
code: theorem sup_mul : (M ⊔ N) * P = M * P ⊔ N * P 
goal: (M ⊔ N) * P = M * P ⊔ N * P

full_name: Submodule.mul_subset_mul
code: theorem mul_subset_mul : (↑M : Set A) * (↑N : Set A) ⊆ (↑(M * N) : Set A) 
goal: ↑M * ↑N ⊆ ↑(M * N)

full_name: Submodule.map_mul
code: protected theorem map_mul {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    map f.toLinearMap (M * N) = map f.toLinearMap M * map f.toLinearMap N 
goal: Submodule.map f.toLinearMap (M * N) = Submodule.map f.toLinearMap M * Submodule.map f.toLinearMap N

full_name: Submodule.map_op_mul
code: theorem map_op_mul :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M * N) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) N *
        map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R)) (M * N) =
  Submodule.map (↑(MulOpposite.opLinearEquiv R)) N * Submodule.map (↑(MulOpposite.opLinearEquiv R)) M

full_name: Submodule.comap_unop_mul
code: theorem comap_unop_mul :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M * N) =
      comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) N *
        comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (M * N) =
  Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) N * Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) M

full_name: Submodule.map_unop_mul
code: theorem map_unop_mul (M N : Submodule R Aᵐᵒᵖ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M * N) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) N *
        map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) (M * N) =
  Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) N * Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) M

full_name: Submodule.comap_op_mul
code: theorem comap_op_mul (M N : Submodule R Aᵐᵒᵖ) :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M * N) =
      comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) N *
        comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R)) (M * N) =
  Submodule.comap (↑(MulOpposite.opLinearEquiv R)) N * Submodule.comap (↑(MulOpposite.opLinearEquiv R)) M

full_name: Submodule.restrictScalars_mul
code: lemma restrictScalars_mul {A B C} [CommSemiring A] [CommSemiring B] [Semiring C]
    [Algebra A B] [Algebra A C] [Algebra B C] [IsScalarTower A B C] {I J : Submodule B C} :
  (I * J).restrictScalars A = I.restrictScalars A * J.restrictScalars A 
goal: Submodule.restrictScalars A (I * J) = Submodule.restrictScalars A I * Submodule.restrictScalars A J

full_name: Submodule.hasDistribPointwiseNeg
code: /-- `Submodule.pointwiseNeg` distributes over multiplication.

This is available as an instance in the `Pointwise` locale. -/
protected def hasDistribPointwiseNeg {A} [Ring A] [Algebra R A] : HasDistribNeg (Submodule R A) 
goal: HasDistribNeg (Submodule R A)

full_name: Submodule.mem_span_mul_finite_of_mem_span_mul
code: theorem mem_span_mul_finite_of_mem_span_mul {R A} [Semiring R] [AddCommMonoid A] [Mul A]
    [Module R A] {S : Set A} {S' : Set A} {x : A} (hx : x ∈ span R (S * S')) :
    ∃ T T' : Finset A, ↑T ⊆ S ∧ ↑T' ⊆ S' ∧ x ∈ span R (T * T' : Set A) 
goal: ∃ T T', ↑T ⊆ S ∧ ↑T' ⊆ S' ∧ x ∈ Submodule.span R (↑T * ↑T')

full_name: Submodule.mul_eq_span_mul_set
code: theorem mul_eq_span_mul_set (s t : Submodule R A) : s * t = span R ((s : Set A) * (t : Set A)) 
goal: s * t = Submodule.span R (↑s * ↑t)

full_name: Submodule.iSup_mul
code: theorem iSup_mul (s : ι → Submodule R A) (t : Submodule R A) : (⨆ i, s i) * t = ⨆ i, s i * t 
goal: (⨆ i, s i) * t = ⨆ i, s i * t

full_name: Submodule.mul_iSup
code: theorem mul_iSup (t : Submodule R A) (s : ι → Submodule R A) : (t * ⨆ i, s i) = ⨆ i, t * s i 
goal: t * ⨆ i, s i = ⨆ i, t * s i

full_name: Submodule.mem_span_mul_finite_of_mem_mul
code: theorem mem_span_mul_finite_of_mem_mul {P Q : Submodule R A} {x : A} (hx : x ∈ P * Q) :
    ∃ T T' : Finset A, (T : Set A) ⊆ P ∧ (T' : Set A) ⊆ Q ∧ x ∈ span R (T * T' : Set A) 
goal: ∃ T T', ↑T ⊆ ↑P ∧ ↑T' ⊆ ↑Q ∧ x ∈ Submodule.span R (↑T * ↑T')

full_name: Submodule.mem_span_singleton_mul
code: theorem mem_span_singleton_mul {x y : A} : x ∈ span R {y} * P ↔ ∃ z ∈ P, y * z = x 
goal: x ∈ Submodule.span R {y} * P ↔ ∃ z ∈ P, y * z = x

full_name: Submodule.mem_mul_span_singleton
code: theorem mem_mul_span_singleton {x y : A} : x ∈ P * span R {y} ↔ ∃ z ∈ P, z * y = x 
goal: x ∈ P * Submodule.span R {y} ↔ ∃ z ∈ P, z * y = x

full_name: Submodule.span_singleton_mul
code: lemma span_singleton_mul {x : A} {p : Submodule R A} :
    Submodule.span R {x} * p = x • p 
goal: Submodule.span R {x} * p = x • p

full_name: Submodule.mem_smul_iff_inv_mul_mem
code: lemma mem_smul_iff_inv_mul_mem {S} [Field S] [Algebra R S] {x : S} {p : Submodule R S} {y : S}
    (hx : x ≠ 0) : y ∈ x • p ↔ x⁻¹ * y ∈ p 
goal: y ∈ x • p ↔ x⁻¹ * y ∈ p

full_name: Submodule.mul_mem_smul_iff
code: lemma mul_mem_smul_iff {S} [CommRing S] [Algebra R S] {x : S} {p : Submodule R S} {y : S}
    (hx : x ∈ nonZeroDivisors S) :
    x * y ∈ x • p ↔ y ∈ p 
goal: x * y ∈ x • p ↔ y ∈ p

full_name: Submodule.mul_smul_mul_eq_smul_mul_smul
code: theorem mul_smul_mul_eq_smul_mul_smul (x y : R) : (x * y) • (M * N) = (x • M) * (y • N) 
goal: (x * y) • (M * N) = x • M * y • N

full_name: Submodule.idemSemiring
code: /-- Sub-R-modules of an R-algebra form an idempotent semiring. -/
instance idemSemiring : IdemSemiring (Submodule R A) 
goal: IdemSemiring (Submodule R A)

full_name: Submodule.span_pow
code: theorem span_pow (s : Set A) : ∀ n : ℕ, span R s ^ n = span R (s ^ n)
  
goal: Submodule.span R s ^ n = Submodule.span R (s ^ n)

full_name: Submodule.pow_eq_span_pow_set
code: theorem pow_eq_span_pow_set (n : ℕ) : M ^ n = span R ((M : Set A) ^ n) 
goal: M ^ n = Submodule.span R (↑M ^ n)

full_name: Submodule.pow_subset_pow
code: theorem pow_subset_pow {n : ℕ} : (↑M : Set A) ^ n ⊆ ↑(M ^ n : Submodule R A) 
goal: ↑M ^ n ⊆ ↑(M ^ n)

full_name: Submodule.pow_mem_pow
code: theorem pow_mem_pow {x : A} (hx : x ∈ M) (n : ℕ) : x ^ n ∈ M ^ n 
goal: x ^ n ∈ M ^ n

full_name: Submodule.pow_toAddSubmonoid
code: theorem pow_toAddSubmonoid {n : ℕ} (h : n ≠ 0) : (M ^ n).toAddSubmonoid = M.toAddSubmonoid ^ n 
goal: (M ^ n).toAddSubmonoid = M.toAddSubmonoid ^ n

full_name: Submodule.le_pow_toAddSubmonoid
code: theorem le_pow_toAddSubmonoid {n : ℕ} : M.toAddSubmonoid ^ n ≤ (M ^ n).toAddSubmonoid 
goal: M.toAddSubmonoid ^ n ≤ (M ^ n).toAddSubmonoid

full_name: Submodule.pow_induction_on_left'
code: /-- Dependent version of `Submodule.pow_induction_on_left`. -/
@[elab_as_elim]
protected theorem pow_induction_on_left' {C : ∀ (n : ℕ) (x), x ∈ M ^ n → Prop}
    (algebraMap : ∀ r : R, C 0 (algebraMap _ _ r) (algebraMap_mem r))
    (add : ∀ x y i hx hy, C i x hx → C i y hy → C i (x + y) (add_mem ‹_› ‹_›))
    (mem_mul : ∀ m (hm : m ∈ M), ∀ (i x hx), C i x hx → C i.succ (m * x)
      ((pow_succ' M i).symm ▸ (mul_mem_mul hm hx)))
    -- Porting note: swapped argument order to match order of `C`
    {n : ℕ} {x : A}
    (hx : x ∈ M ^ n) : C n x hx 
goal: C n x hx

full_name: Submodule.pow_induction_on_right'
code: /-- Dependent version of `Submodule.pow_induction_on_right`. -/
@[elab_as_elim]
protected theorem pow_induction_on_right' {C : ∀ (n : ℕ) (x), x ∈ M ^ n → Prop}
    (algebraMap : ∀ r : R, C 0 (algebraMap _ _ r) (algebraMap_mem r))
    (add : ∀ x y i hx hy, C i x hx → C i y hy → C i (x + y) (add_mem ‹_› ‹_›))
    (mul_mem :
      ∀ i x hx, C i x hx →
        ∀ m (hm : m ∈ M), C i.succ (x * m) (mul_mem_mul hx hm))
    -- Porting note: swapped argument order to match order of `C`
    {n : ℕ} {x : A} (hx : x ∈ M ^ n) : C n x hx 
goal: C n x hx

full_name: Submodule.pow_induction_on_left
code: /-- To show a property on elements of `M ^ n` holds, it suffices to show that it holds for scalars,
is closed under addition, and holds for `m * x` where `m ∈ M` and it holds for `x` -/
@[elab_as_elim]
protected theorem pow_induction_on_left {C : A → Prop} (hr : ∀ r : R, C (algebraMap _ _ r))
    (hadd : ∀ x y, C x → C y → C (x + y)) (hmul : ∀ m ∈ M, ∀ (x), C x → C (m * x)) {x : A} {n : ℕ}
    (hx : x ∈ M ^ n) : C x 
goal: C x

full_name: Submodule.pow_induction_on_right
code: /-- To show a property on elements of `M ^ n` holds, it suffices to show that it holds for scalars,
is closed under addition, and holds for `x * m` where `m ∈ M` and it holds for `x` -/
@[elab_as_elim]
protected theorem pow_induction_on_right {C : A → Prop} (hr : ∀ r : R, C (algebraMap _ _ r))
    (hadd : ∀ x y, C x → C y → C (x + y)) (hmul : ∀ x, C x → ∀ m ∈ M, C (x * m)) {x : A} {n : ℕ}
    (hx : x ∈ M ^ n) : C x 
goal: C x

full_name: Submodule.mapHom_apply
code: /-- `Submonoid.map` as a `MonoidWithZeroHom`, when applied to `AlgHom`s. -/
@[simps]
def mapHom {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    Submodule R A →*₀ Submodule R A' 
goal: (Submodule.mapHom f) p = Submodule.map f.toLinearMap p

full_name: Submodule.mapHom
code: /-- `Submonoid.map` as a `MonoidWithZeroHom`, when applied to `AlgHom`s. -/
@[simps]
def mapHom {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    Submodule R A →*₀ Submodule R A' 
goal: Submodule R A →*₀ Submodule R A'

full_name: Submodule.equivOpposite_symm_apply
code: /-- The ring of submodules of the opposite algebra is isomorphic to the opposite ring of
submodules. -/
@[simps apply symm_apply]
def equivOpposite : Submodule R Aᵐᵒᵖ ≃+* (Submodule R A)ᵐᵒᵖ 
goal: Submodule.equivOpposite.symm p = Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (MulOpposite.unop p)

full_name: Submodule.equivOpposite
code: /-- The ring of submodules of the opposite algebra is isomorphic to the opposite ring of
submodules. -/
@[simps apply symm_apply]
def equivOpposite : Submodule R Aᵐᵒᵖ ≃+* (Submodule R A)ᵐᵒᵖ 
goal: Submodule R Aᵐᵒᵖ ≃+* (Submodule R A)ᵐᵒᵖ

full_name: Submodule.equivOpposite_apply
code: /-- The ring of submodules of the opposite algebra is isomorphic to the opposite ring of
submodules. -/
@[simps apply symm_apply]
def equivOpposite : Submodule R Aᵐᵒᵖ ≃+* (Submodule R A)ᵐᵒᵖ 
goal: Submodule.equivOpposite p = MulOpposite.op (Submodule.comap (↑(MulOpposite.opLinearEquiv R)) p)

full_name: Submodule.map_pow
code: protected theorem map_pow {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') (n : ℕ) :
    map f.toLinearMap (M ^ n) = map f.toLinearMap M ^ n 
goal: Submodule.map f.toLinearMap (M ^ n) = Submodule.map f.toLinearMap M ^ n

full_name: Submodule.comap_unop_pow
code: theorem comap_unop_pow (n : ℕ) :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M ^ n) =
      comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M ^ n 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (M ^ n) =
  Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) M ^ n

full_name: Submodule.comap_op_pow
code: theorem comap_op_pow (n : ℕ) (M : Submodule R Aᵐᵒᵖ) :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M ^ n) =
      comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M ^ n 
goal: Submodule.comap (↑(MulOpposite.opLinearEquiv R)) (M ^ n) = Submodule.comap (↑(MulOpposite.opLinearEquiv R)) M ^ n

full_name: Submodule.map_op_pow
code: theorem map_op_pow (n : ℕ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M ^ n) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M ^ n 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R)) (M ^ n) = Submodule.map (↑(MulOpposite.opLinearEquiv R)) M ^ n

full_name: Submodule.map_unop_pow
code: theorem map_unop_pow (n : ℕ) (M : Submodule R Aᵐᵒᵖ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M ^ n) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M ^ n 
goal: Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) (M ^ n) = Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) M ^ n

full_name: Submodule.span.ringHom
code: /-- `span` is a semiring homomorphism (recall multiplication is pointwise multiplication of subsets
on either side). -/
@[simps]
def span.ringHom : SetSemiring A →+* Submodule R A 
goal: SetSemiring A →+* Submodule R A

full_name: Submodule.span.ringHom_apply
code: /-- `span` is a semiring homomorphism (recall multiplication is pointwise multiplication of subsets
on either side). -/
@[simps]
def span.ringHom : SetSemiring A →+* Submodule R A 
goal: Submodule.span.ringHom s = Submodule.span R (SetSemiring.down s)

full_name: Submodule.pointwiseMulSemiringAction
code: /-- The action on a submodule corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale.

This is a stronger version of `Submodule.pointwiseDistribMulAction`. -/
protected def pointwiseMulSemiringAction : MulSemiringAction α (Submodule R A) 
goal: MulSemiringAction α (Submodule R A)

full_name: Submodule.mul_mem_mul_rev
code: theorem mul_mem_mul_rev (hm : m ∈ M) (hn : n ∈ N) : n * m ∈ M * N 
goal: n * m ∈ M * N

full_name: Submodule.mul_comm
code: protected theorem mul_comm : M * N = N * M 
goal: M * N = N * M

full_name: Submodule.instIdemCommSemiring
code: /-- Sub-R-modules of an R-algebra A form a semiring. -/
instance : IdemCommSemiring (Submodule R A) 
goal: IdemCommSemiring (Submodule R A)

full_name: Submodule.prod_span
code: theorem prod_span {ι : Type*} (s : Finset ι) (M : ι → Set A) :
    (∏ i ∈ s, Submodule.span R (M i)) = Submodule.span R (∏ i ∈ s, M i) 
goal: ∏ i ∈ s, Submodule.span R (M i) = Submodule.span R (∏ i ∈ s, M i)

full_name: Submodule.prod_span_singleton
code: theorem prod_span_singleton {ι : Type*} (s : Finset ι) (x : ι → A) :
    (∏ i ∈ s, span R ({x i} : Set A)) = span R {∏ i ∈ s, x i} 
goal: ∏ i ∈ s, Submodule.span R {x i} = Submodule.span R {∏ i ∈ s, x i}

full_name: Submodule.moduleSet
code: /-- R-submodules of the R-algebra A are a module over `Set A`. -/
instance moduleSet : Module (SetSemiring A) (Submodule R A) 
goal: Module (SetSemiring A) (Submodule R A)

full_name: Submodule.smul_def
code: theorem smul_def (s : SetSemiring A) (P : Submodule R A) :
    s • P = span R (SetSemiring.down (α := A) s) * P 
goal: s • P = Submodule.span R (SetSemiring.down s) * P

full_name: Submodule.smul_le_smul
code: theorem smul_le_smul {s t : SetSemiring A} {M N : Submodule R A}
    (h₁ : SetSemiring.down (α := A) s ⊆ SetSemiring.down (α := A) t)
    (h₂ : M ≤ N) : s • M ≤ t • N 
goal: s • M ≤ t • N

full_name: Submodule.singleton_smul
code: theorem singleton_smul (a : A) (M : Submodule R A) :
    Set.up ({a} : Set A) • M = M.map (LinearMap.mulLeft R a) 
goal: Set.up {a} • M = Submodule.map (LinearMap.mulLeft R a) M

full_name: Submodule.instDiv
code: /-- The elements of `I / J` are the `x` such that `x • J ⊆ I`.

In fact, we define `x ∈ I / J` to be `∀ y ∈ J, x * y ∈ I` (see `mem_div_iff_forall_mul_mem`),
which is equivalent to `x • J ⊆ I` (see `mem_div_iff_smul_subset`), but nicer to use in proofs.

This is the general form of the ideal quotient, traditionally written $I : J$.
-/
instance : Div (Submodule R A) 
goal: Div (Submodule R A)

full_name: Submodule.mem_div_iff_forall_mul_mem
code: theorem mem_div_iff_forall_mul_mem {x : A} {I J : Submodule R A} : x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I 
goal: x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I

full_name: Submodule.mem_div_iff_smul_subset
code: theorem mem_div_iff_smul_subset {x : A} {I J : Submodule R A} : x ∈ I / J ↔ x • (J : Set A) ⊆ I 
goal: x ∈ I / J ↔ x • ↑J ⊆ ↑I

full_name: Submodule.le_div_iff
code: theorem le_div_iff {I J K : Submodule R A} : I ≤ J / K ↔ ∀ x ∈ I, ∀ z ∈ K, x * z ∈ J 
goal: I ≤ J / K ↔ ∀ x ∈ I, ∀ z ∈ K, x * z ∈ J

full_name: Submodule.le_div_iff_mul_le
code: theorem le_div_iff_mul_le {I J K : Submodule R A} : I ≤ J / K ↔ I * K ≤ J 
goal: I ≤ J / K ↔ I * K ≤ J

full_name: Submodule.one_le_one_div
code: @[simp]
theorem one_le_one_div {I : Submodule R A} : 1 ≤ 1 / I ↔ I ≤ 1 
goal: 1 ≤ 1 / I ↔ I ≤ 1

full_name: Submodule.le_self_mul_one_div
code: theorem le_self_mul_one_div {I : Submodule R A} (hI : I ≤ 1) : I ≤ I * (1 / I) 
goal: I ≤ I * (1 / I)

full_name: Submodule.mul_one_div_le_one
code: theorem mul_one_div_le_one {I : Submodule R A} : I * (1 / I) ≤ 1 
goal: I * (1 / I) ≤ 1

full_name: Submodule.map_div
code: @[simp]
protected theorem map_div {B : Type*} [CommSemiring B] [Algebra R B] (I J : Submodule R A)
    (h : A ≃ₐ[R] B) : (I / J).map h.toLinearMap = I.map h.toLinearMap / J.map h.toLinearMap 
goal: Submodule.map h.toLinearMap (I / J) = Submodule.map h.toLinearMap I / Submodule.map h.toLinearMap J