fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
one_notMem_nonunits [Monoid α] : (1 : α) ∉ nonunits α :=
not_not_intro isUnit_one
@[deprecated (since := "2025-05-23")] alias one_not_mem_nonunits := one_notMem_nonunits
@[simp high] -- High priority shortcut lemma | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maximal"
] | Mathlib/RingTheory/Ideal/Nonunits.lean | one_notMem_nonunits | null |
map_mem_nonunits_iff [Monoid α] [Monoid β] [FunLike F α β] [MonoidHomClass F α β] (f : F)
[IsLocalHom f] (a) : f a ∈ nonunits β ↔ a ∈ nonunits α :=
⟨fun h ha => h <| ha.map f, fun h ha => h <| ha.of_map⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maximal"
] | Mathlib/RingTheory/Ideal/Nonunits.lean | map_mem_nonunits_iff | null |
coe_subset_nonunits [Semiring α] {I : Ideal α} (h : I ≠ ⊤) : (I : Set α) ⊆ nonunits α :=
fun _x hx hu => h <| I.eq_top_of_isUnit_mem hx hu | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maximal"
] | Mathlib/RingTheory/Ideal/Nonunits.lean | coe_subset_nonunits | null |
exists_max_ideal_of_mem_nonunits [CommSemiring α] (h : a ∈ nonunits α) :
∃ I : Ideal α, I.IsMaximal ∧ a ∈ I := by
have : Ideal.span ({a} : Set α) ≠ ⊤ := by
intro H
rw [Ideal.span_singleton_eq_top] at H
contradiction
rcases Ideal.exists_le_maximal _ this with ⟨I, Imax, H⟩
use I, Imax
apply H
apply Ideal.subset_span
exact Set.mem_singleton a | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maximal"
] | Mathlib/RingTheory/Ideal/Nonunits.lean | exists_max_ideal_of_mem_nonunits | null |
@[stacks 05K9]
IsOka (P : Ideal R → Prop) : Prop where
top : P ⊤
oka {I : Ideal R} {a : R} : P (I ⊔ span {a}) → P (I.colon (span {a})) → P I | structure | RingTheory | [
"Mathlib.RingTheory.Ideal.Colon"
] | Mathlib/RingTheory/Ideal/Oka.lean | IsOka | A predicate `P : Ideal R → Prop` over the ideals of a ring `R` is said to be Oka if R satisfies
it (`P ⊤`) and whenever we have `I : Ideal R`, `P (I.colon (span {a})` and `P (I ⊔ span {a})` for
some `a : R` then `P I`. |
@[stacks 05KE]
isPrime_of_maximal_not {I : Ideal R} (hI : Maximal (¬P ·) I) : I.IsPrime where
ne_top' hI' := hI.prop (hI' ▸ hP.top)
mem_or_mem' := by
by_contra!
obtain ⟨a, b, hab, ha, hb⟩ := this
have h₁ : P (I ⊔ span {a}) := of_not_not <| hI.not_prop_of_gt (Submodule.lt_sup_iff_notMem.2 ha)
have h₂ : P (I.colon (span {a})) := of_not_not <| hI.not_prop_of_gt <| lt_of_le_of_ne le_colon
(fun H ↦ hb <| H ▸ mem_colon_singleton.2 (mul_comm a b ▸ hab))
exact hI.prop (hP.oka h₁ h₂) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Colon"
] | Mathlib/RingTheory/Ideal/Oka.lean | isPrime_of_maximal_not | If an ideal is maximal for not satisfying an Oka predicate then it is prime. |
forall_of_forall_prime (hmax : ∀ I, ¬P I → ∃ I, Maximal (¬P ·) I)
(hprime : ∀ I, I.IsPrime → P I) (I : Ideal R) : P I := by
by_contra! hI
obtain ⟨I, hI⟩ := hmax I hI
exact hI.prop <| hprime I (hP.isPrime_of_maximal_not hI) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Colon"
] | Mathlib/RingTheory/Ideal/Oka.lean | forall_of_forall_prime | If a ring `R` verify:
1. All prime ideals of `R` satisfy an Oka predicate `P`.
2. One ideal not satisfying `P` implies that there is an ideal maximal for not satisfying `P`.
Then all the ideals of `R` satisfy `P`. |
forall_of_forall_prime'
(hchain : ∀ C ⊆ {I | ¬P I}, IsChain (· ≤ ·) C → ∀ _ ∈ C, P (sSup C) → ∃ I ∈ C, P I)
(hprime : ∀ I, I.IsPrime → P I) : ∀ I, P I := by
refine forall_of_forall_prime hP (fun I hI ↦ ?_) hprime
obtain ⟨M, _, hM⟩ : ∃ M, I ≤ M ∧ Maximal (¬P ·) M := by
refine zorn_le_nonempty₀ {I | ¬P I} (fun C hC₁ hC₂ J hJ ↦ ⟨sSup C, ?_, fun _ ↦ le_sSup⟩) I hI
intro H
obtain ⟨_, h₁, h₂⟩ := hchain C hC₁ hC₂ J hJ H
exact hC₁ h₁ h₂
exact ⟨M, hM⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Colon"
] | Mathlib/RingTheory/Ideal/Oka.lean | forall_of_forall_prime' | A variant of `forall_of_forall_prime` with a different spelling of the condition `hmax`. |
coe_span_smul {R' M' : Type*} [CommSemiring R'] [AddCommMonoid M'] [Module R' M']
(s : Set R') (N : Submodule R' M') :
(Ideal.span s : Set R') • N = s • N :=
set_smul_eq_of_le _ _ _
(by rintro r n hr hn
induction hr using Submodule.span_induction with
| mem _ h => exact mem_set_smul_of_mem_mem h hn
| zero => rw [zero_smul]; exact Submodule.zero_mem _
| add _ _ _ _ ihr ihs => rw [add_smul]; exact Submodule.add_mem _ ihr ihs
| smul _ _ hr =>
rw [mem_span_set] at hr
obtain ⟨c, hc, rfl⟩ := hr
rw [Finsupp.sum, Finset.smul_sum, Finset.sum_smul]
refine Submodule.sum_mem _ fun i hi => ?_
rw [← mul_smul, smul_eq_mul, mul_comm, mul_smul]
exact mem_set_smul_of_mem_mem (hc hi) <| Submodule.smul_mem _ _ hn) <|
set_smul_mono_left _ Submodule.subset_span | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | coe_span_smul | null |
span_singleton_toAddSubgroup_eq_zmultiples (a : ℤ) :
(span ℤ {a}).toAddSubgroup = AddSubgroup.zmultiples a := by
ext i
simp [Ideal.mem_span_singleton', AddSubgroup.mem_zmultiples_iff]
@[simp] lemma _root_.Ideal.span_singleton_toAddSubgroup_eq_zmultiples (a : ℤ) :
(Ideal.span {a}).toAddSubgroup = AddSubgroup.zmultiples a :=
Submodule.span_singleton_toAddSubgroup_eq_zmultiples _
variable {R : Type u} {M : Type v} {M' F G : Type*} | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_toAddSubgroup_eq_zmultiples | null |
protected _root_.Ideal.smul_eq_mul (I J : Ideal R) : I • J = I * J :=
rfl
variable {I J : Ideal R} {N : Submodule R M} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | _root_.Ideal.smul_eq_mul | This duplicates the global `smul_eq_mul`, but doesn't have to unfold anywhere near as much to
apply. |
smul_le_right : I • N ≤ N :=
smul_le.2 fun r _ _ ↦ N.smul_mem r | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | smul_le_right | null |
map_le_smul_top (I : Ideal R) (f : R →ₗ[R] M) :
Submodule.map f I ≤ I • (⊤ : Submodule R M) := by
rintro _ ⟨y, hy, rfl⟩
rw [← mul_one y, ← smul_eq_mul, f.map_smul]
exact smul_mem_smul hy mem_top
variable (I J N)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | map_le_smul_top | null |
top_smul : (⊤ : Ideal R) • N = N :=
le_antisymm smul_le_right fun r hri => one_smul R r ▸ smul_mem_smul mem_top hri | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | top_smul | null |
protected mul_smul : (I * J) • N = I • J • N :=
Submodule.smul_assoc _ _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_smul | null |
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' := by
suffices LinearMap.range (LinearMap.toSpanSingleton R M x) ≤ M' by
rw [← LinearMap.toSpanSingleton_one R M x]
exact this (LinearMap.mem_range_self _ 1)
rw [LinearMap.range_eq_map, ← hs, map_le_iff_le_comap, Ideal.span, span_le]
exact fun r hr ↦ H ⟨r, hr⟩
variable {M' : Type w} [AddCommMonoid M'] [Module R M']
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_of_span_top_of_smul_mem | null |
map_smul'' (f : M →ₗ[R] M') : (I • N).map f = I • N.map f :=
le_antisymm
(map_le_iff_le_comap.2 <|
smul_le.2 fun r hr n hn =>
show f (r • n) ∈ I • N.map f from
(f.map_smul r n).symm ▸ smul_mem_smul hr (mem_map_of_mem hn)) <|
smul_le.2 fun r hr _ hn =>
let ⟨p, hp, hfp⟩ := mem_map.1 hn
hfp ▸ f.map_smul r p ▸ mem_map_of_mem (smul_mem_smul hr hp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | map_smul'' | null |
mem_smul_top_iff (N : Submodule R M) (x : N) :
x ∈ I • (⊤ : Submodule R N) ↔ (x : M) ∈ I • N := by
have : Submodule.map N.subtype (I • ⊤) = I • N := by
rw [Submodule.map_smul'', Submodule.map_top, Submodule.range_subtype]
simp [← this, -map_smul'']
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_smul_top_iff | null |
smul_comap_le_comap_smul (f : M →ₗ[R] M') (S : Submodule R M') (I : Ideal R) :
I • S.comap f ≤ (I • S).comap f := by
refine Submodule.smul_le.mpr fun r hr x hx => ?_
rw [Submodule.mem_comap] at hx ⊢
rw [f.map_smul]
exact Submodule.smul_mem_smul hr hx | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | smul_comap_le_comap_smul | null |
mem_smul_span_singleton {I : Ideal R} {m : M} {x : M} :
x ∈ I • span R ({m} : Set M) ↔ ∃ y ∈ I, y • m = x :=
⟨fun hx =>
smul_induction_on hx
(fun r hri _ hnm =>
let ⟨s, hs⟩ := mem_span_singleton.1 hnm
⟨r * s, I.mul_mem_right _ hri, hs ▸ mul_smul r s m⟩)
fun m1 m2 ⟨y1, hyi1, hy1⟩ ⟨y2, hyi2, hy2⟩ =>
⟨y1 + y2, I.add_mem hyi1 hyi2, by rw [add_smul, hy1, hy2]⟩,
fun ⟨_, hyi, hy⟩ => hy ▸ smul_mem_smul hyi (subset_span <| Set.mem_singleton m)⟩
variable {I J : Ideal R} {N P : Submodule R M}
variable (S : Set R) (T : Set M) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_smul_span_singleton | null |
smul_eq_map₂ : I • N = Submodule.map₂ (LinearMap.lsmul R M) I N :=
le_antisymm (smul_le.mpr fun _m hm _n ↦ Submodule.apply_mem_map₂ _ hm)
(map₂_le.mpr fun _m hm _n ↦ smul_mem_smul hm) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | smul_eq_map₂ | null |
span_smul_span : Ideal.span S • span R T = span R (⋃ (s ∈ S) (t ∈ T), {s • t}) := by
rw [smul_eq_map₂]
exact (map₂_span_span _ _ _ _).trans <| congr_arg _ <| Set.image2_eq_iUnion _ _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_smul_span | null |
ideal_span_singleton_smul (r : R) (N : Submodule R M) :
(Ideal.span {r} : Ideal R) • N = r • N := by
have : span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N := by
convert span_eq (r • N)
exact (Set.image_eq_iUnion _ (N : Set M)).symm
conv_lhs => rw [← span_eq N, span_smul_span]
simpa | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | ideal_span_singleton_smul | null |
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' := by
choose f hf using H
apply M'.mem_of_span_top_of_smul_mem _ (Ideal.span_range_pow_eq_top s hs f)
rintro ⟨_, r, hr, rfl⟩
exact hf r
open Pointwise in
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_of_span_eq_top_of_smul_pow_mem | 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`. |
map_pointwise_smul (r : R) (N : Submodule R M) (f : M →ₗ[R] M') :
(r • N).map f = r • N.map f := by
simp_rw [← ideal_span_singleton_smul, map_smul''] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | map_pointwise_smul | null |
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)) := by
rw [← I.span_eq, Submodule.span_smul_span, I.span_eq]
simp
variable (I) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_smul_span | null |
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 := by
constructor; swap
· rintro ⟨a, ha, rfl⟩
exact Submodule.sum_mem _ fun c _ => smul_mem_smul (ha c) <| subset_span <| Set.mem_range_self _
refine fun hx => span_induction ?_ ?_ ?_ ?_ (mem_smul_span.mp hx)
· simp only [Set.mem_iUnion, Set.mem_range, Set.mem_singleton_iff]
rintro x ⟨y, hy, x, ⟨i, rfl⟩, rfl⟩
refine ⟨Finsupp.single i y, fun j => ?_, ?_⟩
· letI := Classical.decEq ι
rw [Finsupp.single_apply]
split_ifs
· assumption
· exact I.zero_mem
refine @Finsupp.sum_single_index ι R M _ _ i _ (fun i y => y • f i) ?_
simp
· exact ⟨0, fun _ => I.zero_mem, Finsupp.sum_zero_index⟩
· rintro x y - - ⟨ax, hax, rfl⟩ ⟨ay, hay, rfl⟩
refine ⟨ax + ay, fun i => I.add_mem (hax i) (hay i), Finsupp.sum_add_index' ?_ ?_⟩ <;>
intros <;> simp only [zero_smul, add_smul]
· rintro c x - ⟨a, ha, rfl⟩
refine ⟨c • a, fun i => I.mul_mem_left c (ha i), ?_⟩
rw [Finsupp.sum_smul_index, Finsupp.smul_sum] <;> intros <;> simp only [zero_smul, mul_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_ideal_smul_span_iff_exists_sum | 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`. |
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 := by
rw [← Submodule.mem_ideal_smul_span_iff_exists_sum, ← Set.image_eq_range] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_ideal_smul_span_iff_exists_sum' | null |
@[simp]
add_eq_sup {I J : Ideal R} : I + J = I ⊔ J :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | add_eq_sup | null |
zero_eq_bot : (0 : Ideal R) = ⊥ :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | zero_eq_bot | null |
sum_eq_sup {ι : Type*} (s : Finset ι) (f : ι → Ideal R) : s.sum f = s.sup f :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sum_eq_sup | null |
@[simp, grind =]
one_eq_top : (1 : Ideal R) = ⊤ := by
rw [Submodule.one_eq_span, ← Ideal.span, Ideal.span_singleton_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | one_eq_top | null |
add_eq_one_iff : I + J = 1 ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1 := by
rw [one_eq_top, eq_top_iff_one, add_eq_sup, Submodule.mem_sup] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | add_eq_one_iff | null |
mul_mem_mul {r s} (hr : r ∈ I) (hs : s ∈ J) : r * s ∈ I * J :=
Submodule.smul_mem_smul hr hs | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_mem_mul | null |
bot_pow {n : ℕ} (hn : n ≠ 0) :
(⊥ : Ideal R) ^ n = ⊥ := Submodule.bot_pow hn | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | bot_pow | null |
pow_mem_pow {x : R} (hx : x ∈ I) (n : ℕ) : x ^ n ∈ I ^ n :=
Submodule.pow_mem_pow _ hx _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_mem_pow | null |
mul_le : I * J ≤ K ↔ ∀ r ∈ I, ∀ s ∈ J, r * s ∈ K :=
Submodule.smul_le | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_le | null |
mul_le_left : I * J ≤ J :=
mul_le.2 fun _ _ _ => J.mul_mem_left _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_le_left | null |
sup_mul_left_self : I ⊔ J * I = I :=
sup_eq_left.2 mul_le_left
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_mul_left_self | null |
mul_left_self_sup : J * I ⊔ I = I :=
sup_eq_right.2 mul_le_left | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_left_self_sup | null |
mul_le_right [I.IsTwoSided] : I * J ≤ I :=
mul_le.2 fun _ hr _ _ ↦ I.mul_mem_right _ hr
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_le_right | null |
sup_mul_right_self [I.IsTwoSided] : I ⊔ I * J = I :=
sup_eq_left.2 mul_le_right
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_mul_right_self | null |
mul_right_self_sup [I.IsTwoSided] : I * J ⊔ I = I :=
sup_eq_right.2 mul_le_right | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_right_self_sup | null |
protected mul_assoc : I * J * K = I * (J * K) :=
Submodule.smul_assoc I J K
variable (I) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_assoc | null |
mul_bot : I * ⊥ = ⊥ := by simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_bot | null |
bot_mul : ⊥ * I = ⊥ := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | bot_mul | null |
top_mul : ⊤ * I = I :=
Submodule.top_smul I
variable {I} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | top_mul | null |
mul_mono (hik : I ≤ K) (hjl : J ≤ L) : I * J ≤ K * L :=
Submodule.smul_mono hik hjl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_mono | null |
mul_mono_left (h : I ≤ J) : I * K ≤ J * K :=
Submodule.smul_mono_left h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_mono_left | null |
mul_mono_right (h : J ≤ K) : I * J ≤ I * K :=
smul_mono_right I h
variable (I J K) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_mono_right | null |
mul_sup : I * (J ⊔ K) = I * J ⊔ I * K :=
Submodule.smul_sup I J K | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_sup | null |
sup_mul : (I ⊔ J) * K = I * K ⊔ J * K :=
Submodule.sup_smul I J K | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_mul | null |
mul_iSup {ι : Sort*} (J : ι → Ideal R) :
I * (⨆ i, J i) = ⨆ i, I * J i :=
Submodule.smul_iSup | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_iSup | null |
iSup_mul {ι : Sort*} (J : ι → Ideal R) (I : Ideal R) :
(⨆ i, J i) * I = ⨆ i, J i * I :=
Submodule.iSup_smul
variable {I J K} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | iSup_mul | null |
pow_le_pow_right {m n : ℕ} (h : m ≤ n) : I ^ n ≤ I ^ m := by
obtain _ | m := m
· rw [Submodule.pow_zero, one_eq_top]; exact le_top
obtain ⟨n, rfl⟩ := Nat.exists_eq_add_of_le h
rw [add_comm, Submodule.pow_add _ m.add_one_ne_zero]
exact mul_le_left | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_le_pow_right | null |
pow_le_self {n : ℕ} (hn : n ≠ 0) : I ^ n ≤ I :=
calc
I ^ n ≤ I ^ 1 := pow_le_pow_right (Nat.pos_of_ne_zero hn)
_ = I := Submodule.pow_one _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_le_self | null |
pow_right_mono (e : I ≤ J) (n : ℕ) : I ^ n ≤ J ^ n := by
induction n with
| zero => rw [Submodule.pow_zero, Submodule.pow_zero]
| succ _ hn =>
rw [Submodule.pow_succ, Submodule.pow_succ]
exact Ideal.mul_mono hn e | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_right_mono | null |
protected mul_one : I * 1 = I :=
mul_le_right.antisymm
fun i hi ↦ mul_one i ▸ mul_mem_mul hi (one_eq_top (R := R) ▸ Submodule.mem_top) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_one | null |
protected pow_add : I ^ (m + n) = I ^ m * I ^ n := by
obtain rfl | h := eq_or_ne n 0
· rw [add_zero, Submodule.pow_zero, IsTwoSided.mul_one]
· exact Submodule.pow_add _ h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_add | null |
protected pow_succ : I ^ (n + 1) = I * I ^ n := by
rw [add_comm, IsTwoSided.pow_add, Submodule.pow_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_succ | null |
@[simp]
mul_eq_bot [NoZeroDivisors R] : I * J = ⊥ ↔ I = ⊥ ∨ J = ⊥ :=
⟨fun hij =>
or_iff_not_imp_left.mpr fun I_ne_bot =>
J.eq_bot_iff.mpr fun j hj =>
let ⟨i, hi, ne0⟩ := I.ne_bot_iff.mp I_ne_bot
Or.resolve_left (mul_eq_zero.mp ((I * J).eq_bot_iff.mp hij _ (mul_mem_mul hi hj))) ne0,
fun h => by obtain rfl | rfl := h; exacts [bot_mul _, mul_bot _]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_eq_bot | null |
pow_eq_zero_of_mem {I : Ideal R} {n m : ℕ} (hnI : I ^ n = 0) (hmn : n ≤ m) {x : R}
(hx : x ∈ I) : x ^ m = 0 := by
simpa [hnI] using pow_le_pow_right hmn <| pow_mem_pow hx m | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | pow_eq_zero_of_mem | null |
mul_mem_mul_rev {r s} (hr : r ∈ I) (hs : s ∈ J) : s * r ∈ I * J :=
mul_comm r s ▸ mul_mem_mul hr hs | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_mem_mul_rev | null |
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 := by
classical
refine Finset.induction_on s ?_ ?_
· grind [Submodule.mem_top]
· grind [mul_mem_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | prod_mem_prod | null |
sup_pow_add_le_pow_sup_pow {n m : ℕ} : (I ⊔ J) ^ (n + m) ≤ I ^ n ⊔ J ^ m := by
rw [← Ideal.add_eq_sup, ← Ideal.add_eq_sup, add_pow, Ideal.sum_eq_sup]
apply Finset.sup_le
intro i hi
by_cases hn : n ≤ i
· exact (Ideal.mul_le_right.trans (Ideal.mul_le_right.trans
((Ideal.pow_le_pow_right hn).trans le_sup_left)))
· refine (Ideal.mul_le_right.trans (Ideal.mul_le_left.trans
((Ideal.pow_le_pow_right ?_).trans le_sup_right)))
cutsat
variable (I J K) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_pow_add_le_pow_sup_pow | null |
protected mul_comm : I * J = J * I :=
le_antisymm (mul_le.2 fun _ hrI _ hsJ => mul_mem_mul_rev hsJ hrI)
(mul_le.2 fun _ hrJ _ hsI => mul_mem_mul_rev hsI hrJ) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_comm | null |
span_mul_span (S T : Set R) : span S * span T = span (⋃ (s ∈ S) (t ∈ T), {s * t}) :=
Submodule.span_smul_span S T
variable {I J K} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_mul_span | null |
span_mul_span' (S T : Set R) : span S * span T = span (S * T) := by
unfold span
rw [Submodule.span_mul_span] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_mul_span' | null |
span_singleton_mul_span_singleton (r s : R) :
span {r} * span {s} = (span {r * s} : Ideal R) := by
unfold span
rw [Submodule.span_mul_span, Set.singleton_mul_singleton] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_span_singleton | null |
span_singleton_pow (s : R) (n : ℕ) : span {s} ^ n = (span {s ^ n} : Ideal R) := by
induction n with
| zero => simp [Set.singleton_one]
| succ n ih => simp only [pow_succ, ih, span_singleton_mul_span_singleton] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_pow | null |
mem_mul_span_singleton {x y : R} {I : Ideal R} : x ∈ I * span {y} ↔ ∃ z ∈ I, z * y = x :=
Submodule.mem_smul_span_singleton | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_mul_span_singleton | null |
mem_span_singleton_mul {x y : R} {I : Ideal R} : x ∈ span {y} * I ↔ ∃ z ∈ I, y * z = x := by
simp only [mul_comm, mem_mul_span_singleton]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mem_span_singleton_mul | null |
range_mul (A : Type*) [CommSemiring A] [Module R A]
[SMulCommClass R A A] [IsScalarTower R A A] (a : A) : LinearMap.range (LinearMap.mul R A a) =
(Ideal.span {a}).restrictScalars R := by
aesop (add simp Ideal.mem_span_singleton) (add simp dvd_def) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | range_mul | null |
range_mul' (a : R) : LinearMap.range (LinearMap.mul R R a) = Ideal.span {a} := range_mul .. | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | range_mul' | null |
le_span_singleton_mul_iff {x : R} {I J : Ideal R} :
I ≤ span {x} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI :=
show (∀ {zI} (_ : zI ∈ I), zI ∈ span {x} * J) ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI by
simp only [mem_span_singleton_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | le_span_singleton_mul_iff | null |
span_singleton_mul_le_iff {x : R} {I J : Ideal R} :
span {x} * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J := by
simp only [mul_le, mem_span_singleton]
constructor
· intro h zI hzI
exact h x (dvd_refl x) zI hzI
· rintro h _ ⟨z, rfl⟩ zI hzI
rw [mul_comm x z, mul_assoc]
exact J.mul_mem_left _ (h zI hzI) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_le_iff | null |
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 := by
simp only [span_singleton_mul_le_iff, mem_span_singleton_mul, eq_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_le_span_singleton_mul | null |
span_singleton_mul_right_mono [IsDomain R] {x : R} (hx : x ≠ 0) :
span {x} * I ≤ span {x} * J ↔ I ≤ J := by
simp_rw [span_singleton_mul_le_span_singleton_mul, mul_right_inj' hx,
exists_eq_right', SetLike.le_def] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_right_mono | null |
span_singleton_mul_left_mono [IsDomain R] {x : R} (hx : x ≠ 0) :
I * span {x} ≤ J * span {x} ↔ I ≤ J := by
simpa only [mul_comm I, mul_comm J] using span_singleton_mul_right_mono hx | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_left_mono | null |
span_singleton_mul_right_inj [IsDomain R] {x : R} (hx : x ≠ 0) :
span {x} * I = span {x} * J ↔ I = J := by
simp only [le_antisymm_iff, span_singleton_mul_right_mono hx] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_right_inj | null |
span_singleton_mul_left_inj [IsDomain R] {x : R} (hx : x ≠ 0) :
I * span {x} = J * span {x} ↔ I = J := by
simp only [le_antisymm_iff, span_singleton_mul_left_mono hx] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_left_inj | null |
span_singleton_mul_right_injective [IsDomain R] {x : R} (hx : x ≠ 0) :
Function.Injective ((span {x} : Ideal R) * ·) := fun _ _ =>
(span_singleton_mul_right_inj hx).mp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_right_injective | null |
span_singleton_mul_left_injective [IsDomain R] {x : R} (hx : x ≠ 0) :
Function.Injective fun I : Ideal R => I * span {x} := fun _ _ =>
(span_singleton_mul_left_inj hx).mp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_left_injective | null |
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 := by
simp only [le_antisymm_iff, le_span_singleton_mul_iff, span_singleton_mul_le_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | eq_span_singleton_mul | null |
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 := by
simp only [le_antisymm_iff, span_singleton_mul_le_span_singleton_mul, eq_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | span_singleton_mul_eq_span_singleton_mul | null |
prod_span {ι : Type*} (s : Finset ι) (I : ι → Set R) :
(∏ i ∈ s, Ideal.span (I i)) = Ideal.span (∏ i ∈ s, I i) :=
Submodule.prod_span s I | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | prod_span | null |
prod_span_singleton {ι : Type*} (s : Finset ι) (I : ι → R) :
(∏ i ∈ s, Ideal.span ({I i} : Set R)) = Ideal.span {∏ i ∈ s, I i} :=
Submodule.prod_span_singleton s I
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | prod_span_singleton | null |
multiset_prod_span_singleton (m : Multiset R) :
(m.map fun x => Ideal.span {x}).prod = Ideal.span ({Multiset.prod m} : Set R) :=
Multiset.induction_on m (by simp) fun a m ih => by
simp only [Multiset.map_cons, Multiset.prod_cons, ih, ← Ideal.span_singleton_mul_span_singleton]
open scoped Function in -- required for scoped `on` notation | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | multiset_prod_span_singleton | null |
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} := by
ext x
simp only [Submodule.mem_finsetInf, Ideal.mem_span_singleton]
exact ⟨Finset.prod_dvd_of_coprime hI, fun h i hi => (Finset.dvd_prod_of_mem _ hi).trans h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | finset_inf_span_singleton | null |
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} := by
rw [← Finset.inf_univ_eq_iInf, finset_inf_span_singleton]
rwa [Finset.coe_univ, Set.pairwise_univ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | iInf_span_singleton | null |
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)} := by
rw [iInf_span_singleton, Nat.cast_prod]
exact fun i j h ↦ (hI h).cast | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | iInf_span_singleton_natCast | null |
sup_eq_top_iff_isCoprime {R : Type*} [CommSemiring R] (x y : R) :
span ({x} : Set R) ⊔ span {y} = ⊤ ↔ IsCoprime x y := by
rw [eq_top_iff_one, Submodule.mem_sup]
constructor
· rintro ⟨u, hu, v, hv, h1⟩
rw [mem_span_singleton'] at hu hv
rw [← hu.choose_spec, ← hv.choose_spec] at h1
exact ⟨_, _, h1⟩
· exact fun ⟨u, v, h1⟩ =>
⟨_, mem_span_singleton'.mpr ⟨_, rfl⟩, _, mem_span_singleton'.mpr ⟨_, rfl⟩, h1⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_eq_top_iff_isCoprime | null |
mul_le_inf : I * J ≤ I ⊓ J :=
mul_le.2 fun r hri s hsj => ⟨I.mul_mem_right s hri, J.mul_mem_left r hsj⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_le_inf | null |
multiset_prod_le_inf {s : Multiset (Ideal R)} : s.prod ≤ s.inf := by
classical
refine s.induction_on ?_ ?_
· rw [Multiset.inf_zero]
exact le_top
intro a s ih
rw [Multiset.prod_cons, Multiset.inf_cons]
exact le_trans mul_le_inf (inf_le_inf le_rfl ih) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | multiset_prod_le_inf | null |
prod_le_inf {s : Finset ι} {f : ι → Ideal R} : s.prod f ≤ s.inf f :=
multiset_prod_le_inf | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | prod_le_inf | null |
mul_eq_inf_of_coprime (h : I ⊔ J = ⊤) : I * J = I ⊓ J :=
le_antisymm mul_le_inf fun r ⟨hri, hrj⟩ =>
let ⟨s, hsi, t, htj, hst⟩ := Submodule.mem_sup.1 ((eq_top_iff_one _).1 h)
mul_one r ▸
hst ▸
(mul_add r s t).symm ▸ Ideal.add_mem (I * J) (mul_mem_mul_rev hsi hrj) (mul_mem_mul hri htj) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_eq_inf_of_coprime | null |
sup_mul_eq_of_coprime_left (h : I ⊔ J = ⊤) : I ⊔ J * K = I ⊔ K :=
le_antisymm (sup_le_sup_left mul_le_left _) fun i hi => by
rw [eq_top_iff_one] at h; rw [Submodule.mem_sup] at h hi ⊢
obtain ⟨i1, hi1, j, hj, h⟩ := h; obtain ⟨i', hi', k, hk, hi⟩ := hi
refine ⟨_, add_mem hi' (mul_mem_right k _ hi1), _, mul_mem_mul hj hk, ?_⟩
rw [add_assoc, ← add_mul, h, one_mul, hi] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_mul_eq_of_coprime_left | null |
sup_mul_eq_of_coprime_right (h : I ⊔ K = ⊤) : I ⊔ J * K = I ⊔ J := by
rw [mul_comm]
exact sup_mul_eq_of_coprime_left h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | sup_mul_eq_of_coprime_right | null |
mul_sup_eq_of_coprime_left (h : I ⊔ J = ⊤) : I * K ⊔ J = K ⊔ J := by
rw [sup_comm] at h
rw [sup_comm, sup_mul_eq_of_coprime_left h, sup_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_sup_eq_of_coprime_left | null |
mul_sup_eq_of_coprime_right (h : K ⊔ J = ⊤) : I * K ⊔ J = I ⊔ J := by
rw [sup_comm] at h
rw [sup_comm, sup_mul_eq_of_coprime_right h, sup_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Operations",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Fintype.Lattice",
"Mathlib.RingTheory.Coprime.Lemmas",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.NonUnitalSubsemiring.Basic"
] | Mathlib/RingTheory/Ideal/Operations.lean | mul_sup_eq_of_coprime_right | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.