ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Module/BigOperators.lean

full_name: List.sum_smul
code: theorem List.sum_smul {l : List R} {x : M} : l.sum • x = (l.map fun r ↦ r • x).sum 
goal: l.sum • x = (List.map (fun r => r • x) l).sum

full_name: Multiset.sum_smul
code: theorem Multiset.sum_smul {l : Multiset R} {x : M} : l.sum • x = (l.map fun r ↦ r • x).sum 
goal: l.sum • x = (Multiset.map (fun r => r • x) l).sum

full_name: Multiset.sum_smul_sum
code: theorem Multiset.sum_smul_sum {s : Multiset R} {t : Multiset M} :
    s.sum • t.sum = ((s ×ˢ t).map fun p : R × M ↦ p.fst • p.snd).sum 
goal: s.sum • t.sum = (Multiset.map (fun p => p.1 • p.2) (s ×ˢ t)).sum

full_name: Finset.sum_smul
code: theorem Finset.sum_smul {f : ι → R} {s : Finset ι} {x : M} :
    (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x 
goal: (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x

full_name: Finset.sum_smul_sum
code: lemma Finset.sum_smul_sum (s : Finset α) (t : Finset β) {f : α → R} {g : β → M} :
    (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j 
goal: (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j

full_name: Fintype.sum_smul_sum
code: lemma Fintype.sum_smul_sum [Fintype α] [Fintype β] (f : α → R) (g : β → M) :
    (∑ i, f i) • ∑ j, g j = ∑ i, ∑ j, f i • g j 
goal: (∑ i : α, f i) • ∑ j : β, g j = ∑ i : α, ∑ j : β, f i • g j

full_name: Finset.cast_card
code: theorem Finset.cast_card [CommSemiring R] (s : Finset α) : (s.card : R) = ∑ a ∈ s, 1 
goal: ↑s.card = ∑ a ∈ s, 1

full_name: Fintype.sum_piFinset_apply
code: lemma sum_piFinset_apply (f : κ → α) (s : Finset κ) (i : ι) :
    ∑ g ∈ piFinset fun _ : ι ↦ s, f (g i) = s.card ^ (card ι - 1) • ∑ b ∈ s, f b 
goal: ∑ g ∈ Fintype.piFinset fun x => s, f (g i) = s.card ^ (Fintype.card ι - 1) • ∑ b ∈ s, f b
File: Mathlib/Algebra/Module/Zlattice/Covolume.lean

full_name: Zlattice.covolume
code: /-- The covolume of a `ℤ`-lattice is the volume of some fundamental domain; see
`Zlattice.covolume_eq_volume` for the proof that the volume does not depend on the choice of
the fundamental domain. -/
def covolume (μ : Measure E := by volume_tac) : ℝ 
goal: ℝ

full_name: Zlattice.covolume_eq_measure_fundamentalDomain
code: theorem covolume_eq_measure_fundamentalDomain {F : Set E} (h : IsAddFundamentalDomain L F μ) :
    covolume L μ = (μ F).toReal 
goal: Zlattice.covolume L μ = (μ F).toReal

full_name: Zlattice.covolume_ne_zero
code: theorem covolume_ne_zero : covolume L μ ≠ 0 
goal: Zlattice.covolume L μ ≠ 0

full_name: Zlattice.covolume_pos
code: theorem covolume_pos : 0 < covolume L μ 
goal: 0 < Zlattice.covolume L μ

full_name: Zlattice.covolume_eq_det_mul_measure
code: theorem covolume_eq_det_mul_measure {ι : Type*} [Fintype ι] [DecidableEq ι] (b : Basis ι ℤ L)
    (b₀ : Basis ι ℝ E) :
    covolume L μ = |b₀.det ((↑) ∘ b)| * (μ (Zspan.fundamentalDomain b₀)).toReal 
goal: Zlattice.covolume L μ = |b₀.det (Subtype.val ∘ ⇑b)| * (μ (Zspan.fundamentalDomain b₀)).toReal

full_name: Zlattice.covolume_eq_det
code: theorem covolume_eq_det {ι : Type*} [Fintype ι] [DecidableEq ι] (L : AddSubgroup (ι → ℝ))
    [DiscreteTopology L] [IsZlattice ℝ L] (b : Basis ι ℤ L) :
    covolume L = |(Matrix.of ((↑) ∘ b)).det| 
goal: Zlattice.covolume L MeasureTheory.volume = |(Matrix.of (Subtype.val ∘ ⇑b)).det|
File: Mathlib/Algebra/Module/PointwisePi.lean

full_name: vadd_pi_subset
code: @[to_additive]
theorem smul_pi_subset [∀ i, SMul K (R i)] (r : K) (s : Set ι) (t : ∀ i, Set (R i)) :
    r • pi s t ⊆ pi s (r • t) 
goal: r +ᵥ s.pi t ⊆ s.pi (r +ᵥ t)

full_name: smul_pi_subset
code: @[to_additive]
theorem smul_pi_subset [∀ i, SMul K (R i)] (r : K) (s : Set ι) (t : ∀ i, Set (R i)) :
    r • pi s t ⊆ pi s (r • t) 
goal: r • s.pi t ⊆ s.pi (r • t)

full_name: smul_univ_pi
code: @[to_additive]
theorem smul_univ_pi [∀ i, SMul K (R i)] (r : K) (t : ∀ i, Set (R i)) :
    r • pi (univ : Set ι) t = pi (univ : Set ι) (r • t) 
goal: r • Set.univ.pi t = Set.univ.pi (r • t)

full_name: vadd_univ_pi
code: @[to_additive]
theorem smul_univ_pi [∀ i, SMul K (R i)] (r : K) (t : ∀ i, Set (R i)) :
    r • pi (univ : Set ι) t = pi (univ : Set ι) (r • t) 
goal: r +ᵥ Set.univ.pi t = Set.univ.pi (r +ᵥ t)

full_name: smul_pi
code: @[to_additive]
theorem smul_pi [Group K] [∀ i, MulAction K (R i)] (r : K) (S : Set ι) (t : ∀ i, Set (R i)) :
    r • S.pi t = S.pi (r • t) 
goal: r • S.pi t = S.pi (r • t)

full_name: vadd_pi
code: @[to_additive]
theorem smul_pi [Group K] [∀ i, MulAction K (R i)] (r : K) (S : Set ι) (t : ∀ i, Set (R i)) :
    r • S.pi t = S.pi (r • t) 
goal: r +ᵥ S.pi t = S.pi (r +ᵥ t)

full_name: smul_pi₀
code: theorem smul_pi₀ [GroupWithZero K] [∀ i, MulAction K (R i)] {r : K} (S : Set ι) (t : ∀ i, Set (R i))
    (hr : r ≠ 0) : r • S.pi t = S.pi (r • t) 
goal: r • S.pi t = S.pi (r • t)
File: Mathlib/Algebra/Module/DedekindDomain.lean

full_name: Submodule.isInternal_prime_power_torsion_of_is_torsion_by_ideal
code: /-- Over a Dedekind domain, an `I`-torsion module is the internal direct sum of its `p i ^ e i`-
torsion submodules, where `I = ∏ i, p i ^ e i` is its unique decomposition in prime ideals. -/
theorem isInternal_prime_power_torsion_of_is_torsion_by_ideal {I : Ideal R} (hI : I ≠ ⊥)
    (hM : Module.IsTorsionBySet R M I) :
    DirectSum.IsInternal fun p : (factors I).toFinset =>
      torsionBySet R M (p ^ (factors I).count ↑p : Ideal R) 
goal: DirectSum.IsInternal fun p =>
  Submodule.torsionBySet R M ↑(↑p ^ Multiset.count (↑p) (UniqueFactorizationMonoid.factors I))

full_name: Submodule.isInternal_prime_power_torsion
code: /-- A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules where `p i` are factors of `(⊤ : Submodule R M).annihilator` and
`e i` are their multiplicities. -/
theorem isInternal_prime_power_torsion [Module.Finite R M] (hM : Module.IsTorsion R M) :
    DirectSum.IsInternal fun p : (factors (⊤ : Submodule R M).annihilator).toFinset =>
      torsionBySet R M (p ^ (factors (⊤ : Submodule R M).annihilator).count ↑p : Ideal R) 
goal: DirectSum.IsInternal fun p =>
  Submodule.torsionBySet R M ↑(↑p ^ Multiset.count (↑p) (UniqueFactorizationMonoid.factors ⊤.annihilator))

full_name: Submodule.exists_isInternal_prime_power_torsion
code: /-- A finitely generated torsion module over a Dedekind domain is an internal direct sum of its
`p i ^ e i`-torsion submodules for some prime ideals `p i` and numbers `e i`. -/
theorem exists_isInternal_prime_power_torsion [Module.Finite R M] (hM : Module.IsTorsion R M) :
    ∃ (P : Finset <| Ideal R) (_ : DecidableEq P) (_ : ∀ p ∈ P, Prime p) (e : P → ℕ),
      DirectSum.IsInternal fun p : P => torsionBySet R M (p ^ e p : Ideal R) 
goal: ∃ P x, ∃ (_ : ∀ p ∈ P, Prime p), ∃ e, DirectSum.IsInternal fun p => Submodule.torsionBySet R M ↑(↑p ^ e p)
File: Mathlib/Algebra/Module/Rat.lean

full_name: map_ratCast_smul
code: theorem map_ratCast_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₂] (c : ℚ) (x : M) :
    f ((c : R) • x) = (c : S) • f x 
goal: f (↑c • x) = ↑c • f x

full_name: map_rat_smul
code: theorem map_rat_smul [AddCommGroup M] [AddCommGroup M₂]
    [_instM : Module ℚ M] [_instM₂ : Module ℚ M₂]
    {F : Type*} [FunLike F M M₂] [AddMonoidHomClass F M M₂]
    (f : F) (c : ℚ) (x : M) : f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: subsingleton_rat_module
code: /-- There can be at most one `Module ℚ E` structure on an additive commutative group. -/
instance subsingleton_rat_module (E : Type*) [AddCommGroup E] : Subsingleton (Module ℚ E) 
goal: Subsingleton (Module ℚ E)

full_name: ratCast_smul_eq
code: /-- If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on rational numbers in `R` and `S`. -/
theorem ratCast_smul_eq {E : Type*} (R S : Type*) [AddCommGroup E] [DivisionRing R]
    [DivisionRing S] [Module R E] [Module S E] (r : ℚ) (x : E) : (r : R) • x = (r : S) • x 
goal: ↑r • x = ↑r • x

full_name: IsScalarTower.rat
code: instance IsScalarTower.rat {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M]
    [Module ℚ R] [Module ℚ M] : IsScalarTower ℚ R M 
goal: IsScalarTower ℚ R M

full_name: SMulCommClass.rat
code: instance SMulCommClass.rat {R : Type u} {M : Type v} [Semiring R] [AddCommGroup M] [Module R M]
    [Module ℚ M] : SMulCommClass ℚ R M 
goal: SMulCommClass ℚ R M

full_name: SMulCommClass.rat'
code: instance SMulCommClass.rat' {R : Type u} {M : Type v} [Semiring R] [AddCommGroup M] [Module R M]
    [Module ℚ M] : SMulCommClass R ℚ M 
goal: SMulCommClass R ℚ M

full_name: RatModule.noZeroSMulDivisors
code: instance (priority := 100) RatModule.noZeroSMulDivisors [AddCommGroup M] [Module ℚ M] :
    NoZeroSMulDivisors ℤ M 
goal: NoZeroSMulDivisors ℤ M
File: Mathlib/Algebra/Module/Submodule/EqLocus.lean

full_name: LinearMap.eqLocus
code: /-- A linear map version of `AddMonoidHom.eqLocusM` -/
def eqLocus (f g : F) : Submodule R M 
goal: Submodule R M

full_name: LinearMap.mem_eqLocus
code: @[simp]
theorem mem_eqLocus {x : M} {f g : F} : x ∈ eqLocus f g ↔ f x = g x 
goal: x ∈ LinearMap.eqLocus f g ↔ f x = g x

full_name: LinearMap.eqLocus_toAddSubmonoid
code: theorem eqLocus_toAddSubmonoid (f g : F) :
    (eqLocus f g).toAddSubmonoid = (f : M →+ M₂).eqLocusM g 
goal: (LinearMap.eqLocus f g).toAddSubmonoid = (↑f).eqLocusM ↑g

full_name: LinearMap.eqLocus_eq_top
code: @[simp]
theorem eqLocus_eq_top {f g : F} : eqLocus f g = ⊤ ↔ f = g 
goal: LinearMap.eqLocus f g = ⊤ ↔ f = g

full_name: LinearMap.eqLocus_same
code: @[simp]
theorem eqLocus_same (f : F) : eqLocus f f = ⊤ 
goal: LinearMap.eqLocus f f = ⊤

full_name: LinearMap.le_eqLocus
code: theorem le_eqLocus {f g : F} {S : Submodule R M} : S ≤ eqLocus f g ↔ Set.EqOn f g S 
goal: S ≤ LinearMap.eqLocus f g ↔ Set.EqOn ⇑f ⇑g ↑S

full_name: LinearMap.eqOn_sup
code: theorem eqOn_sup {f g : F} {S T : Submodule R M} (hS : Set.EqOn f g S) (hT : Set.EqOn f g T) :
    Set.EqOn f g ↑(S ⊔ T) 
goal: Set.EqOn ⇑f ⇑g ↑(S ⊔ T)

full_name: LinearMap.ext_on_codisjoint
code: theorem ext_on_codisjoint {f g : F} {S T : Submodule R M} (hST : Codisjoint S T)
    (hS : Set.EqOn f g S) (hT : Set.EqOn f g T) : f = g 
goal: f = g

full_name: LinearMap.eqLocus_eq_ker_sub
code: theorem eqLocus_eq_ker_sub (f g : M →ₛₗ[τ₁₂] M₂) : eqLocus f g = ker (f - g) 
goal: LinearMap.eqLocus f g = LinearMap.ker (f - g)
File: Mathlib/Algebra/Module/Submodule/IterateMapComap.lean

full_name: LinearMap.iterateMapComap
code: /-- The `LinearMap.iterateMapComap f i n K : Submodule R N` is
`f⁻¹(i(⋯(f⁻¹(i(K)))))` (`n` times). -/
def iterateMapComap (n : ℕ) 
goal: Submodule R N → Submodule R N

full_name: LinearMap.iterateMapComap_le_succ
code: /-- If `f(K) ≤ i(K)`, then `LinearMap.iterateMapComap` is not decreasing. -/
theorem iterateMapComap_le_succ (K : Submodule R N) (h : K.map f ≤ K.map i) (n : ℕ) :
    f.iterateMapComap i n K ≤ f.iterateMapComap i (n + 1) K 
goal: f.iterateMapComap i n K ≤ f.iterateMapComap i (n + 1) K

full_name: LinearMap.iterateMapComap_eq_succ
code: /-- If `f` is surjective, `i` is injective, and there exists some `m` such that
`LinearMap.iterateMapComap f i m K = LinearMap.iterateMapComap f i (m + 1) K`,
then for any `n`,
`LinearMap.iterateMapComap f i n K = LinearMap.iterateMapComap f i (n + 1) K`.
In particular, by taking `n = 0`, the kernel of `f` is contained in `K`
(`LinearMap.ker_le_of_iterateMapComap_eq_succ`),
which is a consequence of `LinearMap.ker_le_comap`. -/
theorem iterateMapComap_eq_succ (K : Submodule R N)
    (m : ℕ) (heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K)
    (hf : Surjective f) (hi : Injective i) (n : ℕ) :
    f.iterateMapComap i n K = f.iterateMapComap i (n + 1) K 
goal: f.iterateMapComap i n K = f.iterateMapComap i (n + 1) K

full_name: LinearMap.ker_le_of_iterateMapComap_eq_succ
code: /-- If `f` is surjective, `i` is injective, and there exists some `m` such that
`LinearMap.iterateMapComap f i m K = LinearMap.iterateMapComap f i (m + 1) K`,
then the kernel of `f` is contained in `K`.
This is a corollary of `LinearMap.iterateMapComap_eq_succ` and `LinearMap.ker_le_comap`.
As a special case, if one can take `K` to be zero,
then `f` is injective. This is the key result for establishing the strong rank condition
for noetherian rings. -/
theorem ker_le_of_iterateMapComap_eq_succ (K : Submodule R N)
    (m : ℕ) (heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K)
    (hf : Surjective f) (hi : Injective i) : LinearMap.ker f ≤ K 
goal: LinearMap.ker f ≤ K
File: Mathlib/Algebra/Module/MinimalAxioms.lean

full_name: Module.ofMinimalAxioms
code: /-- Define a `Module` structure on a Type by proving a minimized set of axioms. -/
abbrev Module.ofMinimalAxioms {R : Type u} {M : Type v} [Semiring R] [AddCommGroup M] [SMul R M]
    -- Scalar multiplication distributes over addition from the left.
    (smul_add : ∀ (r : R) (x y : M), r • (x + y) = r • x + r • y)
    -- Scalar multiplication distributes over addition from the right.
    (add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x)
    -- Scalar multiplication distributes over multiplication from the right.
    (mul_smul : ∀ (r s : R) (x : M), (r * s) • x = r • s • x)
    -- Scalar multiplication by one is the identity.
    (one_smul : ∀ x : M, (1 : R) • x = x) : Module R M 
goal: Module R M
File: Mathlib/Algebra/Module/Submodule/Order.lean

full_name: Submodule.toOrderedAddCommMonoid
code: /-- A submodule of an `OrderedAddCommMonoid` is an `OrderedAddCommMonoid`. -/
instance toOrderedAddCommMonoid [OrderedAddCommMonoid M] [Module R M] (S : Submodule R M) :
    OrderedAddCommMonoid S 
goal: OrderedAddCommMonoid ↥S

full_name: Submodule.toLinearOrderedAddCommMonoid
code: /-- A submodule of a `LinearOrderedAddCommMonoid` is a `LinearOrderedAddCommMonoid`. -/
instance toLinearOrderedAddCommMonoid [LinearOrderedAddCommMonoid M] [Module R M]
    (S : Submodule R M) : LinearOrderedAddCommMonoid S 
goal: LinearOrderedAddCommMonoid ↥S

full_name: Submodule.toOrderedCancelAddCommMonoid
code: /-- A submodule of an `OrderedCancelAddCommMonoid` is an `OrderedCancelAddCommMonoid`. -/
instance toOrderedCancelAddCommMonoid [OrderedCancelAddCommMonoid M] [Module R M]
    (S : Submodule R M) : OrderedCancelAddCommMonoid S 
goal: OrderedCancelAddCommMonoid ↥S

full_name: Submodule.toLinearOrderedCancelAddCommMonoid
code: /-- A submodule of a `LinearOrderedCancelAddCommMonoid` is a
`LinearOrderedCancelAddCommMonoid`. -/
instance toLinearOrderedCancelAddCommMonoid [LinearOrderedCancelAddCommMonoid M] [Module R M]
    (S : Submodule R M) : LinearOrderedCancelAddCommMonoid S 
goal: LinearOrderedCancelAddCommMonoid ↥S

full_name: Submodule.toOrderedAddCommGroup
code: /-- A submodule of an `OrderedAddCommGroup` is an `OrderedAddCommGroup`. -/
instance toOrderedAddCommGroup [OrderedAddCommGroup M] [Module R M] (S : Submodule R M) :
    OrderedAddCommGroup S 
goal: OrderedAddCommGroup ↥S

full_name: Submodule.toLinearOrderedAddCommGroup
code: /-- A submodule of a `LinearOrderedAddCommGroup` is a
`LinearOrderedAddCommGroup`. -/
instance toLinearOrderedAddCommGroup [LinearOrderedAddCommGroup M] [Module R M]
    (S : Submodule R M) : LinearOrderedAddCommGroup S 
goal: LinearOrderedAddCommGroup ↥S
File: Mathlib/Algebra/Module/Pi.lean

full_name: IsSMulRegular.pi
code: theorem _root_.IsSMulRegular.pi {α : Type*} [∀ i, SMul α <| f i] {k : α}
    (hk : ∀ i, IsSMulRegular (f i) k) : IsSMulRegular (∀ i, f i) k 
goal: IsSMulRegular ((i : I) → f i) k

full_name: Pi.smulWithZero
code: instance smulWithZero (α) [Zero α] [∀ i, Zero (f i)] [∀ i, SMulWithZero α (f i)] :
    SMulWithZero α (∀ i, f i) 
goal: SMulWithZero α ((i : I) → f i)

full_name: Pi.smulWithZero'
code: instance smulWithZero' {g : I → Type*} [∀ i, Zero (g i)] [∀ i, Zero (f i)]
    [∀ i, SMulWithZero (g i) (f i)] : SMulWithZero (∀ i, g i) (∀ i, f i) 
goal: SMulWithZero ((i : I) → g i) ((i : I) → f i)

full_name: Pi.mulActionWithZero
code: instance mulActionWithZero (α) [MonoidWithZero α] [∀ i, Zero (f i)]
    [∀ i, MulActionWithZero α (f i)] : MulActionWithZero α (∀ i, f i) 
goal: MulActionWithZero α ((i : I) → f i)

full_name: Pi.mulActionWithZero'
code: instance mulActionWithZero' {g : I → Type*} [∀ i, MonoidWithZero (g i)] [∀ i, Zero (f i)]
    [∀ i, MulActionWithZero (g i) (f i)] : MulActionWithZero (∀ i, g i) (∀ i, f i) 
goal: MulActionWithZero ((i : I) → g i) ((i : I) → f i)

full_name: Pi.module
code: instance module (α) {r : Semiring α} {m : ∀ i, AddCommMonoid <| f i} [∀ i, Module α <| f i] :
    @Module α (∀ i : I, f i) r (@Pi.addCommMonoid I f m) 
goal: Module α ((i : I) → f i)

full_name: Pi.Function.module
code: /-- A special case of `Pi.module` for non-dependent types. Lean struggles to elaborate
definitions elsewhere in the library without this. -/
instance Function.module (α β : Type*) [Semiring α] [AddCommMonoid β] [Module α β] :
    Module α (I → β) 
goal: Module α (I → β)

full_name: Pi.module'
code: instance module' {g : I → Type*} {r : ∀ i, Semiring (f i)} {m : ∀ i, AddCommMonoid (g i)}
    [∀ i, Module (f i) (g i)] : Module (∀ i, f i) (∀ i, g i) 
goal: Module ((i : I) → f i) ((i : I) → g i)

full_name: Pi.noZeroSMulDivisors
code: instance noZeroSMulDivisors (α) [Semiring α] [∀ i, AddCommMonoid <| f i]
    [∀ i, Module α <| f i] [∀ i, NoZeroSMulDivisors α <| f i] :
    NoZeroSMulDivisors α (∀ i : I, f i) 
goal: NoZeroSMulDivisors α ((i : I) → f i)

full_name: Function.noZeroSMulDivisors
code: /-- A special case of `Pi.noZeroSMulDivisors` for non-dependent types. Lean struggles to
synthesize this instance by itself elsewhere in the library. -/
instance _root_.Function.noZeroSMulDivisors {ι α β : Type*} [Semiring α] [AddCommMonoid β]
    [Module α β] [NoZeroSMulDivisors α β] : NoZeroSMulDivisors α (ι → β) 
goal: NoZeroSMulDivisors α (ι → β)
File: Mathlib/Algebra/Module/Prod.lean

full_name: Prod.smulWithZero
code: instance smulWithZero [Zero R] [Zero M] [Zero N] [SMulWithZero R M] [SMulWithZero R N] :
    SMulWithZero R (M × N) 
goal: SMulWithZero R (M × N)

full_name: Prod.mulActionWithZero
code: instance mulActionWithZero [MonoidWithZero R] [Zero M] [Zero N] [MulActionWithZero R M]
    [MulActionWithZero R N] : MulActionWithZero R (M × N) 
goal: MulActionWithZero R (M × N)

full_name: Prod.instModule
code: instance instModule [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] :
    Module R (M × N) 
goal: Module R (M × N)

full_name: Prod.noZeroSMulDivisors
code: instance noZeroSMulDivisors {r : Semiring R} [AddCommMonoid M] [AddCommMonoid N]
    [Module R M] [Module R N] [NoZeroSMulDivisors R M] [NoZeroSMulDivisors R N] :
    NoZeroSMulDivisors R (M × N) 
goal: NoZeroSMulDivisors R (M × N)
File: Mathlib/Algebra/Module/Algebra.lean

full_name: LinearMap.restrictScalarsLinearMap
code: /-- Restriction of scalars for linear maps between modules over a `k`-algebra is itself `k`-linear.
-/
@[simps]
def restrictScalarsLinearMap : (M →ₗ[A] N) →ₗ[k] M →ₗ[k] N 
goal: (M →ₗ[A] N) →ₗ[k] M →ₗ[k] N

full_name: LinearMap.restrictScalarsLinearMap_apply
code: /-- Restriction of scalars for linear maps between modules over a `k`-algebra is itself `k`-linear.
-/
@[simps]
def restrictScalarsLinearMap : (M →ₗ[A] N) →ₗ[k] M →ₗ[k] N 
goal: (LinearMap.restrictScalarsLinearMap k A M N) fₗ = ↑k fₗ
File: Mathlib/Algebra/Module/Card.lean

full_name: Cardinal.mk_le_of_module
code: /-- The cardinality of a nontrivial module over a ring is at least the cardinality of the ring if
there are no zero divisors (for instance if the ring is a field) -/
theorem mk_le_of_module (R : Type u) (E : Type v)
    [AddCommGroup E] [Ring R] [Module R E] [Nontrivial E] [NoZeroSMulDivisors R E] :
    Cardinal.lift.{v} (#R) ≤ Cardinal.lift.{u} (#E) 
goal: Cardinal.lift.{v, u} (Cardinal.mk R) ≤ Cardinal.lift.{u, v} (Cardinal.mk E)
File: Mathlib/Algebra/MvPolynomial/Funext.lean

full_name: _private.Mathlib.Algebra.MvPolynomial.Funext.0.MvPolynomial.funext_fin
code: private theorem funext_fin {n : ℕ} {p : MvPolynomial (Fin n) R}
    (h : ∀ x : Fin n → R, eval x p = 0) : p = 0 
goal: p = 0

full_name: MvPolynomial.funext
code: /-- Two multivariate polynomials over an infinite integral domain are equal
if they are equal upon evaluating them on an arbitrary assignment of the variables. -/
theorem funext {σ : Type*} {p q : MvPolynomial σ R} (h : ∀ x : σ → R, eval x p = eval x q) :
    p = q 
goal: p = q

full_name: MvPolynomial.funext_iff
code: theorem funext_iff {σ : Type*} {p q : MvPolynomial σ R} :
    p = q ↔ ∀ x : σ → R, eval x p = eval x q 
goal: p = q ↔ ∀ (x : σ → R), (MvPolynomial.eval x) p = (MvPolynomial.eval x) q
File: Mathlib/Algebra/MvPolynomial/Comap.lean

full_name: MvPolynomial.comap
code: /-- Given an algebra hom `f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R`
and a variable evaluation `v : τ → R`,
`comap f v` produces a variable evaluation `σ → R`.
-/
noncomputable def comap (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) : (τ → R) → σ → R 
goal: (τ → R) → σ → R

full_name: MvPolynomial.comap_apply
code: @[simp]
theorem comap_apply (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) (x : τ → R) (i : σ) :
    comap f x i = aeval x (f (X i)) 
goal: MvPolynomial.comap f x i = (MvPolynomial.aeval x) (f (MvPolynomial.X i))

full_name: MvPolynomial.comap_id_apply
code: @[simp]
theorem comap_id_apply (x : σ → R) : comap (AlgHom.id R (MvPolynomial σ R)) x = x 
goal: MvPolynomial.comap (AlgHom.id R (MvPolynomial σ R)) x = x

full_name: MvPolynomial.comap_id
code: theorem comap_id : comap (AlgHom.id R (MvPolynomial σ R)) = id 
goal: MvPolynomial.comap (AlgHom.id R (MvPolynomial σ R)) = id

full_name: MvPolynomial.comap_comp_apply
code: theorem comap_comp_apply (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R)
    (g : MvPolynomial τ R →ₐ[R] MvPolynomial υ R) (x : υ → R) :
    comap (g.comp f) x = comap f (comap g x) 
goal: MvPolynomial.comap (g.comp f) x = MvPolynomial.comap f (MvPolynomial.comap g x)

full_name: MvPolynomial.comap_comp
code: theorem comap_comp (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R)
    (g : MvPolynomial τ R →ₐ[R] MvPolynomial υ R) : comap (g.comp f) = comap f ∘ comap g 
goal: MvPolynomial.comap (g.comp f) = MvPolynomial.comap f ∘ MvPolynomial.comap g

full_name: MvPolynomial.comap_eq_id_of_eq_id
code: theorem comap_eq_id_of_eq_id (f : MvPolynomial σ R →ₐ[R] MvPolynomial σ R) (hf : ∀ φ, f φ = φ)
    (x : σ → R) : comap f x = x 
goal: MvPolynomial.comap f x = x

full_name: MvPolynomial.comap_rename
code: theorem comap_rename (f : σ → τ) (x : τ → R) : comap (rename f) x = x ∘ f 
goal: MvPolynomial.comap (MvPolynomial.rename f) x = x ∘ f

full_name: MvPolynomial.comapEquiv
code: /-- If two polynomial types over the same coefficient ring `R` are equivalent,
there is a bijection between the types of functions from their variable types to `R`.
-/
noncomputable def comapEquiv (f : MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R) : (τ → R) ≃ (σ → R) 
goal: (τ → R) ≃ (σ → R)

full_name: MvPolynomial.comapEquiv_coe
code: @[simp]
theorem comapEquiv_coe (f : MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R) :
    (comapEquiv f : (τ → R) → σ → R) = comap f 
goal: ⇑(MvPolynomial.comapEquiv f) = MvPolynomial.comap ↑f

full_name: MvPolynomial.comapEquiv_symm_coe
code: @[simp]
theorem comapEquiv_symm_coe (f : MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R) :
    ((comapEquiv f).symm : (σ → R) → τ → R) = comap f.symm 
goal: ⇑(MvPolynomial.comapEquiv f).symm = MvPolynomial.comap ↑f.symm