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 ⌀ |
|---|---|---|---|---|---|---|
IsSubDPIdeal {A : Type*} [CommSemiring A] {I : Ideal A} (hI : DividedPowers I)
(J : Ideal A) : Prop where
isSubideal : J ≤ I
dpow_mem : ∀ (n : ℕ) (_: n ≠ 0) {j : A} (_ : j ∈ J), hI.dpow n j ∈ J | structure | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | IsSubDPIdeal | A sub-ideal `J` of a divided power ideal `(I, hI)` is a sub-dp-ideal if for all `n > 0` and
all `x ∈ J`, `hI.dpow n j ∈ J`. |
self : IsSubDPIdeal hI I where
isSubideal := le_rfl
dpow_mem _ hn _ ha := hI.dpow_mem hn ha | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | self | null |
dividedPowers {J : Ideal A} (hJ : IsSubDPIdeal hI J) [∀ x, Decidable (x ∈ J)] :
DividedPowers J where
dpow n x := if x ∈ J then hI.dpow n x else 0
dpow_null hx := by simp [if_neg hx]
dpow_zero hx := by simp [if_pos hx, hI.dpow_zero (hJ.isSubideal hx)]
dpow_one hx := by simp [if_pos hx, hI.dpow_one (hJ.isSubideal hx)]
dpow_mem hn hx := by simp [if_pos hx, hJ.dpow_mem _ hn hx]
dpow_add hx hy := by simp_rw [if_pos hx, if_pos hy, if_pos (Ideal.add_mem J hx hy),
hI.dpow_add (hJ.isSubideal hx) (hJ.isSubideal hy)]
dpow_mul hx := by
simp [if_pos hx, if_pos (mul_mem_left J _ hx), hI.dpow_mul (hJ.isSubideal hx)]
mul_dpow hx := by simp [if_pos hx, hI.mul_dpow (hJ.isSubideal hx)]
dpow_comp hn hx := by
simp [if_pos hx, if_pos (hJ.dpow_mem _ hn hx), hI.dpow_comp hn (hJ.isSubideal hx)]
variable {J : Ideal A} (hJ : IsSubDPIdeal hI J) [∀ x, Decidable (x ∈ J)] | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dividedPowers | The divided power structure on a sub-dp-ideal. |
dpow_eq (n : ℕ) (a : A) :
(IsSubDPIdeal.dividedPowers hI hJ).dpow n a = if a ∈ J then hI.dpow n a else 0 := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_eq | null |
dpow_eq_of_mem {n : ℕ} {a : A} (ha : a ∈ J) :
(IsSubDPIdeal.dividedPowers hI hJ).dpow n a = hI.dpow n a := by rw [dpow_eq, if_pos ha] | lemma | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_eq_of_mem | null |
isDPMorphism (hJ : IsSubDPIdeal hI J) :
(IsSubDPIdeal.dividedPowers hI hJ).IsDPMorphism hI (RingHom.id A) := by
simpa only [isDPMorphism_iff, Ideal.map_id, RingHom.id_apply]
using ⟨hJ.1, fun _ _ _ ha ↦ by rw [dpow_eq_of_mem _ _ ha]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isDPMorphism | null |
isSubDPIdeal_inf_iff {A : Type*} [CommRing A] {I : Ideal A} (hI : DividedPowers I)
{J : Ideal A} : IsSubDPIdeal hI (J ⊓ I) ↔
∀ {n : ℕ} {a b : A} (_ : a ∈ I) (_ : b ∈ I) (_ : a - b ∈ J), hI.dpow n a - hI.dpow n b ∈ J := by
refine ⟨fun hIJ n a b ha hb hab ↦ ?_, fun hIJ ↦ ?_⟩
· have hab' : a - b ∈ I := I.sub_mem ha hb
rw [← add_sub_cancel b a, hI.dpow_add' hb hab', range_add_one, sum_insert notMem_range_self,
tsub_self, hI.dpow_zero hab', mul_one, add_sub_cancel_left]
exact J.sum_mem (fun i hi ↦ SemilatticeInf.inf_le_left J I ((J ⊓ I).smul_mem _
(hIJ.dpow_mem _ (ne_of_gt (Nat.sub_pos_of_lt (mem_range.mp hi))) ⟨hab, hab'⟩)))
· refine ⟨SemilatticeInf.inf_le_right J I, fun {n} hn {a} ha ↦ ⟨?_, hI.dpow_mem hn ha.right⟩⟩
rw [← sub_zero (hI.dpow n a), ← hI.dpow_eval_zero hn]
exact hIJ ha.right I.zero_mem (J.sub_mem ha.left J.zero_mem)
variable {A B : Type*} [CommSemiring A] {I : Ideal A} {hI : DividedPowers I} [CommSemiring B]
{J : Ideal B} {hJ : DividedPowers J} | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_inf_iff | The ideal `J ⊓ I` is a sub-dp-ideal of `I` if and only if the divided powers have
some compatibility mod `J`. (The necessity was proved as a sanity check.) |
span_isSubDPIdeal_iff {S : Set A} (hS : S ⊆ I) :
IsSubDPIdeal hI (span S) ↔ ∀ {n : ℕ} (_ : n ≠ 0), ∀ s ∈ S, hI.dpow n s ∈ span S := by
refine ⟨fun hhI n hn s hs ↦ hhI.dpow_mem n hn (subset_span hs), fun hhI ↦ ?_⟩
· -- interesting direction
have hSI := span_le.mpr hS
apply IsSubDPIdeal.mk hSI
intro m hm z hz
induction hz using Submodule.span_induction generalizing m hm with
| mem x h => exact hhI hm x h
| zero =>
rw [hI.dpow_eval_zero hm]
exact (span S).zero_mem
| add x y hxI hyI hx hy =>
rw [hI.dpow_add' (hSI hxI) (hSI hyI)]
apply Submodule.sum_mem (span S)
intro m _
by_cases hm0 : m = 0
· exact hm0 ▸ mul_mem_left (span S) _ (hy _ hm)
· exact mul_mem_right _ (span S) (hx _ hm0)
| smul a x hxI hx =>
rw [Algebra.id.smul_eq_mul, hI.dpow_mul (hSI hxI)]
exact mul_mem_left (span S) (a ^ m) (hx m hm) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | span_isSubDPIdeal_iff | [P. Berthelot and A. Ogus, *Notes on crystalline cohomology* (Lemma 3.6)][BerthelotOgus-1978] |
isSubDPIdeal_sup {J K : Ideal A} (hJ : IsSubDPIdeal hI J) (hK : IsSubDPIdeal hI K) :
IsSubDPIdeal hI (J ⊔ K) := by
rw [← J.span_eq, ← K.span_eq, ← span_union,
span_isSubDPIdeal_iff (Set.union_subset_iff.mpr ⟨hJ.1, hK.1⟩)]
intro n hn a ha
rcases ha with ha | ha
· exact span_mono Set.subset_union_left (subset_span (hJ.2 n hn ha))
· exact span_mono Set.subset_union_right (subset_span (hK.2 n hn ha)) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_sup | null |
isSubDPIdeal_iSup {ι : Type*} {J : ι → Ideal A} (hJ : ∀ i, IsSubDPIdeal hI (J i)) :
IsSubDPIdeal hI (iSup J) := by
rw [iSup_eq_span, span_isSubDPIdeal_iff (Set.iUnion_subset_iff.mpr <| fun i ↦ (hJ i).1)]
simp_rw [Set.mem_iUnion]
rintro n hn a ⟨i, ha⟩
exact span_mono (Set.subset_iUnion _ i) (subset_span ((hJ i).2 n hn ha)) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_iSup | null |
isSubDPIdeal_iInf {ι : Type*} {J : ι → Ideal A} (hJ : ∀ i, IsSubDPIdeal hI (J i)) :
IsSubDPIdeal hI (I ⊓ iInf (fun i ↦ J i)) := by
by_cases hι : Nonempty ι
· refine ⟨fun _ hx ↦ hx.1, ?_⟩
intro n hn x hx
simp only [Ideal.mem_inf, mem_iInf] at hx ⊢
exact ⟨hI.dpow_mem hn hx.1, fun i ↦ IsSubDPIdeal.dpow_mem (hJ i) n hn (hx.2 i)⟩
· push_neg at hι
simp only [iInf_of_empty, le_top, inf_of_le_left]
exact IsSubDPIdeal.self hI | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_iInf | null |
isSubDPIdeal_map_of_isSubDPIdeal {f : A →+* B} (hf : IsDPMorphism hI hJ f) {K : Ideal A}
(hK : IsSubDPIdeal hI K) : IsSubDPIdeal hJ (map f K) := by
rw [Ideal.map, span_isSubDPIdeal_iff]
· rintro n hn y ⟨x, hx, rfl⟩
exact hf.2 x (hK.1 hx) ▸ mem_map_of_mem _ (hK.2 _ hn hx)
· rintro y ⟨x, hx, rfl⟩
exact hf.1 (mem_map_of_mem f (hK.1 hx)) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_map_of_isSubDPIdeal | null |
isSubDPIdeal_map {f : A →+* B} (hf : IsDPMorphism hI hJ f) :
IsSubDPIdeal hJ (Ideal.map f I) :=
isSubDPIdeal_map_of_isSubDPIdeal hf (IsSubDPIdeal.self hI) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_map | The image of a divided power morphism from `I` to `J` is a sub-dp-ideal of `J`. |
@[ext]
SubDPIdeal {A : Type*} [CommSemiring A] {I : Ideal A} (hI : DividedPowers I) where
/-- The underlying ideal. -/
carrier : Ideal A
isSubideal : carrier ≤ I
dpow_mem : ∀ (n : ℕ) (_ : n ≠ 0), ∀ j ∈ carrier, hI.dpow n j ∈ carrier | structure | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | SubDPIdeal | A `SubDPIdeal` of `I` is a sub-ideal `J` of `I` such that for all `n > 0` `x ∈ J`,
`hI.dpow n j ∈ J`. The unbundled version of this definition is called `IsSubDPIdeal`. |
mk' {J : Ideal A} (hJ : hI.IsSubDPIdeal J) : hI.SubDPIdeal := ⟨J, hJ.1, hJ.2⟩ | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | mk' | Constructs a `SubPDIdeal` given an ideal `J` satisfying `hI.IsSubDPIdeal J`. |
@[coe]
toIdeal (J : hI.SubDPIdeal) : Ideal A := J.carrier | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | toIdeal | The coercion from `SubDPIdeal` to `Ideal`. |
coe_def (J : SubDPIdeal hI) : J.toIdeal = J.carrier := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | coe_def | null |
memCarrier {s : SubDPIdeal hI} {x : A} : x ∈ s.carrier ↔ x ∈ s := Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | memCarrier | null |
toIsSubDPIdeal (J : SubDPIdeal hI) : IsSubDPIdeal hI J.carrier where
isSubideal := J.isSubideal
dpow_mem := J.dpow_mem
open Ideal | lemma | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | toIsSubDPIdeal | null |
prod (J : Ideal A) : SubDPIdeal hI where
carrier := I • J
isSubideal := mul_le_right
dpow_mem m hm x hx := by
induction hx using Submodule.smul_induction_on' generalizing m with
| smul a ha b hb =>
rw [Algebra.id.smul_eq_mul, smul_eq_mul, mul_comm a b, hI.dpow_mul ha, mul_comm]
exact Submodule.mul_mem_mul (J.pow_mem_of_mem hb m (zero_lt_iff.mpr hm))
(hI.dpow_mem hm ha)
| add x hx y hy hx' hy' =>
rw [hI.dpow_add' (mul_le_right hx) (mul_le_right hy)]
apply Submodule.sum_mem (I • J)
intro k _
by_cases hk0 : k = 0
· exact hk0 ▸ mul_mem_left (I • J) _ (hy' _ hm)
· exact mul_mem_right _ (I • J) (hx' k hk0) | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | prod | If `J` is an ideal of `A`, then `I⬝J` is a sub-dp-ideal of `I`.
See [P. Berthelot, *Cohomologie cristalline des schémas de caractéristique $p$ > 0*,
(Proposition 1.6.1 (i))][Berthelot-1974] |
le_iff {J J' : SubDPIdeal hI} : J ≤ J' ↔ J.carrier ≤ J'.carrier := Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | le_iff | null |
lt_iff {J J' : SubDPIdeal hI} : J < J' ↔ J.carrier < J'.carrier := Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | lt_iff | null |
protected span (S : Set A) : SubDPIdeal hI := sInf {J : SubDPIdeal hI | S ⊆ J.carrier} | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | span | `I` is a sub-dp-ideal of itself. -/
instance : Top (SubDPIdeal hI) :=
⟨{carrier := I
isSubideal := le_refl _
dpow_mem := fun _ hn _ hx ↦ hI.dpow_mem hn hx }⟩
instance inhabited : Inhabited hI.SubDPIdeal := ⟨⊤⟩
/-- `(0)` is a sub-dp-ideal of the dp-ideal `I`. -/
instance : Bot (SubDPIdeal hI) :=
⟨{carrier := ⊥
isSubideal := bot_le
dpow_mem := fun _ hn x hx ↦ by rw [mem_bot.mp hx, hI.dpow_eval_zero hn, mem_bot]}⟩
/-- The intersection of two sub-dp-ideals is a sub-dp-ideal. -/
instance : Min (SubDPIdeal hI) :=
⟨fun J J' ↦
{ carrier := J.carrier ⊓ J'.carrier
isSubideal := fun _ hx ↦ J.isSubideal hx.1
dpow_mem := fun _ hn x hx ↦ ⟨J.dpow_mem _ hn x hx.1, J'.dpow_mem _ hn x hx.2⟩ }⟩
theorem inf_carrier_def (J J' : SubDPIdeal hI) : (J ⊓ J').carrier = J.carrier ⊓ J'.carrier := rfl
instance : InfSet (SubDPIdeal hI) :=
⟨fun S ↦
{ carrier := ⨅ s ∈ Insert.insert ⊤ S, (s : hI.SubDPIdeal).carrier
isSubideal := fun x hx ↦ by
simp only [mem_iInf] at hx
exact hx ⊤ (Set.mem_insert ⊤ S)
dpow_mem := fun _ hn x hx ↦ by
simp only [mem_iInf] at hx ⊢
exact fun s hs ↦ s.dpow_mem _ hn x (hx s hs) }⟩
theorem sInf_carrier_def (S : Set (SubDPIdeal hI)) :
(sInf S).carrier = ⨅ s ∈ Insert.insert ⊤ S, (s : hI.SubDPIdeal).carrier := rfl
instance : Max (SubDPIdeal hI) :=
⟨fun J J' ↦ SubDPIdeal.mk' (isSubDPIdeal_sup J.toIsSubDPIdeal J'.toIsSubDPIdeal)⟩
theorem sup_carrier_def (J J' : SubDPIdeal hI) : (J ⊔ J').carrier = J ⊔ J' := rfl
instance : SupSet (SubDPIdeal hI) :=
⟨fun S ↦ SubDPIdeal.mk' (J := sSup ((fun J ↦ J.carrier) '' S)) <| by
have h : (⋃ (i : Ideal A) (_ : i ∈ (fun J ↦ J.carrier) '' S), ↑i) ⊆ (I : Set A) := by
rintro a ⟨-, ⟨J, rfl⟩, haJ⟩
rw [Set.mem_iUnion, SetLike.mem_coe, exists_prop] at haJ
obtain ⟨J', hJ'⟩ := (Set.mem_image _ _ _).mp haJ.1
exact J'.isSubideal (hJ'.2 ▸ haJ.2)
rw [sSup_eq_iSup, Submodule.iSup_eq_span', submodule_span_eq, span_isSubDPIdeal_iff h]
rintro n hn x ⟨T, ⟨J, rfl⟩, ⟨J', ⟨⟨hJ', rfl⟩, h'⟩⟩⟩
apply subset_span
apply Set.mem_biUnion hJ'
obtain ⟨K, hKS, rfl⟩ := hJ'
exact K.dpow_mem _ hn x h'⟩
theorem sSup_carrier_def (S : Set (SubDPIdeal hI)) : (sSup S).carrier = sSup ((toIdeal) '' S) := rfl
instance : CompleteLattice (SubDPIdeal hI) := by
refine Function.Injective.completeLattice (fun J : SubDPIdeal hI ↦ (J : Set.Iic I))
(fun J J' h ↦ by simpa only [SubDPIdeal.ext_iff, Subtype.mk.injEq] using h) (fun J J' ↦ by rfl)
(fun J J' ↦ by rfl)
(fun S ↦ ?_) (fun S ↦ ?_) rfl rfl
· conv_rhs => rw [iSup]
rw [Subtype.ext_iff, Set.Iic.coe_sSup]
dsimp only
rw [sSup_carrier_def, sSup_image, sSup_image, iSup_range]
have (J : hI.SubDPIdeal) :
((⨆ (_ : J ∈ S), (J : Set.Iic I) : Set.Iic I) : Ideal A) = ⨆ (_ : J ∈ S), (J : Ideal A) := by
by_cases hJ : J ∈ S
· simp [ciSup_pos hJ]
· simp [hJ, not_false_eq_true, iSup_neg, Set.Iic.coe_bot]
simp_rw [this]
rfl
· conv_rhs => rw [iInf]
rw [Subtype.ext_iff, Set.Iic.coe_sInf]
dsimp only
rw [sInf_carrier_def, sInf_image, iInf_range, inf_iInf, iInf_insert, inf_iInf]
apply iInf_congr (fun J ↦ ?_)
by_cases hJ : J ∈ S
· rw [ciInf_pos hJ, ciInf_pos hJ]; rfl
· simp [hJ, iInf_neg, le_top, inf_of_le_left, Set.Iic.coe_top, le_refl]; rfl
end CompleteLattice
section Generated
variable (hI)
/-- The sub-dp-ideal of I generated by a family of elements of A. |
_root_.DividedPowers.dpow_span_isSubideal {S : Set A} (hS : S ⊆ I) :
span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x} ≤ I := by
rw [span_le]
rintro y ⟨n, hn, x, hx, hxy⟩
exact hxy ▸ hI.dpow_mem hn (hS hx) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | _root_.DividedPowers.dpow_span_isSubideal | null |
dpow_mem_span_of_mem_span {S : Set A} (hS : S ⊆ I) {k : ℕ} (hk : k ≠ 0)
{z : A} (hz : z ∈ span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x}) :
hI.dpow k z ∈ span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x} := by
let J := span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x}
have hSI := hI.dpow_span_isSubideal hS
have haux : ∀ (n : ℕ) (_ : n ≠ 0),
hI.dpow n z ∈ span {y | ∃ n, ∃ (_ : n ≠ 0), ∃ x, ∃ (_ : x ∈ S), y = hI.dpow n x} := by
refine Submodule.span_induction ?_ ?_ ?_ ?_ hz
· -- Elements of S
rintro y ⟨m, hm, x, hxS, hxy⟩ n hn
rw [hxy, hI.dpow_comp hm (hS hxS)]
exact mul_mem_left _ _ (subset_span ⟨n * m, mul_ne_zero hn hm, x, hxS, rfl⟩)
· -- Zero
exact fun _ hn ↦ by simp only [hI.dpow_eval_zero hn, zero_mem]
· intro x y hx hy hx_pow hy_pow n hn
rw [hI.dpow_add' (hSI hx) (hSI hy)]
apply Submodule.sum_mem (span _)
intro m _
by_cases hm0 : m = 0
· rw [hm0]; exact (span _).mul_mem_left _ (hy_pow n hn)
· exact (span _).mul_mem_right _ (hx_pow m hm0)
· intro a x hx hx_pow n hn
rw [smul_eq_mul, hI.dpow_mul (hSI hx)]
exact mul_mem_left (span _) (a ^ n) (hx_pow n hn)
exact haux _ hk | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_mem_span_of_mem_span | null |
span_carrier_eq_dpow_span {S : Set A} (hS : S ⊆ I) :
(SubDPIdeal.span hI S).carrier =
span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x} := by
set J : SubDPIdeal hI := {
carrier := span {y : A | ∃ (n : ℕ) (_ : n ≠ 0) (x : A) (_ : x ∈ S), y = hI.dpow n x }
isSubideal := hI.dpow_span_isSubideal hS
dpow_mem _ hk _ hz := dpow_mem_span_of_mem_span hI hS hk hz }
simp only [SubDPIdeal.span, sInf_carrier_def]
apply le_antisymm
· have h : J ∈ insert ⊤ {J : hI.SubDPIdeal | S ⊆ ↑J.carrier} :=
Set.mem_insert_of_mem _
(fun x hx ↦ subset_span ⟨1, one_ne_zero, x, hx, by rw [hI.dpow_one (hS hx)]⟩)
refine sInf_le_of_le ⟨J, ?_⟩ (le_refl _)
simp only [h, ciInf_pos, J]
· rw [le_iInf₂_iff]
intro K hK
have : S ≤ K := by
simp only [Set.mem_insert_iff, Set.mem_setOf_eq] at hK
rcases hK with rfl | hKS
exacts [hS, hKS]
rw [span_le]
rintro y ⟨n, hn, x, hx, rfl⟩
exact K.dpow_mem n hn x (this hx) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | span_carrier_eq_dpow_span | The underlying ideal of `SubDPIdeal.span hI S` is generated by the elements
of the form `hI.dpow n x` with `n > 0` and `x ∈ S`. |
isSubDPIdeal_ker {f : A →+* B} (hf : IsDPMorphism hI hJ f) :
IsSubDPIdeal hI (RingHom.ker f ⊓ I) := by
rw [isSubDPIdeal_inf_iff]
simp only [isDPMorphism_def] at hf
intro n a b ha hb
simp only [RingHom.sub_mem_ker_iff, ← hf.2 a ha, ← hf.2 b hb]
exact congr_arg _
open Ideal | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_ker | The kernel of a divided power morphism from `I` to `J` is a sub-dp-ideal of `I`. |
DPMorphism.ker (f : DPMorphism hI hJ) : SubDPIdeal hI where
carrier := RingHom.ker f.toRingHom ⊓ I
isSubideal := inf_le_right
dpow_mem _ hn a := by
simp only [mem_inf, and_imp, RingHom.mem_ker]
intro ha ha'
rw [← f.isDPMorphism.2 a ha', ha]
exact ⟨dpow_eval_zero hJ hn, hI.dpow_mem hn ha'⟩ | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | DPMorphism.ker | The kernel of a divided power morphism, as a `SubDPIdeal`. |
subDPIdeal_inf_of_quot {A : Type*} [CommRing A] {I : Ideal A} {hI : DividedPowers I}
{J : Ideal A} {hJ : DividedPowers (I.map (Ideal.Quotient.mk J))} {φ : DPMorphism hI hJ}
(hφ : φ.toRingHom = Ideal.Quotient.mk J) :
SubDPIdeal hI where
carrier := J ⊓ I
isSubideal := by simp only [inf_le_right]
dpow_mem := fun _ hn a ⟨haJ, haI⟩ ↦ by
refine ⟨?_, hI.dpow_mem hn haI⟩
rw [SetLike.mem_coe, ← Quotient.eq_zero_iff_mem, ← hφ, ← φ.dpow_comp a haI]
suffices ha0 : φ.toRingHom a = 0 by
rw [ha0, hJ.dpow_eval_zero hn]
rw [hφ, Quotient.eq_zero_iff_mem]
exact haJ | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | subDPIdeal_inf_of_quot | The ideal of `A` in which the two divided power structures `hI` and `hI'` coincide. -/
-- TODO : prove that this is the largest ideal which is a sub-dp-ideal in both `hI` and `hI'`.
def dpEqualizer : Ideal A where
carrier := { a ∈ I | ∀ n : ℕ, hI.dpow n a = hI'.dpow n a }
add_mem' {a b} ha hb := by
apply And.intro (I.add_mem ha.1 hb.1) (fun n ↦ ?_)
rw [hI.dpow_add ha.1 hb.1, hI'.dpow_add ha.1 hb.1]
exact Finset.sum_congr rfl (fun k _ ↦ by rw [ha.2, hb.2])
zero_mem' := by
apply And.intro I.zero_mem (fun n ↦ ?_)
by_cases hn : n = 0
· rw [hn, hI.dpow_zero (zero_mem I), hI'.dpow_zero (zero_mem I)]
· rw [hI.dpow_eval_zero hn, hI'.dpow_eval_zero hn]
smul_mem' a x hx := by
rw [Algebra.id.smul_eq_mul]
exact ⟨I.mul_mem_left a hx.1, (fun n ↦ by rw [hI.dpow_mul hx.1, hI'.dpow_mul hx.1, hx.2])⟩
theorem mem_dpEqualizer_iff {x : A} :
x ∈ dpEqualizer hI hI' ↔ x ∈ I ∧ ∀ n : ℕ, hI.dpow n x = hI'.dpow n x := by
simp [dpEqualizer, Submodule.mem_mk, AddSubmonoid.mem_mk, AddSubsemigroup.mem_mk,
Set.mem_setOf_eq]
theorem dpEqualizer_is_dp_ideal_left :
DividedPowers.IsSubDPIdeal hI (dpEqualizer hI hI') :=
IsSubDPIdeal.mk (fun _ hx ↦ hx.1) (fun _ hn x hx ↦ ⟨hI.dpow_mem hn hx.1,
fun m ↦ by rw [hI.dpow_comp hn hx.1, hx.2, hx.2, hI'.dpow_comp hn hx.1]⟩)
theorem dpEqualizer_is_dp_ideal_right :
DividedPowers.IsSubDPIdeal hI' (dpEqualizer hI hI') :=
IsSubDPIdeal.mk (fun _ hx ↦ hx.1) (fun _ hn x hx ↦ ⟨hI'.dpow_mem hn hx.1, fun m ↦ by
rw [← hx.2, hI.dpow_comp hn hx.1, hx.2, hx.2, hI'.dpow_comp hn hx.1]⟩)
open Ideal
theorem le_equalizer_of_isDPMorphism {B : Type*} [CommSemiring B] (f : A →+* B)
{K : Ideal B} (hI_le_K : Ideal.map f I ≤ K)
(hK hK' : DividedPowers K) (hIK : IsDPMorphism hI hK f) (hIK' : IsDPMorphism hI hK' f) :
Ideal.map f I ≤ dpEqualizer hK hK' := by
rw [Ideal.map, span_le]
rintro b ⟨a, ha, rfl⟩
exact ⟨hI_le_K (mem_map_of_mem f ha), fun n ↦ by rw [hIK.2 a ha, hIK'.2 a ha]⟩
/-- If there is a divided power structure on `I⬝(A/J)` such that the quotient map is
a dp-morphism, then `J ⊓ I` is a sub-dp-ideal of `I`. |
noncomputable dpow : ℕ → B → B := fun n ↦
Function.extend (fun a ↦ f a : I → B) (fun a ↦ f (hI.dpow n a) : I → B) 0
variable {f} (hf : Function.Surjective f) {J} (hIJ : J = I.map f)
(hIf : hI.IsSubDPIdeal (RingHom.ker f ⊓ I)) | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow | The definition of divided powers on the codomain `B` of a surjective ring homomorphism
from a ring `A` with divided powers `hI`. This definition is tagged as noncomputable
because it makes use of `Function.extend`, but under the hypothesis
`IsSubDPIdeal hI (RingHom.ker f ⊓ I)`, `dividedPowers_unique` proves that no choices are
involved. |
dpow_apply' (hIf : IsSubDPIdeal hI (RingHom.ker f ⊓ I)) {n : ℕ} {a : A} (ha : a ∈ I) :
dpow hI f n (f a) = f (hI.dpow n a) := by
classical
simp only [dpow, Function.extend_def]
have h : ∃ (a_1 : I), f ↑a_1 = f a := by use ⟨a, ha⟩
rw [dif_pos h, ← sub_eq_zero, ← map_sub, ← RingHom.mem_ker]
apply (hI.isSubDPIdeal_inf_iff.mp hIf) (Submodule.coe_mem _) ha
rw [RingHom.mem_ker, map_sub, sub_eq_zero, h.choose_spec]
open Ideal | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_apply' | Divided powers on the the codomain `B` of a surjective ring homomorphism `f` are compatible
with `f`. |
noncomputable dividedPowers : DividedPowers J where
dpow := dpow hI f
dpow_null n {x} hx' := by
classical
rw [dpow, Function.extend_def, dif_neg, Pi.zero_apply]
rintro ⟨⟨a, ha⟩, rfl⟩
exact (hIJ ▸ hx') (apply_coe_mem_map f I ⟨a, ha⟩)
dpow_zero {x} hx := by
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
rw [dpow_apply' hI hIf ha, hI.dpow_zero ha, map_one]
dpow_one {x} hx := by
obtain ⟨a, ha, hax⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
rw [← hax, dpow_apply' hI hIf ha, hI.dpow_one ha]
dpow_mem {n x} hn hx := by
rw [hIJ] at hx ⊢
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp hx
rw [dpow_apply' hI hIf ha]
exact mem_map_of_mem _ (hI.dpow_mem hn ha)
dpow_add hx hy := by
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
obtain ⟨b, hb, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hy)
rw [← map_add, dpow_apply' hI hIf (I.add_mem ha hb), hI.dpow_add ha hb, map_sum,
Finset.sum_congr rfl]
exact fun k _ ↦ by rw [dpow_apply' hI hIf ha, dpow_apply' hI hIf hb, ← _root_.map_mul]
dpow_mul {n x y} hy := by
obtain ⟨a, rfl⟩ := hf x
obtain ⟨b, hb, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hy)
rw [dpow_apply' hI hIf hb, ← _root_.map_mul, ← map_pow,
dpow_apply' hI hIf (mul_mem_left I a hb), hI.dpow_mul hb, _root_.map_mul]
mul_dpow hx := by
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
simp only [dpow_apply' hI hIf ha]
rw [← _root_.map_mul, hI.mul_dpow ha, _root_.map_mul, map_natCast]
dpow_comp hn hx := by
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
simp only [dpow_apply' hI hIf, ha, hI.dpow_mem hn ha]
rw [hI.dpow_comp hn ha, _root_.map_mul, map_natCast] | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dividedPowers | When `f.ker ⊓ I` is a sub-dp-ideal of `I`, this is the induced divided power structure on
the ideal `I.map f` of the target. |
dpow_def {n : ℕ} {x : B} : (dividedPowers hI hf hIJ hIf).dpow n x = dpow hI f n x := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_def | null |
dpow_apply {n : ℕ} {a : A} (ha : a ∈ I) :
(dividedPowers hI hf hIJ hIf).dpow n (f a) = f (hI.dpow n a) := by
rw [dpow_def, dpow_apply' hI hIf ha] | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_apply | null |
isDPMorphism : IsDPMorphism hI (dividedPowers hI hf hIJ hIf) f :=
⟨le_of_eq hIJ.symm, fun a ha ↦ by rw [dpow_apply hI hf hIJ hIf ha]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isDPMorphism | null |
dividedPowers_unique (hquot : DividedPowers J)
(hm : DividedPowers.IsDPMorphism hI hquot f) : hquot = dividedPowers hI hf hIJ hIf :=
ext _ _ fun n x hx ↦ by
obtain ⟨a, ha, rfl⟩ := (mem_map_iff_of_surjective f hf).mp (hIJ ▸ hx)
rw [hm.2 a ha, dpow_apply hI hf hIJ hIf ha] | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dividedPowers_unique | null |
noncomputable dpow (J : Ideal A) : ℕ → A ⧸ J → A ⧸ J :=
DividedPowers.Quotient.OfSurjective.dpow hI (Ideal.Quotient.mk J) | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow | The definition of divided powers on `A ⧸ J`. Tagged as noncomputable because it makes use of
`Function.extend`, but under `IsSubDPIdeal hI (J ⊓ I)`, `dividedPowers_unique` proves that no
choices are involved. |
private isSubDPIdeal_aux (hIJ : IsSubDPIdeal hI (J ⊓ I)) :
IsSubDPIdeal hI (RingHom.ker (Ideal.Quotient.mk J) ⊓ I) := by
simpa [Ideal.mk_ker] using hIJ | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isSubDPIdeal_aux | null |
noncomputable dividedPowers : DividedPowers (I.map (Ideal.Quotient.mk J)) :=
DividedPowers.Quotient.OfSurjective.dividedPowers
hI Ideal.Quotient.mk_surjective (refl _) (isSubDPIdeal_aux hI hIJ) | def | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dividedPowers | When `I ⊓ J` is a sub-dp-ideal of `I`, this is the divided power structure on the ideal
`I(A⧸J)` of the quotient. |
dpow_apply {n : ℕ} {a : A} (ha : a ∈ I) :
(dividedPowers hI hIJ).dpow n (Ideal.Quotient.mk J a) = (Ideal.Quotient.mk J) (hI.dpow n a) :=
DividedPowers.Quotient.OfSurjective.dpow_apply
hI Ideal.Quotient.mk_surjective (refl _) (isSubDPIdeal_aux hI hIJ) ha | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dpow_apply | Divided powers on the quotient are compatible with quotient map |
isDPMorphism : hI.IsDPMorphism (dividedPowers hI hIJ) (Ideal.Quotient.mk J) :=
DividedPowers.Quotient.OfSurjective.isDPMorphism
hI Ideal.Quotient.mk_surjective (refl _) (isSubDPIdeal_aux hI hIJ) | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | isDPMorphism | null |
dividedPowers_unique (hquot : DividedPowers (I.map (Ideal.Quotient.mk J)))
(hm : DividedPowers.IsDPMorphism hI hquot (Ideal.Quotient.mk J)) :
hquot = dividedPowers hI hIJ :=
DividedPowers.Quotient.OfSurjective.dividedPowers_unique
hI Ideal.Quotient.mk_surjective (refl _) (isSubDPIdeal_aux hI hIJ) hquot hm | theorem | RingTheory | [
"Mathlib.RingTheory.DividedPowers.DPMorphism",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/DividedPowers/SubDPIdeal.lean | dividedPowers_unique | null |
@[mk_iff, stacks 00UQ]
FormallyEtale : Prop where
comp_bijective :
∀ ⦃B : Type u⦄ [CommRing B],
∀ [Algebra R B] (I : Ideal B) (_ : I ^ 2 = ⊥),
Function.Bijective ((Ideal.Quotient.mkₐ R I).comp : (A →ₐ[R] B) → A →ₐ[R] B ⧸ I) | class | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | FormallyEtale | An `R` algebra `A` is formally étale if for every `R`-algebra, every square-zero ideal
`I : Ideal B` and `f : A →ₐ[R] B ⧸ I`, there exists exactly one lift `A →ₐ[R] B`. |
iff_unramified_and_smooth :
FormallyEtale R A ↔ FormallyUnramified R A ∧ FormallySmooth R A := by
rw [FormallyUnramified.iff_comp_injective, formallySmooth_iff, formallyEtale_iff]
simp_rw [← forall_and, Function.Bijective] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | iff_unramified_and_smooth | null |
of_unramified_and_smooth [h₁ : FormallyUnramified R A]
[h₂ : FormallySmooth R A] : FormallyEtale R A :=
FormallyEtale.iff_unramified_and_smooth.mpr ⟨h₁, h₂⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | of_unramified_and_smooth | null |
of_equiv [FormallyEtale R A] (e : A ≃ₐ[R] B) : FormallyEtale R B :=
FormallyEtale.iff_unramified_and_smooth.mpr
⟨FormallyUnramified.of_equiv e, FormallySmooth.of_equiv e⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | of_equiv | null |
iff_of_equiv (e : A ≃ₐ[R] B) : FormallyEtale R A ↔ FormallyEtale R B :=
⟨fun _ ↦ of_equiv e, fun _ ↦ of_equiv e.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | iff_of_equiv | null |
comp [FormallyEtale R A] [FormallyEtale A B] : FormallyEtale R B :=
FormallyEtale.iff_unramified_and_smooth.mpr
⟨FormallyUnramified.comp R A B, FormallySmooth.comp R A B⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | comp | null |
base_change [FormallyEtale R A] : FormallyEtale B (B ⊗[R] A) :=
FormallyEtale.iff_unramified_and_smooth.mpr ⟨inferInstance, inferInstance⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | base_change | null |
of_isLocalization : FormallyEtale R Rₘ :=
FormallyEtale.iff_unramified_and_smooth.mpr
⟨FormallyUnramified.of_isLocalization M, FormallySmooth.of_isLocalization M⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | of_isLocalization | null |
localization_base [FormallyEtale R Sₘ] : FormallyEtale Rₘ Sₘ :=
FormallyEtale.iff_unramified_and_smooth.mpr
⟨FormallyUnramified.localization_base M, FormallySmooth.localization_base M⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | localization_base | null |
localization_map [FormallyEtale R S] : FormallyEtale Rₘ Sₘ := by
haveI : FormallyEtale S Sₘ := FormallyEtale.of_isLocalization (M.map (algebraMap R S))
haveI : FormallyEtale R Sₘ := FormallyEtale.comp R S Sₘ
exact FormallyEtale.localization_base M | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | localization_map | The localization of a formally étale map is formally étale. |
@[stacks 00U1 "Note that this is a different definition from this Stacks entry, but
<https://stacks.math.columbia.edu/tag/00UR> shows that it is equivalent to the definition here."]
Etale : Prop where
formallyEtale : FormallyEtale R A := by infer_instance
finitePresentation : FinitePresentation R A := by infer_instance | class | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | Etale | An `R`-algebra `A` is étale if it is formally étale and of finite presentation. |
of_equiv [Etale R A] (e : A ≃ₐ[R] B) : Etale R B where
formallyEtale := FormallyEtale.of_equiv e
finitePresentation := FinitePresentation.equiv e | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | of_equiv | Being étale is transported via algebra isomorphisms. |
comp [Algebra A B] [IsScalarTower R A B] [Etale R A] [Etale A B] : Etale R B where
formallyEtale := FormallyEtale.comp R A B
finitePresentation := FinitePresentation.trans R A B | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | comp | Étale is stable under composition. |
baseChange [Etale R A] : Etale B (B ⊗[R] A) where | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | baseChange | Étale is stable under base change. |
of_isLocalization_Away (r : R) [IsLocalization.Away r A] : Etale R A where
formallyEtale := Algebra.FormallyEtale.of_isLocalization (Submonoid.powers r)
finitePresentation := IsLocalization.Away.finitePresentation r | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | of_isLocalization_Away | Localization at an element is étale. |
@[algebraize Algebra.FormallyEtale]
FormallyEtale (f : R →+* S) : Prop :=
letI := f.toAlgebra
Algebra.FormallyEtale R S | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | FormallyEtale | A ring homomorphism `R →+* A` is formally étale if it is formally unramified and formally smooth.
See `Algebra.FormallyEtale`. |
formallyEtale_algebraMap [Algebra R S] :
(algebraMap R S).FormallyEtale ↔ Algebra.FormallyEtale R S := by
rw [FormallyEtale, toAlgebra_algebraMap] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Etale/Basic.lean | formallyEtale_algebraMap | null |
of_isSeparable_aux [Algebra.IsSeparable K L] [EssFiniteType K L] :
FormallyEtale K L := by
have := FormallyUnramified.of_isSeparable K L
have := FormallyUnramified.finite_of_free (R := K) (S := L)
constructor
intro B _ _ I h
refine ⟨FormallyUnramified.iff_comp_injective.mp (FormallyUnramified.of_isSeparable K L) I h, ?_⟩
intro f
let pb := Field.powerBasisOfFiniteOfSeparable K L
obtain ⟨x, hx⟩ := Ideal.Quotient.mk_surjective (f pb.gen)
have helper : ∀ x, IsScalarTower.toAlgHom K B (B ⧸ I) x = Ideal.Quotient.mk I x := fun _ ↦ rfl
have hx' : Ideal.Quotient.mk I (aeval x (minpoly K pb.gen)) = 0 := by
rw [← helper, ← aeval_algHom_apply, helper, hx, aeval_algHom_apply, minpoly.aeval, map_zero]
obtain ⟨u, hu⟩ : ∃ u, (aeval x) (derivative (minpoly K pb.gen)) * u + 1 ∈ I := by
have := (isUnit_iff_ne_zero.mpr ((Algebra.IsSeparable.isSeparable K
pb.gen).aeval_derivative_ne_zero (minpoly.aeval K _))).map f
rw [← aeval_algHom_apply, ← hx, ← helper, aeval_algHom_apply, helper] at this
obtain ⟨u, hu⟩ := Ideal.Quotient.mk_surjective (-this.unit⁻¹ : B ⧸ I)
use u
rw [← Ideal.Quotient.eq_zero_iff_mem, map_add, map_mul, map_one, hu, mul_neg,
IsUnit.mul_val_inv, neg_add_cancel]
use pb.liftEquiv.symm ⟨x + u * aeval x (minpoly K pb.gen), ?_⟩
· apply pb.algHom_ext
simp [hx, hx']
· rw [← eval_map_algebraMap, Polynomial.eval_add_of_sq_eq_zero, derivative_map,
← one_mul (eval x _), eval_map_algebraMap, eval_map_algebraMap, ← mul_assoc, ← add_mul,
← Ideal.mem_bot, ← h, pow_two, add_comm]
· exact Ideal.mul_mem_mul hu (Ideal.Quotient.eq_zero_iff_mem.mp hx')
rw [← Ideal.mem_bot, ← h]
apply Ideal.pow_mem_pow
rw [← Ideal.Quotient.eq_zero_iff_mem, map_mul, hx', mul_zero]
open scoped IntermediateField in | theorem | RingTheory | [
"Mathlib.RingTheory.Etale.Pi",
"Mathlib.RingTheory.Unramified.Field"
] | Mathlib/RingTheory/Etale/Field.lean | of_isSeparable_aux | This is a weaker version of `of_isSeparable` that additionally assumes `EssFiniteType K L`.
Use that instead.
This is Iversen Corollary II.5.3. |
of_isSeparable [Algebra.IsSeparable K L] : FormallyEtale K L := by
constructor
intro B _ _ I h
refine ⟨FormallyUnramified.iff_comp_injective.mp (FormallyUnramified.of_isSeparable K L) I h, ?_⟩
intro f
have : ∀ k : L, ∃! g : K⟮k⟯ →ₐ[K] B,
(Ideal.Quotient.mkₐ K I).comp g = f.comp (IsScalarTower.toAlgHom K _ L) := by
intro k
have := IsSeparable.of_algHom _ _ (IsScalarTower.toAlgHom K (K⟮k⟯) L)
have := IntermediateField.adjoin.finiteDimensional
(Algebra.IsSeparable.isSeparable K k).isIntegral
have := FormallyEtale.of_isSeparable_aux K (K⟮k⟯)
have := FormallyEtale.comp_bijective (R := K) (A := K⟮k⟯) I h
exact this.existsUnique _
choose g hg₁ hg₂ using this
have hg₃ : ∀ x y (h : x ∈ K⟮y⟯), g y ⟨x, h⟩ = g x (IntermediateField.AdjoinSimple.gen K x) := by
intro x y h
have e : K⟮x⟯ ≤ K⟮y⟯ := by
rw [IntermediateField.adjoin_le_iff]
rintro _ rfl
exact h
rw [← hg₂ _ ((g _).comp (IntermediateField.inclusion e))]
· rfl
apply AlgHom.ext
intro ⟨a, _⟩
rw [← AlgHom.comp_assoc, hg₁, AlgHom.comp_assoc]
simp
have H : ∀ x y : L, ∃ α : L, x ∈ K⟮α⟯ ∧ y ∈ K⟮α⟯ := by
intro x y
have : FiniteDimensional K K⟮x, y⟯ := by
apply IntermediateField.finiteDimensional_adjoin
intro x _; exact (Algebra.IsSeparable.isSeparable K x).isIntegral
have := IsSeparable.of_algHom _ _ (IsScalarTower.toAlgHom K (K⟮x, y⟯) L)
obtain ⟨⟨α, hα⟩, e⟩ := Field.exists_primitive_element K K⟮x,y⟯
apply_fun (IntermediateField.map (IntermediateField.val _)) at e
rw [IntermediateField.adjoin_map, ← AlgHom.fieldRange_eq_map] at e
simp only [IntermediateField.coe_val, Set.image_singleton,
IntermediateField.fieldRange_val] at e
have hx : x ∈ K⟮α⟯ := e ▸ IntermediateField.subset_adjoin K {x, y} (by simp)
have hy : y ∈ K⟮α⟯ := e ▸ IntermediateField.subset_adjoin K {x, y} (by simp)
exact ⟨α, hx, hy⟩
refine ⟨⟨⟨⟨⟨fun x ↦ g x (IntermediateField.AdjoinSimple.gen K x), ?_⟩, ?_⟩, ?_, ?_⟩, ?_⟩, ?_⟩
· change g 1 1 = 1; rw [map_one]
· intro x y
obtain ⟨α, hx, hy⟩ := H x y
simp only [← hg₃ _ _ hx, ← hg₃ _ _ hy, ← map_mul, ← hg₃ _ _ (mul_mem hx hy)]
rfl
· change g 0 0 = 0; rw [map_zero]
· intro x y
obtain ⟨α, hx, hy⟩ := H x y
simp only [← hg₃ _ _ hx, ← hg₃ _ _ hy, ← map_add, ← hg₃ _ _ (add_mem hx hy)]
... | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Pi",
"Mathlib.RingTheory.Unramified.Field"
] | Mathlib/RingTheory/Etale/Field.lean | of_isSeparable | null |
iff_isSeparable [EssFiniteType K L] :
FormallyEtale K L ↔ Algebra.IsSeparable K L :=
⟨fun _ ↦ FormallyUnramified.isSeparable K L, fun _ ↦ of_isSeparable K L⟩
attribute [local instance] IsArtinianRing.fieldOfSubtypeIsMaximal in | theorem | RingTheory | [
"Mathlib.RingTheory.Etale.Pi",
"Mathlib.RingTheory.Unramified.Field"
] | Mathlib/RingTheory/Etale/Field.lean | iff_isSeparable | null |
iff_exists_algEquiv_prod [EssFiniteType K A] :
FormallyEtale K A ↔
∃ (I : Type u) (_ : Finite I) (Ai : I → Type u) (_ : ∀ i, Field (Ai i))
(_ : ∀ i, Algebra K (Ai i)) (_ : A ≃ₐ[K] Π i, Ai i),
∀ i, Algebra.IsSeparable K (Ai i) := by
classical
constructor
· intro H
have := FormallyUnramified.finite_of_free K A
have := FormallyUnramified.isReduced_of_field K A
have : IsArtinianRing A := isArtinian_of_tower K inferInstance
letI : Fintype (MaximalSpectrum A) := (nonempty_fintype _).some
let v (i : MaximalSpectrum A) : A := (IsArtinianRing.equivPi A).symm (Pi.single i 1)
let e : A ≃ₐ[K] _ := { __ := IsArtinianRing.equivPi A, commutes' := fun r ↦ rfl }
have := (FormallyEtale.iff_of_equiv e).mp inferInstance
rw [FormallyEtale.pi_iff] at this
exact ⟨_, inferInstance, _, _, _, e, fun I ↦ (iff_isSeparable _ _).mp inferInstance⟩
· intro ⟨I, _, Ai, _, _, e, _⟩
rw [FormallyEtale.iff_of_equiv e, FormallyEtale.pi_iff]
exact fun I ↦ of_isSeparable K (Ai I) | theorem | RingTheory | [
"Mathlib.RingTheory.Etale.Pi",
"Mathlib.RingTheory.Unramified.Field"
] | Mathlib/RingTheory/Etale/Field.lean | iff_exists_algEquiv_prod | If `A` is an essentially of finite type algebra over a field `K`, then `A` is formally étale
over `K` if and only if `A` is a finite product of separable field extensions. |
Algebra.Etale.iff_exists_algEquiv_prod :
Etale K A ↔
∃ (I : Type u) (_ : Finite I) (Ai : I → Type u) (_ : ∀ i, Field (Ai i))
(_ : ∀ i, Algebra K (Ai i)) (_ : A ≃ₐ[K] Π i, Ai i),
∀ i, Module.Finite K (Ai i) ∧ Algebra.IsSeparable K (Ai i) := by
constructor
· intro H
obtain ⟨I, _, Ai, _, _, e, _⟩ := (FormallyEtale.iff_exists_algEquiv_prod K A).mp inferInstance
have := FormallyUnramified.finite_of_free K A
exact ⟨_, ‹_›, _, _, _, e, fun i ↦ ⟨.of_surjective ((LinearMap.proj i).comp e.toLinearMap)
((Function.surjective_eval i).comp e.surjective), inferInstance⟩⟩
· intro ⟨I, _, Ai, _, _, e, H⟩
choose h₁ h₂ using H
have := Module.Finite.of_surjective e.symm.toLinearMap e.symm.surjective
refine ⟨?_, FinitePresentation.of_finiteType.mp inferInstance⟩
exact (FormallyEtale.iff_exists_algEquiv_prod K A).mpr ⟨_, inferInstance, _, _, _, e, h₂⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Etale.Pi",
"Mathlib.RingTheory.Unramified.Field"
] | Mathlib/RingTheory/Etale/Field.lean | Algebra.Etale.iff_exists_algEquiv_prod | `A` is étale over a field `K` if and only if
`A` is a finite product of finite separable field extensions. |
@[simps! apply] noncomputable
KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale [Algebra.FormallyEtale S T] :
T ⊗[S] Ω[S⁄R] ≃ₗ[T] Ω[T⁄R] := by
refine LinearEquiv.ofBijective (mapBaseChange R S T)
⟨?_, fun x ↦ (KaehlerDifferential.exact_mapBaseChange_map R S T x).mp (Subsingleton.elim _ _)⟩
rw [injective_iff_map_eq_zero]
intro x hx
obtain ⟨x, rfl⟩ := (Algebra.H1Cotangent.exact_δ_mapBaseChange R S T x).mp hx
rw [Subsingleton.elim x 0, map_zero] | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale | The canonical isomorphism `T ⊗[S] Ω[S⁄R] ≃ₗ[T] Ω[T⁄R]` for `T` a formally étale `S`-algebra.
Also see `S ⊗[R] Ω[A⁄R] ≃ₗ[S] Ω[S ⊗[R] A⁄S]` at `KaehlerDifferential.tensorKaehlerEquiv`. |
KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale_symm_D_algebraMap
[Algebra.FormallyEtale S T] (s : S) :
(tensorKaehlerEquivOfFormallyEtale R S T).symm (D R T (algebraMap S T s)) = 1 ⊗ₜ D R S s := by
rw [LinearEquiv.symm_apply_eq, tensorKaehlerEquivOfFormallyEtale_apply, mapBaseChange_tmul,
one_smul, map_D] | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale_symm_D_algebraMap | null |
KaehlerDifferential.isBaseChange_of_formallyEtale [Algebra.FormallyEtale S T] :
IsBaseChange T (map R R S T) := by
change Function.Bijective _
convert (tensorKaehlerEquivOfFormallyEtale R S T).bijective using 1
change _ = ((tensorKaehlerEquivOfFormallyEtale
R S T).toLinearMap.restrictScalars S : T ⊗[S] Ω[S⁄R] → _)
congr!
ext
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | KaehlerDifferential.isBaseChange_of_formallyEtale | null |
KaehlerDifferential.isLocalizedModule_map (M : Submonoid S) [IsLocalization M T] :
IsLocalizedModule M (map R R S T) :=
have := Algebra.FormallyEtale.of_isLocalization (Rₘ := T) M
(isLocalizedModule_iff_isBaseChange M T _).mpr (isBaseChange_of_formallyEtale R S T) | instance | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | KaehlerDifferential.isLocalizedModule_map | null |
noncomputable
tensorCotangentSpace
(H : f.toRingHom.FormallyEtale) :
T ⊗[S] P.CotangentSpace ≃ₗ[T] Q.CotangentSpace :=
letI := f.toRingHom.toAlgebra
haveI : IsScalarTower R P.Ring Q.Ring :=
.of_algebraMap_eq fun r ↦ (f.toRingHom_algebraMap r).symm
letI := ((algebraMap S T).comp (algebraMap P.Ring S)).toAlgebra
haveI : IsScalarTower P.Ring S T := .of_algebraMap_eq' rfl
haveI : IsScalarTower P.Ring Q.Ring T :=
.of_algebraMap_eq fun r ↦ (f.algebraMap_toRingHom r).symm
haveI : FormallyEtale P.Ring Q.Ring := ‹_›
{ __ := (CotangentSpace.map f).liftBaseChange T
invFun := LinearMap.liftBaseChange T (by
refine LinearMap.liftBaseChange _ ?_ ∘ₗ
(tensorKaehlerEquivOfFormallyEtale R P.Ring Q.Ring).symm.toLinearMap
exact (TensorProduct.mk _ _ _ 1).restrictScalars P.Ring ∘ₗ
(TensorProduct.mk _ _ _ 1).restrictScalars P.Ring)
left_inv x := by
change (LinearMap.liftBaseChange _ _ ∘ₗ LinearMap.liftBaseChange _ _) x =
LinearMap.id (R := T) x
congr 1
ext : 4
refine Derivation.liftKaehlerDifferential_unique
(R := R) (S := P.Ring) (M := T ⊗[S] P.CotangentSpace) _ _ ?_
ext a
have : (tensorKaehlerEquivOfFormallyEtale R P.Ring Q.Ring).symm
((D R Q.Ring) (f.toRingHom a)) = 1 ⊗ₜ D _ _ a :=
tensorKaehlerEquivOfFormallyEtale_symm_D_algebraMap R P.Ring Q.Ring a
simp [this]
right_inv x := by
change (LinearMap.liftBaseChange _ _ ∘ₗ LinearMap.liftBaseChange _ _) x =
LinearMap.id (R := T) x
congr 1
ext a
dsimp
obtain ⟨x, hx⟩ := (tensorKaehlerEquivOfFormallyEtale R P.Ring _).surjective (D R Q.Ring a)
simp only [one_smul, ← hx, LinearEquiv.symm_apply_apply]
change (((CotangentSpace.map f).liftBaseChange T).restrictScalars Q.Ring ∘ₗ
LinearMap.liftBaseChange _ _) x = ((TensorProduct.mk _ _ _ 1) ∘ₗ
(tensorKaehlerEquivOfFormallyEtale R P.Ring Q.Ring).toLinearMap) x
congr 1
ext a
simp; rfl } | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorCotangentSpace | If `P → Q` is formally étale, then `T ⊗ₛ (S ⊗ₚ Ω[P/R]) ≃ T ⊗_Q Ω[Q/R]`. |
noncomputable
tensorCotangentInvFun
[alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
(H : Function.Bijective ((f.mapKer halg).liftBaseChange Q.Ring)) :
Q.Cotangent →+ T ⊗[S] P.Cotangent :=
letI := ((algebraMap S T).comp (algebraMap P.Ring S)).toAlgebra
haveI : IsScalarTower P.Ring S T := .of_algebraMap_eq' rfl
haveI : IsScalarTower P.Ring Q.Ring T :=
.of_algebraMap_eq fun r ↦ halg ▸ (f.algebraMap_toRingHom r).symm
letI e := LinearEquiv.ofBijective _ H
letI f' : Q.ker →ₗ[Q.Ring] T ⊗[S] P.Cotangent :=
(LinearMap.liftBaseChange _
((TensorProduct.mk _ _ _ 1).restrictScalars _ ∘ₗ Cotangent.mk)) ∘ₗ e.symm.toLinearMap
QuotientAddGroup.lift _ f' <| by
intro x hx
refine Submodule.smul_induction_on hx ?_ fun _ _ ↦ add_mem
clear x hx
rintro a ha b -
obtain ⟨x, hx⟩ := e.surjective ⟨a, ha⟩
obtain rfl : (e x).1 = a := congr_arg Subtype.val hx
obtain ⟨y, rfl⟩ := e.surjective b
simp only [AddMonoidHom.mem_ker, AddMonoidHom.coe_coe, map_smul,
LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply,
LinearEquiv.symm_apply_apply, f']
clear hx ha
induction x with
| zero => simp only [LinearEquiv.map_zero, ZeroMemClass.coe_zero, zero_smul]
| add x y _ _ =>
simp only [LinearEquiv.map_add, Submodule.coe_add, add_smul, zero_add, *]
| tmul a b =>
induction y with
| zero => simp only [LinearMap.map_zero, smul_zero]
| add x y hx hy => simp only [LinearMap.map_add, smul_add, hx, hy, zero_add]
| tmul c d =>
simp only [LinearMap.liftBaseChange_tmul, LinearMap.coe_comp, SetLike.val_smul,
LinearMap.coe_restrictScalars, Function.comp_apply, mk_apply, smul_eq_mul, e,
LinearMap.liftBaseChange_tmul, LinearEquiv.ofBijective_apply]
have h₂ : b.1 • Cotangent.mk d = 0 := by ext; simp [Cotangent.smul_eq_zero_of_mem _ b.2]
rw [TensorProduct.smul_tmul', mul_smul, f.mapKer_apply_coe, ← halg,
algebraMap_smul, ← TensorProduct.tmul_smul, h₂, tmul_zero, smul_zero]
omit [IsScalarTower R S T] in | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorCotangentInvFun | (Implementation)
If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`.
This is the inverse. |
tensorCotangentInvFun_smul_mk
[alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
(H : Function.Bijective ((f.mapKer halg).liftBaseChange Q.Ring)) (x : Q.Ring) (y : P.ker) :
tensorCotangentInvFun f halg H (x • .mk ⟨f.toRingHom y, (f.mapKer halg y).2⟩) =
x • 1 ⊗ₜ .mk y := by
letI := ((algebraMap S T).comp (algebraMap P.Ring S)).toAlgebra
haveI : IsScalarTower P.Ring S T := .of_algebraMap_eq' rfl
haveI : IsScalarTower P.Ring Q.Ring T :=
.of_algebraMap_eq fun r ↦ halg ▸ (f.algebraMap_toRingHom r).symm
letI e := LinearEquiv.ofBijective _ H
trans tensorCotangentInvFun f halg H (.mk ((f.mapKer halg).liftBaseChange Q.Ring (x ⊗ₜ y)))
· simp; rfl
change ((TensorProduct.mk _ _ _ 1).restrictScalars _ ∘ₗ Cotangent.mk).liftBaseChange _
(e.symm (e (x ⊗ₜ y))) = _
rw [e.symm_apply_apply]
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorCotangentInvFun_smul_mk | null |
noncomputable
tensorCotangent [alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
(H : Function.Bijective ((f.mapKer halg).liftBaseChange Q.Ring)) :
T ⊗[S] P.Cotangent ≃ₗ[T] Q.Cotangent :=
{ __ := (Cotangent.map f).liftBaseChange T
invFun := tensorCotangentInvFun f halg H
left_inv x := by
simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom]
induction x with
| zero => simp only [map_zero]
| add x y _ _ => simp only [map_add, *]
| tmul a b =>
obtain ⟨b, rfl⟩ := Cotangent.mk_surjective b
obtain ⟨a, rfl⟩ := Q.algebraMap_surjective a
simp only [LinearMap.liftBaseChange_tmul, Cotangent.map_mk, Hom.toAlgHom_apply,
algebraMap_smul]
refine (tensorCotangentInvFun_smul_mk f halg H a b).trans ?_
simp [algebraMap_eq_smul_one, TensorProduct.smul_tmul']
right_inv x := by
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
obtain ⟨x, rfl⟩ := H.surjective x
simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom]
induction x with
| zero => simp only [map_zero]
| add x y _ _ => simp only [map_add, *]
| tmul a b =>
simp only [LinearMap.liftBaseChange_tmul, map_smul]
simp [Hom.mapKer, tensorCotangentInvFun_smul_mk] } | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorCotangent | If `J ≃ Q ⊗ₚ I` (e.g. when `T = Q ⊗ₚ S` and `P → Q` is flat), then `T ⊗ₛ I/I² ≃ J/J²`. |
noncomputable
tensorH1Cotangent [alg : Algebra P.Ring Q.Ring] (halg : algebraMap P.Ring Q.Ring = f.toRingHom)
[Module.Flat S T]
(H₁ : f.toRingHom.FormallyEtale)
(H₂ : Function.Bijective ((f.mapKer halg).liftBaseChange Q.Ring)) :
T ⊗[S] P.H1Cotangent ≃ₗ[T] Q.H1Cotangent := by
refine .ofBijective ((H1Cotangent.map f).liftBaseChange T) ?_
constructor
· rw [injective_iff_map_eq_zero]
intro x hx
apply Module.Flat.lTensor_preserves_injective_linearMap _ h1Cotangentι_injective
apply (Extension.tensorCotangent f halg H₂).injective
simp only [map_zero]
rw [← h1Cotangentι.map_zero, ← hx]
change ((Cotangent.map f).liftBaseChange T ∘ₗ h1Cotangentι.baseChange T) x =
(h1Cotangentι ∘ₗ _) x
congr 1
ext x
simp
· intro x
have : Function.Exact (h1Cotangentι.baseChange T) (P.cotangentComplex.baseChange T) :=
Module.Flat.lTensor_exact T (LinearMap.exact_subtype_ker_map _)
obtain ⟨a, ha⟩ := (this ((Extension.tensorCotangent f halg H₂).symm x.1)).mp (by
apply (Extension.tensorCotangentSpace f H₁).injective
rw [LinearEquiv.map_zero, ← x.2]
have : (CotangentSpace.map f).liftBaseChange T ∘ₗ P.cotangentComplex.baseChange T =
Q.cotangentComplex ∘ₗ (Cotangent.map f).liftBaseChange T := by
ext x; obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x; dsimp
simp only [CotangentSpace.map_tmul,
map_one, Hom.toAlgHom_apply, one_smul, cotangentComplex_mk]
exact (DFunLike.congr_fun this _).trans (DFunLike.congr_arg Q.cotangentComplex
((tensorCotangent f halg H₂).apply_symm_apply x.1)))
refine ⟨a, Subtype.ext (.trans ?_ ((LinearEquiv.eq_symm_apply _).mp ha))⟩
change (h1Cotangentι ∘ₗ (H1Cotangent.map f).liftBaseChange T) _ =
((Cotangent.map f).liftBaseChange T ∘ₗ h1Cotangentι.baseChange T) _
congr 1
ext; dsimp | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorH1Cotangent | If `J ≃ Q ⊗ₚ I`, `S → T` is flat and `P → Q` is formally étale, then `T ⊗ H¹(L_P) ≃ H¹(L_Q)`. |
noncomputable
tensorH1CotangentOfIsLocalization (M : Submonoid S) [IsLocalization M T] :
T ⊗[S] H1Cotangent R S ≃ₗ[T] H1Cotangent R T := by
letI P : Extension R S := (Generators.self R S).toExtension
letI M' := M.comap (algebraMap P.Ring S)
letI fQ : Localization M' →ₐ[R] T := IsLocalization.liftAlgHom (M := M')
(f := (IsScalarTower.toAlgHom R S T).comp (IsScalarTower.toAlgHom R P.Ring S)) (fun ⟨y, hy⟩ ↦
by simpa using IsLocalization.map_units T ⟨algebraMap P.Ring S y, hy⟩)
letI Q : Extension R T := .ofSurjective fQ (by
intro x
obtain ⟨x, ⟨s, hs⟩, rfl⟩ := IsLocalization.mk'_surjective M x
obtain ⟨x, rfl⟩ := P.algebraMap_surjective x
obtain ⟨s, rfl⟩ := P.algebraMap_surjective s
refine ⟨IsLocalization.mk' _ x ⟨s, show s ∈ M' from hs⟩, ?_⟩
simp only [fQ, IsLocalization.coe_liftAlgHom, AlgHom.toRingHom_eq_coe]
rw [IsLocalization.lift_mk'_spec]
simp)
letI f : P.Hom Q :=
{ toRingHom := algebraMap P.Ring (Localization M')
toRingHom_algebraMap x := (IsScalarTower.algebraMap_apply R P.Ring (Localization M') _).symm
algebraMap_toRingHom x := @IsLocalization.lift_eq .. }
haveI : FormallySmooth R P.Ring := inferInstanceAs (FormallySmooth R (MvPolynomial _ _))
haveI : FormallySmooth P.Ring (Localization M') := .of_isLocalization M'
haveI : FormallySmooth R Q.Ring := .comp R P.Ring (Localization M')
haveI : Module.Flat S T := IsLocalization.flat T M
letI : Algebra P.Ring Q.Ring := inferInstanceAs (Algebra P.Ring (Localization M'))
letI := ((algebraMap S T).comp (algebraMap P.Ring S)).toAlgebra
letI := fQ.toRingHom.toAlgebra
haveI : IsScalarTower P.Ring S T := .of_algebraMap_eq' rfl
haveI : IsScalarTower P.Ring (Localization M') T :=
.of_algebraMap_eq fun r ↦ (f.algebraMap_toRingHom r).symm
haveI : IsLocalizedModule M' (IsScalarTower.toAlgHom P.Ring S T).toLinearMap := by
rw [isLocalizedModule_iff_isLocalization]
convert ‹IsLocalization M T› using 1
exact Submonoid.map_comap_eq_of_surjective P.algebraMap_surjective _
refine Extension.tensorH1Cotangent f rfl ?_ ?_ ≪≫ₗ Extension.equivH1CotangentOfFormallySmooth _
· exact RingHom.formallyEtale_algebraMap.mpr
(FormallyEtale.of_isLocalization (M := M') (Rₘ := Localization M'))
· let F : P.ker →ₗ[P.Ring] RingHom.ker fQ := f.mapKer rfl
refine (isLocalizedModule_iff_isBaseChange M' (Localization M') F).mp ?_
have : (LinearMap.ker <| Algebra.linearMap P.Ring S).localized' (Localization M') M'
(Algebra.linearMap P.Ring (Localization M')) = RingHom.ker fQ := by
rw [LinearMap.localized'_ker_eq_ker_localizedMap (Localization M') M'
(Algebra.linearMap P.Ring (Localization M'))
(f' := (IsScalarTower.toAlgHom P.Ring S T).toLinearMap)]
ext x
obtain ⟨x, ⟨s, hs⟩, rfl⟩ := IsLocalization.mk'_surjective M' x
simp only [LinearMap.mem_ker, LinearMap.extendScalarsOfIsLocalization_apply', RingHom.mem_ker,
IsLocalization.coe_liftAlgHom, AlgHom.toRingHom_eq_coe, IsLocalization.lift_mk'_spec,
RingHom.coe_coe, AlgHom.coe_comp, IsScalarTower.coe_toAlgHom', Function.comp_apply,
mul_zero, fQ]
... | def | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorH1CotangentOfIsLocalization | let `p` be a submonoid of an `R`-algebra `S`. Then `Sₚ ⊗ H¹(L_{S/R}) ≃ H¹(L_{Sₚ/R})`. |
tensorH1CotangentOfIsLocalization_toLinearMap
(M : Submonoid S) [IsLocalization M T] :
(tensorH1CotangentOfIsLocalization R T M).toLinearMap =
(Algebra.H1Cotangent.map R R S T).liftBaseChange T := by
ext x : 3
simp only [AlgebraTensorModule.curry_apply, curry_apply, LinearMap.coe_restrictScalars,
LinearEquiv.coe_coe, LinearMap.liftBaseChange_tmul, one_smul]
simp only [tensorH1CotangentOfIsLocalization, Generators.toExtension_Ring,
Generators.toExtension_commRing, Generators.toExtension_algebra₂,
Extension.tensorH1Cotangent,
LinearEquiv.ofBijective_apply, LinearMap.liftBaseChange_tmul, one_smul,
Extension.equivH1CotangentOfFormallySmooth, LinearEquiv.trans_apply]
letI P : Extension R S := (Generators.self R S).toExtension
letI M' := M.comap (algebraMap P.Ring S)
letI fQ : Localization M' →ₐ[R] T := IsLocalization.liftAlgHom (M := M')
(f := (IsScalarTower.toAlgHom R S T).comp (IsScalarTower.toAlgHom R P.Ring S)) (fun ⟨y, hy⟩ ↦
by simpa using IsLocalization.map_units T ⟨algebraMap P.Ring S y, hy⟩)
letI Q : Extension R T := .ofSurjective fQ (by
intro x
obtain ⟨x, ⟨s, hs⟩, rfl⟩ := IsLocalization.mk'_surjective M x
obtain ⟨x, rfl⟩ := P.algebraMap_surjective x
obtain ⟨s, rfl⟩ := P.algebraMap_surjective s
refine ⟨IsLocalization.mk' _ x ⟨s, show s ∈ M' from hs⟩, ?_⟩
simp only [fQ, IsLocalization.coe_liftAlgHom, AlgHom.toRingHom_eq_coe]
rw [IsLocalization.lift_mk'_spec]
simp)
letI f : (Generators.self R T).toExtension.Hom Q :=
{ toRingHom := (MvPolynomial.aeval Q.σ).toRingHom
toRingHom_algebraMap := (MvPolynomial.aeval Q.σ).commutes
algebraMap_toRingHom := by
have : (IsScalarTower.toAlgHom R Q.Ring T).comp (MvPolynomial.aeval Q.σ) =
IsScalarTower.toAlgHom _ (Generators.self R T).toExtension.Ring _ := by
ext i
change _ = algebraMap (Generators.self R T).Ring _ (.X i)
simp
exact DFunLike.congr_fun this }
rw [← Extension.H1Cotangent.equivOfFormallySmooth_symm, LinearEquiv.symm_apply_eq,
@Extension.H1Cotangent.equivOfFormallySmooth_apply (f := f),
Algebra.H1Cotangent.map, ← (Extension.H1Cotangent.map f).coe_restrictScalars S,
← LinearMap.comp_apply, ← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | tensorH1CotangentOfIsLocalization_toLinearMap | null |
H1Cotangent.isLocalizedModule (M : Submonoid S) [IsLocalization M T] :
IsLocalizedModule M (Algebra.H1Cotangent.map R R S T) := by
rw [isLocalizedModule_iff_isBaseChange M T]
change Function.Bijective ((Algebra.H1Cotangent.map R R S T).liftBaseChange T)
rw [← tensorH1CotangentOfIsLocalization_toLinearMap R T M]
exact (tensorH1CotangentOfIsLocalization R T M).bijective | instance | RingTheory | [
"Mathlib.RingTheory.Etale.Basic",
"Mathlib.RingTheory.Kaehler.JacobiZariski",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Etale/Kaehler.lean | H1Cotangent.isLocalizedModule | null |
pi_iff [Finite I] :
FormallyEtale R (Π i, A i) ↔ ∀ i, FormallyEtale R (A i) := by
simp_rw [FormallyEtale.iff_unramified_and_smooth, forall_and]
rw [FormallyUnramified.pi_iff A, FormallySmooth.pi_iff A] | theorem | RingTheory | [
"Mathlib.RingTheory.Smooth.Pi",
"Mathlib.RingTheory.Unramified.Pi",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Etale/Pi.lean | pi_iff | null |
Algebra.Extension where
/-- The underlying algebra of an extension. -/
Ring : Type w
[commRing : CommRing Ring]
[algebra₁ : Algebra R Ring]
[algebra₂ : Algebra Ring S]
[isScalarTower : IsScalarTower R Ring S]
/-- A chosen (set-theoretic) section of an extension. -/
σ : S → Ring
algebraMap_σ : ∀ x, algebraMap Ring S (σ x) = x | structure | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Algebra.Extension | An extension of an `R`-algebra `S` is an `R` algebra `P` together with a surjection `P →ₐ[R] S`.
Also see `Algebra.Extension.ofSurjective`. |
@[simp]
σ_smul (x y) : P.σ x • y = x * y := by
rw [Algebra.smul_def, algebraMap_σ] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | σ_smul | null |
σ_injective : P.σ.Injective := by
intro x y e
rw [← P.algebraMap_σ x, ← P.algebraMap_σ y, e] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | σ_injective | null |
algebraMap_surjective : Function.Surjective (algebraMap P.Ring S) := (⟨_, P.algebraMap_σ ·⟩) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | algebraMap_surjective | null |
@[simps -isSimp Ring σ]
noncomputable
ofSurjective {P : Type w} [CommRing P] [Algebra R P] (f : P →ₐ[R] S)
(h : Function.Surjective f) : Extension.{w} R S where
Ring := P
algebra₂ := f.toAlgebra
isScalarTower := letI := f.toAlgebra; IsScalarTower.of_algebraMap_eq' f.comp_algebraMap.symm
σ x := (h x).choose
algebraMap_σ x := (h x).choose_spec
variable (R S) in | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | ofSurjective | Construct `Extension` from a surjective algebra homomorphism. |
@[simps -isSimp Ring σ]
noncomputable
self : Extension R S where
Ring := S
σ := _root_.id
algebraMap_σ _ := rfl | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | self | The trivial extension of `S`. |
ker : Ideal P.Ring := RingHom.ker (algebraMap P.Ring S) | abbrev | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | ker | The kernel of an extension. |
noncomputable
localization (P : Extension.{w} R S) : Extension R S' where
Ring := Localization (M.comap (algebraMap P.Ring S))
algebra₂ := (IsLocalization.lift (M := (M.comap (algebraMap P.Ring S)))
(g := (algebraMap S S').comp (algebraMap P.Ring S))
(by simpa using fun x hx ↦ IsLocalization.map_units S' ⟨_, hx⟩)).toAlgebra
isScalarTower := by
letI : Algebra (Localization (M.comap (algebraMap P.Ring S))) S' :=
(IsLocalization.lift (M := (M.comap (algebraMap P.Ring S)))
(g := (algebraMap S S').comp (algebraMap P.Ring S))
(by simpa using fun x hx ↦ IsLocalization.map_units S' ⟨_, hx⟩)).toAlgebra
apply IsScalarTower.of_algebraMap_eq'
rw [RingHom.algebraMap_toAlgebra, IsScalarTower.algebraMap_eq R P.Ring (Localization _),
← RingHom.comp_assoc, IsLocalization.lift_comp, RingHom.comp_assoc,
← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq]
σ s := Localization.mk (P.σ (IsLocalization.sec M s).1) ⟨P.σ (IsLocalization.sec M s).2, by simp⟩
algebraMap_σ s := by
simp [RingHom.algebraMap_toAlgebra, Localization.mk_eq_mk', IsLocalization.lift_mk',
Units.mul_inv_eq_iff_eq_mul, IsUnit.coe_liftRight, IsLocalization.sec_spec] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | localization | An `R`-extension `P → S` gives an `R`-extension `Pₘ → Sₘ`.
Note that this is different from `baseChange` as the base does not change. |
noncomputable
baseChange {T} [CommRing T] [Algebra R T] (P : Extension R S) : Extension T (T ⊗[R] S) where
Ring := T ⊗[R] P.Ring
__ := ofSurjective (P := T ⊗[R] P.Ring) (Algebra.TensorProduct.map (AlgHom.id T T)
(IsScalarTower.toAlgHom _ _ _)) (LinearMap.lTensor_surjective T
(g := (IsScalarTower.toAlgHom R P.Ring S).toLinearMap) P.algebraMap_surjective) | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | baseChange | The base change of an `R`-extension of `S` to `T` gives a `T`-extension of `T ⊗[R] S`. |
@[ext]
Hom where
/-- The underlying ring homomorphism of a hom between extensions. -/
toRingHom : P.Ring →+* P'.Ring
toRingHom_algebraMap :
∀ x, toRingHom (algebraMap R P.Ring x) = algebraMap R' P'.Ring (algebraMap R R' x)
algebraMap_toRingHom :
∀ x, (algebraMap P'.Ring S' (toRingHom x)) = algebraMap S S' (algebraMap P.Ring S x)
attribute [simp] Hom.toRingHom_algebraMap Hom.algebraMap_toRingHom
variable {P P'} | structure | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom | Given a commuting square
```
R --→ P -→ S
| |
↓ ↓
R' -→ P' → S
```
A hom between `P` and `P'` is a ring homomorphism that makes the two squares commute. |
noncomputable
Hom.toAlgHom [Algebra R S'] [IsScalarTower R R' S'] (f : Hom P P') :
P.Ring →ₐ[R] P'.Ring where
__ := f.toRingHom
commutes' := by simp [← IsScalarTower.algebraMap_apply]
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.toAlgHom | A hom between extensions as an algebra homomorphism. |
Hom.toAlgHom_apply [Algebra R S'] [IsScalarTower R R' S'] (f : Hom P P') (x) :
f.toAlgHom x = f.toRingHom x := rfl
variable (P P') | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.toAlgHom_apply | null |
@[simps]
protected noncomputable Hom.id : Hom P P := ⟨RingHom.id _, by simp, by simp⟩
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.id | The identity hom. |
Hom.toAlgHom_id : Hom.toAlgHom (.id P) = AlgHom.id _ _ := by ext1; simp
variable {P P' P''}
variable [IsScalarTower R R' R''] [IsScalarTower S S' S''] in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.toAlgHom_id | null |
@[simps]
noncomputable Hom.comp (f : Hom P' P'') (g : Hom P P') : Hom P P'' where
toRingHom := f.toRingHom.comp g.toRingHom
toRingHom_algebraMap := by simp [← IsScalarTower.algebraMap_apply]
algebraMap_toRingHom := by simp [← IsScalarTower.algebraMap_apply]
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.comp | The composition of two homs. |
Hom.comp_id (f : Hom P P') : f.comp (Hom.id P) = f := by ext; simp
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.comp_id | null |
Hom.id_comp (f : Hom P P') : (Hom.id P').comp f = f := by
ext; simp [Hom.id] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.id_comp | null |
@[simps]
Hom.mapKer (f : P.Hom P')
[alg : Algebra P.Ring P'.Ring] (halg : algebraMap P.Ring P'.Ring = f.toRingHom) :
P.ker →ₗ[P.Ring] P'.ker where
toFun x := ⟨f.toRingHom x, by simp [show algebraMap P.Ring S x = 0 from x.2]⟩
map_add' _ _ := Subtype.ext (map_add _ _ _)
map_smul' := by simp [Algebra.smul_def, ← halg] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Hom.mapKer | A map between extensions induce a map between kernels. |
noncomputable
infinitesimal (P : Extension R S) : Extension R S where
Ring := P.Ring ⧸ P.ker ^ 2
σ := Ideal.Quotient.mk _ ∘ P.σ
algebraMap_σ x := by dsimp; exact P.algebraMap_σ x | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | infinitesimal | Given an `R`-algebra extension `0 → I → P → S → 0` of `S`,
the infinitesimal extension associated to it is `0 → I/I² → P/I² → S → 0`. |
noncomputable
toInfinitesimal (P : Extension R S) : P.Hom P.infinitesimal where
toRingHom := Ideal.Quotient.mk _
toRingHom_algebraMap _ := rfl
algebraMap_toRingHom _ := rfl | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | toInfinitesimal | The canonical map `P → P/I²` as maps between extensions. |
ker_infinitesimal (P : Extension R S) :
P.infinitesimal.ker = P.ker.cotangentIdeal :=
AlgHom.ker_kerSquareLift _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | ker_infinitesimal | null |
Cotangent : Type _ := P.ker.Cotangent | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent | The cotangent space of an extension.
This is a type synonym so that `P.Ring` can act on it through the action of `S` without creating
a diamond. |
Cotangent.of (x : P.ker.Cotangent) : P.Cotangent := x | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.of | The identity map `P.ker.Cotangent → P.Cotangent` into the type synonym. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.