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 ⌀ |
|---|---|---|---|---|---|---|
isPrime_ideal_prod_top' {I : Ideal S} [h : I.IsPrime] : (prod (⊤ : Ideal R) I).IsPrime := by
letI : IsPrime (prod I (⊤ : Ideal R)) := isPrime_ideal_prod_top
rw [← map_prodComm_prod]
exact map_isPrime_of_equiv (RingEquiv.prodComm (R := S) (S := R)) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | isPrime_ideal_prod_top' | null |
ideal_prod_prime_aux {I : Ideal R} {J : Ideal S} :
(Ideal.prod I J).IsPrime → I = ⊤ ∨ J = ⊤ := by
contrapose!
simp only [ne_top_iff_one, isPrime_iff, not_and, not_forall, not_or]
exact fun ⟨hI, hJ⟩ _ => ⟨⟨0, 1⟩, ⟨1, 0⟩, by simp, by simp [hJ], by simp [hI]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | ideal_prod_prime_aux | null |
ideal_prod_prime (I : Ideal (R × S)) :
I.IsPrime ↔
(∃ p : Ideal R, p.IsPrime ∧ I = Ideal.prod p ⊤) ∨
∃ p : Ideal S, p.IsPrime ∧ I = Ideal.prod ⊤ p := by
constructor
· rw [ideal_prod_eq I]
intro hI
rcases ideal_prod_prime_aux hI with (h | h)
· right
rw [h] at hI ⊢
exact ⟨_, ⟨isPrime_of_isPrime_prod_top' hI, rfl⟩⟩
· left
rw [h] at hI ⊢
exact ⟨_, ⟨isPrime_of_isPrime_prod_top hI, rfl⟩⟩
· rintro (⟨p, ⟨h, rfl⟩⟩ | ⟨p, ⟨h, rfl⟩⟩)
· exact isPrime_ideal_prod_top
· exact isPrime_ideal_prod_top' | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | ideal_prod_prime | Classification of prime ideals in product rings: the prime ideals of `R × S` are precisely the
ideals of the form `p × S` or `R × p`, where `p` is a prime ideal of `R` or `S`. |
@[mk_iff]
IsPrincipalIdealRing (R : Type u) [Semiring R] : Prop where
principal : ∀ S : Ideal R, S.IsPrincipal
attribute [instance] IsPrincipalIdealRing.principal | class | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | IsPrincipalIdealRing | A ring is a principal ideal ring if all (left) ideals are principal. |
span (s : Set α) : Ideal α :=
Submodule.span α s
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span | The ideal generated by a subset of a ring |
submodule_span_eq {s : Set α} : Submodule.span α s = Ideal.span s :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | submodule_span_eq | null |
span_empty : span (∅ : Set α) = ⊥ :=
Submodule.span_empty
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_empty | null |
span_univ : span (Set.univ : Set α) = ⊤ :=
Submodule.span_univ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_univ | null |
span_union (s t : Set α) : span (s ∪ t) = span s ⊔ span t :=
Submodule.span_union _ _ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_union | null |
span_iUnion {ι} (s : ι → Set α) : span (⋃ i, s i) = ⨆ i, span (s i) :=
Submodule.span_iUnion _ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_iUnion | null |
iSup_eq_span {ι} (p : ι → Ideal α) :
⨆ i, p i = span (⋃ i, ↑(p i)) :=
Submodule.iSup_eq_span p | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | iSup_eq_span | null |
mem_span {s : Set α} (x) : x ∈ span s ↔ ∀ p : Ideal α, s ⊆ p → x ∈ p :=
mem_iInter₂ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span | null |
subset_span {s : Set α} : s ⊆ span s :=
Submodule.subset_span | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | subset_span | null |
span_le {s : Set α} {I} : span s ≤ I ↔ s ⊆ I :=
Submodule.span_le
@[gcongr] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_le | null |
span_mono {s t : Set α} : s ⊆ t → span s ≤ span t :=
Submodule.span_mono
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_mono | null |
span_eq : span (I : Set α) = I :=
Submodule.span_eq _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_eq | null |
span_singleton_one : span ({1} : Set α) = ⊤ :=
(eq_top_iff_one _).2 <| subset_span <| mem_singleton _ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_one | null |
isCompactElement_top : CompleteLattice.IsCompactElement (⊤ : Ideal α) := by
simpa only [← span_singleton_one] using Submodule.singleton_span_isCompactElement 1 | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | isCompactElement_top | null |
mem_span_insert {s : Set α} {x y} :
x ∈ span (insert y s) ↔ ∃ a, ∃ z ∈ span s, x = a * y + z :=
Submodule.mem_span_insert | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_insert | null |
mem_span_singleton' {x y : α} : x ∈ span ({y} : Set α) ↔ ∃ a, a * y = x :=
Submodule.mem_span_singleton | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_singleton' | null |
mem_span_singleton_self (x : α) : x ∈ span ({x} : Set α) :=
Submodule.mem_span_singleton_self x | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_singleton_self | null |
span_singleton_le_iff_mem {x : α} : span {x} ≤ I ↔ x ∈ I :=
Submodule.span_singleton_le_iff_mem _ _ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_le_iff_mem | null |
span_singleton_mul_left_unit {a : α} (h2 : IsUnit a) (x : α) :
span ({a * x} : Set α) = span {x} :=
Submodule.span_singleton_smul_eq h2 x | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_mul_left_unit | null |
span_insert (x) (s : Set α) : span (insert x s) = span ({x} : Set α) ⊔ span s :=
Submodule.span_insert x s | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_insert | null |
span_eq_bot {s : Set α} : span s = ⊥ ↔ ∀ x ∈ s, (x : α) = 0 :=
Submodule.span_eq_bot
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_eq_bot | null |
span_singleton_eq_bot {x} : span ({x} : Set α) = ⊥ ↔ x = 0 :=
Submodule.span_singleton_eq_bot | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_eq_bot | null |
span_singleton_ne_top {α : Type*} [CommSemiring α] {x : α} (hx : ¬IsUnit x) :
Ideal.span ({x} : Set α) ≠ ⊤ :=
(Ideal.ne_top_iff_one _).mpr fun h1 =>
let ⟨y, hy⟩ := Ideal.mem_span_singleton'.mp h1
hx ⟨⟨x, y, mul_comm y x ▸ hy, hy⟩, rfl⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_ne_top | null |
span_zero : span (0 : Set α) = ⊥ := by rw [← Set.singleton_zero, span_singleton_eq_bot]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_zero | null |
span_singleton_zero : span {(0 : α)} = ⊥ := Submodule.span_zero_singleton _
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_zero | null |
span_insert_zero {s : Set α} : span (insert (0 : α) s) = span s :=
Submodule.span_insert_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_insert_zero | null |
span_sdiff_singleton_zero {s : Set α} : span (s \ {0}) = span s :=
Submodule.span_sdiff_singleton_zero
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_sdiff_singleton_zero | null |
span_one : span (1 : Set α) = ⊤ := by rw [← Set.singleton_one, span_singleton_one] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_one | null |
span_eq_top_iff_finite (s : Set α) :
span s = ⊤ ↔ ∃ s' : Finset α, ↑s' ⊆ s ∧ span (s' : Set α) = ⊤ := by
simp_rw [eq_top_iff_one]
exact ⟨Submodule.mem_span_finite_of_mem_span, fun ⟨s', h₁, h₂⟩ => span_mono h₁ h₂⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_eq_top_iff_finite | null |
mem_span_singleton_sup {x y : α} {I : Ideal α} :
x ∈ Ideal.span {y} ⊔ I ↔ ∃ a : α, ∃ b ∈ I, a * y + b = x := by
rw [Submodule.mem_sup]
constructor
· rintro ⟨ya, hya, b, hb, rfl⟩
obtain ⟨a, rfl⟩ := mem_span_singleton'.mp hya
exact ⟨a, b, hb, rfl⟩
· rintro ⟨a, b, hb, rfl⟩
exact ⟨a * y, Ideal.mem_span_singleton'.mpr ⟨a, rfl⟩, b, hb, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_singleton_sup | null |
ofRel (r : α → α → Prop) : Ideal α :=
Submodule.span α { x | ∃ a b, r a b ∧ x + b = a } | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | ofRel | The ideal generated by an arbitrary binary relation. |
zero_ne_one_of_proper {I : Ideal α} (h : I ≠ ⊤) : (0 : α) ≠ 1 := fun hz =>
I.ne_top_iff_one.1 h <| hz ▸ I.zero_mem | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | zero_ne_one_of_proper | null |
span_pair_comm {x y : α} : (span {x, y} : Ideal α) = span {y, x} := by
simp only [span_insert, sup_comm] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_pair_comm | null |
mem_span_pair {x y z : α} : z ∈ span ({x, y} : Set α) ↔ ∃ a b, a * x + b * y = z :=
Submodule.mem_span_pair
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_pair | null |
span_pair_add_mul_left {R : Type u} [CommRing R] {x y : R} (z : R) :
(span {x + y * z, y} : Ideal R) = span {x, y} := by
ext
rw [mem_span_pair, mem_span_pair]
exact
⟨fun ⟨a, b, h⟩ =>
⟨a, b + a * z, by
rw [← h]
ring1⟩,
fun ⟨a, b, h⟩ =>
⟨a, b - a * z, by
rw [← h]
ring1⟩⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_pair_add_mul_left | null |
span_pair_add_mul_right {R : Type u} [CommRing R] {x y : R} (z : R) :
(span {x, y + x * z} : Ideal R) = span {x, y} := by
rw [span_pair_comm, span_pair_add_mul_left, span_pair_comm] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_pair_add_mul_right | null |
mem_span_singleton {x y : α} : x ∈ span ({y} : Set α) ↔ y ∣ x :=
mem_span_singleton'.trans <| exists_congr fun _ => by rw [eq_comm, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_singleton | null |
span_singleton_le_span_singleton {x y : α} :
span ({x} : Set α) ≤ span ({y} : Set α) ↔ y ∣ x :=
span_le.trans <| singleton_subset_iff.trans mem_span_singleton | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_le_span_singleton | null |
span_singleton_eq_span_singleton {α : Type u} [CommSemiring α] [IsDomain α] {x y : α} :
span ({x} : Set α) = span ({y} : Set α) ↔ Associated x y := by
rw [← dvd_dvd_iff_associated, le_antisymm_iff, and_comm]
apply and_congr <;> rw [span_singleton_le_span_singleton]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_eq_span_singleton | null |
span_pair_eq_span_left_iff_dvd : span {a, b} = span {a} ↔ a ∣ b := by
rw [Ideal.span_insert, sup_eq_left, span_singleton_le_span_singleton]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_pair_eq_span_left_iff_dvd | null |
span_pair_eq_span_right_iff_dvd : span {a, b} = span {b} ↔ b ∣ a := by
rw [Ideal.span_insert, sup_eq_right, span_singleton_le_span_singleton] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_pair_eq_span_right_iff_dvd | null |
span_singleton_mul_right_unit {a : α} (h2 : IsUnit a) (x : α) :
span ({x * a} : Set α) = span {x} := by rw [mul_comm, span_singleton_mul_left_unit h2]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_mul_right_unit | null |
span_singleton_eq_top {x} : span ({x} : Set α) = ⊤ ↔ IsUnit x := by
rw [isUnit_iff_dvd_one, ← span_singleton_le_span_singleton, span_singleton_one, eq_top_iff] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_eq_top | null |
factors_decreasing [IsDomain α] (b₁ b₂ : α) (h₁ : b₁ ≠ 0) (h₂ : ¬IsUnit b₂) :
span ({b₁ * b₂} : Set α) < span {b₁} :=
lt_of_le_not_ge
(Ideal.span_le.2 <| singleton_subset_iff.2 <| Ideal.mem_span_singleton.2 ⟨b₂, rfl⟩) fun h =>
h₂ <| isUnit_of_dvd_one <|
(mul_dvd_mul_iff_left h₁).1 <| by rwa [mul_one, ← Ideal.span_singleton_le_span_singleton] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | factors_decreasing | null |
mem_span_insert' {s : Set α} {x y} : x ∈ span (insert y s) ↔ ∃ a, x + a * y ∈ span s :=
Submodule.mem_span_insert'
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | mem_span_insert' | null |
span_singleton_neg (x : α) : (span {-x} : Ideal α) = span {x} := by
ext
simp only [mem_span_singleton']
exact ⟨fun ⟨y, h⟩ => ⟨-y, h ▸ neg_mul_comm y x⟩, fun ⟨y, h⟩ => ⟨-y, h ▸ neg_mul_neg y x⟩⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_neg | null |
span_singleton_abs [LinearOrder α] (x : α) :
span {|x|} = span {x} := by
obtain h | h := abs_choice x <;>
simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | span_singleton_abs | null |
ker_toSpanSingleton_eq_span :
LinearMap.ker (LinearMap.toSpanSingleton R R e) = Ideal.span {1 - e} := SetLike.ext fun x ↦ by
rw [Ideal.mem_span_singleton']
refine ⟨fun h ↦ ⟨x, by rw [mul_sub, show x * e = 0 from h, mul_one, sub_zero]⟩, fun h ↦ ?_⟩
obtain ⟨x, rfl⟩ := h
change x * (1 - e) * e = 0
rw [mul_assoc, sub_mul, one_mul, he, sub_self, mul_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | ker_toSpanSingleton_eq_span | null |
ker_toSpanSingleton_one_sub_eq_span :
LinearMap.ker (LinearMap.toSpanSingleton R R (1 - e)) = Ideal.span {e} := by
rw [ker_toSpanSingleton_eq_span he.one_sub, sub_sub_cancel] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Associated",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.Algebra.Ring.Regular",
"Mathlib.LinearAlgebra.Span.Basic",
"Mathlib.RingTheory.Ideal.Lattice",
"Mathlib.Tactic.Ring"
] | Mathlib/RingTheory/Ideal/Span.lean | ker_toSpanSingleton_one_sub_eq_span | null |
isCoprime_iff_nat_coprime {a b : ℤ} : IsCoprime a b ↔ Nat.Coprime a.natAbs b.natAbs := by
rw [isCoprime_iff_gcd_eq_one, Nat.coprime_iff_gcd_eq_one, gcd_eq_natAbs] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | isCoprime_iff_nat_coprime | null |
gcd_ne_one_iff_gcd_mul_right_ne_one {a : ℤ} {m n : ℕ} :
a.gcd (m * n) ≠ 1 ↔ a.gcd m ≠ 1 ∨ a.gcd n ≠ 1 := by
simp only [← isCoprime_iff_gcd_eq_one, ← not_and_or, not_iff_not, IsCoprime.mul_right_iff] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | gcd_ne_one_iff_gcd_mul_right_ne_one | If `gcd a (m * n) ≠ 1`, then `gcd a m ≠ 1` or `gcd a n ≠ 1`. |
sq_of_gcd_eq_one {a b c : ℤ} (h : Int.gcd a b = 1) (heq : a * b = c ^ 2) :
∃ a0 : ℤ, a = a0 ^ 2 ∨ a = -a0 ^ 2 := by
have h' : IsUnit (GCDMonoid.gcd a b) := by
rw [← coe_gcd, h, Int.ofNat_one]
exact isUnit_one
obtain ⟨d, ⟨u, hu⟩⟩ := exists_associated_pow_of_mul_eq_pow h' heq
use d
rw [← hu]
rcases Int.units_eq_one_or u with hu' | hu' <;>
· rw [hu']
simp | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | sq_of_gcd_eq_one | null |
sq_of_isCoprime {a b c : ℤ} (h : IsCoprime a b) (heq : a * b = c ^ 2) :
∃ a0 : ℤ, a = a0 ^ 2 ∨ a = -a0 ^ 2 :=
sq_of_gcd_eq_one (isCoprime_iff_gcd_eq_one.mp h) heq | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | sq_of_isCoprime | null |
natAbs_euclideanDomain_gcd (a b : ℤ) :
Int.natAbs (EuclideanDomain.gcd a b) = Int.gcd a b := by
apply Nat.dvd_antisymm <;> rw [← Int.natCast_dvd_natCast]
· rw [Int.natAbs_dvd]
exact Int.dvd_coe_gcd (EuclideanDomain.gcd_dvd_left _ _) (EuclideanDomain.gcd_dvd_right _ _)
· rw [Int.dvd_natAbs]
exact EuclideanDomain.dvd_gcd (Int.gcd_dvd_left ..) (Int.gcd_dvd_right ..) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | natAbs_euclideanDomain_gcd | null |
Int.Prime.dvd_mul {m n : ℤ} {p : ℕ} (hp : Nat.Prime p) (h : (p : ℤ) ∣ m * n) :
p ∣ m.natAbs ∨ p ∣ n.natAbs := by
rwa [← hp.dvd_mul, ← Int.natAbs_mul, ← Int.natCast_dvd] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | Int.Prime.dvd_mul | null |
Int.Prime.dvd_mul' {m n : ℤ} {p : ℕ} (hp : Nat.Prime p) (h : (p : ℤ) ∣ m * n) :
(p : ℤ) ∣ m ∨ (p : ℤ) ∣ n := by
rw [Int.natCast_dvd, Int.natCast_dvd]
exact Int.Prime.dvd_mul hp h | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | Int.Prime.dvd_mul' | null |
Int.Prime.dvd_pow {n : ℤ} {k p : ℕ} (hp : Nat.Prime p) (h : (p : ℤ) ∣ n ^ k) :
p ∣ n.natAbs := by
rw [Int.natCast_dvd, Int.natAbs_pow] at h
exact hp.dvd_of_dvd_pow h | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | Int.Prime.dvd_pow | null |
Int.Prime.dvd_pow' {n : ℤ} {k p : ℕ} (hp : Nat.Prime p) (h : (p : ℤ) ∣ n ^ k) :
(p : ℤ) ∣ n := by
rw [Int.natCast_dvd]
exact Int.Prime.dvd_pow hp h | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | Int.Prime.dvd_pow' | null |
prime_two_or_dvd_of_dvd_two_mul_pow_self_two {m : ℤ} {p : ℕ} (hp : Nat.Prime p)
(h : (p : ℤ) ∣ 2 * m ^ 2) : p = 2 ∨ p ∣ Int.natAbs m := by
rcases Int.Prime.dvd_mul hp h with hp2 | hpp
· apply Or.intro_left
exact le_antisymm (Nat.le_of_dvd zero_lt_two hp2) (Nat.Prime.two_le hp)
· apply Or.intro_right
rw [sq, Int.natAbs_mul] at hpp
exact or_self_iff.mp ((Nat.Prime.dvd_mul hp).mp hpp) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | prime_two_or_dvd_of_dvd_two_mul_pow_self_two | null |
exists_prime_and_dvd {n : ℤ} (hn : n.natAbs ≠ 1) : ∃ p, Prime p ∧ p ∣ n := by
obtain ⟨p, pp, pd⟩ := Nat.exists_prime_and_dvd hn
exact ⟨p, Nat.prime_iff_prime_int.mp pp, Int.natCast_dvd.mpr pd⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | exists_prime_and_dvd | null |
prime_iff_natAbs_prime {k : ℤ} : Prime k ↔ Nat.Prime k.natAbs :=
(Int.associated_natAbs k).prime_iff.trans Nat.prime_iff_prime_int.symm | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | prime_iff_natAbs_prime | null |
instDecidablePredPrime : DecidablePred (Prime : ℤ → Prop) := fun m ↦
decidable_of_iff (Nat.Prime m.natAbs) prime_iff_natAbs_prime.symm | instance | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | instDecidablePredPrime | null |
span_natAbs (a : ℤ) : Ideal.span ({(a.natAbs : ℤ)} : Set ℤ) = Ideal.span {a} := by
rw [Ideal.span_singleton_eq_span_singleton]
exact (associated_natAbs _).symm | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | span_natAbs | null |
eq_pow_of_mul_eq_pow_odd_left {a b c : ℤ} (hab : IsCoprime a b) {k : ℕ} (hk : Odd k)
(h : a * b = c ^ k) : ∃ d, a = d ^ k := by
obtain ⟨d, hd⟩ := exists_associated_pow_of_mul_eq_pow' hab h
replace hd := hd.symm
rw [associated_iff_natAbs, natAbs_eq_natAbs_iff, ← hk.neg_pow] at hd
obtain rfl | rfl := hd <;> exact ⟨_, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | eq_pow_of_mul_eq_pow_odd_left | null |
eq_pow_of_mul_eq_pow_odd_right {a b c : ℤ} (hab : IsCoprime a b) {k : ℕ} (hk : Odd k)
(h : a * b = c ^ k) : ∃ d, b = d ^ k :=
eq_pow_of_mul_eq_pow_odd_left (c := c) hab.symm hk (by rwa [mul_comm] at h) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | eq_pow_of_mul_eq_pow_odd_right | null |
eq_pow_of_mul_eq_pow_odd {a b c : ℤ} (hab : IsCoprime a b) {k : ℕ} (hk : Odd k)
(h : a * b = c ^ k) : (∃ d, a = d ^ k) ∧ ∃ e, b = e ^ k :=
⟨eq_pow_of_mul_eq_pow_odd_left hab hk h, eq_pow_of_mul_eq_pow_odd_right hab hk h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Data.Nat.Prime.Int",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Int/Basic.lean | eq_pow_of_mul_eq_pow_odd | null |
IsIntegrallyClosedIn (R A : Type*) [CommRing R] [CommRing A] [Algebra R A] :=
IsIntegralClosure R R A | abbrev | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | IsIntegrallyClosedIn | `R` is integrally closed in `A` if all integral elements of `A` are also elements of `R`. |
IsIntegrallyClosed (R : Type*) [CommRing R] := IsIntegrallyClosedIn R (FractionRing R) | abbrev | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | IsIntegrallyClosed | `R` is integrally closed if all integral elements of `Frac(R)` are also elements of `R`.
This definition uses `FractionRing R` to denote `Frac(R)`. See `isIntegrallyClosed_iff`
if you want to choose another field of fractions for `R`. |
AlgHom.isIntegrallyClosedIn (f : A →ₐ[R] B) (hf : Function.Injective f) :
IsIntegrallyClosedIn R B → IsIntegrallyClosedIn R A := by
rintro ⟨inj, cl⟩
refine ⟨Function.Injective.of_comp (f := f) ?_, fun hx => ?_, ?_⟩
· convert inj
aesop
· obtain ⟨y, fx_eq⟩ := cl.mp ((isIntegral_algHom_iff f hf).mpr hx)
aesop
· rintro ⟨y, rfl⟩
apply (isIntegral_algHom_iff f hf).mp
simp_all | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | AlgHom.isIntegrallyClosedIn | Being integrally closed is preserved under injective algebra homomorphisms. |
AlgEquiv.isIntegrallyClosedIn (e : A ≃ₐ[R] B) :
IsIntegrallyClosedIn R A ↔ IsIntegrallyClosedIn R B :=
⟨AlgHom.isIntegrallyClosedIn e.symm e.symm.injective, AlgHom.isIntegrallyClosedIn e e.injective⟩
variable (K : Type*) [CommRing K] [Algebra R K] [IsFractionRing R K] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | AlgEquiv.isIntegrallyClosedIn | Being integrally closed is preserved under algebra isomorphisms. |
isIntegrallyClosed_iff_isIntegrallyClosedIn :
IsIntegrallyClosed R ↔ IsIntegrallyClosedIn R K :=
(IsLocalization.algEquiv R⁰ _ _).isIntegrallyClosedIn | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosed_iff_isIntegrallyClosedIn | `R` is integrally closed iff it is the integral closure of itself in its field of fractions. |
isIntegrallyClosed_iff_isIntegralClosure : IsIntegrallyClosed R ↔ IsIntegralClosure R R K :=
isIntegrallyClosed_iff_isIntegrallyClosedIn K | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosed_iff_isIntegralClosure | `R` is integrally closed iff it is the integral closure of itself in its field of fractions. |
isIntegrallyClosedIn_iff {R A : Type*} [CommRing R] [CommRing A] [Algebra R A] :
IsIntegrallyClosedIn R A ↔
Function.Injective (algebraMap R A) ∧
∀ {x : A}, IsIntegral R x → ∃ y, algebraMap R A y = x := by
constructor
· rintro ⟨_, cl⟩
simp_all
· rintro ⟨inj, cl⟩
refine ⟨inj, by simp_all, ?_⟩
rintro ⟨y, rfl⟩
apply isIntegral_algebraMap | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosedIn_iff | `R` is integrally closed in `A` iff all integral elements of `A` are also elements of `R`. |
isIntegrallyClosed_iff :
IsIntegrallyClosed R ↔ ∀ {x : K}, IsIntegral R x → ∃ y, algebraMap R K y = x := by
simp [isIntegrallyClosed_iff_isIntegrallyClosedIn K, isIntegrallyClosedIn_iff,
IsFractionRing.injective R K] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosed_iff | `R` is integrally closed iff all integral elements of its fraction field `K`
are also elements of `R`. |
algebraMap_eq_of_integral [IsIntegrallyClosedIn R A] {x : A} :
IsIntegral R x → ∃ y : R, algebraMap R A y = x :=
IsIntegralClosure.isIntegral_iff.mp | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | algebraMap_eq_of_integral | null |
isIntegral_iff [IsIntegrallyClosedIn R A] {x : A} :
IsIntegral R x ↔ ∃ y : R, algebraMap R A y = x :=
IsIntegralClosure.isIntegral_iff | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegral_iff | null |
exists_algebraMap_eq_of_isIntegral_pow [IsIntegrallyClosedIn R A]
{x : A} {n : ℕ} (hn : 0 < n)
(hx : IsIntegral R <| x ^ n) : ∃ y : R, algebraMap R A y = x :=
isIntegral_iff.mp <| hx.of_pow hn | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | exists_algebraMap_eq_of_isIntegral_pow | null |
exists_algebraMap_eq_of_pow_mem_subalgebra {A : Type*} [CommRing A] [Algebra R A]
{S : Subalgebra R A} [IsIntegrallyClosedIn S A] {x : A} {n : ℕ} (hn : 0 < n)
(hx : x ^ n ∈ S) : ∃ y : S, algebraMap S A y = x :=
exists_algebraMap_eq_of_isIntegral_pow hn <| isIntegral_iff.mpr ⟨⟨x ^ n, hx⟩, rfl⟩
variable (A) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | exists_algebraMap_eq_of_pow_mem_subalgebra | null |
integralClosure_eq_bot_iff (hRA : Function.Injective (algebraMap R A)) :
integralClosure R A = ⊥ ↔ IsIntegrallyClosedIn R A := by
refine eq_bot_iff.trans ?_
constructor
· intro h
refine ⟨ hRA, fun hx => Set.mem_range.mp (Algebra.mem_bot.mp (h hx)), ?_⟩
rintro ⟨y, rfl⟩
apply isIntegral_algebraMap
· intro h x hx
rw [Algebra.mem_bot, Set.mem_range]
exact isIntegral_iff.mp hx
variable (R)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | integralClosure_eq_bot_iff | null |
integralClosure_eq_bot [IsIntegrallyClosedIn R A] [NoZeroSMulDivisors R A] [Nontrivial A] :
integralClosure R A = ⊥ :=
(integralClosure_eq_bot_iff A (FaithfulSMul.algebraMap_injective _ _)).mpr ‹_›
variable {A} {B : Type*} [CommRing B] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | integralClosure_eq_bot | null |
of_isIntegralClosure [Algebra R B] [Algebra A B] [IsScalarTower R A B]
[IsIntegralClosure A R B] :
IsIntegrallyClosedIn A B :=
have : Algebra.IsIntegral R A := IsIntegralClosure.isIntegral_algebra R B
IsIntegralClosure.tower_top (R := R)
variable {R} | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | of_isIntegralClosure | If `R` is the integral closure of `S` in `A`, then it is integrally closed in `A`. |
_root_.IsIntegralClosure.of_isIntegrallyClosedIn
[Algebra R B] [Algebra A B] [IsScalarTower R A B]
[IsIntegrallyClosedIn A B] [Algebra.IsIntegral R A] :
IsIntegralClosure A R B := by
refine ⟨IsIntegralClosure.algebraMap_injective _ A _, fun {x} ↦
⟨fun hx ↦ IsIntegralClosure.isIntegral_iff.mp (IsIntegral.tower_top (A := A) hx), ?_⟩⟩
rintro ⟨y, rfl⟩
exact IsIntegral.map (IsScalarTower.toAlgHom A A B) (Algebra.IsIntegral.isIntegral y) | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | _root_.IsIntegralClosure.of_isIntegrallyClosedIn | null |
@[simp]
integralClosure_eq_bot [IsIntegrallyClosed R] : integralClosure R K = ⊥ :=
(integralClosure_eq_bot_iff K).mpr ‹_› | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | integralClosure_eq_bot | Note that this is not a duplicate instance, since `IsIntegrallyClosed R` is instead defined
as `IsIntegrallyClosed R R (FractionRing R)`. -/
instance [iic : IsIntegrallyClosed R] : IsIntegralClosure R R K :=
(isIntegrallyClosed_iff_isIntegralClosure K).mp iic
theorem algebraMap_eq_of_integral [IsIntegrallyClosed R] {x : K} :
IsIntegral R x → ∃ y : R, algebraMap R K y = x :=
IsIntegralClosure.isIntegral_iff.mp
theorem isIntegral_iff [IsIntegrallyClosed R] {x : K} :
IsIntegral R x ↔ ∃ y : R, algebraMap R K y = x :=
IsIntegrallyClosedIn.isIntegral_iff
theorem exists_algebraMap_eq_of_isIntegral_pow [IsIntegrallyClosed R] {x : K} {n : ℕ} (hn : 0 < n)
(hx : IsIntegral R <| x ^ n) : ∃ y : R, algebraMap R K y = x :=
IsIntegrallyClosedIn.exists_algebraMap_eq_of_isIntegral_pow hn hx
theorem exists_algebraMap_eq_of_pow_mem_subalgebra {K : Type*} [CommRing K] [Algebra R K]
{S : Subalgebra R K} [IsIntegrallyClosed S] [IsFractionRing S K] {x : K} {n : ℕ} (hn : 0 < n)
(hx : x ^ n ∈ S) : ∃ y : S, algebraMap S K y = x :=
IsIntegrallyClosedIn.exists_algebraMap_eq_of_pow_mem_subalgebra hn hx
theorem of_equiv (f : R ≃+* S) [h : IsIntegrallyClosed R] : IsIntegrallyClosed S := by
let _ : Algebra S R := f.symm.toRingHom.toAlgebra
let f : S ≃ₐ[S] R := AlgEquiv.ofRingEquiv fun _ ↦ rfl
let g : FractionRing S ≃ₐ[S] FractionRing R := IsFractionRing.algEquivOfAlgEquiv f
refine (isIntegrallyClosed_iff (FractionRing S)).mpr (fun hx ↦ ?_)
rcases (isIntegrallyClosed_iff _).mp h ((isIntegral_algEquiv g).mpr hx).tower_top with ⟨z, hz⟩
exact ⟨f.symm z, (IsFractionRing.algEquivOfAlgEquiv_algebraMap f.symm z).symm.trans <|
(AlgEquiv.symm_apply_eq g).mpr hz⟩
variable (R S K)
instance _root_.IsIntegralClosure.of_isIntegrallyClosed [IsIntegrallyClosed R]
[Algebra S R] [Algebra S K] [IsScalarTower S R K] [Algebra.IsIntegral S R] :
IsIntegralClosure R S K :=
IsIntegralClosure.of_isIntegrallyClosedIn
variable {R}
theorem integralClosure_eq_bot_iff : integralClosure R K = ⊥ ↔ IsIntegrallyClosed R :=
(IsIntegrallyClosedIn.integralClosure_eq_bot_iff _ (IsFractionRing.injective _ _)).trans
(isIntegrallyClosed_iff_isIntegrallyClosedIn _).symm
@[simp]
theorem pow_dvd_pow_iff [IsDomain R] [IsIntegrallyClosed R]
{n : ℕ} (hn : n ≠ 0) {a b : R} : a ^ n ∣ b ^ n ↔ a ∣ b := by
refine ⟨fun ⟨x, hx⟩ ↦ ?_, fun h ↦ pow_dvd_pow_of_dvd h n⟩
by_cases ha : a = 0
· simpa [ha, hn] using hx
let K := FractionRing R
replace ha : algebraMap R K a ≠ 0 := fun h ↦
ha <| (injective_iff_map_eq_zero _).1 (IsFractionRing.injective R K) _ h
let y := (algebraMap R K b) / (algebraMap R K a)
have hy : IsIntegral R y := by
refine ⟨X ^ n - C x, monic_X_pow_sub_C _ hn, ?_⟩
simp only [y, eval₂_sub, eval₂_X_pow, div_pow, eval₂_C]
replace hx := congr_arg (algebraMap R K) hx
rw [map_pow] at hx
simp [hx, ha]
obtain ⟨k, hk⟩ := algebraMap_eq_of_integral hy
refine ⟨k, IsFractionRing.injective R K ?_⟩
rw [map_mul, hk, mul_div_cancel₀ _ ha]
@[simp]
theorem _root_.Associated.pow_iff [IsDomain R] [IsIntegrallyClosed R] {n : ℕ} (hn : n ≠ 0)
{a b : R} :
Associated (a ^ n) (b ^ n) ↔ Associated a b := by
simp_rw [← dvd_dvd_iff_associated, pow_dvd_pow_iff hn]
variable (R)
/-- This is almost a duplicate of `IsIntegrallyClosedIn.integralClosure_eq_bot`,
except the `NoZeroSMulDivisors` hypothesis isn't inferred automatically from `IsFractionRing`. |
isIntegrallyClosedOfFiniteExtension [IsDomain R] [FiniteDimensional K L] :
IsIntegrallyClosed (integralClosure R L) :=
letI : IsFractionRing (integralClosure R L) L := isFractionRing_of_finite_extension K L
(integralClosure_eq_bot_iff L).mp integralClosure_idem | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosedOfFiniteExtension | null |
isIntegrallyClosed_of_isLocalization [IsIntegrallyClosed R] [IsDomain R] (M : Submonoid R)
(hM : M ≤ R⁰) [IsLocalization M S] : IsIntegrallyClosed S := by
let K := FractionRing R
let g : S →+* K := IsLocalization.map _ (T := R⁰) (RingHom.id R) hM
letI := g.toAlgebra
have : IsScalarTower R S K := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
have := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization M S K
refine (isIntegrallyClosed_iff_isIntegralClosure (K := K)).mpr
⟨IsFractionRing.injective _ _, fun {x} ↦ ⟨?_, fun e ↦ e.choose_spec ▸ isIntegral_algebraMap⟩⟩
intro hx
obtain ⟨⟨y, y_mem⟩, hy⟩ := hx.exists_multiple_integral_of_isLocalization M _
obtain ⟨z, hz⟩ := (isIntegrallyClosed_iff _).mp ‹_› hy
refine ⟨IsLocalization.mk' S z ⟨y, y_mem⟩, (IsLocalization.lift_mk'_spec _ _ _ _).mpr ?_⟩
rw [RingHom.comp_id, hz, ← Algebra.smul_def, Submonoid.mk_smul] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | isIntegrallyClosed_of_isLocalization | null |
Field.instIsIntegrallyClosed (K : Type*) [Field K] : IsIntegrallyClosed K :=
(isIntegrallyClosed_iff K).mpr fun {x} _ ↦ ⟨x, rfl⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Localization.Integral",
"Mathlib.RingTheory.Localization.LocalizationLocalization"
] | Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean | Field.instIsIntegrallyClosed | Any field is integral closed. -/
/- Although `infer_instance` can find this if you import Mathlib, in this file they have not been
proven yet. However, it is used to prove a fundamental property of `IsIntegrallyClosed`,
and it is not desirable to involve more content from other files. |
noncomputable
galRestrict' (f : L →ₐ[K] L₂) : (B →ₐ[A] B₂) :=
(IsIntegralClosure.equiv A (integralClosure A L₂) L₂ B₂).toAlgHom.comp
(((f.restrictScalars A).comp (IsScalarTower.toAlgHom A B L)).codRestrict
(integralClosure A L₂) (fun x ↦ IsIntegral.map _ (IsIntegralClosure.isIntegral A L x)))
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict' | A generalization of `galRestrictHom` beyond endomorphisms. |
algebraMap_galRestrict'_apply (σ : L →ₐ[K] L₂) (x : B) :
algebraMap B₂ L₂ (galRestrict' A B B₂ σ x) = σ (algebraMap B L x) := by
simp [galRestrict', galRestrict', Subalgebra.algebraMap_eq]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | algebraMap_galRestrict'_apply | null |
galRestrict'_id : galRestrict' A B B (.id K L) = .id A B := by
ext
apply IsIntegralClosure.algebraMap_injective B A L
simp | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict'_id | null |
galRestrict'_comp (σ : L →ₐ[K] L₂) (σ' : L₂ →ₐ[K] L₃) :
galRestrict' A B B₃ (σ'.comp σ) = (galRestrict' A B₂ B₃ σ').comp (galRestrict' A B B₂ σ) := by
ext x
apply (IsIntegralClosure.equiv A (integralClosure A L₃) L₃ B₃).symm.injective
ext
simp [galRestrict', Subalgebra.algebraMap_eq] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict'_comp | null |
noncomputable
galLift (σ : B →ₐ[A] B₂) : L →ₐ[K] L₂ :=
haveI := (IsFractionRing.injective A K).isDomain
haveI := NoZeroSMulDivisors.trans_faithfulSMul A K L₂
haveI := IsIntegralClosure.isLocalization A K L B
haveI H : ∀ (y : Algebra.algebraMapSubmonoid B A⁰),
IsUnit (((algebraMap B₂ L₂).comp σ) (y : B)) := by
rintro ⟨_, x, hx, rfl⟩
simpa only [RingHom.coe_comp, RingHom.coe_coe, Function.comp_apply, AlgHom.commutes,
isUnit_iff_ne_zero, ne_eq, map_eq_zero_iff _ (FaithfulSMul.algebraMap_injective _ _),
← IsScalarTower.algebraMap_apply] using nonZeroDivisors.ne_zero hx
haveI H_eq : (IsLocalization.lift (S := L) H).comp (algebraMap K L) = (algebraMap K L₂) := by
apply IsLocalization.ringHom_ext A⁰
ext
simp only [RingHom.coe_comp, Function.comp_apply, ← IsScalarTower.algebraMap_apply A K L,
← IsScalarTower.algebraMap_apply A K L₂,
IsScalarTower.algebraMap_apply A B L, IsScalarTower.algebraMap_apply A B₂ L₂,
IsLocalization.lift_eq, RingHom.coe_coe, AlgHom.commutes]
{ IsLocalization.lift (S := L) H with commutes' := DFunLike.congr_fun H_eq }
omit [IsIntegralClosure B₂ A L₂] in
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLift | A generalization of the the lift `End(B/A) → End(L/K)` in an ALKB setup.
This is inverse to the restriction. See `galRestrictHom`. |
galLift_algebraMap_apply (σ : B →ₐ[A] B₂) (x : B) :
galLift K L L₂ σ (algebraMap B L x) = algebraMap B₂ L₂ (σ x) := by
simp [galLift]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLift_algebraMap_apply | null |
galLift_id : galLift K L L (.id A B) = .id K L := by
ext; simp [galLift]
omit [IsIntegralClosure B₃ A L₃] in | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLift_id | null |
galLift_comp [Algebra.IsAlgebraic K L₂] (σ : B →ₐ[A] B₂) (σ' : B₂ →ₐ[A] B₃) :
galLift K L L₃ (σ'.comp σ) = (galLift K L₂ L₃ σ').comp (galLift K L L₂ σ) :=
have := (IsFractionRing.injective A K).isDomain
have := IsIntegralClosure.isLocalization A K L B
AlgHom.coe_ringHom_injective <| IsLocalization.ringHom_ext (Algebra.algebraMapSubmonoid B A⁰)
<| RingHom.ext fun x ↦ by simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLift_comp | null |
galLift_galRestrict' (σ : L →ₐ[K] L₂) :
galLift K L L₂ (galRestrict' A B B₂ σ) = σ :=
have := (IsFractionRing.injective A K).isDomain
have := IsIntegralClosure.isLocalization A K L B
AlgHom.coe_ringHom_injective <| IsLocalization.ringHom_ext (Algebra.algebraMapSubmonoid B A⁰)
<| RingHom.ext fun x ↦ by simp [galRestrict', Subalgebra.algebraMap_eq, galLift]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLift_galRestrict' | null |
galRestrict'_galLift (σ : B →ₐ[A] B₂) :
galRestrict' A B B₂ (galLift K L L₂ σ) = σ :=
have := (IsFractionRing.injective A K).isDomain
have := IsIntegralClosure.isLocalization A K L B
AlgHom.ext fun x ↦ IsIntegralClosure.algebraMap_injective B₂ A L₂
(by simp [galRestrict', Subalgebra.algebraMap_eq, galLift]) | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict'_galLift | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.