File: Mathlib/RingTheory/Ideal/Operations.lean

full_name: Submodule.hasSMul'
code: instance hasSMul' : SMul (Ideal R) (Submodule R M) 
goal: SMul (Ideal R) (Submodule R M)

full_name: Ideal.smul_eq_mul
code: /-- This duplicates the global `smul_eq_mul`, but doesn't have to unfold anywhere near as much to
apply. -/
protected theorem _root_.Ideal.smul_eq_mul (I J : Ideal R) : I • J = I * J 
goal: I • J = I * J

full_name: Module.annihilator
code: /-- `Module.annihilator R M` is the ideal of all elements `r : R` such that `r • M = 0`. -/
def _root_.Module.annihilator : Ideal R 
goal: Ideal R

full_name: Module.mem_annihilator
code: theorem _root_.Module.mem_annihilator {r} : r ∈ Module.annihilator R M ↔ ∀ m : M, r • m = 0 
goal: r ∈ Module.annihilator R M ↔ ∀ (m : M), r • m = 0

full_name: LinearMap.annihilator_le_of_injective
code: theorem _root_.LinearMap.annihilator_le_of_injective (f : M →ₗ[R] M') (hf : Function.Injective f) :
    Module.annihilator R M' ≤ Module.annihilator R M 
goal: Module.annihilator R M' ≤ Module.annihilator R M

full_name: LinearMap.annihilator_le_of_surjective
code: theorem _root_.LinearMap.annihilator_le_of_surjective (f : M →ₗ[R] M')
    (hf : Function.Surjective f) : Module.annihilator R M ≤ Module.annihilator R M' 
goal: Module.annihilator R M ≤ Module.annihilator R M'

full_name: LinearEquiv.annihilator_eq
code: theorem _root_.LinearEquiv.annihilator_eq (e : M ≃ₗ[R] M') :
    Module.annihilator R M = Module.annihilator R M' 
goal: Module.annihilator R M = Module.annihilator R M'

full_name: Submodule.annihilator
code: /-- `N.annihilator` is the ideal of all elements `r : R` such that `r • N = 0`. -/
abbrev annihilator (N : Submodule R M) : Ideal R 
goal: Ideal R

full_name: Submodule.annihilator_top
code: theorem annihilator_top : (⊤ : Submodule R M).annihilator = Module.annihilator R M 
goal: ⊤.annihilator = Module.annihilator R M

full_name: Submodule.mem_annihilator
code: theorem mem_annihilator {r} : r ∈ N.annihilator ↔ ∀ n ∈ N, r • n = (0 : M) 
goal: r ∈ N.annihilator ↔ ∀ n ∈ N, r • n = 0

full_name: Submodule.mem_annihilator'
code: theorem mem_annihilator' {r} : r ∈ N.annihilator ↔ N ≤ comap (r • (LinearMap.id : M →ₗ[R] M)) ⊥ 
goal: r ∈ N.annihilator ↔ N ≤ Submodule.comap (r • LinearMap.id) ⊥

full_name: Submodule.mem_annihilator_span
code: theorem mem_annihilator_span (s : Set M) (r : R) :
    r ∈ (Submodule.span R s).annihilator ↔ ∀ n : s, r • (n : M) = 0 
goal: r ∈ (Submodule.span R s).annihilator ↔ ∀ (n : ↑s), r • ↑n = 0

full_name: Submodule.mem_annihilator_span_singleton
code: theorem mem_annihilator_span_singleton (g : M) (r : R) :
    r ∈ (Submodule.span R ({g} : Set M)).annihilator ↔ r • g = 0 
goal: r ∈ (Submodule.span R {g}).annihilator ↔ r • g = 0

full_name: Submodule.annihilator_bot
code: theorem annihilator_bot : (⊥ : Submodule R M).annihilator = ⊤ 
goal: ⊥.annihilator = ⊤

full_name: Submodule.annihilator_eq_top_iff
code: theorem annihilator_eq_top_iff : N.annihilator = ⊤ ↔ N = ⊥ 
goal: N.annihilator = ⊤ ↔ N = ⊥

full_name: Submodule.annihilator_mono
code: theorem annihilator_mono (h : N ≤ P) : P.annihilator ≤ N.annihilator 
goal: P.annihilator ≤ N.annihilator

full_name: Submodule.annihilator_iSup
code: theorem annihilator_iSup (ι : Sort w) (f : ι → Submodule R M) :
    annihilator (⨆ i, f i) = ⨅ i, annihilator (f i) 
goal: (⨆ i, f i).annihilator = ⨅ i, (f i).annihilator

full_name: Submodule.smul_mem_smul
code: theorem smul_mem_smul {r} {n} (hr : r ∈ I) (hn : n ∈ N) : r • n ∈ I • N 
goal: r • n ∈ I • N

full_name: Submodule.smul_le
code: theorem smul_le {P : Submodule R M} : I • N ≤ P ↔ ∀ r ∈ I, ∀ n ∈ N, r • n ∈ P 
goal: I • N ≤ P ↔ ∀ r ∈ I, ∀ n ∈ N, r • n ∈ P

full_name: Submodule.coe_set_smul
code: @[simp, norm_cast]
lemma coe_set_smul : (I : Set R) • N = I • N 
goal: ↑I • N = I • N

full_name: Submodule.smul_induction_on
code: @[elab_as_elim]
theorem smul_induction_on {p : M → Prop} {x} (H : x ∈ I • N) (smul : ∀ r ∈ I, ∀ n ∈ N, p (r • n))
    (add : ∀ x y, p x → p y → p (x + y)) : p x 
goal: p x

full_name: Submodule.smul_induction_on'
code: /-- Dependent version of `Submodule.smul_induction_on`. -/
@[elab_as_elim]
theorem smul_induction_on' {x : M} (hx : x ∈ I • N) {p : ∀ x, x ∈ I • N → Prop}
    (smul : ∀ (r : R) (hr : r ∈ I) (n : M) (hn : n ∈ N), p (r • n) (smul_mem_smul hr hn))
    (add : ∀ x hx y hy, p x hx → p y hy → p (x + y) (Submodule.add_mem _ ‹_› ‹_›)) : p x hx 
goal: p x hx

full_name: Submodule.mem_smul_span_singleton
code: theorem mem_smul_span_singleton {I : Ideal R} {m : M} {x : M} :
    x ∈ I • span R ({m} : Set M) ↔ ∃ y ∈ I, y • m = x 
goal: x ∈ I • Submodule.span R {m} ↔ ∃ y ∈ I, y • m = x

full_name: Submodule.smul_le_right
code: theorem smul_le_right : I • N ≤ N 
goal: I • N ≤ N

full_name: Submodule.smul_mono
code: theorem smul_mono (hij : I ≤ J) (hnp : N ≤ P) : I • N ≤ J • P 
goal: I • N ≤ J • P

full_name: Submodule.smul_mono_left
code: theorem smul_mono_left (h : I ≤ J) : I • N ≤ J • N 
goal: I • N ≤ J • N

full_name: Submodule.instCovariantClassIdealHSMulLe
code: instance : CovariantClass (Ideal R) (Submodule R M) HSMul.hSMul LE.le 
goal: CovariantClass (Ideal R) (Submodule R M) HSMul.hSMul LE.le

full_name: Submodule.smul_mono_right
code: @[deprecated smul_mono_right (since := "2024-03-31")]
protected theorem smul_mono_right (h : N ≤ P) : I • N ≤ I • P 
goal: I • N ≤ I • P

full_name: Submodule.map_le_smul_top
code: theorem map_le_smul_top (I : Ideal R) (f : R →ₗ[R] M) :
    Submodule.map f I ≤ I • (⊤ : Submodule R M) 
goal: Submodule.map f I ≤ I • ⊤

full_name: Submodule.annihilator_smul
code: @[simp]
theorem annihilator_smul (N : Submodule R M) : annihilator N • N = ⊥ 
goal: N.annihilator • N = ⊥

full_name: Submodule.annihilator_mul
code: @[simp]
theorem annihilator_mul (I : Ideal R) : annihilator I * I = ⊥ 
goal: Submodule.annihilator I * I = ⊥

full_name: Submodule.mul_annihilator
code: @[simp]
theorem mul_annihilator (I : Ideal R) : I * annihilator I = ⊥ 
goal: I * Submodule.annihilator I = ⊥

full_name: Submodule.smul_bot
code: @[simp]
theorem smul_bot : I • (⊥ : Submodule R M) = ⊥ 
goal: I • ⊥ = ⊥

full_name: Submodule.bot_smul
code: @[simp]
theorem bot_smul : (⊥ : Ideal R) • N = ⊥ 
goal: ⊥ • N = ⊥

full_name: Submodule.top_smul
code: @[simp]
theorem top_smul : (⊤ : Ideal R) • N = N 
goal: ⊤ • N = N

full_name: Submodule.smul_sup
code: theorem smul_sup : I • (N ⊔ P) = I • N ⊔ I • P 
goal: I • (N ⊔ P) = I • N ⊔ I • P

full_name: Submodule.sup_smul
code: theorem sup_smul : (I ⊔ J) • N = I • N ⊔ J • N 
goal: (I ⊔ J) • N = I • N ⊔ J • N

full_name: Submodule.smul_assoc
code: protected theorem smul_assoc : (I • J) • N = I • J • N 
goal: (I • J) • N = I • J • N

full_name: Submodule.smul_inf_le
code: @[deprecated smul_inf_le (since := "2024-03-31")]
protected theorem smul_inf_le (M₁ M₂ : Submodule R M) :
    I • (M₁ ⊓ M₂) ≤ I • M₁ ⊓ I • M₂ 
goal: I • (M₁ ⊓ M₂) ≤ I • M₁ ⊓ I • M₂

full_name: Submodule.smul_iSup
code: theorem smul_iSup {ι : Sort*} {I : Ideal R} {t : ι → Submodule R M} : I • iSup t = ⨆ i, I • t i 
goal: I • iSup t = ⨆ i, I • t i

full_name: Submodule.smul_iInf_le
code: @[deprecated smul_iInf_le (since := "2024-03-31")]
protected theorem smul_iInf_le {ι : Sort*} {I : Ideal R} {t : ι → Submodule R M} :
    I • iInf t ≤ ⨅ i, I • t i 
goal: I • iInf t ≤ ⨅ i, I • t i

full_name: Submodule.span_smul_span
code: theorem span_smul_span : Ideal.span S • span R T = span R (⋃ (s ∈ S) (t ∈ T), {s • t}) 
goal: Ideal.span S • Submodule.span R T = Submodule.span R (⋃ s ∈ S, ⋃ t ∈ T, {s • t})

full_name: Submodule.ideal_span_singleton_smul
code: theorem ideal_span_singleton_smul (r : R) (N : Submodule R M) :
    (Ideal.span {r} : Ideal R) • N = r • N 
goal: Ideal.span {r} • N = r • N

full_name: Submodule.mem_of_span_top_of_smul_mem
code: theorem mem_of_span_top_of_smul_mem (M' : Submodule R M) (s : Set R) (hs : Ideal.span s = ⊤) (x : M)
    (H : ∀ r : s, (r : R) • x ∈ M') : x ∈ M' 
goal: x ∈ M'

full_name: Submodule.mem_of_span_eq_top_of_smul_pow_mem
code: /-- Given `s`, a generating set of `R`, to check that an `x : M` falls in a
submodule `M'` of `x`, we only need to show that `r ^ n • x ∈ M'` for some `n` for each `r : s`. -/
theorem mem_of_span_eq_top_of_smul_pow_mem (M' : Submodule R M) (s : Set R) (hs : Ideal.span s = ⊤)
    (x : M) (H : ∀ r : s, ∃ n : ℕ, ((r : R) ^ n : R) • x ∈ M') : x ∈ M' 
goal: x ∈ M'

full_name: Submodule.map_smul''
code: @[simp]
theorem map_smul'' (f : M →ₗ[R] M') : (I • N).map f = I • N.map f 
goal: Submodule.map f (I • N) = I • Submodule.map f N

full_name: Submodule.map_pointwise_smul
code: @[simp]
theorem map_pointwise_smul (r : R) (N : Submodule R M) (f : M →ₗ[R] M') :
    (r • N).map f = r • N.map f 
goal: Submodule.map f (r • N) = r • Submodule.map f N

full_name: Submodule.mem_smul_span
code: theorem mem_smul_span {s : Set M} {x : M} :
    x ∈ I • Submodule.span R s ↔ x ∈ Submodule.span R (⋃ (a ∈ I) (b ∈ s), ({a • b} : Set M)) 
goal: x ∈ I • Submodule.span R s ↔ x ∈ Submodule.span R (⋃ a ∈ I, ⋃ b ∈ s, {a • b})

full_name: Submodule.mem_ideal_smul_span_iff_exists_sum
code: /-- If `x` is an `I`-multiple of the submodule spanned by `f '' s`,
then we can write `x` as an `I`-linear combination of the elements of `f '' s`. -/
theorem mem_ideal_smul_span_iff_exists_sum {ι : Type*} (f : ι → M) (x : M) :
    x ∈ I • span R (Set.range f) ↔
      ∃ (a : ι →₀ R) (_ : ∀ i, a i ∈ I), (a.sum fun i c => c • f i) = x 
goal: x ∈ I • Submodule.span R (Set.range f) ↔ ∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • f i) = x

full_name: Submodule.mem_ideal_smul_span_iff_exists_sum'
code: theorem mem_ideal_smul_span_iff_exists_sum' {ι : Type*} (s : Set ι) (f : ι → M) (x : M) :
    x ∈ I • span R (f '' s) ↔
    ∃ (a : s →₀ R) (_ : ∀ i, a i ∈ I), (a.sum fun i c => c • f i) = x 
goal: x ∈ I • Submodule.span R (f '' s) ↔ ∃ a, ∃ (_ : ∀ (i : ↑s), a i ∈ I), (a.sum fun i c => c • f ↑i) = x

full_name: Submodule.mem_smul_top_iff
code: theorem mem_smul_top_iff (N : Submodule R M) (x : N) :
    x ∈ I • (⊤ : Submodule R N) ↔ (x : M) ∈ I • N 
goal: x ∈ I • ⊤ ↔ ↑x ∈ I • N

full_name: Submodule.smul_comap_le_comap_smul
code: @[simp]
theorem smul_comap_le_comap_smul (f : M →ₗ[R] M') (S : Submodule R M') (I : Ideal R) :
    I • S.comap f ≤ (I • S).comap f 
goal: I • Submodule.comap f S ≤ Submodule.comap f (I • S)

full_name: Ideal.add_eq_sup
code: @[simp]
theorem add_eq_sup {I J : Ideal R} : I + J = I ⊔ J 
goal: I + J = I ⊔ J

full_name: Ideal.zero_eq_bot
code: @[simp, nolint simpNF]
theorem zero_eq_bot : (0 : Ideal R) = ⊥ 
goal: 0 = ⊥

full_name: Ideal.sum_eq_sup
code: @[simp]
theorem sum_eq_sup {ι : Type*} (s : Finset ι) (f : ι → Ideal R) : s.sum f = s.sup f 
goal: s.sum f = s.sup f

full_name: Ideal.instMul
code: instance : Mul (Ideal R) 
goal: Mul (Ideal R)

full_name: Ideal.one_eq_top
code: @[simp]
theorem one_eq_top : (1 : Ideal R) = ⊤ 
goal: 1 = ⊤

full_name: Ideal.add_eq_one_iff
code: theorem add_eq_one_iff : I + J = 1 ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1 
goal: I + J = 1 ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1

full_name: Ideal.mul_mem_mul
code: theorem mul_mem_mul {r s} (hr : r ∈ I) (hs : s ∈ J) : r * s ∈ I * J 
goal: r * s ∈ I * J

full_name: Ideal.mul_mem_mul_rev
code: theorem mul_mem_mul_rev {r s} (hr : r ∈ I) (hs : s ∈ J) : s * r ∈ I * J 
goal: s * r ∈ I * J

full_name: Ideal.pow_mem_pow
code: theorem pow_mem_pow {x : R} (hx : x ∈ I) (n : ℕ) : x ^ n ∈ I ^ n 
goal: x ^ n ∈ I ^ n

full_name: Ideal.prod_mem_prod
code: theorem prod_mem_prod {ι : Type*} {s : Finset ι} {I : ι → Ideal R} {x : ι → R} :
    (∀ i ∈ s, x i ∈ I i) → (∏ i ∈ s, x i) ∈ ∏ i ∈ s, I i 
goal: (∀ i ∈ s, x i ∈ I i) → ∏ i ∈ s, x i ∈ ∏ i ∈ s, I i

full_name: Ideal.mul_le
code: theorem mul_le : I * J ≤ K ↔ ∀ r ∈ I, ∀ s ∈ J, r * s ∈ K 
goal: I * J ≤ K ↔ ∀ r ∈ I, ∀ s ∈ J, r * s ∈ K

full_name: Ideal.mul_le_left
code: theorem mul_le_left : I * J ≤ J 
goal: I * J ≤ J

full_name: Ideal.mul_le_right
code: theorem mul_le_right : I * J ≤ I 
goal: I * J ≤ I

full_name: Ideal.sup_mul_right_self
code: @[simp]
theorem sup_mul_right_self : I ⊔ I * J = I 
goal: I ⊔ I * J = I

full_name: Ideal.sup_mul_left_self
code: @[simp]
theorem sup_mul_left_self : I ⊔ J * I = I 
goal: I ⊔ J * I = I

full_name: Ideal.mul_right_self_sup
code: @[simp]
theorem mul_right_self_sup : I * J ⊔ I = I 
goal: I * J ⊔ I = I

full_name: Ideal.mul_left_self_sup
code: @[simp]
theorem mul_left_self_sup : J * I ⊔ I = I 
goal: J * I ⊔ I = I

full_name: Ideal.mul_comm
code: protected theorem mul_comm : I * J = J * I 
goal: I * J = J * I

full_name: Ideal.mul_assoc
code: protected theorem mul_assoc : I * J * K = I * (J * K) 
goal: I * J * K = I * (J * K)

full_name: Ideal.span_mul_span
code: theorem span_mul_span (S T : Set R) : span S * span T = span (⋃ (s ∈ S) (t ∈ T), {s * t}) 
goal: Ideal.span S * Ideal.span T = Ideal.span (⋃ s ∈ S, ⋃ t ∈ T, {s * t})

full_name: Ideal.span_mul_span'
code: theorem span_mul_span' (S T : Set R) : span S * span T = span (S * T) 
goal: Ideal.span S * Ideal.span T = Ideal.span (S * T)

full_name: Ideal.span_singleton_mul_span_singleton
code: theorem span_singleton_mul_span_singleton (r s : R) :
    span {r} * span {s} = (span {r * s} : Ideal R) 
goal: Ideal.span {r} * Ideal.span {s} = Ideal.span {r * s}

full_name: Ideal.span_singleton_pow
code: theorem span_singleton_pow (s : R) (n : ℕ) : span {s} ^ n = (span {s ^ n} : Ideal R) 
goal: Ideal.span {s} ^ n = Ideal.span {s ^ n}

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

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

full_name: Ideal.le_span_singleton_mul_iff
code: theorem le_span_singleton_mul_iff {x : R} {I J : Ideal R} :
    I ≤ span {x} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI 
goal: I ≤ Ideal.span {x} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI

full_name: Ideal.span_singleton_mul_le_iff
code: theorem span_singleton_mul_le_iff {x : R} {I J : Ideal R} :
    span {x} * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J 
goal: Ideal.span {x} * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J

full_name: Ideal.span_singleton_mul_le_span_singleton_mul
code: theorem span_singleton_mul_le_span_singleton_mul {x y : R} {I J : Ideal R} :
    span {x} * I ≤ span {y} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ 
goal: Ideal.span {x} * I ≤ Ideal.span {y} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ

full_name: Ideal.span_singleton_mul_right_mono
code: theorem span_singleton_mul_right_mono [IsDomain R] {x : R} (hx : x ≠ 0) :
    span {x} * I ≤ span {x} * J ↔ I ≤ J 
goal: Ideal.span {x} * I ≤ Ideal.span {x} * J ↔ I ≤ J

full_name: Ideal.span_singleton_mul_left_mono
code: theorem span_singleton_mul_left_mono [IsDomain R] {x : R} (hx : x ≠ 0) :
    I * span {x} ≤ J * span {x} ↔ I ≤ J 
goal: I * Ideal.span {x} ≤ J * Ideal.span {x} ↔ I ≤ J

full_name: Ideal.span_singleton_mul_right_inj
code: theorem span_singleton_mul_right_inj [IsDomain R] {x : R} (hx : x ≠ 0) :
    span {x} * I = span {x} * J ↔ I = J 
goal: Ideal.span {x} * I = Ideal.span {x} * J ↔ I = J

full_name: Ideal.span_singleton_mul_left_inj
code: theorem span_singleton_mul_left_inj [IsDomain R] {x : R} (hx : x ≠ 0) :
    I * span {x} = J * span {x} ↔ I = J 
goal: I * Ideal.span {x} = J * Ideal.span {x} ↔ I = J

full_name: Ideal.span_singleton_mul_right_injective
code: theorem span_singleton_mul_right_injective [IsDomain R] {x : R} (hx : x ≠ 0) :
    Function.Injective ((span {x} : Ideal R) * ·) 
goal: Function.Injective fun x_1 => Ideal.span {x} * x_1

full_name: Ideal.span_singleton_mul_left_injective
code: theorem span_singleton_mul_left_injective [IsDomain R] {x : R} (hx : x ≠ 0) :
    Function.Injective fun I : Ideal R => I * span {x} 
goal: Function.Injective fun I => I * Ideal.span {x}

full_name: Ideal.eq_span_singleton_mul
code: theorem eq_span_singleton_mul {x : R} (I J : Ideal R) :
    I = span {x} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I 
goal: I = Ideal.span {x} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I

full_name: Ideal.span_singleton_mul_eq_span_singleton_mul
code: theorem span_singleton_mul_eq_span_singleton_mul {x y : R} (I J : Ideal R) :
    span {x} * I = span {y} * J ↔
      (∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ) ∧ ∀ zJ ∈ J, ∃ zI ∈ I, x * zI = y * zJ 
goal: Ideal.span {x} * I = Ideal.span {y} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ) ∧ ∀ zJ ∈ J, ∃ zI ∈ I, x * zI = y * zJ

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

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

full_name: Ideal.multiset_prod_span_singleton
code: @[simp]
theorem multiset_prod_span_singleton (m : Multiset R) :
    (m.map fun x => Ideal.span {x}).prod = Ideal.span ({Multiset.prod m} : Set R) 
goal: (Multiset.map (fun x => Ideal.span {x}) m).prod = Ideal.span {m.prod}

full_name: Ideal.finset_inf_span_singleton
code: theorem finset_inf_span_singleton {ι : Type*} (s : Finset ι) (I : ι → R)
    (hI : Set.Pairwise (↑s) (IsCoprime on I)) :
    (s.inf fun i => Ideal.span ({I i} : Set R)) = Ideal.span {∏ i ∈ s, I i} 
goal: (s.inf fun i => Ideal.span {I i}) = Ideal.span {∏ i ∈ s, I i}

full_name: Ideal.iInf_span_singleton
code: theorem iInf_span_singleton {ι : Type*} [Fintype ι] {I : ι → R}
    (hI : ∀ (i j) (_ : i ≠ j), IsCoprime (I i) (I j)) :
    ⨅ i, span ({I i} : Set R) = span {∏ i, I i} 
goal: ⨅ i, Ideal.span {I i} = Ideal.span {∏ i : ι, I i}

full_name: Ideal.iInf_span_singleton_natCast
code: theorem iInf_span_singleton_natCast {R : Type*} [CommRing R] {ι : Type*} [Fintype ι]
    {I : ι → ℕ} (hI : Pairwise fun i j => (I i).Coprime (I j)) :
    ⨅ (i : ι), span {(I i : R)} = span {((∏ i : ι, I i : ℕ) : R)} 
goal: ⨅ i, Ideal.span {↑(I i)} = Ideal.span {↑(∏ i : ι, I i)}

full_name: Ideal.sup_eq_top_iff_isCoprime
code: theorem sup_eq_top_iff_isCoprime {R : Type*} [CommSemiring R] (x y : R) :
    span ({x} : Set R) ⊔ span {y} = ⊤ ↔ IsCoprime x y 
goal: Ideal.span {x} ⊔ Ideal.span {y} = ⊤ ↔ IsCoprime x y

full_name: Ideal.mul_le_inf
code: theorem mul_le_inf : I * J ≤ I ⊓ J 
goal: I * J ≤ I ⊓ J

full_name: Ideal.multiset_prod_le_inf
code: theorem multiset_prod_le_inf {s : Multiset (Ideal R)} : s.prod ≤ s.inf 
goal: s.prod ≤ s.inf

full_name: Ideal.prod_le_inf
code: theorem prod_le_inf {s : Finset ι} {f : ι → Ideal R} : s.prod f ≤ s.inf f 
goal: s.prod f ≤ s.inf f

full_name: Ideal.mul_eq_inf_of_coprime
code: theorem mul_eq_inf_of_coprime (h : I ⊔ J = ⊤) : I * J = I ⊓ J 
goal: I * J = I ⊓ J

full_name: Ideal.sup_mul_eq_of_coprime_left
code: theorem sup_mul_eq_of_coprime_left (h : I ⊔ J = ⊤) : I ⊔ J * K = I ⊔ K 
goal: I ⊔ J * K = I ⊔ K

full_name: Ideal.sup_mul_eq_of_coprime_right
code: theorem sup_mul_eq_of_coprime_right (h : I ⊔ K = ⊤) : I ⊔ J * K = I ⊔ J 
goal: I ⊔ J * K = I ⊔ J

full_name: Ideal.mul_sup_eq_of_coprime_left
code: theorem mul_sup_eq_of_coprime_left (h : I ⊔ J = ⊤) : I * K ⊔ J = K ⊔ J 
goal: I * K ⊔ J = K ⊔ J

full_name: Ideal.mul_sup_eq_of_coprime_right
code: theorem mul_sup_eq_of_coprime_right (h : K ⊔ J = ⊤) : I * K ⊔ J = I ⊔ J 
goal: I * K ⊔ J = I ⊔ J

full_name: Ideal.sup_prod_eq_top
code: theorem sup_prod_eq_top {s : Finset ι} {J : ι → Ideal R} (h : ∀ i, i ∈ s → I ⊔ J i = ⊤) :
    (I ⊔ ∏ i ∈ s, J i) = ⊤ 
goal: I ⊔ ∏ i ∈ s, J i = ⊤

full_name: Ideal.sup_iInf_eq_top
code: theorem sup_iInf_eq_top {s : Finset ι} {J : ι → Ideal R} (h : ∀ i, i ∈ s → I ⊔ J i = ⊤) :
    (I ⊔ ⨅ i ∈ s, J i) = ⊤ 
goal: I ⊔ ⨅ i ∈ s, J i = ⊤

full_name: Ideal.prod_sup_eq_top
code: theorem prod_sup_eq_top {s : Finset ι} {J : ι → Ideal R} (h : ∀ i, i ∈ s → J i ⊔ I = ⊤) :
    (∏ i ∈ s, J i) ⊔ I = ⊤ 
goal: (∏ i ∈ s, J i) ⊔ I = ⊤

full_name: Ideal.iInf_sup_eq_top
code: theorem iInf_sup_eq_top {s : Finset ι} {J : ι → Ideal R} (h : ∀ i, i ∈ s → J i ⊔ I = ⊤) :
    (⨅ i ∈ s, J i) ⊔ I = ⊤ 
goal: (⨅ i ∈ s, J i) ⊔ I = ⊤

full_name: Ideal.sup_pow_eq_top
code: theorem sup_pow_eq_top {n : ℕ} (h : I ⊔ J = ⊤) : I ⊔ J ^ n = ⊤ 
goal: I ⊔ J ^ n = ⊤

full_name: Ideal.pow_sup_eq_top
code: theorem pow_sup_eq_top {n : ℕ} (h : I ⊔ J = ⊤) : I ^ n ⊔ J = ⊤ 
goal: I ^ n ⊔ J = ⊤

full_name: Ideal.pow_sup_pow_eq_top
code: theorem pow_sup_pow_eq_top {m n : ℕ} (h : I ⊔ J = ⊤) : I ^ m ⊔ J ^ n = ⊤ 
goal: I ^ m ⊔ J ^ n = ⊤

full_name: Ideal.mul_bot
code: theorem mul_bot : I * ⊥ = ⊥ 
goal: I * ⊥ = ⊥

full_name: Ideal.bot_mul
code: theorem bot_mul : ⊥ * I = ⊥ 
goal: ⊥ * I = ⊥

full_name: Ideal.mul_top
code: @[simp]
theorem mul_top : I * ⊤ = I 
goal: I * ⊤ = I

full_name: Ideal.top_mul
code: @[simp]
theorem top_mul : ⊤ * I = I 
goal: ⊤ * I = I

full_name: Ideal.mul_mono
code: theorem mul_mono (hik : I ≤ K) (hjl : J ≤ L) : I * J ≤ K * L 
goal: I * J ≤ K * L

full_name: Ideal.mul_mono_left
code: theorem mul_mono_left (h : I ≤ J) : I * K ≤ J * K 
goal: I * K ≤ J * K

full_name: Ideal.mul_mono_right
code: theorem mul_mono_right (h : J ≤ K) : I * J ≤ I * K 
goal: I * J ≤ I * K

full_name: Ideal.mul_sup
code: theorem mul_sup : I * (J ⊔ K) = I * J ⊔ I * K 
goal: I * (J ⊔ K) = I * J ⊔ I * K

full_name: Ideal.sup_mul
code: theorem sup_mul : (I ⊔ J) * K = I * K ⊔ J * K 
goal: (I ⊔ J) * K = I * K ⊔ J * K

full_name: Ideal.pow_le_pow_right
code: theorem pow_le_pow_right {m n : ℕ} (h : m ≤ n) : I ^ n ≤ I ^ m 
goal: I ^ n ≤ I ^ m

full_name: Ideal.pow_le_self
code: theorem pow_le_self {n : ℕ} (hn : n ≠ 0) : I ^ n ≤ I 
goal: I ^ n ≤ I

full_name: Ideal.pow_right_mono
code: theorem pow_right_mono {I J : Ideal R} (e : I ≤ J) (n : ℕ) : I ^ n ≤ J ^ n 
goal: I ^ n ≤ J ^ n

full_name: Ideal.mul_eq_bot
code: @[simp]
theorem mul_eq_bot {R : Type*} [CommSemiring R] [NoZeroDivisors R] {I J : Ideal R} :
    I * J = ⊥ ↔ I = ⊥ ∨ J = ⊥ 
goal: I * J = ⊥ ↔ I = ⊥ ∨ J = ⊥

full_name: Ideal.instNoZeroDivisors
code: instance {R : Type*} [CommSemiring R] [NoZeroDivisors R] : NoZeroDivisors (Ideal R) 
goal: NoZeroDivisors (Ideal R)

full_name: Ideal.instNoZeroSMulDivisorsSubtypeMem
code: instance {R : Type*} [CommSemiring R] {S : Type*} [CommRing S] [Algebra R S]
    [NoZeroSMulDivisors R S] {I : Ideal S} : NoZeroSMulDivisors R I 
goal: NoZeroSMulDivisors R ↥I

full_name: Ideal.multiset_prod_eq_bot
code: /-- A product of ideals in an integral domain is zero if and only if one of the terms is zero. -/
@[simp]
lemma multiset_prod_eq_bot {R : Type*} [CommRing R] [IsDomain R] {s : Multiset (Ideal R)} :
    s.prod = ⊥ ↔ ⊥ ∈ s 
goal: s.prod = ⊥ ↔ ⊥ ∈ s

full_name: Ideal.prod_eq_bot
code: /-- A product of ideals in an integral domain is zero if and only if one of the terms is zero. -/
@[deprecated multiset_prod_eq_bot (since := "2023-12-26")]
theorem prod_eq_bot {R : Type*} [CommRing R] [IsDomain R] {s : Multiset (Ideal R)} :
    s.prod = ⊥ ↔ ∃ I ∈ s, I = ⊥ 
goal: s.prod = ⊥ ↔ ∃ I ∈ s, I = ⊥

full_name: Ideal.span_pair_mul_span_pair
code: theorem span_pair_mul_span_pair (w x y z : R) :
    (span {w, x} : Ideal R) * span {y, z} = span {w * y, w * z, x * y, x * z} 
goal: Ideal.span {w, x} * Ideal.span {y, z} = Ideal.span {w * y, w * z, x * y, x * z}

full_name: Ideal.isCoprime_iff_codisjoint
code: theorem isCoprime_iff_codisjoint : IsCoprime I J ↔ Codisjoint I J 
goal: IsCoprime I J ↔ Codisjoint I J

full_name: Ideal.isCoprime_iff_add
code: theorem isCoprime_iff_add : IsCoprime I J ↔ I + J = 1 
goal: IsCoprime I J ↔ I + J = 1

full_name: Ideal.isCoprime_iff_exists
code: theorem isCoprime_iff_exists : IsCoprime I J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1 
goal: IsCoprime I J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1

full_name: Ideal.isCoprime_iff_sup_eq
code: theorem isCoprime_iff_sup_eq : IsCoprime I J ↔ I ⊔ J = ⊤ 
goal: IsCoprime I J ↔ I ⊔ J = ⊤

full_name: Ideal.isCoprime_tfae
code: theorem isCoprime_tfae : TFAE [IsCoprime I J, Codisjoint I J, I + J = 1,
    ∃ i ∈ I, ∃ j ∈ J, i + j = 1, I ⊔ J = ⊤] 
goal: [IsCoprime I J, Codisjoint I J, I + J = 1, ∃ i ∈ I, ∃ j ∈ J, i + j = 1, I ⊔ J = ⊤].TFAE

full_name: IsCoprime.codisjoint
code: theorem _root_.IsCoprime.codisjoint (h : IsCoprime I J) : Codisjoint I J 
goal: Codisjoint I J

full_name: IsCoprime.add_eq
code: theorem _root_.IsCoprime.add_eq (h : IsCoprime I J) : I + J = 1 
goal: I + J = 1

full_name: IsCoprime.exists
code: theorem _root_.IsCoprime.exists (h : IsCoprime I J) : ∃ i ∈ I, ∃ j ∈ J, i + j = 1 
goal: ∃ i ∈ I, ∃ j ∈ J, i + j = 1

full_name: IsCoprime.sup_eq
code: theorem _root_.IsCoprime.sup_eq (h : IsCoprime I J) : I ⊔ J = ⊤ 
goal: I ⊔ J = ⊤

full_name: Ideal.inf_eq_mul_of_isCoprime
code: theorem inf_eq_mul_of_isCoprime (coprime : IsCoprime I J) : I ⊓ J = I * J 
goal: I ⊓ J = I * J

full_name: Ideal.isCoprime_span_singleton_iff
code: theorem isCoprime_span_singleton_iff (x y : R) :
    IsCoprime (span <| singleton x) (span <| singleton y) ↔ IsCoprime x y 
goal: IsCoprime (Ideal.span {x}) (Ideal.span {y}) ↔ IsCoprime x y

full_name: Ideal.isCoprime_biInf
code: theorem isCoprime_biInf {J : ι → Ideal R} {s : Finset ι}
    (hf : ∀ j ∈ s, IsCoprime I (J j)) : IsCoprime I (⨅ j ∈ s, J j) 
goal: IsCoprime I (⨅ j ∈ s, J j)

full_name: Ideal.radical
code: /-- The radical of an ideal `I` consists of the elements `r` such that `r ^ n ∈ I` for some `n`. -/
def radical (I : Ideal R) : Ideal R 
goal: Ideal R

full_name: Ideal.mem_radical_iff
code: theorem mem_radical_iff {r : R} : r ∈ I.radical ↔ ∃ n : ℕ, r ^ n ∈ I 
goal: r ∈ I.radical ↔ ∃ n, r ^ n ∈ I

full_name: Ideal.IsRadical
code: /-- An ideal is radical if it contains its radical. -/
def IsRadical (I : Ideal R) : Prop 
goal: Prop

full_name: Ideal.le_radical
code: theorem le_radical : I ≤ radical I 
goal: I ≤ I.radical

full_name: Ideal.radical_eq_iff
code: /-- An ideal is radical iff it is equal to its radical. -/
theorem radical_eq_iff : I.radical = I ↔ I.IsRadical 
goal: I.radical = I ↔ I.IsRadical

full_name: Ideal.isRadical_iff_pow_one_lt
code: theorem isRadical_iff_pow_one_lt (k : ℕ) (hk : 1 < k) : I.IsRadical ↔ ∀ r, r ^ k ∈ I → r ∈ I 
goal: I.IsRadical ↔ ∀ (r : R), r ^ k ∈ I → r ∈ I

full_name: Ideal.radical_top
code: theorem radical_top : (radical ⊤ : Ideal R) = ⊤ 
goal: ⊤.radical = ⊤

full_name: Ideal.radical_mono
code: theorem radical_mono (H : I ≤ J) : radical I ≤ radical J 
goal: I.radical ≤ J.radical

full_name: Ideal.radical_isRadical
code: theorem radical_isRadical : (radical I).IsRadical 
goal: I.radical.IsRadical

full_name: Ideal.radical_idem
code: @[simp]
theorem radical_idem : radical (radical I) = radical I 
goal: I.radical.radical = I.radical

full_name: Ideal.IsRadical.radical_le_iff
code: theorem IsRadical.radical_le_iff (hJ : J.IsRadical) : I.radical ≤ J ↔ I ≤ J 
goal: I.radical ≤ J ↔ I ≤ J

full_name: Ideal.radical_le_radical_iff
code: theorem radical_le_radical_iff : radical I ≤ radical J ↔ I ≤ radical J 
goal: I.radical ≤ J.radical ↔ I ≤ J.radical

full_name: Ideal.radical_eq_top
code: theorem radical_eq_top : radical I = ⊤ ↔ I = ⊤ 
goal: I.radical = ⊤ ↔ I = ⊤

full_name: Ideal.IsPrime.isRadical
code: theorem IsPrime.isRadical (H : IsPrime I) : I.IsRadical 
goal: I.IsRadical

full_name: Ideal.IsPrime.radical
code: theorem IsPrime.radical (H : IsPrime I) : radical I = I 
goal: I.radical = I

full_name: Ideal.mem_radical_of_pow_mem
code: theorem mem_radical_of_pow_mem {I : Ideal R} {x : R} {m : ℕ} (hx : x ^ m ∈ radical I) :
    x ∈ radical I 
goal: x ∈ I.radical

full_name: Ideal.disjoint_powers_iff_not_mem
code: theorem disjoint_powers_iff_not_mem (y : R) (hI : I.IsRadical) :
    Disjoint (Submonoid.powers y : Set R) ↑I ↔ y ∉ I.1 
goal: Disjoint ↑(Submonoid.powers y) ↑I ↔ y ∉ I.toAddSubmonoid

full_name: Ideal.radical_sup
code: theorem radical_sup : radical (I ⊔ J) = radical (radical I ⊔ radical J) 
goal: (I ⊔ J).radical = (I.radical ⊔ J.radical).radical

full_name: Ideal.radical_inf
code: theorem radical_inf : radical (I ⊓ J) = radical I ⊓ radical J 
goal: (I ⊓ J).radical = I.radical ⊓ J.radical

full_name: Ideal.IsRadical.inf
code: theorem IsRadical.inf (hI : IsRadical I) (hJ : IsRadical J) : IsRadical (I ⊓ J) 
goal: (I ⊓ J).IsRadical

full_name: Ideal.radical_iInf_le
code: /-- The reverse inclusion does not hold for e.g. `I := fun n : ℕ ↦ Ideal.span {(2 ^ n : ℤ)}`. -/
theorem radical_iInf_le {ι} (I : ι → Ideal R) : radical (⨅ i, I i) ≤ ⨅ i, radical (I i) 
goal: (⨅ i, I i).radical ≤ ⨅ i, (I i).radical

full_name: Ideal.isRadical_iInf
code: theorem isRadical_iInf {ι} (I : ι → Ideal R) (hI : ∀ i, IsRadical (I i)) : IsRadical (⨅ i, I i) 
goal: (⨅ i, I i).IsRadical

full_name: Ideal.radical_mul
code: theorem radical_mul : radical (I * J) = radical I ⊓ radical J 
goal: (I * J).radical = I.radical ⊓ J.radical

full_name: Ideal.IsPrime.radical_le_iff
code: theorem IsPrime.radical_le_iff (hJ : IsPrime J) : I.radical ≤ J ↔ I ≤ J 
goal: I.radical ≤ J ↔ I ≤ J

full_name: Ideal.radical_eq_sInf
code: theorem radical_eq_sInf (I : Ideal R) : radical I = sInf { J : Ideal R | I ≤ J ∧ IsPrime J } 
goal: I.radical = sInf {J | I ≤ J ∧ J.IsPrime}

full_name: Ideal.isRadical_bot_of_noZeroDivisors
code: theorem isRadical_bot_of_noZeroDivisors {R} [CommSemiring R] [NoZeroDivisors R] :
    (⊥ : Ideal R).IsRadical 
goal: ⊥.IsRadical

full_name: Ideal.radical_bot_of_noZeroDivisors
code: @[simp]
theorem radical_bot_of_noZeroDivisors {R : Type u} [CommSemiring R] [NoZeroDivisors R] :
    radical (⊥ : Ideal R) = ⊥ 
goal: ⊥.radical = ⊥

full_name: Ideal.instIdemCommSemiring
code: instance : IdemCommSemiring (Ideal R) 
goal: IdemCommSemiring (Ideal R)

full_name: Ideal.top_pow
code: theorem top_pow (n : ℕ) : (⊤ ^ n : Ideal R) = ⊤ 
goal: ⊤ ^ n = ⊤

full_name: Ideal.radical_pow
code: lemma radical_pow : ∀ {n}, n ≠ 0 → radical (I ^ n) = radical I
  
goal: n ≠ 0 → (I ^ n).radical = I.radical

full_name: Ideal.IsPrime.mul_le
code: theorem IsPrime.mul_le {I J P : Ideal R} (hp : IsPrime P) : I * J ≤ P ↔ I ≤ P ∨ J ≤ P 
goal: I * J ≤ P ↔ I ≤ P ∨ J ≤ P

full_name: Ideal.IsPrime.inf_le
code: theorem IsPrime.inf_le {I J P : Ideal R} (hp : IsPrime P) : I ⊓ J ≤ P ↔ I ≤ P ∨ J ≤ P 
goal: I ⊓ J ≤ P ↔ I ≤ P ∨ J ≤ P

full_name: Ideal.IsPrime.multiset_prod_le
code: theorem IsPrime.multiset_prod_le {s : Multiset (Ideal R)} {P : Ideal R} (hp : IsPrime P) :
    s.prod ≤ P ↔ ∃ I ∈ s, I ≤ P 
goal: s.prod ≤ P ↔ ∃ I ∈ s, I ≤ P

full_name: Ideal.IsPrime.multiset_prod_map_le
code: theorem IsPrime.multiset_prod_map_le {s : Multiset ι} (f : ι → Ideal R) {P : Ideal R}
    (hp : IsPrime P) : (s.map f).prod ≤ P ↔ ∃ i ∈ s, f i ≤ P 
goal: (Multiset.map f s).prod ≤ P ↔ ∃ i ∈ s, f i ≤ P

full_name: Ideal.IsPrime.multiset_prod_mem_iff_exists_mem
code: theorem IsPrime.multiset_prod_mem_iff_exists_mem {I : Ideal R} (hI : I.IsPrime) (s : Multiset R) :
    s.prod ∈ I ↔ ∃ p ∈ s, p ∈ I 
goal: s.prod ∈ I ↔ ∃ p ∈ s, p ∈ I

full_name: Ideal.IsPrime.prod_le
code: theorem IsPrime.prod_le {s : Finset ι} {f : ι → Ideal R} {P : Ideal R} (hp : IsPrime P) :
    s.prod f ≤ P ↔ ∃ i ∈ s, f i ≤ P 
goal: s.prod f ≤ P ↔ ∃ i ∈ s, f i ≤ P

full_name: Ideal.IsPrime.prod_mem_iff_exists_mem
code: theorem IsPrime.prod_mem_iff_exists_mem {I : Ideal R} (hI : I.IsPrime) (s : Finset R) :
    s.prod (fun x ↦ x) ∈ I ↔ ∃ p ∈ s, p ∈ I 
goal: ∏ x ∈ s, x ∈ I ↔ ∃ p ∈ s, p ∈ I

full_name: Ideal.IsPrime.inf_le'
code: theorem IsPrime.inf_le' {s : Finset ι} {f : ι → Ideal R} {P : Ideal R} (hp : IsPrime P) :
    s.inf f ≤ P ↔ ∃ i ∈ s, f i ≤ P 
goal: s.inf f ≤ P ↔ ∃ i ∈ s, f i ≤ P

full_name: Ideal.subset_union
code: theorem subset_union {R : Type u} [Ring R] {I J K : Ideal R} :
    (I : Set R) ⊆ J ∪ K ↔ I ≤ J ∨ I ≤ K 
goal: ↑I ⊆ ↑J ∪ ↑K ↔ I ≤ J ∨ I ≤ K

full_name: Ideal.subset_union_prime'
code: theorem subset_union_prime' {R : Type u} [CommRing R] {s : Finset ι} {f : ι → Ideal R} {a b : ι}
    (hp : ∀ i ∈ s, IsPrime (f i)) {I : Ideal R} :
    ((I : Set R) ⊆ f a ∪ f b ∪ ⋃ i ∈ (↑s : Set ι), f i) ↔ I ≤ f a ∨ I ≤ f b ∨ ∃ i ∈ s, I ≤ f i 
goal: ↑I ⊆ ↑(f a) ∪ ↑(f b) ∪ ⋃ i ∈ ↑s, ↑(f i) ↔ I ≤ f a ∨ I ≤ f b ∨ ∃ i ∈ s, I ≤ f i

full_name: Ideal.subset_union_prime
code: /-- Prime avoidance. Atiyah-Macdonald 1.11, Eisenbud 3.3, Stacks 00DS, Matsumura Ex.1.6. -/
theorem subset_union_prime {R : Type u} [CommRing R] {s : Finset ι} {f : ι → Ideal R} (a b : ι)
    (hp : ∀ i ∈ s, i ≠ a → i ≠ b → IsPrime (f i)) {I : Ideal R} :
    ((I : Set R) ⊆ ⋃ i ∈ (↑s : Set ι), f i) ↔ ∃ i ∈ s, I ≤ f i 
goal: ↑I ⊆ ⋃ i ∈ ↑s, ↑(f i) ↔ ∃ i ∈ s, I ≤ f i

full_name: Ideal.le_of_dvd
code: /-- If `I` divides `J`, then `I` contains `J`.

In a Dedekind domain, to divide and contain are equivalent, see `Ideal.dvd_iff_le`.
-/
theorem le_of_dvd {I J : Ideal R} : I ∣ J → J ≤ I
  
goal: I ∣ J → J ≤ I

full_name: Ideal.isUnit_iff
code: @[simp]
theorem isUnit_iff {I : Ideal R} : IsUnit I ↔ I = ⊤ 
goal: IsUnit I ↔ I = ⊤

full_name: Ideal.uniqueUnits
code: instance uniqueUnits : Unique (Ideal R)ˣ 
goal: Unique (Ideal R)ˣ

full_name: Ideal.finsuppTotal
code: /-- A variant of `Finsupp.total` that takes in vectors valued in `I`. -/
noncomputable def finsuppTotal : (ι →₀ I) →ₗ[R] M 
goal: (ι →₀ ↥I) →ₗ[R] M

full_name: Ideal.finsuppTotal_apply
code: theorem finsuppTotal_apply (f : ι →₀ I) :
    finsuppTotal ι M I v f = f.sum fun i x => (x : R) • v i 
goal: (Ideal.finsuppTotal ι M I v) f = f.sum fun i x => ↑x • v i

full_name: Ideal.finsuppTotal_apply_eq_of_fintype
code: theorem finsuppTotal_apply_eq_of_fintype [Fintype ι] (f : ι →₀ I) :
    finsuppTotal ι M I v f = ∑ i, (f i : R) • v i 
goal: (Ideal.finsuppTotal ι M I v) f = ∑ i : ι, ↑(f i) • v i

full_name: Ideal.range_finsuppTotal
code: theorem range_finsuppTotal :
    LinearMap.range (finsuppTotal ι M I v) = I • Submodule.span R (Set.range v) 
goal: LinearMap.range (Ideal.finsuppTotal ι M I v) = I • Submodule.span R (Set.range v)

full_name: Finsupp.mem_ideal_span_range_iff_exists_finsupp
code: theorem Finsupp.mem_ideal_span_range_iff_exists_finsupp {x : R} {v : α → R} :
    x ∈ Ideal.span (Set.range v) ↔ ∃ c : α →₀ R, (c.sum fun i a => a * v i) = x 
goal: x ∈ Ideal.span (Set.range v) ↔ ∃ c, (c.sum fun i a => a * v i) = x

full_name: mem_ideal_span_range_iff_exists_fun
code: /-- An element `x` lies in the span of `v` iff it can be written as sum `∑ cᵢ • vᵢ = x`.
-/
theorem mem_ideal_span_range_iff_exists_fun [Fintype α] {x : R} {v : α → R} :
    x ∈ Ideal.span (Set.range v) ↔ ∃ c : α → R, ∑ i, c i * v i = x 
goal: x ∈ Ideal.span (Set.range v) ↔ ∃ c, ∑ i : α, c i * v i = x

full_name: Associates.mk_ne_zero'
code: theorem Associates.mk_ne_zero' {R : Type*} [CommSemiring R] {r : R} :
    Associates.mk (Ideal.span {r} : Ideal R) ≠ 0 ↔ r ≠ 0 
goal: Associates.mk (Ideal.span {r}) ≠ 0 ↔ r ≠ 0

full_name: Ideal.span_singleton_nonZeroDivisors
code: theorem Ideal.span_singleton_nonZeroDivisors {R : Type*} [CommSemiring R] [NoZeroDivisors R]
    {r : R} : span {r} ∈ (Ideal R)⁰ ↔ r ∈ R⁰ 
goal: Ideal.span {r} ∈ nonZeroDivisors (Ideal R) ↔ r ∈ nonZeroDivisors R

full_name: Submodule.moduleSubmodule
code: instance moduleSubmodule : Module (Ideal R) (Submodule R M) 
goal: Module (Ideal R) (Submodule R M)

full_name: Submodule.span_smul_eq
code: lemma span_smul_eq
    (s : Set R) (N : Submodule R M) :
    Ideal.span s • N = s • N 
goal: Ideal.span s • N = s • N

full_name: Submodule.set_smul_top_eq_span
code: @[simp]
theorem set_smul_top_eq_span (s : Set R) :
    s • ⊤ = Ideal.span s 
goal: s • ⊤ = Ideal.span s