File: Mathlib/Algebra/Module/Basic.lean

full_name: map_inv_natCast_smul
code: theorem map_inv_natCast_smul [AddCommMonoid M] [AddCommMonoid M₂] {F : Type*} [FunLike F M M₂]
    [AddMonoidHomClass F M M₂] (f : F) (R S : Type*)
    [DivisionSemiring R] [DivisionSemiring S] [Module R M]
    [Module S M₂] (n : ℕ) (x : M) : f ((n⁻¹ : R) • x) = (n⁻¹ : S) • f x 
goal: f ((↑n)⁻¹ • x) = (↑n)⁻¹ • f x

full_name: map_inv_intCast_smul
code: theorem map_inv_intCast_smul [AddCommGroup M] [AddCommGroup M₂] {F : Type*} [FunLike F M M₂]
    [AddMonoidHomClass F M M₂] (f : F) (R S : Type*) [DivisionRing R] [DivisionRing S] [Module R M]
    [Module S M₂] (z : ℤ) (x : M) : f ((z⁻¹ : R) • x) = (z⁻¹ : S) • f x 
goal: f ((↑z)⁻¹ • x) = (↑z)⁻¹ • f x

full_name: inv_natCast_smul_eq
code: /-- If `E` is a vector space over two division semirings `R` and `S`, then scalar multiplications
agree on inverses of natural numbers in `R` and `S`. -/
theorem inv_natCast_smul_eq {E : Type*} (R S : Type*) [AddCommMonoid E] [DivisionSemiring R]
    [DivisionSemiring S] [Module R E] [Module S E] (n : ℕ) (x : E) :
    (n⁻¹ : R) • x = (n⁻¹ : S) • x 
goal: (↑n)⁻¹ • x = (↑n)⁻¹ • x

full_name: inv_intCast_smul_eq
code: /-- If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on inverses of integer numbers in `R` and `S`. -/
theorem inv_intCast_smul_eq {E : Type*} (R S : Type*) [AddCommGroup E] [DivisionRing R]
    [DivisionRing S] [Module R E] [Module S E] (n : ℤ) (x : E) : (n⁻¹ : R) • x = (n⁻¹ : S) • x 
goal: (↑n)⁻¹ • x = (↑n)⁻¹ • x

full_name: inv_natCast_smul_comm
code: /-- If `E` is a vector space over a division semiring `R` and has a monoid action by `α`, then that
action commutes by scalar multiplication of inverses of natural numbers in `R`. -/
theorem inv_natCast_smul_comm {α E : Type*} (R : Type*) [AddCommMonoid E] [DivisionSemiring R]
    [Monoid α] [Module R E] [DistribMulAction α E] (n : ℕ) (s : α) (x : E) :
    (n⁻¹ : R) • s • x = s • (n⁻¹ : R) • x 
goal: (↑n)⁻¹ • s • x = s • (↑n)⁻¹ • x

full_name: inv_intCast_smul_comm
code: /-- If `E` is a vector space over a division ring `R` and has a monoid action by `α`, then that
action commutes by scalar multiplication of inverses of integers in `R` -/
theorem inv_intCast_smul_comm {α E : Type*} (R : Type*) [AddCommGroup E] [DivisionRing R]
    [Monoid α] [Module R E] [DistribMulAction α E] (n : ℤ) (s : α) (x : E) :
    (n⁻¹ : R) • s • x = s • (n⁻¹ : R) • x 
goal: (↑n)⁻¹ • s • x = s • (↑n)⁻¹ • x

full_name: instNoZeroSMulDivisorsNatOfInt_1
code: instance [NoZeroSMulDivisors ℤ M] : NoZeroSMulDivisors ℕ M 
goal: NoZeroSMulDivisors ℕ M

full_name: GroupWithZero.toNoZeroSMulDivisors
code: /-- This instance applies to `DivisionSemiring`s, in particular `NNReal` and `NNRat`. -/
instance (priority := 100) GroupWithZero.toNoZeroSMulDivisors : NoZeroSMulDivisors R M 
goal: NoZeroSMulDivisors R M

full_name: Function.support_smul_subset_left
code: lemma support_smul_subset_left [Zero R] [Zero M] [SMulWithZero R M] (f : α → R) (g : α → M) :
    support (f • g) ⊆ support f 
goal: Function.support (f • g) ⊆ Function.support f

full_name: Function.support_smul_subset_right
code: lemma support_smul_subset_right [Zero M] [SMulZeroClass R M] (f : α → R) (g : α → M) :
    support (f • g) ⊆ support g 
goal: Function.support (f • g) ⊆ Function.support g

full_name: Function.support_const_smul_of_ne_zero
code: lemma support_const_smul_of_ne_zero [Zero R] [Zero M] [SMulWithZero R M] [NoZeroSMulDivisors R M]
    (c : R) (g : α → M) (hc : c ≠ 0) : support (c • g) = support g 
goal: Function.support (c • g) = Function.support g

full_name: Function.support_smul
code: lemma support_smul [Zero R] [Zero M] [SMulWithZero R M] [NoZeroSMulDivisors R M] (f : α → R)
    (g : α → M) : support (f • g) = support f ∩ support g 
goal: Function.support (f • g) = Function.support f ∩ Function.support g

full_name: Function.support_const_smul_subset
code: lemma support_const_smul_subset [Zero M] [SMulZeroClass R M] (a : R) (f : α → M) :
    support (a • f) ⊆ support f 
goal: Function.support (a • f) ⊆ Function.support f

full_name: Set.indicator_smul_apply
code: lemma indicator_smul_apply (s : Set α) (r : α → R) (f : α → M) (a : α) :
    indicator s (fun a ↦ r a • f a) a = r a • indicator s f a 
goal: s.indicator (fun a => r a • f a) a = r a • s.indicator f a

full_name: Set.indicator_smul
code: lemma indicator_smul (s : Set α) (r : α → R) (f : α → M) :
    indicator s (fun a ↦ r a • f a) = fun a ↦ r a • indicator s f a 
goal: (s.indicator fun a => r a • f a) = fun a => r a • s.indicator f a

full_name: Set.indicator_const_smul_apply
code: lemma indicator_const_smul_apply (s : Set α) (r : R) (f : α → M) (a : α) :
    indicator s (r • f ·) a = r • indicator s f a 
goal: s.indicator (fun x => r • f x) a = r • s.indicator f a

full_name: Set.indicator_const_smul
code: lemma indicator_const_smul (s : Set α) (r : R) (f : α → M) :
    indicator s (r • f ·) = (r • indicator s f ·) 
goal: (s.indicator fun x => r • f x) = fun x => r • s.indicator f x

full_name: Set.indicator_smul_apply_left
code: lemma indicator_smul_apply_left (s : Set α) (r : α → R) (f : α → M) (a : α) :
    indicator s (fun a ↦ r a • f a) a = indicator s r a • f a 
goal: s.indicator (fun a => r a • f a) a = s.indicator r a • f a

full_name: Set.indicator_smul_left
code: lemma indicator_smul_left (s : Set α) (r : α → R) (f : α → M) :
    indicator s (fun a ↦ r a • f a) = fun a ↦ indicator s r a • f a 
goal: (s.indicator fun a => r a • f a) = fun a => s.indicator r a • f a

full_name: Set.indicator_smul_const_apply
code: lemma indicator_smul_const_apply (s : Set α) (r : α → R) (m : M) (a : α) :
    indicator s (r · • m) a = indicator s r a • m 
goal: s.indicator (fun x => r x • m) a = s.indicator r a • m

full_name: Set.indicator_smul_const
code: lemma indicator_smul_const (s : Set α) (r : α → R) (m : M) :
    indicator s (r · • m) = (indicator s r · • m) 
goal: (s.indicator fun x => r x • m) = fun x => s.indicator r x • m