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 ⌀ |
|---|---|---|---|---|---|---|
isNilpotent_finsum {ι : Type*} {f : ι → R}
(hf : ∀ b, IsNilpotent (f b)) :
IsNilpotent (finsum f) :=
Commute.isNilpotent_finsum hf fun _ _ ↦ Commute.all _ _ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | isNilpotent_finsum | null |
NoZeroSMulDivisors.isReduced (R M : Type*)
[MonoidWithZero R] [Zero M] [MulActionWithZero R M] [Nontrivial M] [NoZeroSMulDivisors R M] :
IsReduced R := by
refine ⟨fun x ⟨k, hk⟩ ↦ ?_⟩
induction k with
| zero =>
rw [pow_zero] at hk
exact eq_zero_of_zero_eq_one hk.symm x
| succ k ih =>
obtain ⟨m : M, hm : m ≠ 0⟩ := exists_ne (0 : M)
have : x ^ (k + 1) • m = 0 := by simp only [hk, zero_smul]
rw [pow_succ', mul_smul] at this
rcases eq_zero_or_eq_zero_of_smul_eq_zero this with rfl | hx
· rfl
· exact ih <| (eq_zero_or_eq_zero_of_smul_eq_zero hx).resolve_right hm | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.GroupWithZero.Action.Defs",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.NoZeroSMulDivisors.Defs",
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.Data.Nat.Lattice",
"Mathlib.RingTheory.Nilpotent.Defs... | Mathlib/RingTheory/Nilpotent/Basic.lean | NoZeroSMulDivisors.isReduced | null |
IsNilpotent [Zero R] [Pow R ℕ] (x : R) : Prop :=
∃ n : ℕ, x ^ n = 0 | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent | An element is said to be nilpotent if some natural-number-power of it equals zero.
Note that we require only the bare minimum assumptions for the definition to make sense. Even
`MonoidWithZero` is too strong since nilpotency is important in the study of rings that are only
power-associative. |
IsNilpotent.mk [Zero R] [Pow R ℕ] (x : R) (n : ℕ) (e : x ^ n = 0) : IsNilpotent x :=
⟨n, e⟩
@[simp] lemma isNilpotent_of_subsingleton [Zero R] [Pow R ℕ] [Subsingleton R] : IsNilpotent x :=
⟨0, Subsingleton.elim _ _⟩
@[simp] theorem IsNilpotent.zero [MonoidWithZero R] : IsNilpotent (0 : R) :=
⟨1, pow_one 0⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.mk | null |
not_isNilpotent_one [MonoidWithZero R] [Nontrivial R] :
¬ IsNilpotent (1 : R) := fun ⟨_, H⟩ ↦ zero_ne_one (H.symm.trans (one_pow _)) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | not_isNilpotent_one | null |
IsNilpotent.pow_succ (n : ℕ) {S : Type*} [MonoidWithZero S] {x : S}
(hx : IsNilpotent x) : IsNilpotent (x ^ n.succ) := by
obtain ⟨N, hN⟩ := hx
use N
rw [← pow_mul, Nat.succ_mul, pow_add, hN, mul_zero] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.pow_succ | null |
IsNilpotent.of_pow [MonoidWithZero R] {x : R} {m : ℕ}
(h : IsNilpotent (x ^ m)) : IsNilpotent x := by
obtain ⟨n, h⟩ := h
use m * n
rw [← h, pow_mul x m n] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.of_pow | null |
IsNilpotent.pow_of_pos {n} {S : Type*} [MonoidWithZero S] {x : S}
(hx : IsNilpotent x) (hn : n ≠ 0) : IsNilpotent (x ^ n) := by
cases n with
| zero => contradiction
| succ => exact IsNilpotent.pow_succ _ hx
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.pow_of_pos | null |
IsNilpotent.pow_iff_pos {n} {S : Type*} [MonoidWithZero S] {x : S} (hn : n ≠ 0) :
IsNilpotent (x ^ n) ↔ IsNilpotent x :=
⟨of_pow, (pow_of_pos · hn)⟩ | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.pow_iff_pos | null |
IsNilpotent.map [MonoidWithZero R] [MonoidWithZero S] {r : R} {F : Type*}
[FunLike F R S] [MonoidWithZeroHomClass F R S] (hr : IsNilpotent r) (f : F) :
IsNilpotent (f r) := by
use hr.choose
rw [← map_pow, hr.choose_spec, map_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.map | null |
IsNilpotent.map_iff [MonoidWithZero R] [MonoidWithZero S] {r : R} {F : Type*}
[FunLike F R S] [MonoidWithZeroHomClass F R S] {f : F} (hf : Function.Injective f) :
IsNilpotent (f r) ↔ IsNilpotent r :=
⟨fun ⟨k, hk⟩ ↦ ⟨k, (map_eq_zero_iff f hf).mp <| by rwa [map_pow]⟩, fun h ↦ h.map f⟩ | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.map_iff | null |
IsUnit.isNilpotent_mul_unit_of_commute_iff [MonoidWithZero R] {r u : R}
(hu : IsUnit u) (h_comm : Commute r u) :
IsNilpotent (r * u) ↔ IsNilpotent r :=
exists_congr fun n ↦ by rw [h_comm.mul_pow, (hu.pow n).mul_left_eq_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsUnit.isNilpotent_mul_unit_of_commute_iff | null |
IsUnit.isNilpotent_unit_mul_of_commute_iff [MonoidWithZero R] {r u : R}
(hu : IsUnit u) (h_comm : Commute r u) :
IsNilpotent (u * r) ↔ IsNilpotent r :=
h_comm ▸ hu.isNilpotent_mul_unit_of_commute_iff h_comm | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsUnit.isNilpotent_unit_mul_of_commute_iff | null |
noncomputable nilpotencyClass : ℕ := sInf {k | x ^ k = 0}
@[simp] lemma nilpotencyClass_eq_zero_of_subsingleton [Subsingleton R] :
nilpotencyClass x = 0 := by
let s : Set ℕ := {k | x ^ k = 0}
suffices s = univ by change sInf _ = 0; simp [s] at this; simp [this]
exact eq_univ_iff_forall.mpr fun k ↦ Subsingleton.elim _ _ | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | nilpotencyClass | If `x` is nilpotent, the nilpotency class is the smallest natural number `k` such that
`x ^ k = 0`. If `x` is not nilpotent, the nilpotency class takes the junk value `0`. |
isNilpotent_of_pos_nilpotencyClass (hx : 0 < nilpotencyClass x) :
IsNilpotent x := by
let s : Set ℕ := {k | x ^ k = 0}
change s.Nonempty
change 0 < sInf s at hx
by_contra contra
simp [not_nonempty_iff_eq_empty.mp contra] at hx | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isNilpotent_of_pos_nilpotencyClass | null |
pow_nilpotencyClass (hx : IsNilpotent x) : x ^ (nilpotencyClass x) = 0 :=
Nat.sInf_mem hx | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_nilpotencyClass | null |
nilpotencyClass_eq_succ_iff {k : ℕ} :
nilpotencyClass x = k + 1 ↔ x ^ (k + 1) = 0 ∧ x ^ k ≠ 0 := by
let s : Set ℕ := {k | x ^ k = 0}
have : ∀ k₁ k₂ : ℕ, k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s := fun k₁ k₂ h_le hk₁ ↦ pow_eq_zero_of_le h_le hk₁
simp [s, nilpotencyClass, Nat.sInf_upward_closed_eq_succ_iff this]
@[simp] lemma nilpotencyClass_zero [Nontrivial R] :
nilpotencyClass (0 : R) = 1 :=
nilpotencyClass_eq_succ_iff.mpr <| by constructor <;> simp
@[simp] lemma pos_nilpotencyClass_iff [Nontrivial R] :
0 < nilpotencyClass x ↔ IsNilpotent x := by
refine ⟨isNilpotent_of_pos_nilpotencyClass, fun hx ↦ Nat.pos_of_ne_zero fun hx' ↦ ?_⟩
replace hx := pow_nilpotencyClass hx
rw [hx', pow_zero] at hx
exact one_ne_zero hx | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | nilpotencyClass_eq_succ_iff | null |
pow_pred_nilpotencyClass [Nontrivial R] (hx : IsNilpotent x) :
x ^ (nilpotencyClass x - 1) ≠ 0 :=
(nilpotencyClass_eq_succ_iff.mp <| Nat.eq_add_of_sub_eq (pos_nilpotencyClass_iff.mpr hx) rfl).2 | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_pred_nilpotencyClass | null |
eq_zero_of_nilpotencyClass_eq_one (hx : nilpotencyClass x = 1) :
x = 0 := by
have : IsNilpotent x := isNilpotent_of_pos_nilpotencyClass (hx ▸ Nat.one_pos)
rw [← pow_nilpotencyClass this, hx, pow_one]
@[simp] lemma nilpotencyClass_eq_one [Nontrivial R] :
nilpotencyClass x = 1 ↔ x = 0 :=
⟨eq_zero_of_nilpotencyClass_eq_one, fun hx ↦ hx ▸ nilpotencyClass_zero⟩ | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | eq_zero_of_nilpotencyClass_eq_one | null |
@[mk_iff]
IsReduced (R : Type*) [Zero R] [Pow R ℕ] : Prop where
/-- A reduced structure has no nonzero nilpotent elements. -/
eq_zero : ∀ x : R, IsNilpotent x → x = 0 | class | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsReduced | A structure that has zero and pow is reduced if it has no nonzero nilpotent elements. |
pow_eq_zero [Zero R] [Pow R ℕ] [IsReduced R] {n : ℕ} (h : x ^ n = 0) :
x = 0 := IsReduced.eq_zero x ⟨n, h⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_eq_zero | null |
pow_eq_zero_iff [MonoidWithZero R] [IsReduced R] {n : ℕ} (hn : n ≠ 0) :
x ^ n = 0 ↔ x = 0 := ⟨pow_eq_zero, fun h ↦ h.symm ▸ zero_pow hn⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_eq_zero_iff | null |
pow_ne_zero_iff [MonoidWithZero R] [IsReduced R] {n : ℕ} (hn : n ≠ 0) :
x ^ n ≠ 0 ↔ x ≠ 0 := not_congr (pow_eq_zero_iff hn) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_ne_zero_iff | null |
pow_ne_zero [Zero R] [Pow R ℕ] [IsReduced R] (n : ℕ) (h : x ≠ 0) :
x ^ n ≠ 0 := fun H ↦ h (pow_eq_zero H) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_ne_zero | null |
@[simp]
pow_eq_zero_iff' [MonoidWithZero R] [IsReduced R] [Nontrivial R] {n : ℕ} :
x ^ n = 0 ↔ x = 0 ∧ n ≠ 0 := by
cases n <;> simp | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | pow_eq_zero_iff' | A variant of `IsReduced.pow_eq_zero_iff` assuming `R` is not trivial. |
IsNilpotent.eq_zero [Zero R] [Pow R ℕ] [IsReduced R] (h : IsNilpotent x) : x = 0 :=
IsReduced.eq_zero x h
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsNilpotent.eq_zero | null |
isNilpotent_iff_eq_zero [MonoidWithZero R] [IsReduced R] : IsNilpotent x ↔ x = 0 :=
⟨fun h => h.eq_zero, fun h => h.symm ▸ IsNilpotent.zero⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isNilpotent_iff_eq_zero | null |
isReduced_of_injective [MonoidWithZero R] [MonoidWithZero S] {F : Type*}
[FunLike F R S] [MonoidWithZeroHomClass F R S]
(f : F) (hf : Function.Injective f) [IsReduced S] :
IsReduced R := by
constructor
intro x hx
apply hf
rw [map_zero]
exact (hx.map f).eq_zero | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isReduced_of_injective | null |
IsRadical [Dvd R] [Pow R ℕ] (y : R) : Prop :=
∀ (n : ℕ) (x), y ∣ x ^ n → y ∣ x | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | IsRadical | An element `y` in a monoid is radical if for any element `x`, `y` divides `x` whenever it
divides a power of `x`. |
isRadical_iff_pow_one_lt [Monoid R] (k : ℕ) (hk : 1 < k) :
IsRadical y ↔ ∀ x, y ∣ x ^ k → y ∣ x :=
⟨(· k), k.pow_imp_self_of_one_lt hk _ fun _ _ h ↦ .inl (dvd_mul_of_dvd_left h _)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isRadical_iff_pow_one_lt | null |
isNilpotent_mul_right (h_comm : Commute x y) (h : IsNilpotent x) : IsNilpotent (x * y) := by
obtain ⟨n, hn⟩ := h
use n
rw [h_comm.mul_pow, hn, zero_mul] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isNilpotent_mul_right | null |
isNilpotent_mul_left (h_comm : Commute x y) (h : IsNilpotent y) : IsNilpotent (x * y) := by
rw [h_comm.eq]
exact h_comm.symm.isNilpotent_mul_right h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Hom",
"Mathlib.Algebra.GroupWithZero.Units.Basic",
"Mathlib.Algebra.Ring.Defs",
"Mathlib.Data.Nat.Lattice"
] | Mathlib/RingTheory/Nilpotent/Defs.lean | isNilpotent_mul_left | null |
noncomputable exp (a : A) : A :=
∑ i ∈ range (nilpotencyClass a), (i.factorial : ℚ)⁻¹ • (a ^ i) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp | The exponential map on algebras, defined in analogy with the usual exponential series.
It provides meaningful (non-junk) values for nilpotent elements. |
exp_eq_sum {a : A} {k : ℕ} (h : a ^ k = 0) :
exp a = ∑ i ∈ range k, (i.factorial : ℚ)⁻¹ • (a ^ i) := by
have h₁ : ∑ i ∈ range k, (i.factorial : ℚ)⁻¹ • (a ^ i) =
∑ i ∈ range (nilpotencyClass a), (i.factorial : ℚ)⁻¹ • (a ^ i) +
∑ i ∈ Ico (nilpotencyClass a) k, (i.factorial : ℚ)⁻¹ • (a ^ i) :=
(sum_range_add_sum_Ico _ (csInf_le' h)).symm
suffices ∑ i ∈ Ico (nilpotencyClass a) k, (i.factorial : ℚ)⁻¹ • (a ^ i) = 0 by
dsimp [exp]
rw [h₁, this, add_zero]
exact sum_eq_zero fun _ h₂ => by
rw [pow_eq_zero_of_le (mem_Ico.1 h₂).1 (pow_nilpotencyClass ⟨k, h⟩), smul_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_eq_sum | null |
exp_smul_eq_sum {M : Type*} [AddCommGroup M] [Module A M] [Module ℚ M] {a : A} {m : M}
{k : ℕ} (h : (a ^ k) • m = 0) (hn : IsNilpotent a) :
exp a • m = ∑ i ∈ range k, (i.factorial : ℚ)⁻¹ • (a ^ i) • m := by
rcases le_or_gt (nilpotencyClass a) k with h₀ | h₀
· simp_rw [exp_eq_sum (pow_eq_zero_of_le h₀ (pow_nilpotencyClass hn)), sum_smul, smul_assoc]
rw [exp, sum_smul, ← sum_range_add_sum_Ico _ (Nat.le_of_succ_le h₀)]
suffices ∑ i ∈ Ico k (nilpotencyClass a), ((i.factorial : ℚ)⁻¹ • (a ^ i)) • m = 0 by
simp_rw [this, add_zero, smul_assoc]
refine sum_eq_zero fun r h₂ ↦ ?_
rw [smul_assoc, ← pow_sub_mul_pow a (mem_Ico.1 h₂).1, mul_smul, h, smul_zero, smul_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_smul_eq_sum | null |
exp_add_of_commute {a b : A} (h₁ : Commute a b) (h₂ : IsNilpotent a) (h₃ : IsNilpotent b) :
exp (a + b) = exp a * exp b := by
obtain ⟨n₁, hn₁⟩ := h₂
obtain ⟨n₂, hn₂⟩ := h₃
let N := n₁ ⊔ n₂
have h₄ : a ^ (N + 1) = 0 := pow_eq_zero_of_le (by omega) hn₁
have h₅ : b ^ (N + 1) = 0 := pow_eq_zero_of_le (by omega) hn₂
rw [exp_eq_sum (k := 2 * N + 1)
(Commute.add_pow_eq_zero_of_add_le_succ_of_pow_eq_zero h₁ h₄ h₅ (by cutsat)),
exp_eq_sum h₄, exp_eq_sum h₅]
set R2N := range (2 * N + 1) with hR2N
set RN := range (N + 1) with hRN
have s₁ := by
calc ∑ i ∈ R2N, (i ! : ℚ)⁻¹ • (a + b) ^ i
= ∑ i ∈ R2N, (i ! : ℚ)⁻¹ • ∑ j ∈ range (i + 1), a ^ j * b ^ (i - j) * i.choose j := ?_
_ = ∑ i ∈ R2N, (∑ j ∈ range (i + 1),
((j ! : ℚ)⁻¹ * ((i - j) ! : ℚ)⁻¹) • (a ^ j * b ^ (i - j))) := ?_
_ = ∑ ij ∈ R2N ×ˢ R2N with ij.1 + ij.2 ≤ 2 * N,
((ij.1 ! : ℚ)⁻¹ * (ij.2 ! : ℚ)⁻¹) • (a ^ ij.1 * b ^ ij.2) := ?_
· refine sum_congr rfl fun i _ ↦ ?_
rw [Commute.add_pow h₁ i]
· simp_rw [smul_sum]
refine sum_congr rfl fun i hi ↦ sum_congr rfl fun j hj ↦ ?_
simp only [mem_range] at hi hj
replace hj := Nat.le_of_lt_succ hj
suffices (i ! : ℚ)⁻¹ * (i.choose j) = ((j ! : ℚ)⁻¹ * ((i - j)! : ℚ)⁻¹) by
rw [← Nat.cast_commute (i.choose j), ← this, ← mul_smul_comm, ← nsmul_eq_mul,
mul_smul, ← smul_assoc, smul_comm, smul_assoc]
norm_cast
rw [Nat.choose_eq_factorial_div_factorial hj,
Nat.cast_div (Nat.factorial_mul_factorial_dvd_factorial hj) (by positivity)]
simp [field]
· rw [hR2N, sum_sigma']
apply sum_bij (fun ⟨i, j⟩ _ ↦ (j, i - j))
· simp only [mem_sigma, mem_range, mem_filter, mem_product, and_imp]
cutsat
· simp only [mem_sigma, mem_range, Prod.mk.injEq, and_imp]
rintro ⟨x₁, y₁⟩ - h₁ ⟨x₂, y₂⟩ - h₂ h₃ h₄
simp_all
cutsat
· simp only [mem_filter, mem_product, mem_range, mem_sigma, exists_prop, Sigma.exists,
and_imp, Prod.forall, Prod.mk.injEq]
exact fun x y _ _ _ ↦ ⟨x + y, x, by cutsat⟩
· simp only [mem_sigma, mem_range, implies_true]
have z₁ : ∑ ij ∈ R2N ×ˢ R2N with ¬ ij.1 + ij.2 ≤ 2 * N,
((ij.1 ! : ℚ)⁻¹ * (ij.2 ! : ℚ)⁻¹) • (a ^ ij.1 * b ^ ij.2) = 0 :=
sum_eq_zero fun i hi ↦ by
rw [mem_filter] at hi
cases le_or_gt (N + 1) i.1 with
| inl h => rw [pow_eq_zero_of_le h h₄, zero_mul, smul_zero]
| inr _ => rw [pow_eq_zero_of_le (by linarith) h₅, mul_zero, smul_zero]
... | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_add_of_commute | null |
exp_zero :
exp (0 : A) = 1 := by
simp [exp_eq_sum (pow_one 0)] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_zero | null |
exp_mul_exp_neg_self {a : A} (h : IsNilpotent a) :
exp a * exp (-a) = 1 := by
simp [← exp_add_of_commute (Commute.neg_right rfl) h h.neg] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_mul_exp_neg_self | null |
exp_neg_mul_exp_self {a : A} (h : IsNilpotent a) :
exp (- a) * exp a = 1 := by
simp [← exp_add_of_commute (Commute.neg_left rfl) h.neg h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_neg_mul_exp_self | null |
isUnit_exp {a : A} (h : IsNilpotent a) : IsUnit (exp a) := by
apply isUnit_iff_exists.2
use exp (- a)
exact ⟨exp_mul_exp_neg_self h, exp_neg_mul_exp_self h⟩
@[deprecated (since := "2025-03-11")]
alias exp_of_nilpotent_is_unit := isUnit_exp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | isUnit_exp | null |
map_exp {B F : Type*} [Ring B] [FunLike F A B] [RingHomClass F A B] [Module ℚ B]
{a : A} (ha : IsNilpotent a) (f : F) :
f (exp a) = exp (f a) := by
obtain ⟨k, hk⟩ := ha
have hk' : (f a) ^ k = 0 := by simp [← map_pow, hk]
simp [exp_eq_sum hk, exp_eq_sum hk', map_rat_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | map_exp | null |
exp_smul {G : Type*} [Monoid G] [MulSemiringAction G A]
(g : G) {a : A} (ha : IsNilpotent a) :
exp (g • a) = g • exp a :=
(map_exp ha (MulSemiringAction.toRingHom G A g)).symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_smul | null |
commute_exp_left_of_commute
{fM : Module.End R M} {fN : Module.End R N} {g : M →ₗ[R] N}
(hfM : IsNilpotent fM)
(hfN : IsNilpotent fN)
(h : fN ∘ₗ g = g ∘ₗ fM) :
exp fN ∘ₗ g = g ∘ₗ exp fM := by
ext m
obtain ⟨k, hfM⟩ := hfM
obtain ⟨l, hfN⟩ := hfN
let kl := max k l
replace hfM : fM ^ kl = 0 := pow_eq_zero_of_le (by omega) hfM
replace hfN : fN ^ kl = 0 := pow_eq_zero_of_le (by omega) hfN
have (i : ℕ) : (fN ^ i) (g m) = g ((fM ^ i) m) := by
simpa using LinearMap.congr_fun (Module.End.commute_pow_left_of_commute h i) m
simp [exp_eq_sum hfM, exp_eq_sum hfN, this, map_rat_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | commute_exp_left_of_commute | null |
exp_mul_of_derivation (R B : Type*) [CommRing R] [NonUnitalNonAssocRing B]
[Module R B] [SMulCommClass R B B] [IsScalarTower R B B] [Module ℚ B]
(D : B →ₗ[R] B) (h_der : ∀ x y, D (x * y) = x * D y + (D x) * y)
(h_nil : IsNilpotent D) (x y : B) :
exp D (x * y) = (exp D x) * (exp D y) := by
let DL : Module.End R (B ⊗[R] B) := D.lTensor B
let DR : Module.End R (B ⊗[R] B) := D.rTensor B
have h_nilL : IsNilpotent DL := h_nil.map <| lTensorAlgHom R B B
have h_nilR : IsNilpotent DR := h_nil.map <| rTensorAlgHom R B B
have h_comm : Commute DL DR := by ext; simp [DL, DR]
set m : B ⊗[R] B →ₗ[R] B := LinearMap.mul' R B with hm
have h₁ : exp D (x * y) = m (exp (DL + DR) (x ⊗ₜ[R] y)) := by
suffices exp D ∘ₗ m = m ∘ₗ exp (DL + DR) by simpa using LinearMap.congr_fun this (x ⊗ₜ[R] y)
apply commute_exp_left_of_commute (h_comm.isNilpotent_add h_nilL h_nilR) h_nil
ext
simp [DL, DR, hm, h_der]
have h₂ : exp DL = (exp D).lTensor B := (h_nil.map_exp (lTensorAlgHom R B B)).symm
have h₃ : exp DR = (exp D).rTensor B := (h_nil.map_exp (rTensorAlgHom R B B)).symm
simp [h₁, exp_add_of_commute h_comm h_nilL h_nilR, h₂, h₃, hm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Algebra.Module.Rat",
"Mathlib.Data.Nat.Cast.Field",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Nilpotent.Basic... | Mathlib/RingTheory/Nilpotent/Exp.lean | exp_mul_of_derivation | null |
RingHom.ker_isRadical_iff_reduced_of_surjective {S F} [CommSemiring R] [Semiring S]
[FunLike F R S] [RingHomClass F R S] {f : F} (hf : Function.Surjective f) :
(RingHom.ker f).IsRadical ↔ IsReduced S := by
simp_rw [isReduced_iff, hf.forall, IsNilpotent, ← map_pow, ← RingHom.mem_ker]
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | RingHom.ker_isRadical_iff_reduced_of_surjective | null |
isRadical_iff_span_singleton [CommSemiring R] :
IsRadical y ↔ (Ideal.span ({y} : Set R)).IsRadical := by
simp_rw [IsRadical, ← Ideal.mem_span_singleton]
exact forall_swap.trans (forall_congr' fun r => exists_imp.symm) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isRadical_iff_span_singleton | null |
isNilpotent_iff_zero_mem_powers [Monoid R] [Zero R] {x : R} :
IsNilpotent x ↔ 0 ∈ Submonoid.powers x := Iff.rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent_iff_zero_mem_powers | null |
nilradical (R : Type*) [CommSemiring R] : Ideal R :=
(0 : Ideal R).radical | def | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilradical | The nilradical of a commutative semiring is the ideal of nilpotent elements. |
mem_nilradical : x ∈ nilradical R ↔ IsNilpotent x :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | mem_nilradical | null |
nilradical_eq_sInf (R : Type*) [CommSemiring R] :
nilradical R = sInf { J : Ideal R | J.IsPrime } :=
(Ideal.radical_eq_sInf ⊥).trans <| by simp_rw [and_iff_right bot_le] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilradical_eq_sInf | null |
nilpotent_iff_mem_prime : IsNilpotent x ↔ ∀ J : Ideal R, J.IsPrime → x ∈ J := by
rw [← mem_nilradical, nilradical_eq_sInf, Submodule.mem_sInf]
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilpotent_iff_mem_prime | null |
nilradical_le_prime (J : Ideal R) [H : J.IsPrime] : nilradical R ≤ J :=
(nilradical_eq_sInf R).symm ▸ sInf_le H
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilradical_le_prime | null |
nilradical_eq_zero (R : Type*) [CommSemiring R] [IsReduced R] : nilradical R = 0 :=
Ideal.ext fun _ => isNilpotent_iff_eq_zero | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilradical_eq_zero | null |
nilradical_eq_bot_iff {R : Type*} [CommSemiring R] : nilradical R = ⊥ ↔ IsReduced R := by
simp_rw [eq_bot_iff, SetLike.le_def, Submodule.mem_bot, mem_nilradical, isReduced_iff] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | nilradical_eq_bot_iff | null |
@[simp]
isNilpotent_mulLeft_iff (a : A) : IsNilpotent (mulLeft R a) ↔ IsNilpotent a := by
constructor <;> rintro ⟨n, hn⟩ <;> use n <;>
simp only [mulLeft_eq_zero_iff, pow_mulLeft] at hn ⊢ <;>
exact hn
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent_mulLeft_iff | null |
isNilpotent_mulRight_iff (a : A) : IsNilpotent (mulRight R a) ↔ IsNilpotent a := by
constructor <;> rintro ⟨n, hn⟩ <;> use n <;>
simp only [mulRight_eq_zero_iff, pow_mulRight] at hn ⊢ <;>
exact hn
variable {R}
variable {ι M : Type*} [Fintype ι] [DecidableEq ι] [AddCommMonoid M] [Module R M]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent_mulRight_iff | null |
isNilpotent_toMatrix_iff (b : Basis ι R M) (f : M →ₗ[R] M) :
IsNilpotent (toMatrix b b f) ↔ IsNilpotent f := by
refine exists_congr fun k ↦ ?_
rw [toMatrix_pow]
exact (toMatrix b b).map_eq_zero_iff | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent_toMatrix_iff | null |
@[simp]
Matrix.isNilpotent_toLin'_iff {ι : Type*} [DecidableEq ι] [Fintype ι] [CommSemiring R]
(A : Matrix ι ι R) :
IsNilpotent A.toLin' ↔ IsNilpotent A := by
have : A.toLin'.toMatrix (Pi.basisFun R ι) (Pi.basisFun R ι) = A := LinearMap.toMatrix'_toLin' A
conv_rhs => rw [← this]
rw [LinearMap.isNilpotent_toMatrix_iff] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | Matrix.isNilpotent_toLin'_iff | null |
isNilpotent_restrict_of_le {f : End R M} {p q : Submodule R M}
{hp : MapsTo f p p} {hq : MapsTo f q q} (h : p ≤ q) (hf : IsNilpotent (f.restrict hq)) :
IsNilpotent (f.restrict hp) := by
obtain ⟨n, hn⟩ := hf
use n
ext ⟨x, hx⟩
replace hn := DFunLike.congr_fun hn ⟨x, h hx⟩
simp_rw [LinearMap.zero_apply, ZeroMemClass.coe_zero, ZeroMemClass.coe_eq_zero] at hn ⊢
rw [Module.End.pow_restrict, LinearMap.restrict_apply] at hn ⊢
ext
exact (congr_arg Subtype.val hn :) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent_restrict_of_le | null |
isNilpotent.restrict
{f : M →ₗ[R] M} {p : Submodule R M} (hf : MapsTo f p p) (hnil : IsNilpotent f) :
IsNilpotent (f.restrict hf) := by
obtain ⟨n, hn⟩ := hnil
exact ⟨n, LinearMap.ext fun m ↦ by simp only [Module.End.pow_restrict n, hn,
LinearMap.restrict_apply, LinearMap.zero_apply]; rfl⟩ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | isNilpotent.restrict | null |
IsNilpotent.mapQ (hnp : IsNilpotent f) : IsNilpotent (p.mapQ p f hp) := by
obtain ⟨k, hk⟩ := hnp
use k
simp [← p.mapQ_pow, hk] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.ToLin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/Nilpotent/Lemmas.lean | IsNilpotent.mapQ | null |
isNoetherian_of_surjective (f : M →ₗ[R] P) (hf : LinearMap.range f = ⊤) [IsNoetherian R M] :
IsNoetherian R P :=
⟨fun s =>
have : (s.comap f).map f = s := Submodule.map_comap_eq_self <| hf.symm ▸ le_top
this ▸ (noetherian _).map _⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_surjective | null |
isNoetherian_range (f : M →ₗ[R] P) [IsNoetherian R M] :
IsNoetherian R (LinearMap.range f) :=
isNoetherian_of_surjective _ _ f.range_rangeRestrict | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_range | null |
isNoetherian_quotient {A M : Type*} [Ring A] [AddCommGroup M] [SMul R A] [Module R M]
[Module A M] [IsScalarTower R A M] (N : Submodule A M) [IsNoetherian R M] :
IsNoetherian R (M ⧸ N) :=
isNoetherian_of_surjective M ((Submodule.mkQ N).restrictScalars R) <|
LinearMap.range_eq_top.mpr N.mkQ_surjective | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_quotient | null |
isNoetherian_of_linearEquiv (f : M ≃ₗ[R] P) [IsNoetherian R M] : IsNoetherian R P :=
isNoetherian_of_surjective _ f.toLinearMap f.range | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_linearEquiv | null |
LinearEquiv.isNoetherian_iff (f : M ≃ₗ[R] P) : IsNoetherian R M ↔ IsNoetherian R P :=
⟨fun _ ↦ isNoetherian_of_linearEquiv f, fun _ ↦ isNoetherian_of_linearEquiv f.symm⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | LinearEquiv.isNoetherian_iff | null |
isNoetherian_top_iff : IsNoetherian R (⊤ : Submodule R M) ↔ IsNoetherian R M :=
Submodule.topEquiv.isNoetherian_iff | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_top_iff | null |
isNoetherian_of_injective [IsNoetherian R P] (f : M →ₗ[R] P) (hf : Function.Injective f) :
IsNoetherian R M :=
isNoetherian_of_linearEquiv (LinearEquiv.ofInjective f hf).symm | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_injective | null |
fg_of_injective [IsNoetherian R P] {N : Submodule R M} (f : M →ₗ[R] P)
(hf : Function.Injective f) : N.FG :=
haveI := isNoetherian_of_injective f hf
IsNoetherian.noetherian N | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | fg_of_injective | null |
Finite.of_injective [IsNoetherian R N] (f : M →ₗ[R] N) (hf : Function.Injective f) :
Module.Finite R M :=
⟨fg_of_injective f hf⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | Finite.of_injective | null |
isNoetherian_of_ker_bot [IsNoetherian R P] (f : M →ₗ[R] P) (hf : LinearMap.ker f = ⊥) :
IsNoetherian R M :=
isNoetherian_of_linearEquiv (LinearEquiv.ofInjective f <| LinearMap.ker_eq_bot.mp hf).symm | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_ker_bot | null |
fg_of_ker_bot [IsNoetherian R P] {N : Submodule R M} (f : M →ₗ[R] P)
(hf : LinearMap.ker f = ⊥) : N.FG :=
haveI := isNoetherian_of_ker_bot f hf
IsNoetherian.noetherian N | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | fg_of_ker_bot | null |
isNoetherian_prod [IsNoetherian R M] [IsNoetherian R P] : IsNoetherian R (M × P) :=
⟨fun s =>
Submodule.fg_of_fg_map_of_fg_inf_ker (LinearMap.snd R M P) (noetherian _) <|
have : s ⊓ LinearMap.ker (LinearMap.snd R M P) ≤ LinearMap.range (LinearMap.inl R M P) :=
fun x ⟨_, hx2⟩ => ⟨x.1, Prod.ext rfl <| Eq.symm <| LinearMap.mem_ker.1 hx2⟩
Submodule.map_comap_eq_self this ▸ (noetherian _).map _⟩ | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_prod | null |
isNoetherian_sup (M₁ M₂ : Submodule R P) [IsNoetherian R M₁] [IsNoetherian R M₂] :
IsNoetherian R ↥(M₁ ⊔ M₂) := by
have := isNoetherian_range (M₁.subtype.coprod M₂.subtype)
rwa [LinearMap.range_coprod, Submodule.range_subtype, Submodule.range_subtype] at this
variable {ι : Type*} [Finite ι] | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_sup | null |
isNoetherian_pi :
∀ {M : ι → Type*} [∀ i, AddCommGroup (M i)]
[∀ i, Module R (M i)] [∀ i, IsNoetherian R (M i)], IsNoetherian R (Π i, M i) := by
apply Finite.induction_empty_option _ _ _ ι
· exact fun e h ↦ isNoetherian_of_linearEquiv (LinearEquiv.piCongrLeft R _ e)
· infer_instance
· exact fun ih ↦ isNoetherian_of_linearEquiv (LinearEquiv.piOptionEquivProd R).symm | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_pi | null |
isNoetherian_pi' [IsNoetherian R M] : IsNoetherian R (ι → M) :=
isNoetherian_pi | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_pi' | A version of `isNoetherian_pi` for non-dependent functions. We need this instance because
sometimes Lean fails to apply the dependent version in non-dependent settings (e.g., it fails to
prove that `ι → ℝ` is finite dimensional over `ℝ`). |
isNoetherian_iSup :
∀ {M : ι → Submodule R P} [∀ i, IsNoetherian R (M i)], IsNoetherian R ↥(⨆ i, M i) := by
apply Finite.induction_empty_option _ _ _ ι
· intro _ _ e h _ _; rw [← e.iSup_comp]; apply h
· intros; rw [iSup_of_empty]; infer_instance
· intro _ _ ih _ _; rw [iSup_option]; infer_instance | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_iSup | null |
isNoetherian_of_range_eq_ker [IsNoetherian R M] [IsNoetherian R P]
(f : M →ₗ[R] N) (g : N →ₗ[R] P) (h : LinearMap.range f = LinearMap.ker g) :
IsNoetherian R N :=
isNoetherian_mk <|
wellFounded_gt_exact_sequence
(LinearMap.range f)
(Submodule.map ((LinearMap.ker f).liftQ f le_rfl))
(Submodule.comap ((LinearMap.ker f).liftQ f le_rfl))
(Submodule.comap g.rangeRestrict) (Submodule.map g.rangeRestrict)
(Submodule.gciMapComap <| LinearMap.ker_eq_bot.mp <| Submodule.ker_liftQ_eq_bot _ _ _ le_rfl)
(Submodule.giMapComap g.surjective_rangeRestrict)
(by simp [Submodule.map_comap_eq, inf_comm, Submodule.range_liftQ])
(by simp [Submodule.comap_map_eq, h]) | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_range_eq_ker | If the first and final modules in an exact sequence are Noetherian,
then the middle module is also Noetherian. |
isNoetherian_iff_submodule_quotient (S : Submodule R P) :
IsNoetherian R P ↔ IsNoetherian R S ∧ IsNoetherian R (P ⧸ S) := by
refine ⟨fun _ ↦ ⟨inferInstance, inferInstance⟩, fun ⟨_, _⟩ ↦ ?_⟩
apply isNoetherian_of_range_eq_ker S.subtype S.mkQ
rw [Submodule.ker_mkQ, Submodule.range_subtype] | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_iff_submodule_quotient | null |
isNoetherian_linearMap_pi {ι : Type*} [Finite ι] : IsNoetherian R ((ι → R) →ₗ[R] M) :=
let _i : Fintype ι := Fintype.ofFinite ι; isNoetherian_of_linearEquiv (Module.piEquiv ι R M) | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_linearMap_pi | null |
isNoetherian_linearMap : IsNoetherian R (N →ₗ[R] M) := by
obtain ⟨n, f, hf⟩ := Module.Finite.exists_fin' R N
let g : (N →ₗ[R] M) →ₗ[R] (Fin n → R) →ₗ[R] M := (LinearMap.llcomp R (Fin n → R) N M).flip f
exact isNoetherian_of_injective g hf.injective_linearMapComp_right | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_linearMap | null |
IsNoetherian.induction [IsNoetherian R M] {P : Submodule R M → Prop}
(hgt : ∀ I, (∀ J > I, P J) → P I) (I : Submodule R M) : P I :=
IsWellFounded.induction _ I hgt | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | IsNoetherian.induction | If `∀ I > J, P I` implies `P J`, then `P` holds for all submodules. |
LinearMap.isNoetherian_iff_of_bijective {S P} [Semiring S] [AddCommMonoid P] [Module S P]
{σ : R →+* S} [RingHomSurjective σ] (l : M →ₛₗ[σ] P) (hl : Function.Bijective l) :
IsNoetherian R M ↔ IsNoetherian S P := by
simp_rw [isNoetherian_iff']
let e := Submodule.orderIsoMapComapOfBijective l hl
exact ⟨fun _ ↦ e.symm.strictMono.wellFoundedGT, fun _ ↦ e.strictMono.wellFoundedGT⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | LinearMap.isNoetherian_iff_of_bijective | null |
Submodule.finite_ne_bot_of_iSupIndep {ι : Type*} {N : ι → Submodule R M}
(h : iSupIndep N) :
Set.Finite {i | N i ≠ ⊥} :=
WellFoundedGT.finite_ne_bot_of_iSupIndep h | lemma | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | Submodule.finite_ne_bot_of_iSupIndep | null |
LinearIndependent.finite_of_isNoetherian [Nontrivial R] {ι} {v : ι → M}
(hv : LinearIndependent R v) : Finite ι := by
refine WellFoundedGT.finite_of_iSupIndep
hv.iSupIndep_span_singleton
fun i contra => ?_
apply hv.ne_zero i
have : v i ∈ R ∙ v i := Submodule.mem_span_singleton_self (v i)
rwa [contra, Submodule.mem_bot] at this | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | LinearIndependent.finite_of_isNoetherian | A linearly-independent family of vectors in a module over a non-trivial ring must be finite if
the module is Noetherian. |
LinearIndependent.set_finite_of_isNoetherian [Nontrivial R] {s : Set M}
(hi : LinearIndependent R ((↑) : s → M)) : s.Finite :=
@Set.toFinite _ _ hi.finite_of_isNoetherian | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | LinearIndependent.set_finite_of_isNoetherian | null |
IsNoetherian.disjoint_partialSups_eventually_bot
(f : ℕ → Submodule R M) (h : ∀ n, Disjoint (partialSups f n) (f (n + 1))) :
∃ n : ℕ, ∀ m, n ≤ m → f m = ⊥ := by
suffices t : ∃ n : ℕ, ∀ m, n ≤ m → f (m + 1) = ⊥ by
obtain ⟨n, w⟩ := t
use n + 1
rintro (_ | m) p
· cases p
· apply w
exact Nat.succ_le_succ_iff.mp p
obtain ⟨n, w⟩ := monotone_stabilizes_iff_noetherian.mpr inferInstance (partialSups f)
refine ⟨n, fun m p ↦ (h m).eq_bot_of_ge <| sup_eq_left.mp ?_⟩
simpa only [partialSups_add_one] using (w (m + 1) <| le_add_right p).symm.trans <| w m p | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | IsNoetherian.disjoint_partialSups_eventually_bot | A sequence `f` of submodules of a Noetherian module,
with `f (n+1)` disjoint from the supremum of `f 0`, ..., `f n`,
is eventually zero. |
isNoetherian_of_tower (R) {S M} [Semiring R] [Semiring S] [AddCommMonoid M] [SMul R S]
[Module S M] [Module R M] [IsScalarTower R S M] (h : IsNoetherian R M) : IsNoetherian S M :=
isNoetherian_mk ⟨(Submodule.restrictScalarsEmbedding R S M).dual.wellFounded h.wf⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_tower | Modules over the trivial ring are Noetherian. -/
instance (priority := 100) isNoetherian_of_subsingleton (R M) [Subsingleton R] [Semiring R]
[AddCommMonoid M] [Module R M] : IsNoetherian R M :=
haveI := Module.subsingleton R M
isNoetherian_of_finite R M
theorem isNoetherian_of_submodule_of_noetherian (R M) [Semiring R] [AddCommMonoid M] [Module R M]
(N : Submodule R M) (h : IsNoetherian R M) : IsNoetherian R N :=
isNoetherian_mk ⟨OrderEmbedding.wellFounded (Submodule.MapSubtype.orderEmbedding N).dual h.wf⟩
/-- If `M / S / R` is a scalar tower, and `M / R` is Noetherian, then `M / S` is
also Noetherian. |
isNoetherian_of_isNoetherianRing_of_finite (R M : Type*)
[Ring R] [AddCommGroup M] [Module R M] [IsNoetherianRing R] [Module.Finite R M] :
IsNoetherian R M :=
have ⟨_, _, h⟩ := Module.Finite.exists_fin' R M
isNoetherian_of_surjective _ _ (LinearMap.range_eq_top.mpr h) | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_isNoetherianRing_of_finite | null |
isNoetherian_of_fg_of_noetherian {R M} [Ring R] [AddCommGroup M] [Module R M]
(N : Submodule R M) [I : IsNoetherianRing R] (hN : N.FG) : IsNoetherian R N := by
rw [← Module.Finite.iff_fg] at hN; infer_instance | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_of_fg_of_noetherian | null |
isNoetherian_span_of_finite (R) {M} [Ring R] [AddCommGroup M] [Module R M]
[IsNoetherianRing R] {A : Set M} (hA : A.Finite) : IsNoetherian R (Submodule.span R A) :=
isNoetherian_of_fg_of_noetherian _ (Submodule.fg_def.mpr ⟨A, hA, rfl⟩) | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherian_span_of_finite | In a module over a Noetherian ring, the submodule generated by finitely many vectors is
Noetherian. |
IsNoetherianRing.of_finite (R S) [Ring R] [Ring S] [Module R S] [IsScalarTower R S S]
[IsNoetherianRing R] [Module.Finite R S] : IsNoetherianRing S :=
isNoetherian_of_tower R inferInstance | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | IsNoetherianRing.of_finite | null |
isNoetherianRing_of_surjective (R) [Semiring R] (S) [Semiring S] (f : R →+* S)
(hf : Function.Surjective f) [H : IsNoetherianRing R] : IsNoetherianRing S :=
isNoetherian_mk ⟨OrderEmbedding.wellFounded (Ideal.orderEmbeddingOfSurjective f hf).dual H.wf⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherianRing_of_surjective | null |
isNoetherianRing_rangeS {R} [Semiring R] {S} [Semiring S] (f : R →+* S)
[IsNoetherianRing R] : IsNoetherianRing f.rangeS :=
isNoetherianRing_of_surjective R f.rangeS f.rangeSRestrict f.rangeSRestrict_surjective | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherianRing_rangeS | null |
isNoetherianRing_range {R} [Ring R] {S} [Ring S] (f : R →+* S)
[IsNoetherianRing R] : IsNoetherianRing f.range :=
isNoetherianRing_rangeS f | instance | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherianRing_range | null |
isNoetherianRing_of_ringEquiv (R) [Semiring R] {S} [Semiring S] (f : R ≃+* S)
[IsNoetherianRing R] : IsNoetherianRing S :=
isNoetherianRing_of_surjective R S f.toRingHom f.toEquiv.surjective | theorem | RingTheory | [
"Mathlib.Algebra.Order.SuccPred.PartialSups",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Noetherian.Defs",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory.Finiteness.Finsupp",
"Mathlib.RingTheory.Ideal.Prod"
] | Mathlib/RingTheory/Noetherian/Basic.lean | isNoetherianRing_of_ringEquiv | null |
isNoetherian_def : IsNoetherian R M ↔ ∀ s : Submodule R M, s.FG :=
⟨fun h => h.noetherian, IsNoetherian.mk⟩ | theorem | RingTheory | [
"Mathlib.Order.Filter.AtTopBot.Basic",
"Mathlib.RingTheory.Finiteness.Basic"
] | Mathlib/RingTheory/Noetherian/Defs.lean | isNoetherian_def | `IsNoetherian R M` is the proposition that `M` is a Noetherian `R`-module,
implemented as the predicate that all `R`-submodules of `M` are finitely generated.
-/
-- TODO: should this be renamed to `Noetherian`?
class IsNoetherian (R M) [Semiring R] [AddCommMonoid M] [Module R M] : Prop where
noetherian : ∀ s : Submodule R M, s.FG
attribute [inherit_doc IsNoetherian] IsNoetherian.noetherian
section
variable {R : Type*} {M : Type*} {P : Type*}
variable [Semiring R] [AddCommMonoid M] [AddCommMonoid P]
variable [Module R M] [Module R P]
open IsNoetherian
/-- An R-module is Noetherian iff all its submodules are finitely-generated. |
isNoetherian_submodule {N : Submodule R M} :
IsNoetherian R N ↔ ∀ s : Submodule R M, s ≤ N → s.FG := by
refine ⟨fun ⟨hn⟩ => fun s hs =>
have : s ≤ LinearMap.range N.subtype := N.range_subtype.symm ▸ hs
Submodule.map_comap_eq_self this ▸ (hn _).map _,
fun h => ⟨fun s => ?_⟩⟩
have f := (Submodule.equivMapOfInjective N.subtype Subtype.val_injective s).symm
have h₁ := h (s.map N.subtype) (Submodule.map_subtype_le N s)
have h₂ : (⊤ : Submodule R (s.map N.subtype)).map f = ⊤ := by simp
have h₃ := ((Submodule.fg_top _).2 h₁).map (↑f : _ →ₗ[R] s)
exact (Submodule.fg_top _).1 (h₂ ▸ h₃) | theorem | RingTheory | [
"Mathlib.Order.Filter.AtTopBot.Basic",
"Mathlib.RingTheory.Finiteness.Basic"
] | Mathlib/RingTheory/Noetherian/Defs.lean | isNoetherian_submodule | null |
isNoetherian_submodule_left {N : Submodule R M} :
IsNoetherian R N ↔ ∀ s : Submodule R M, (N ⊓ s).FG :=
isNoetherian_submodule.trans ⟨fun H _ => H _ inf_le_left, fun H _ hs => inf_of_le_right hs ▸ H _⟩ | theorem | RingTheory | [
"Mathlib.Order.Filter.AtTopBot.Basic",
"Mathlib.RingTheory.Finiteness.Basic"
] | Mathlib/RingTheory/Noetherian/Defs.lean | isNoetherian_submodule_left | null |
isNoetherian_submodule_right {N : Submodule R M} :
IsNoetherian R N ↔ ∀ s : Submodule R M, (s ⊓ N).FG :=
isNoetherian_submodule.trans ⟨fun H _ => H _ inf_le_right, fun H _ hs => inf_of_le_left hs ▸ H _⟩ | theorem | RingTheory | [
"Mathlib.Order.Filter.AtTopBot.Basic",
"Mathlib.RingTheory.Finiteness.Basic"
] | Mathlib/RingTheory/Noetherian/Defs.lean | isNoetherian_submodule_right | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.