File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

full_name: SMulMemClass.smul_mem
code: /-- `SMulMemClass S R M` says `S` is a type of subsets `s ≤ M` that are closed under the
scalar action of `R` on `M`.

Note that only `R` is marked as an `outParam` here, since `M` is supplied by the `SetLike`
class instead.
-/
class SMulMemClass (S : Type*) (R : outParam Type*) (M : Type*) [SMul R M] [SetLike S M] :
    Prop where
  /-- Multiplication by a scalar on an element of the set remains in the set. -/
  smul_mem : ∀ {s : S} (r : R) {m : M}, m ∈ s → r • m ∈ s
goal: m ∈ s → r • m ∈ s

full_name: SMulMemClass
code: /-- `SMulMemClass S R M` says `S` is a type of subsets `s ≤ M` that are closed under the
scalar action of `R` on `M`.

Note that only `R` is marked as an `outParam` here, since `M` is supplied by the `SetLike`
class instead.
-/
class SMulMemClass (S : Type*) (R : outParam Type*) (M : Type*) [SMul R M] [SetLike S M] :
    Prop where
  /-- Multiplication by a scalar on an element of the set remains in the set. -/
  smul_mem : ∀ {s : S} (r : R) {m : M}, m ∈ s → r • m ∈ s
goal: Prop

full_name: VAddMemClass.vadd_mem
code: /-- `VAddMemClass S R M` says `S` is a type of subsets `s ≤ M` that are closed under the
additive action of `R` on `M`.

Note that only `R` is marked as an `outParam` here, since `M` is supplied by the `SetLike`
class instead. -/
class VAddMemClass (S : Type*) (R : outParam Type*) (M : Type*) [VAdd R M] [SetLike S M] :
    Prop where
  /-- Addition by a scalar with an element of the set remains in the set. -/
  vadd_mem : ∀ {s : S} (r : R) {m : M}, m ∈ s → r +ᵥ m ∈ s
goal: m ∈ s → r +ᵥ m ∈ s

full_name: VAddMemClass
code: /-- `VAddMemClass S R M` says `S` is a type of subsets `s ≤ M` that are closed under the
additive action of `R` on `M`.

Note that only `R` is marked as an `outParam` here, since `M` is supplied by the `SetLike`
class instead. -/
class VAddMemClass (S : Type*) (R : outParam Type*) (M : Type*) [VAdd R M] [SetLike S M] :
    Prop where
  /-- Addition by a scalar with an element of the set remains in the set. -/
  vadd_mem : ∀ {s : S} (r : R) {m : M}, m ∈ s → r +ᵥ m ∈ s
goal: Prop

full_name: AddSubmonoidClass.nsmulMemClass
code: /-- Not registered as an instance because `R` is an `outParam` in `SMulMemClass S R M`. -/
lemma AddSubmonoidClass.nsmulMemClass {S M : Type*} [AddMonoid M] [SetLike S M]
    [AddSubmonoidClass S M] : SMulMemClass S ℕ M 
goal: SMulMemClass S ℕ M

full_name: AddSubgroupClass.zsmulMemClass
code: /-- Not registered as an instance because `R` is an `outParam` in `SMulMemClass S R M`. -/
lemma AddSubgroupClass.zsmulMemClass {S M : Type*} [SubNegMonoid M] [SetLike S M]
    [AddSubgroupClass S M] : SMulMemClass S ℤ M 
goal: SMulMemClass S ℤ M

full_name: SetLike.vadd
code: /-- A subset closed under the scalar action inherits that action. -/
@[to_additive "A subset closed under the additive action inherits that action."]
instance (priority := 50) smul : SMul R s 
goal: VAdd R ↥s

full_name: SetLike.smul
code: /-- A subset closed under the scalar action inherits that action. -/
@[to_additive "A subset closed under the additive action inherits that action."]
instance (priority := 50) smul : SMul R s 
goal: SMul R ↥s

full_name: SMulMemClass.ofIsScalarTower
code: /-- This can't be an instance because Lean wouldn't know how to find `N`, but we can still use
this to manually derive `SMulMemClass` on specific types. -/
theorem _root_.SMulMemClass.ofIsScalarTower (S M N α : Type*) [SetLike S α] [SMul M N]
    [SMul M α] [Monoid N] [MulAction N α] [SMulMemClass S N α] [IsScalarTower M N α] :
    SMulMemClass S M α 
goal: SMulMemClass S M α

full_name: SetLike.instIsScalarTower
code: instance instIsScalarTower [Mul M] [MulMemClass S M] [IsScalarTower R M M]
    (s : S) : IsScalarTower R s s 
goal: IsScalarTower R ↥s ↥s

full_name: SetLike.instSMulCommClass
code: instance instSMulCommClass [Mul M] [MulMemClass S M] [SMulCommClass R M M]
    (s : S) : SMulCommClass R s s 
goal: SMulCommClass R ↥s ↥s

full_name: SetLike.val_smul
code: @[to_additive (attr := simp, norm_cast)]
protected theorem val_smul (r : R) (x : s) : (↑(r • x) : M) = r • (x : M) 
goal: ↑(r • x) = r • ↑x

full_name: SetLike.val_vadd
code: @[to_additive (attr := simp, norm_cast)]
protected theorem val_smul (r : R) (x : s) : (↑(r • x) : M) = r • (x : M) 
goal: ↑(r +ᵥ x) = r +ᵥ ↑x

full_name: SetLike.mk_vadd_mk
code: @[to_additive (attr := simp)]
theorem mk_smul_mk (r : R) (x : M) (hx : x ∈ s) : r • (⟨x, hx⟩ : s) = ⟨r • x, smul_mem r hx⟩ 
goal: r +ᵥ ⟨x, hx⟩ = ⟨r +ᵥ x, ⋯⟩

full_name: SetLike.mk_smul_mk
code: @[to_additive (attr := simp)]
theorem mk_smul_mk (r : R) (x : M) (hx : x ∈ s) : r • (⟨x, hx⟩ : s) = ⟨r • x, smul_mem r hx⟩ 
goal: r • ⟨x, hx⟩ = ⟨r • x, ⋯⟩

full_name: SetLike.vadd_def
code: @[to_additive]
theorem smul_def (r : R) (x : s) : r • x = ⟨r • x, smul_mem r x.2⟩ 
goal: r +ᵥ x = ⟨r +ᵥ ↑x, ⋯⟩

full_name: SetLike.smul_def
code: @[to_additive]
theorem smul_def (r : R) (x : s) : r • x = ⟨r • x, smul_mem r x.2⟩ 
goal: r • x = ⟨r • ↑x, ⋯⟩

full_name: SetLike.forall_smul_mem_iff
code: @[simp]
theorem forall_smul_mem_iff {R M S : Type*} [Monoid R] [MulAction R M] [SetLike S M]
    [SMulMemClass S R M] {N : S} {x : M} : (∀ a : R, a • x ∈ N) ↔ x ∈ N 
goal: (∀ (a : R), a • x ∈ N) ↔ x ∈ N

full_name: SetLike.smul'
code: /-- A subset closed under the scalar action inherits that action. -/
@[to_additive "A subset closed under the additive action inherits that action."]
instance (priority := 50) smul' : SMul M s 
goal: SMul M ↥s

full_name: SetLike.vadd'
code: /-- A subset closed under the scalar action inherits that action. -/
@[to_additive "A subset closed under the additive action inherits that action."]
instance (priority := 50) smul' : SMul M s 
goal: VAdd M ↥s

full_name: SetLike.val_smul_of_tower
code: @[to_additive (attr := simp, norm_cast)]
protected theorem val_smul_of_tower (r : M) (x : s) : (↑(r • x) : α) = r • (x : α) 
goal: ↑(r • x) = r • ↑x

full_name: SetLike.val_vadd_of_tower
code: @[to_additive (attr := simp, norm_cast)]
protected theorem val_smul_of_tower (r : M) (x : s) : (↑(r • x) : α) = r • (x : α) 
goal: ↑(r +ᵥ x) = r +ᵥ ↑x

full_name: SetLike.mk_smul_of_tower_mk
code: @[to_additive (attr := simp)]
theorem mk_smul_of_tower_mk (r : M) (x : α) (hx : x ∈ s) :
    r • (⟨x, hx⟩ : s) = ⟨r • x, smul_one_smul N r x ▸ smul_mem _ hx⟩ 
goal: r • ⟨x, hx⟩ = ⟨r • x, ⋯⟩

full_name: SetLike.mk_vadd_of_tower_mk
code: @[to_additive (attr := simp)]
theorem mk_smul_of_tower_mk (r : M) (x : α) (hx : x ∈ s) :
    r • (⟨x, hx⟩ : s) = ⟨r • x, smul_one_smul N r x ▸ smul_mem _ hx⟩ 
goal: r +ᵥ ⟨x, hx⟩ = ⟨r +ᵥ x, ⋯⟩

full_name: SetLike.smul_of_tower_def
code: @[to_additive]
theorem smul_of_tower_def (r : M) (x : s) :
    r • x = ⟨r • x, smul_one_smul N r x.1 ▸ smul_mem _ x.2⟩ 
goal: r • x = ⟨r • ↑x, ⋯⟩

full_name: SetLike.vadd_of_tower_def
code: @[to_additive]
theorem smul_of_tower_def (r : M) (x : s) :
    r • x = ⟨r • x, smul_one_smul N r x.1 ▸ smul_mem _ x.2⟩ 
goal: r +ᵥ x = ⟨r +ᵥ ↑x, ⋯⟩

full_name: SubMulAction
code: /-- A SubMulAction is a set which is closed under scalar multiplication.  -/
structure SubMulAction (R : Type u) (M : Type v) [SMul R M] : Type v where
  /-- The underlying set of a `SubMulAction`. -/
  carrier : Set M
  /-- The carrier set is closed under scalar multiplication. -/
  smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier → c • x ∈ carrier
goal: Type v

full_name: SubMulAction.carrier
code: /-- A SubMulAction is a set which is closed under scalar multiplication.  -/
structure SubMulAction (R : Type u) (M : Type v) [SMul R M] : Type v where
  /-- The underlying set of a `SubMulAction`. -/
  carrier : Set M
  /-- The carrier set is closed under scalar multiplication. -/
  smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier → c • x ∈ carrier
goal: Set M

full_name: SubMulAction.smul_mem'
code: /-- A SubMulAction is a set which is closed under scalar multiplication.  -/
structure SubMulAction (R : Type u) (M : Type v) [SMul R M] : Type v where
  /-- The underlying set of a `SubMulAction`. -/
  carrier : Set M
  /-- The carrier set is closed under scalar multiplication. -/
  smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier → c • x ∈ carrier
goal: x ∈ self.carrier → c • x ∈ self.carrier

full_name: SubMulAction.instSetLike
code: instance : SetLike (SubMulAction R M) M 
goal: SetLike (SubMulAction R M) M

full_name: SubMulAction.instSMulMemClass
code: instance : SMulMemClass (SubMulAction R M) R M 
goal: SMulMemClass (SubMulAction R M) R M

full_name: SubMulAction.mem_carrier
code: @[simp]
theorem mem_carrier {p : SubMulAction R M} {x : M} : x ∈ p.carrier ↔ x ∈ (p : Set M) 
goal: x ∈ p.carrier ↔ x ∈ ↑p

full_name: SubMulAction.ext
code: @[ext]
theorem ext {p q : SubMulAction R M} (h : ∀ x, x ∈ p ↔ x ∈ q) : p = q 
goal: p = q

full_name: SubMulAction.copy
code: /-- Copy of a sub_mul_action with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (p : SubMulAction R M) (s : Set M) (hs : s = ↑p) : SubMulAction R M 
goal: SubMulAction R M

full_name: SubMulAction.coe_copy
code: @[simp]
theorem coe_copy (p : SubMulAction R M) (s : Set M) (hs : s = ↑p) : (p.copy s hs : Set M) = s 
goal: ↑(p.copy s hs) = s

full_name: SubMulAction.copy_eq
code: theorem copy_eq (p : SubMulAction R M) (s : Set M) (hs : s = ↑p) : p.copy s hs = p 
goal: p.copy s hs = p

full_name: SubMulAction.instBot
code: instance : Bot (SubMulAction R M) 
goal: Bot (SubMulAction R M)

full_name: SubMulAction.instInhabited
code: instance : Inhabited (SubMulAction R M) 
goal: Inhabited (SubMulAction R M)

full_name: SubMulAction.smul_mem
code: theorem smul_mem (r : R) (h : x ∈ p) : r • x ∈ p 
goal: r • x ∈ p

full_name: SubMulAction.instSMulSubtypeMem
code: instance : SMul R p 
goal: SMul R ↥p

full_name: SubMulAction.val_smul
code: @[simp, norm_cast]
theorem val_smul (r : R) (x : p) : (↑(r • x) : M) = r • (x : M) 
goal: ↑(r • x) = r • ↑x

full_name: SubMulAction.subtype
code: /-- Embedding of a submodule `p` to the ambient space `M`. -/
protected def subtype : p →[R] M 
goal: ↥p →ₑ[id] M

full_name: SubMulAction.subtype_apply
code: @[simp]
theorem subtype_apply (x : p) : p.subtype x = x 
goal: p.subtype x = ↑x

full_name: SubMulAction.subtype_eq_val
code: theorem subtype_eq_val : (SubMulAction.subtype p : p → M) = Subtype.val 
goal: ⇑p.subtype = Subtype.val

full_name: SubMulAction.SMulMemClass.toMulAction
code: /-- A `SubMulAction` of a `MulAction` is a `MulAction`.  -/
instance (priority := 75) toMulAction : MulAction R S' 
goal: MulAction R ↥S'

full_name: SubMulAction.SMulMemClass.subtype
code: /-- The natural `MulActionHom` over `R` from a `SubMulAction` of `M` to `M`. -/
protected def subtype : S' →[R] M 
goal: ↥S' →ₑ[id] M

full_name: SubMulAction.SMulMemClass.coeSubtype
code: @[simp]
protected theorem coeSubtype : (SMulMemClass.subtype S' : S' → M) = Subtype.val 
goal: ⇑(SubMulAction.SMulMemClass.subtype S') = Subtype.val

full_name: SubMulAction.smul_of_tower_mem
code: theorem smul_of_tower_mem (s : S) {x : M} (h : x ∈ p) : s • x ∈ p 
goal: s • x ∈ p

full_name: SubMulAction.smul'
code: instance smul' : SMul S p 
goal: SMul S ↥p

full_name: SubMulAction.isScalarTower
code: instance isScalarTower : IsScalarTower S R p 
goal: IsScalarTower S R ↥p

full_name: SubMulAction.isScalarTower'
code: instance isScalarTower' {S' : Type*} [SMul S' R] [SMul S' S] [SMul S' M] [IsScalarTower S' R M]
    [IsScalarTower S' S M] : IsScalarTower S' S p 
goal: IsScalarTower S' S ↥p

full_name: SubMulAction.val_smul_of_tower
code: @[simp, norm_cast]
theorem val_smul_of_tower (s : S) (x : p) : ((s • x : p) : M) = s • (x : M) 
goal: ↑(s • x) = s • ↑x

full_name: SubMulAction.smul_mem_iff'
code: @[simp]
theorem smul_mem_iff' {G} [Group G] [SMul G R] [MulAction G M] [IsScalarTower G R M] (g : G)
    {x : M} : g • x ∈ p ↔ x ∈ p 
goal: g • x ∈ p ↔ x ∈ p

full_name: SubMulAction.isCentralScalar
code: instance isCentralScalar [SMul Sᵐᵒᵖ R] [SMul Sᵐᵒᵖ M] [IsScalarTower Sᵐᵒᵖ R M]
    [IsCentralScalar S M] :
    IsCentralScalar S p 
goal: IsCentralScalar S ↥p

full_name: SubMulAction.mulAction'
code: /-- If the scalar product forms a `MulAction`, then the subset inherits this action -/
instance mulAction' : MulAction S p 
goal: MulAction S ↥p

full_name: SubMulAction.mulAction
code: instance mulAction : MulAction R p 
goal: MulAction R ↥p

full_name: SubMulAction.val_image_orbit
code: /-- Orbits in a `SubMulAction` coincide with orbits in the ambient space. -/
theorem val_image_orbit {p : SubMulAction R M} (m : p) :
    Subtype.val '' MulAction.orbit R m = MulAction.orbit R (m : M) 
goal: Subtype.val '' MulAction.orbit R m = MulAction.orbit R ↑m

full_name: SubMulAction.val_preimage_orbit
code: theorem val_preimage_orbit {p : SubMulAction R M} (m : p) :
    Subtype.val ⁻¹' MulAction.orbit R (m : M) = MulAction.orbit R m 
goal: Subtype.val ⁻¹' MulAction.orbit R ↑m = MulAction.orbit R m

full_name: SubMulAction.mem_orbit_subMul_iff
code: lemma mem_orbit_subMul_iff {p : SubMulAction R M} {x m : p} :
    x ∈ MulAction.orbit R m ↔ (x : M) ∈ MulAction.orbit R (m : M) 
goal: x ∈ MulAction.orbit R m ↔ ↑x ∈ MulAction.orbit R ↑m

full_name: SubMulAction.stabilizer_of_subMul.submonoid
code: /-- Stabilizers in monoid SubMulAction coincide with stabilizers in the ambient space -/
theorem stabilizer_of_subMul.submonoid {p : SubMulAction R M} (m : p) :
    MulAction.stabilizerSubmonoid R m = MulAction.stabilizerSubmonoid R (m : M) 
goal: MulAction.stabilizerSubmonoid R m = MulAction.stabilizerSubmonoid R ↑m

full_name: SubMulAction.orbitRel_of_subMul
code: lemma orbitRel_of_subMul (p : SubMulAction R M) :
    MulAction.orbitRel R p = (MulAction.orbitRel R M).comap Subtype.val 
goal: MulAction.orbitRel R ↥p = Setoid.comap Subtype.val (MulAction.orbitRel R M)

full_name: SubMulAction.stabilizer_of_subMul
code: /-- Stabilizers in group SubMulAction coincide with stabilizers in the ambient space -/
theorem stabilizer_of_subMul {p : SubMulAction R M} (m : p) :
    MulAction.stabilizer R m = MulAction.stabilizer R (m : M) 
goal: MulAction.stabilizer R m = MulAction.stabilizer R ↑m

full_name: SubMulAction.zero_mem
code: theorem zero_mem (h : (p : Set M).Nonempty) : (0 : M) ∈ p 
goal: 0 ∈ p

full_name: SubMulAction.instZeroSubtypeMemOfNonempty
code: /-- If the scalar product forms a `Module`, and the `SubMulAction` is not `⊥`, then the
subset inherits the zero. -/
instance [n_empty : Nonempty p] : Zero p 
goal: Zero ↥p

full_name: SubMulAction.neg_mem
code: theorem neg_mem (hx : x ∈ p) : -x ∈ p 
goal: -x ∈ p

full_name: SubMulAction.neg_mem_iff
code: @[simp]
theorem neg_mem_iff : -x ∈ p ↔ x ∈ p 
goal: -x ∈ p ↔ x ∈ p

full_name: SubMulAction.instNegSubtypeMem
code: instance : Neg p 
goal: Neg ↥p

full_name: SubMulAction.val_neg
code: @[simp, norm_cast]
theorem val_neg (x : p) : ((-x : p) : M) = -x 
goal: ↑(-x) = -↑x

full_name: SubMulAction.smul_mem_iff
code: theorem smul_mem_iff (s0 : s ≠ 0) : s • x ∈ p ↔ x ∈ p 
goal: s • x ∈ p ↔ x ∈ p

full_name: SubMulAction.inclusion
code: /-- The inclusion of a SubMulAction into the ambient set, as an equivariant map -/
def inclusion (s : SubMulAction M α) : s →[M] α 
goal: ↥s →ₑ[id] α

full_name: SubMulAction.inclusion.toFun_eq_coe
code: theorem inclusion.toFun_eq_coe (s : SubMulAction M α) :
    s.inclusion.toFun = Subtype.val 
goal: s.inclusion.toFun = Subtype.val

full_name: SubMulAction.inclusion.coe_eq
code: theorem inclusion.coe_eq (s : SubMulAction M α) :
    ⇑s.inclusion = Subtype.val 
goal: ⇑s.inclusion = Subtype.val

full_name: SubMulAction.image_inclusion
code: lemma image_inclusion (s : SubMulAction M α) :
    Set.range s.inclusion = s.carrier 
goal: Set.range ⇑s.inclusion = s.carrier

full_name: SubMulAction.inclusion_injective
code: lemma inclusion_injective (s : SubMulAction M α) :
    Function.Injective s.inclusion 
goal: Function.Injective ⇑s.inclusion