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 ⌀ |
|---|---|---|---|---|---|---|
IsAdicCauchy (f : ℕ → M) : Prop :=
∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsAdicCauchy | A sequence `ℕ → M` is an `I`-adic Cauchy sequence if for every `m ≤ n`,
`f m ≡ f n` modulo `I ^ m • ⊤`. |
AdicCauchySequence : Type _ := { f : ℕ → M // IsAdicCauchy I M f } | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | AdicCauchySequence | The type of `I`-adic Cauchy sequences. |
submodule : Submodule R (ℕ → M) where
carrier := { f | IsAdicCauchy I M f }
add_mem' := by
intro f g hf hg m n hmn
exact SModEq.add (hf hmn) (hg hmn)
zero_mem' := by
intro _ _ _
rfl
smul_mem' := by
intro r f hf m n hmn
exact SModEq.smul (hf hmn) r | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | submodule | The type of `I`-adic Cauchy sequences is a submodule of the product `ℕ → M`. |
@[simp]
zero_apply (n : ℕ) : (0 : AdicCauchySequence I M) n = 0 :=
rfl
variable {I M}
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | zero_apply | null |
add_apply (n : ℕ) (f g : AdicCauchySequence I M) : (f + g) n = f n + g n :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | add_apply | null |
sub_apply (n : ℕ) (f g : AdicCauchySequence I M) : (f - g) n = f n - g n :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | sub_apply | null |
smul_apply (n : ℕ) (r : R) (f : AdicCauchySequence I M) : (r • f) n = r • f n :=
rfl
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | smul_apply | null |
ext {x y : AdicCauchySequence I M} (h : ∀ n, x n = y n) : x = y :=
Subtype.eq <| funext h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | ext | null |
mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (f : AdicCauchySequence I M) :
Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (f n) =
Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (f m) :=
(f.property hmn).symm | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | mk_eq_mk | The defining property of an adic Cauchy sequence unwrapped. |
isAdicCauchy_iff (f : ℕ → M) :
IsAdicCauchy I M f ↔ ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)] := by
constructor
· intro h n
exact h (Nat.le_succ n)
· intro h m n hmn
induction n, hmn using Nat.le_induction with
| base => rfl
| succ n hmn ih =>
trans
· exact ih
· refine SModEq.mono (smul_mono (Ideal.pow_le_pow_right hmn) (by rfl)) (h n) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | isAdicCauchy_iff | The `I`-adic Cauchy condition can be checked on successive `n`. |
@[simps]
AdicCauchySequence.mk (f : ℕ → M)
(h : ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)]) : AdicCauchySequence I M where
val := f
property := by rwa [isAdicCauchy_iff] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | AdicCauchySequence.mk | Construct `I`-adic Cauchy sequence from sequence satisfying the successive Cauchy condition. |
@[simps]
mk : AdicCauchySequence I M →ₗ[R] AdicCompletion I M where
toFun f := ⟨fun n ↦ Submodule.mkQ (I ^ n • ⊤ : Submodule R M) (f n), by
intro m n hmn
simp only [mkQ_apply]
exact (f.property hmn).symm⟩
map_add' _ _ := rfl
map_smul' _ _ := rfl | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | mk | The canonical linear map from Cauchy sequences to the completion. |
mk_zero_of (f : AdicCauchySequence I M)
(h : ∃ k : ℕ, ∀ n ≥ k, ∃ m ≥ n, ∃ l ≥ n, f m ∈ (I ^ l • ⊤ : Submodule R M)) :
AdicCompletion.mk I M f = 0 := by
obtain ⟨k, h⟩ := h
ext n
obtain ⟨m, hnm, l, hnl, hl⟩ := h (n + k) (by cutsat)
rw [mk_apply_coe, Submodule.mkQ_apply, val_zero,
← AdicCauchySequence.mk_eq_mk (show n ≤ m by cutsat)]
simpa using (Submodule.smul_mono_left (Ideal.pow_le_pow_right (by cutsat))) hl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | mk_zero_of | Criterion for checking that an adic Cauchy sequence is mapped to zero in the adic completion. |
mk_surjective : Function.Surjective (mk I M) := by
intro x
choose a ha using fun n ↦ Submodule.Quotient.mk_surjective _ (x.val n)
refine ⟨⟨a, ?_⟩, ?_⟩
· intro m n hmn
rw [SModEq.def, ha m, ← mkQ_apply,
← factor_mk (Submodule.smul_mono_left (Ideal.pow_le_pow_right hmn)) (a n),
mkQ_apply, ha n, x.property hmn]
· ext n
simp [ha n] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | mk_surjective | Every element in the adic completion is represented by a Cauchy sequence. |
induction_on {p : AdicCompletion I M → Prop} (x : AdicCompletion I M)
(h : ∀ (f : AdicCauchySequence I M), p (mk I M f)) : p x := by
obtain ⟨f, rfl⟩ := mk_surjective I M x
exact h f
variable {M} | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | induction_on | To show a statement about an element of `adicCompletion I M`, it suffices to check it
on Cauchy sequences. |
lift (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
(h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m) :
M →ₗ[R] AdicCompletion I N where
toFun := fun x ↦ ⟨fun n ↦ f n x, fun hkl ↦ LinearMap.congr_fun (h hkl) x⟩
map_add' x y := by
simp only [map_add]
rfl
map_smul' r x := by
simp only [LinearMapClass.map_smul, RingHom.id_apply]
rfl
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | lift | Lift a compatible family of linear maps `M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N)` to
the `I`-adic completion of `M`. |
eval_lift (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
(h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m)
(n : ℕ) : eval I N n ∘ₗ lift I f h = f n :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_lift | null |
eval_lift_apply (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
(h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m)
(n : ℕ) (x : M) : (lift I f h x).val n = f n x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_lift_apply | null |
bot : IsAdicComplete (⊥ : Ideal R) M where | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | bot | null |
protected subsingleton (h : IsAdicComplete (⊤ : Ideal R) M) : Subsingleton M :=
h.1.subsingleton | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | subsingleton | null |
le_jacobson_bot [IsAdicComplete I R] : I ≤ (⊥ : Ideal R).jacobson := by
intro x hx
rw [← Ideal.neg_mem_iff, Ideal.mem_jacobson_bot]
intro y
rw [add_comm]
let f : ℕ → R := fun n => ∑ i ∈ range n, (x * y) ^ i
have hf : ∀ m n, m ≤ n → f m ≡ f n [SMOD I ^ m • (⊤ : Submodule R R)] := by
intro m n h
simp only [f, Algebra.id.smul_eq_mul, Ideal.mul_top, SModEq.sub_mem]
rw [← add_tsub_cancel_of_le h, Finset.sum_range_add, ← sub_sub, sub_self, zero_sub,
@neg_mem_iff]
apply Submodule.sum_mem
intro n _
rw [mul_pow, pow_add, mul_assoc]
exact Ideal.mul_mem_right _ (I ^ m) (Ideal.pow_mem_pow hx m)
obtain ⟨L, hL⟩ := IsPrecomplete.prec toIsPrecomplete @hf
rw [isUnit_iff_exists_inv]
use L
rw [← sub_eq_zero, neg_mul]
apply IsHausdorff.haus (toIsHausdorff : IsHausdorff I R)
intro n
specialize hL n
rw [SModEq.sub_mem, Algebra.id.smul_eq_mul, Ideal.mul_top] at hL ⊢
rw [sub_zero]
suffices (1 - x * y) * f n - 1 ∈ I ^ n by
convert Ideal.sub_mem _ this (Ideal.mul_mem_left _ (1 + -(x * y)) hL) using 1
ring
cases n
· simp only [Ideal.one_eq_top, pow_zero, mem_top]
· rw [← neg_sub _ (1 : R), neg_mul, mul_geom_sum, neg_sub, sub_sub, add_comm (_ ^ _), ← sub_sub,
sub_self, zero_sub, @neg_mem_iff, mul_pow]
exact Ideal.mul_mem_right _ (I ^ _) (Ideal.pow_mem_pow hx _) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | le_jacobson_bot | null |
private noncomputable mapPreimageDelta (hf : Function.Surjective f) (x : AdicCauchySequence I N)
{n : ℕ} {y yₙ : M} (hy : f y = x (n + 1)) (hyₙ : f yₙ = x n) :
{d : (I ^ n • ⊤ : Submodule R M) | f d = f (yₙ - y) } :=
have h : f (yₙ - y) ∈ Submodule.map f (I ^ n • ⊤ : Submodule R M) := by
rw [Submodule.map_smul'', Submodule.map_top, LinearMap.range_eq_top.2 hf,
map_sub, hyₙ, hy, ← Submodule.neg_mem_iff, neg_sub, ← SModEq.sub_mem]
exact AdicCauchySequence.mk_eq_mk (Nat.le_succ n) x
⟨⟨h.choose, h.choose_spec.1⟩, h.choose_spec.2⟩
/- Inductively construct preimage of Cauchy sequence. -/
private noncomputable def mapPreimage (hf : Function.Surjective f) (x : AdicCauchySequence I N) :
(n : ℕ) → f ⁻¹' {x n}
| .zero => ⟨(hf (x 0)).choose, (hf (x 0)).choose_spec⟩
| .succ n =>
let y := (hf (x (n + 1))).choose
have hy := (hf (x (n + 1))).choose_spec
let ⟨yₙ, (hyₙ : f yₙ = x n)⟩ := mapPreimage hf x n
let ⟨⟨d, _⟩, (p : f d = f (yₙ - y))⟩ := mapPreimageDelta hf x hy hyₙ
⟨yₙ - d, by simpa [p]⟩
variable (I) in | def | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | mapPreimageDelta | null |
map_surjective (hf : Function.Surjective f) : Function.Surjective (map I f) := fun y ↦ by
apply AdicCompletion.induction_on I N y (fun b ↦ ?_)
let a := mapPreimage hf b
refine ⟨AdicCompletion.mk I M (AdicCauchySequence.mk I M (fun n ↦ (a n : M)) ?_), ?_⟩
· refine fun n ↦ SModEq.symm ?_
simp only [SModEq, mapPreimage, Submodule.Quotient.mk_sub,
sub_eq_self, Submodule.Quotient.mk_eq_zero, SetLike.coe_mem, a]
· exact _root_.AdicCompletion.ext fun n ↦ congrArg _ ((a n).property) | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | map_surjective | Adic completion preserves surjectivity |
map_injective {f : M →ₗ[R] N} (hf : Function.Injective f) :
Function.Injective (map I f) := by
obtain ⟨k, hk⟩ := Ideal.exists_pow_inf_eq_pow_smul I (range f)
rw [← LinearMap.ker_eq_bot, LinearMap.ker_eq_bot']
intro x
apply AdicCompletion.induction_on I M x (fun a ↦ ?_)
intro hx
refine AdicCompletion.mk_zero_of _ _ _ ⟨42, fun n _ ↦ ⟨n + k, by cutsat, n, by cutsat, ?_⟩⟩
rw [← Submodule.comap_map_eq_of_injective hf (I ^ n • ⊤ : Submodule R M),
Submodule.map_smul'', Submodule.map_top]
apply (smul_mono_right _ inf_le_right : I ^ n • (I ^ k • ⊤ ⊓ (range f)) ≤ _)
nth_rw 1 [show n = n + k - k by cutsat]
rw [← hk (n + k) (show n + k ≥ k by cutsat)]
exact ⟨by simpa using congrArg (fun x ↦ x.val (n + k)) hx, ⟨a (n + k), rfl⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | map_injective | Adic completion preserves injectivity of finite modules over a Noetherian ring. |
private noncomputable mapExactAuxDelta {n : ℕ} {d : N}
(hdmem : d ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N)) {y yₙ : M}
(hd : f y = x (k + n + 1) - d) (hyₙ : f yₙ - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N)) :
{ d : (I ^ n • ⊤ : Submodule R M)
| f (yₙ + d) - x (k + n + 1) ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N) } :=
have h : f (y - yₙ) ∈ (I ^ (k + n) • ⊤ : Submodule R N) := by
simp only [map_sub, hd]
convert_to x (k + n + 1) - x (k + n) - d - (f yₙ - x (k + n)) ∈ I ^ (k + n) • ⊤
· abel
· refine Submodule.sub_mem _ (Submodule.sub_mem _ ?_ ?_) hyₙ
· rw [← Submodule.Quotient.eq]
exact AdicCauchySequence.mk_eq_mk (by cutsat) _
· exact (Submodule.smul_mono_left (Ideal.pow_le_pow_right (by cutsat))) hdmem
have hincl : I ^ (k + n - k) • (I ^ k • ⊤ ⊓ range f) ≤ I ^ (k + n - k) • (range f) :=
smul_mono_right _ inf_le_right
have hyyₙ : y - yₙ ∈ (I ^ n • ⊤ : Submodule R M) := by
convert_to y - yₙ ∈ (I ^ (k + n - k) • ⊤ : Submodule R M)
· simp
· rw [← Submodule.comap_map_eq_of_injective hf (I ^ (k + n - k) • ⊤ : Submodule R M),
Submodule.map_smul'', Submodule.map_top]
apply hincl
rw [← hkn (k + n) (by cutsat)]
exact ⟨h, ⟨y - yₙ, rfl⟩⟩
⟨⟨y - yₙ, hyyₙ⟩, by simpa [hd, Nat.succ_eq_add_one, Nat.add_assoc]⟩
open Submodule
include hfg in | def | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | mapExactAuxDelta | null |
private noncomputable mapExactAux :
(n : ℕ) → { a : M | f a - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N) }
| .zero =>
let d := (h2 0).choose
let y := (h2 0).choose_spec.choose
have hdy : f y = x (k + 0) - d := (h2 0).choose_spec.choose_spec.right
have hdmem := (h2 0).choose_spec.choose_spec.left
⟨y, by simpa [hdy]⟩
| .succ n =>
let d := (h2 <| n + 1).choose
let y := (h2 <| n + 1).choose_spec.choose
have hdy : f y = x (k + (n + 1)) - d := (h2 <| n + 1).choose_spec.choose_spec.right
have hdmem := (h2 <| n + 1).choose_spec.choose_spec.left
let ⟨yₙ, (hyₙ : f yₙ - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N))⟩ :=
mapExactAux n
let ⟨d, hd⟩ := mapExactAuxDelta hf hkn x hdmem hdy hyₙ
⟨yₙ + d, hd⟩
where
h1 (n : ℕ) : g (x (k + n)) ∈ Submodule.map g (I ^ (k + n) • ⊤ : Submodule R N) := by
rw [map_smul'', Submodule.map_top, range_eq_top.mpr hg]
exact hker (k + n)
h2 (n : ℕ) : ∃ (d : N) (y : M),
d ∈ (I ^ (k + n) • ⊤ : Submodule R N) ∧ f y = x (k + n) - d := by
obtain ⟨d, hdmem, hd⟩ := h1 n
obtain ⟨y, hdy⟩ := (hfg (x (k + n) - d)).mp (by simp [hd])
exact ⟨d, y, hdmem, hdy⟩ | def | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | mapExactAux | Inductively construct preimage of Cauchy sequence in kernel of `g.adicCompletion I`. |
map_exact : Function.Exact (map I f) (map I g) := by
refine LinearMap.exact_of_comp_eq_zero_of_ker_le_range ?_ (fun y ↦ ?_)
· rw [map_comp, hfg.linearMap_comp_eq_zero, AdicCompletion.map_zero]
· apply AdicCompletion.induction_on I N y (fun b ↦ ?_)
intro hz
obtain ⟨k, hk⟩ := Ideal.exists_pow_inf_eq_pow_smul I (LinearMap.range f)
have hb (n : ℕ) : g (b n) ∈ (I ^ n • ⊤ : Submodule R P) := by
simpa using congrArg (fun x ↦ x.val n) hz
let a := mapExactAux hf hfg hg hk b hb
refine ⟨AdicCompletion.mk I M (AdicCauchySequence.mk I M (fun n ↦ (a n : M)) ?_), ?_⟩
· refine fun n ↦ SModEq.symm ?_
simp [a, mapExactAux, SModEq]
· ext n
suffices h : Submodule.Quotient.mk (p := (I ^ n • ⊤ : Submodule R N)) (f (a n)) =
Submodule.Quotient.mk (p := (I ^ n • ⊤ : Submodule R N)) (b (k + n)) by
simp [h, AdicCauchySequence.mk_eq_mk (show n ≤ k + n by cutsat)]
rw [Submodule.Quotient.eq]
have hle : (I ^ (k + n) • ⊤ : Submodule R N) ≤ (I ^ n • ⊤ : Submodule R N) :=
Submodule.smul_mono_left (Ideal.pow_le_pow_right (by cutsat))
exact hle (a n).property | theorem | RingTheory | [
"Mathlib.Algebra.Exact",
"Mathlib.RingTheory.AdicCompletion.Functoriality",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Exactness.lean | map_exact | `AdicCompletion` over a Noetherian ring is exact on finitely generated modules. |
private reduceModIdealAux (f : M →ₗ[R] N) :
M ⧸ (I • ⊤ : Submodule R M) →ₗ[R] N ⧸ (I • ⊤ : Submodule R N) :=
Submodule.mapQ (I • ⊤ : Submodule R M) (I • ⊤ : Submodule R N) f
(fun x hx ↦ by
refine Submodule.smul_induction_on hx (fun r hr x _ ↦ ?_) (fun x y hx hy ↦ ?_)
· simp [Submodule.smul_mem_smul hr Submodule.mem_top]
· simp [Submodule.add_mem _ hx hy])
@[local simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | reduceModIdealAux | `R`-linear version of `reduceModIdeal`. |
private reduceModIdealAux_apply (f : M →ₗ[R] N) (x : M) :
(f.reduceModIdealAux I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | reduceModIdealAux_apply | null |
reduceModIdeal (f : M →ₗ[R] N) :
M ⧸ (I • ⊤ : Submodule R M) →ₗ[R ⧸ I] N ⧸ (I • ⊤ : Submodule R N) where
toFun := f.reduceModIdealAux I
map_add' := by simp
map_smul' r x := by
refine Quotient.inductionOn' r (fun r ↦ ?_)
refine Quotient.inductionOn' x (fun x ↦ ?_)
simp only [Submodule.Quotient.mk''_eq_mk, Ideal.Quotient.mk_eq_mk, Module.Quotient.mk_smul_mk,
Submodule.Quotient.mk_smul, LinearMapClass.map_smul, reduceModIdealAux_apply,
RingHomCompTriple.comp_apply]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | reduceModIdeal | The induced linear map on the quotients mod `I • ⊤`. |
reduceModIdeal_apply (f : M →ₗ[R] N) (x : M) :
(f.reduceModIdeal I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | reduceModIdeal_apply | null |
transitionMap_comp_reduceModIdeal (f : M →ₗ[R] N) {m n : ℕ}
(hmn : m ≤ n) : transitionMap I N hmn ∘ₗ f.reduceModIdeal (I ^ n) =
(f.reduceModIdeal (I ^ m) : _ →ₗ[R] _) ∘ₗ transitionMap I M hmn := by
ext x
simp | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | transitionMap_comp_reduceModIdeal | null |
@[simps]
map (f : M →ₗ[R] N) : AdicCauchySequence I M →ₗ[R] AdicCauchySequence I N where
toFun a := ⟨fun n ↦ f (a n), fun {m n} hmn ↦ by
have hm : Submodule.map f (I ^ m • ⊤ : Submodule R M) ≤ (I ^ m • ⊤ : Submodule R N) := by
rw [Submodule.map_smul'']
exact smul_mono_right _ le_top
apply SModEq.mono hm
apply SModEq.map (a.property hmn) f⟩
map_add' a b := by ext n; simp
map_smul' r a := by ext n; simp
variable (M) in
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map | A linear map induces a linear map on adic Cauchy sequences. |
map_id : map I (LinearMap.id (M := M)) = LinearMap.id :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_id | null |
map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
map I g ∘ₗ map I f = map I (g ∘ₗ f) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_comp | null |
map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (a : AdicCauchySequence I M) :
map I g (map I f a) = map I (g ∘ₗ f) a :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_comp_apply | null |
map_zero : map I (0 : M →ₗ[R] N) = 0 :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_zero | null |
private adicCompletionAux (f : M →ₗ[R] N) :
AdicCompletion I M →ₗ[R] AdicCompletion I N :=
AdicCompletion.lift I (fun n ↦ reduceModIdeal (I ^ n) f ∘ₗ AdicCompletion.eval I M n)
(fun {m n} hmn ↦ by rw [← comp_assoc, AdicCompletion.transitionMap_comp_reduceModIdeal,
comp_assoc, transitionMap_comp_eval])
@[local simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | adicCompletionAux | `R`-linear version of `adicCompletion`. |
private adicCompletionAux_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
(adicCompletionAux I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | adicCompletionAux_val_apply | null |
map (f : M →ₗ[R] N) :
AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N where
toFun := adicCompletionAux I f
map_add' := by simp
map_smul' r x := by
ext n
simp only [adicCompletionAux_val_apply, smul_eval, smul_eq_mul, RingHom.id_apply]
rw [val_smul_eq_evalₐ_smul, val_smul_eq_evalₐ_smul, map_smul]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map | A linear map induces a map on adic completions. |
map_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
(map I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_val_apply | null |
map_ext {N} {f g : AdicCompletion I M → N}
(h : ∀ (a : AdicCauchySequence I M),
f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
f = g := by
ext x
apply induction_on I M x h | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_ext | Equality of maps out of an adic completion can be checked on Cauchy sequences. |
@[ext]
map_ext' {f g : AdicCompletion I M →ₗ[AdicCompletion I R] T}
(h : ∀ (a : AdicCauchySequence I M),
f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
f = g := by
ext x
apply induction_on I M x h | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_ext' | Equality of linear maps out of an adic completion can be checked on Cauchy sequences. |
@[ext]
map_ext'' {f g : AdicCompletion I M →ₗ[R] N}
(h : f.comp (AdicCompletion.mk I M) = g.comp (AdicCompletion.mk I M)) :
f = g := by
ext x
apply induction_on I M x (fun a ↦ LinearMap.ext_iff.mp h a)
variable (M) in
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_ext'' | Equality of linear maps out of an adic completion can be checked on Cauchy sequences. |
map_id :
map I (LinearMap.id (M := M)) =
LinearMap.id (R := AdicCompletion I R) (M := AdicCompletion I M) := by
ext a n
simp | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_id | null |
map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
map I g ∘ₗ map I f = map I (g ∘ₗ f) := by
ext
simp | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_comp | null |
map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M) :
map I g (map I f x) = map I (g ∘ₗ f) x := by
change (map I g ∘ₗ map I f) x = map I (g ∘ₗ f) x
rw [map_comp]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_comp_apply | null |
map_mk (f : M →ₗ[R] N) (a : AdicCauchySequence I M) :
map I f (AdicCompletion.mk I M a) =
AdicCompletion.mk I N (AdicCauchySequence.map I f a) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_mk | null |
map_zero : map I (0 : M →ₗ[R] N) = 0 := by
ext
simp | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | map_zero | null |
congr (f : M ≃ₗ[R] N) :
AdicCompletion I M ≃ₗ[AdicCompletion I R] AdicCompletion I N :=
LinearEquiv.ofLinear (map I f)
(map I f.symm) (by simp [map_comp]) (by simp [map_comp])
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | congr | A linear equiv induces a linear equiv on adic completions. |
congr_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I M) :
congr I f x = map I f x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | congr_apply | null |
congr_symm_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I N) :
(congr I f).symm x = map I f.symm x :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | congr_symm_apply | null |
@[simps!]
pi : AdicCompletion I (∀ j, M j) →ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) :=
LinearMap.pi (fun j ↦ map I (LinearMap.proj j)) | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | pi | The canonical map from the adic completion of the product to the product of the
adic completions. |
sum [DecidableEq ι] :
(⨁ j, (AdicCompletion I (M j))) →ₗ[AdicCompletion I R] AdicCompletion I (⨁ j, M j) :=
toModule (AdicCompletion I R) ι (AdicCompletion I (⨁ j, M j))
(fun j ↦ map I (lof R ι M j))
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sum | The canonical map from the sum of the adic completions to the adic completion
of the sum. |
sum_lof [DecidableEq ι] (j : ι) (x : AdicCompletion I (M j)) :
sum I M ((DirectSum.lof (AdicCompletion I R) ι (fun i ↦ AdicCompletion I (M i)) j) x) =
map I (lof R ι M j) x := by
simp [sum]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sum_lof | null |
sum_of [DecidableEq ι] (j : ι) (x : AdicCompletion I (M j)) :
sum I M ((DirectSum.of (fun i ↦ AdicCompletion I (M i)) j) x) =
map I (lof R ι M j) x := by
rw [← lof_eq_of R]
apply sum_lof
variable [Fintype ι] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sum_of | null |
sumInv : AdicCompletion I (⨁ j, M j) →ₗ[AdicCompletion I R] (⨁ j, (AdicCompletion I (M j))) :=
letI f := map I (linearEquivFunOnFintype R ι M)
letI g := linearEquivFunOnFintype (AdicCompletion I R) ι (fun j ↦ AdicCompletion I (M j))
g.symm.toLinearMap ∘ₗ pi I M ∘ₗ f
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumInv | If `ι` is finite, we use the equivalence of sum and product to obtain an inverse for
`AdicCompletion.sum` from `AdicCompletion.pi`. |
component_sumInv (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
component (AdicCompletion I R) ι _ j (sumInv I M x) =
map I (component R ι _ j) x := by
apply induction_on I _ x (fun x ↦ ?_)
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | component_sumInv | null |
sumInv_apply (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
(sumInv I M x) j = map I (component R ι _ j) x := by
apply induction_on I _ x (fun x ↦ ?_)
rfl
variable [DecidableEq ι] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumInv_apply | null |
sumInv_comp_sum : sumInv I M ∘ₗ sum I M = LinearMap.id := by
ext j x : 2
apply DirectSum.ext_component (AdicCompletion I R) (fun i ↦ ?_)
ext n
simp only [LinearMap.coe_comp, Function.comp_apply, sum_lof, map_mk, component_sumInv,
mk_apply_coe, AdicCauchySequence.map_apply_coe, Submodule.mkQ_apply, LinearMap.id_comp]
rw [DirectSum.component.of, DirectSum.component.of]
split
· next h => subst h; simp
· simp | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumInv_comp_sum | null |
sum_comp_sumInv : sum I M ∘ₗ sumInv I M = LinearMap.id := by
ext f n
simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.id_coe, id_eq, mk_apply_coe,
Submodule.mkQ_apply]
rw [← DirectSum.sum_univ_of (((sumInv I M) ((AdicCompletion.mk I (⨁ (j : ι), M j)) f)))]
simp only [sumInv_apply, map_mk, map_sum, sum_of, val_sum_apply, mk_apply_coe,
AdicCauchySequence.map_apply_coe]
simp only [← Submodule.mkQ_apply, ← map_sum, ← apply_eq_component, lof_eq_of,
DirectSum.sum_univ_of] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sum_comp_sumInv | null |
sumEquivOfFintype :
(⨁ j, (AdicCompletion I (M j))) ≃ₗ[AdicCompletion I R] AdicCompletion I (⨁ j, M j) :=
LinearEquiv.ofLinear (sum I M) (sumInv I M) (sum_comp_sumInv I M) (sumInv_comp_sum I M)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumEquivOfFintype | If `ι` is finite, `sum` has `sumInv` as inverse. |
sumEquivOfFintype_apply (x : ⨁ j, (AdicCompletion I (M j))) :
sumEquivOfFintype I M x = sum I M x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumEquivOfFintype_apply | null |
sumEquivOfFintype_symm_apply (x : AdicCompletion I (⨁ j, M j)) :
(sumEquivOfFintype I M).symm x = sumInv I M x :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | sumEquivOfFintype_symm_apply | null |
piEquivOfFintype :
AdicCompletion I (∀ j, M j) ≃ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) :=
letI f := (congr I (linearEquivFunOnFintype R ι M)).symm
letI g := (linearEquivFunOnFintype (AdicCompletion I R) ι (fun j ↦ AdicCompletion I (M j)))
f.trans ((sumEquivOfFintype I M).symm.trans g)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | piEquivOfFintype | If `ι` is finite, `pi` is a linear equiv. |
piEquivOfFintype_apply (x : AdicCompletion I (∀ j, M j)) :
piEquivOfFintype I M x = pi I M x := by
simp [piEquivOfFintype, sumInv, map_comp_apply] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | piEquivOfFintype_apply | null |
piEquivFin (n : ℕ) :
AdicCompletion I (Fin n → R) ≃ₗ[AdicCompletion I R] Fin n → AdicCompletion I R :=
piEquivOfFintype I (ι := Fin n) (fun _ : Fin n ↦ R)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | piEquivFin | Adic completion of `R^n` is `(AdicCompletion I R)^n`. |
piEquivFin_apply (n : ℕ) (x : AdicCompletion I (Fin n → R)) :
piEquivFin I n x = pi I (fun _ : Fin n ↦ R) x := by
simp only [piEquivFin, piEquivOfFintype_apply] | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.AdicCompletion.Algebra",
"Mathlib.Algebra.DirectSum.Basic"
] | Mathlib/RingTheory/AdicCompletion/Functoriality.lean | piEquivFin_apply | null |
isUnit_iff_notMem_of_isAdicComplete_maximal [IsAdicComplete m R] (r : R) :
IsUnit r ↔ r ∉ m := by
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· by_contra mem
rcases IsUnit.exists_left_inv h with ⟨s, hs⟩
absurd m.ne_top_iff_one.mp (Ideal.IsMaximal.ne_top hmax)
simp [← hs, Ideal.mul_mem_left m s mem]
· have mapu {n : ℕ} (npos : 0 < n) : IsUnit (Ideal.Quotient.mk (m ^ n) r) := by
induction n with
| zero =>
absurd npos
exact Nat.not_lt_zero 0
| succ n ih =>
by_cases neq0 : n = 0
· let max' : (m ^ (n + 1)).IsMaximal := by simpa only [neq0, zero_add, pow_one] using hmax
let hField : Field (R ⧸ m ^ (n + 1)) := Ideal.Quotient.field (m ^ (n + 1))
simpa [isUnit_iff_ne_zero, ne_eq, Ideal.Quotient.eq_zero_iff_mem.not, neq0] using h
· apply factorPowSucc.isUnit_of_isUnit_image (Nat.zero_lt_of_ne_zero neq0)
simpa using (ih (Nat.zero_lt_of_ne_zero neq0))
choose invSeries' invSeries_spec' using fun (n : {n : ℕ // 0 < n}) ↦
(IsUnit.exists_left_inv (mapu n.2))
let invSeries : ℕ → R := fun n ↦ if h : n = 0 then 0 else Classical.choose <|
Ideal.Quotient.mk_surjective <| invSeries' ⟨n, (Nat.zero_lt_of_ne_zero h)⟩
have invSeries_spec {n : ℕ} (npos : 0 < n): (Ideal.Quotient.mk (m ^ n)) (invSeries n) =
invSeries' ⟨n, npos⟩ := by
simpa only [Nat.ne_zero_of_lt npos, invSeries]
using Classical.choose_spec (Ideal.Quotient.mk_surjective (invSeries' ⟨n, npos⟩))
have mod {a b : ℕ} (le : a ≤ b) :
invSeries a ≡ invSeries b [SMOD m ^ a • (⊤ : Submodule R R)] := by
by_cases apos : 0 < a
· simp only [smul_eq_mul, Ideal.mul_top]
rw [SModEq.sub_mem, ← eq_zero_iff_mem, map_sub, ← (mapu apos).mul_right_inj,
mul_zero, mul_sub]
nth_rw 3 [← factor_mk (pow_le_pow_right le), ← factor_mk (pow_le_pow_right le)]
simp only [invSeries_spec apos, invSeries_spec (Nat.lt_of_lt_of_le apos le)]
rw [← map_mul, mul_comm, invSeries_spec', mul_comm, invSeries_spec',
map_one, sub_self]
· simp [Nat.eq_zero_of_not_pos apos]
rcases IsAdicComplete.toIsPrecomplete.prec mod with ⟨inv, hinv⟩
have eq (n : ℕ) : inv * r - 1 ≡ 0 [SMOD m ^ n • (⊤ : Submodule R R)] := by
by_cases npos : 0 < n
· apply SModEq.sub_mem.mpr
simp only [smul_eq_mul, Ideal.mul_top, sub_zero, ← eq_zero_iff_mem]
rw [map_sub, map_one, map_mul, ← sub_add_cancel inv (invSeries n), map_add]
have := SModEq.sub_mem.mp (hinv n).symm
simp only [smul_eq_mul, Ideal.mul_top] at this
simp [Ideal.Quotient.eq_zero_iff_mem.mpr this, invSeries_spec npos, invSeries_spec']
· simp [Nat.eq_zero_of_not_pos npos]
apply isUnit_iff_exists_inv'.mpr
use inv
exact sub_eq_zero.mp <| IsHausdorff.haus IsAdicComplete.toIsHausdorff (inv * r - 1) eq
... | lemma | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.LocalRing.Defs"
] | Mathlib/RingTheory/AdicCompletion/LocalRing.lean | isUnit_iff_notMem_of_isAdicComplete_maximal | null |
isLocalRing_of_isAdicComplete_maximal [IsAdicComplete m R] : IsLocalRing R where
exists_pair_ne := ⟨0, 1, ne_of_mem_of_not_mem m.zero_mem
(m.ne_top_iff_one.mp (Ideal.IsMaximal.ne_top hmax))⟩
isUnit_or_isUnit_of_add_one {a b} hab := by
simp only [isUnit_iff_notMem_of_isAdicComplete_maximal m]
by_contra! h
absurd m.add_mem h.1 h.2
simpa [hab] using m.ne_top_iff_one.mp (Ideal.IsMaximal.ne_top hmax) | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.LocalRing.Defs"
] | Mathlib/RingTheory/AdicCompletion/LocalRing.lean | isLocalRing_of_isAdicComplete_maximal | null |
IsHausdorff.of_le_jacobson (h : I ≤ Ideal.jacobson ⊥) : IsHausdorff I M :=
⟨fun x hx ↦ (Ideal.iInf_pow_smul_eq_bot_of_le_jacobson I h).le (by simpa [SModEq.zero] using hx)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Noetherian.lean | IsHausdorff.of_le_jacobson | null |
IsHausdorff.of_isLocalRing [IsLocalRing R] (h : I ≠ ⊤) : IsHausdorff I M :=
of_le_jacobson I M ((le_maximalIdeal h).trans (maximalIdeal_le_jacobson _)) | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Noetherian.lean | IsHausdorff.of_isLocalRing | null |
IsHausdorff.of_noZeroSMulDivisors [NoZeroSMulDivisors R M] (h : I ≠ ⊤) : IsHausdorff I M :=
⟨fun x hx ↦ (I.iInf_pow_smul_eq_bot_of_noZeroSMulDivisors h).le (by simpa [SModEq.zero] using hx)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Noetherian.lean | IsHausdorff.of_noZeroSMulDivisors | null |
IsHausdorff.of_isDomain [IsDomain R] (h : I ≠ ⊤) : IsHausdorff I R :=
.of_noZeroSMulDivisors I R h | theorem | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.RingTheory.Filtration"
] | Mathlib/RingTheory/AdicCompletion/Noetherian.lean | IsHausdorff.of_isDomain | null |
protected IsAdic.isPrecomplete_iff : IsPrecomplete I R ↔ CompleteSpace R := by
have := hI.hasBasis_nhds_zero.isCountablyGenerated
have : (𝓤 R).IsCountablyGenerated := IsUniformAddGroup.uniformity_countably_generated
simp only [isPrecomplete_iff, smul_eq_mul, Ideal.mul_top, SModEq.sub_mem]
constructor
· intro H
refine UniformSpace.complete_of_cauchySeq_tendsto fun u hu ↦ ?_
have : ∀ i, ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → u n - u m ∈ I ^ i := by
simpa using hI.hasBasis_nhds_zero.uniformity_of_nhds_zero.cauchySeq_iff.mp hu
choose N hN using this
obtain ⟨L, hL⟩ := H (fun i ↦ u ((Finset.Iic i).sup N))
fun _ ↦ hN _ _ (Finset.le_sup (by simpa)) _ (Finset.le_sup (by simp))
use L
suffices ∀ i, ∃ N, ∀ n, N ≤ n → u n - L ∈ I ^ i by
simpa [(hI.hasBasis_nhds L).tendsto_right_iff, sub_eq_neg_add]
refine fun i ↦ ⟨(Finset.Iic i).sup N, fun n hn ↦ ?_⟩
have := Ideal.add_mem _ (hN i ((Finset.Iic i).sup N) (Finset.le_sup (by simp))
n (.trans (Finset.le_sup (by simp)) hn)) (hL i)
rwa [sub_add_sub_cancel] at this
· intro H f hf
obtain ⟨L, hL⟩ := CompleteSpace.complete (f := Filter.atTop.map f)
(hI.hasBasis_nhds_zero.uniformity_of_nhds_zero.cauchySeq_iff.mpr fun i _ ↦
⟨i, fun m hm n hn ↦ by simpa using Ideal.sub_mem _ (hf hm) (hf hn)⟩)
refine ⟨L, fun i ↦ ?_⟩
obtain ⟨N, hN⟩ : ∃ N, ∀ n, N ≤ n → f n - L ∈ I ^ i := by
simpa [sub_eq_neg_add] using (hI.hasBasis_nhds L).tendsto_right_iff.mp hL i
simpa using Ideal.add_mem _ (hN (max i N) le_sup_right) (hf (le_max_left i N)) | lemma | RingTheory | [
"Mathlib.RingTheory.AdicCompletion.Basic",
"Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology"
] | Mathlib/RingTheory/AdicCompletion/Topology.lean | IsAdic.isPrecomplete_iff | `IsPrecomplete I R` is equivalent to being complete in the adic topology. |
adjoin_prod_le (s : Set A) (t : Set B) :
adjoin R (s ×ˢ t) ≤ (adjoin R s).prod (adjoin R t) :=
adjoin_le <| Set.prod_mono subset_adjoin subset_adjoin | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_prod_le | null |
adjoin_inl_union_inr_eq_prod (s) (t) :
adjoin R (LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1})) =
(adjoin R s).prod (adjoin R t) := by
apply le_antisymm
· simp only [adjoin_le_iff, Set.insert_subset_iff, Subalgebra.zero_mem, Subalgebra.one_mem,
subset_adjoin,-- the rest comes from `squeeze_simp`
Set.union_subset_iff,
LinearMap.coe_inl, Set.mk_preimage_prod_right, Set.image_subset_iff, SetLike.mem_coe,
Set.mk_preimage_prod_left, LinearMap.coe_inr, and_self_iff, Set.union_singleton,
Subalgebra.coe_prod]
· rintro ⟨a, b⟩ ⟨ha, hb⟩
let P := adjoin R (LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1}))
have Ha : (a, (0 : B)) ∈ adjoin R (LinearMap.inl R A B '' (s ∪ {1})) :=
mem_adjoin_of_map_mul R LinearMap.inl_map_mul ha
have Hb : ((0 : A), b) ∈ adjoin R (LinearMap.inr R A B '' (t ∪ {1})) :=
mem_adjoin_of_map_mul R LinearMap.inr_map_mul hb
replace Ha : (a, (0 : B)) ∈ P := adjoin_mono Set.subset_union_left Ha
replace Hb : ((0 : A), b) ∈ P := adjoin_mono Set.subset_union_right Hb
simpa [P] using Subalgebra.add_mem _ Ha Hb
variable (A) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_inl_union_inr_eq_prod | null |
adjoin_algebraMap (s : Set S) :
adjoin R (algebraMap S A '' s) = (adjoin R s).map (IsScalarTower.toAlgHom R S A) :=
adjoin_image R (IsScalarTower.toAlgHom R S A) s | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_algebraMap | null |
adjoin_algebraMap_image_union_eq_adjoin_adjoin (s : Set S) (t : Set A) :
adjoin R (algebraMap S A '' s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R :=
le_antisymm
(closure_mono <|
Set.union_subset (Set.range_subset_iff.2 fun r => Or.inl ⟨algebraMap R (adjoin R s) r,
(IsScalarTower.algebraMap_apply _ _ _ _).symm⟩)
(Set.union_subset_union_left _ fun _ ⟨_x, hx, hxs⟩ => hxs ▸ ⟨⟨_, subset_adjoin hx⟩, rfl⟩))
(closure_le.2 <|
Set.union_subset (Set.range_subset_iff.2 fun x => adjoin_mono Set.subset_union_left <|
Algebra.adjoin_algebraMap R A s ▸ ⟨x, x.prop, rfl⟩)
(Set.Subset.trans Set.subset_union_right subset_adjoin)) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_algebraMap_image_union_eq_adjoin_adjoin | null |
adjoin_adjoin_of_tower (s : Set A) : adjoin S (adjoin R s : Set A) = adjoin S s := by
apply le_antisymm (adjoin_le _)
· exact adjoin_mono subset_adjoin
· rw [← Subalgebra.coe_restrictScalars R (S := S), SetLike.coe_subset_coe]
exact adjoin_le subset_adjoin | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_adjoin_of_tower | null |
Subalgebra.restrictScalars_adjoin {s : Set A} :
(adjoin S s).restrictScalars R = (IsScalarTower.toAlgHom R S A).range ⊔ adjoin R s := by
refine le_antisymm (fun _ hx ↦ adjoin_induction
(fun x hx ↦ le_sup_right (α := Subalgebra R A) (subset_adjoin hx))
(fun x ↦ le_sup_left (α := Subalgebra R A) ⟨x, rfl⟩)
(fun _ _ _ _ ↦ add_mem) (fun _ _ _ _ ↦ mul_mem) <|
(Subalgebra.mem_restrictScalars _).mp hx) (sup_le ?_ <| adjoin_le subset_adjoin)
rintro _ ⟨x, rfl⟩; exact algebraMap_mem (adjoin S s) x
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | Subalgebra.restrictScalars_adjoin | null |
adjoin_top {A} [Semiring A] [Algebra S A] (t : Set A) :
adjoin (⊤ : Subalgebra R S) t = (adjoin S t).restrictScalars (⊤ : Subalgebra R S) :=
let equivTop : Subalgebra (⊤ : Subalgebra R S) A ≃o Subalgebra S A :=
{ toFun := fun s => { s with algebraMap_mem' := fun r => s.algebraMap_mem ⟨r, trivial⟩ }
invFun := fun s => s.restrictScalars _
left_inv := fun _ => SetLike.coe_injective rfl
right_inv := fun _ => SetLike.coe_injective rfl
map_rel_iff' := @fun _ _ => Iff.rfl }
le_antisymm
(adjoin_le <| show t ⊆ adjoin S t from subset_adjoin)
(equivTop.symm_apply_le.mpr <|
adjoin_le <| show t ⊆ adjoin (⊤ : Subalgebra R S) t from subset_adjoin) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_top | null |
adjoin_union_eq_adjoin_adjoin :
adjoin R (s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R := by
simpa using adjoin_algebraMap_image_union_eq_adjoin_adjoin R s t | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_union_eq_adjoin_adjoin | null |
adjoin_eq_adjoin_union [CommSemiring B] [Algebra R B] [Algebra A B]
[IsScalarTower R A B] (s : Set A) (t : Set B) (hS : adjoin R s = ⊤) :
(adjoin A t).restrictScalars R = adjoin R ((algebraMap A B '' s) ∪ t) := by
have := congr_arg (Subalgebra.map (IsScalarTower.toAlgHom R A B)) hS
rw [Algebra.map_top, AlgHom.map_adjoin, IsScalarTower.coe_toAlgHom'] at this
rw [adjoin_union_eq_adjoin_adjoin, this, ← IsScalarTower.adjoin_range_toAlgHom]
variable {R} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_eq_adjoin_union | If `A` is spanned over `R` by `s`, then the algebra spanned over `A` by `t` is the equal to the
algebra spanned over `R` by `s ∪ t`. |
pow_smul_mem_of_smul_subset_of_mem_adjoin [CommSemiring B] [Algebra R B] [Algebra A B]
[IsScalarTower R A B] (r : A) (s : Set B) (B' : Subalgebra R B) (hs : r • s ⊆ B') {x : B}
(hx : x ∈ adjoin R s) (hr : algebraMap A B r ∈ B') : ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ B' := by
change x ∈ Subalgebra.toSubmodule (adjoin R s) at hx
rw [adjoin_eq_span, Finsupp.mem_span_iff_linearCombination] at hx
rcases hx with ⟨l, rfl : (l.sum fun (i : Submonoid.closure s) (c : R) => c • (i : B)) = x⟩
choose n₁ n₂ using fun x : Submonoid.closure s => Submonoid.pow_smul_mem_closure_smul r s x.prop
use l.support.sup n₁
intro n hn
rw [Finsupp.smul_sum]
refine B'.toSubmodule.sum_mem ?_
intro a ha
have : n ≥ n₁ a := le_trans (Finset.le_sup ha) hn
dsimp only
rw [← tsub_add_cancel_of_le this, pow_add, ← smul_smul, ←
IsScalarTower.algebraMap_smul A (l a) (a : B), smul_smul (r ^ n₁ a), mul_comm, ← smul_smul,
smul_def, map_pow, IsScalarTower.algebraMap_smul]
apply Subalgebra.mul_mem _ (Subalgebra.pow_mem _ hr _) _
refine Subalgebra.smul_mem _ ?_ _
change _ ∈ B'.toSubmonoid
rw [← Submonoid.closure_eq B'.toSubmonoid]
apply Submonoid.closure_mono hs (n₂ a) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | pow_smul_mem_of_smul_subset_of_mem_adjoin | null |
pow_smul_mem_adjoin_smul (r : R) (s : Set A) {x : A} (hx : x ∈ adjoin R s) :
∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ adjoin R (r • s) :=
pow_smul_mem_of_smul_subset_of_mem_adjoin r s _ subset_adjoin hx (Subalgebra.algebraMap_mem _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | pow_smul_mem_adjoin_smul | null |
adjoin_nonUnitalSubalgebra_eq_span (s : NonUnitalSubalgebra R A) :
Subalgebra.toSubmodule (adjoin R (s : Set A)) = span R {1} ⊔ s.toSubmodule := by
rw [adjoin_eq_span, Submonoid.closure_eq_one_union, span_union, ← NonUnitalAlgebra.adjoin_eq_span,
NonUnitalAlgebra.adjoin_eq] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | adjoin_nonUnitalSubalgebra_eq_span | null |
Subalgebra.adjoin_eq_span_basis {ι : Type*} (bL : Basis ι F L) :
toSubmodule (adjoin E (L : Set K)) = span E (Set.range fun i : ι ↦ (bL i).1) :=
L.adjoin_eq_span_of_eq_span E <| by
simpa only [← L.range_val, Submodule.map_span, Submodule.map_top, ← Set.range_comp]
using congr_arg (Submodule.map L.val) bL.span_eq.symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | Subalgebra.adjoin_eq_span_basis | If `K / E / F` is a ring extension tower, `L` is a subalgebra of `K / F`,
then `E[L]` is generated by any basis of `L / F` as an `E`-module. |
Algebra.restrictScalars_adjoin (F : Type*) [CommSemiring F] {E : Type*} [CommSemiring E]
[Algebra F E] (K : Subalgebra F E) (S : Set E) :
(Algebra.adjoin K S).restrictScalars F = Algebra.adjoin F (K ∪ S) := by
conv_lhs => rw [← Algebra.adjoin_eq K, ← Algebra.adjoin_union_eq_adjoin_adjoin] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | Algebra.restrictScalars_adjoin | null |
Algebra.restrictScalars_adjoin_of_algEquiv
{F E L L' : Type*} [CommSemiring F] [CommSemiring L] [CommSemiring L'] [Semiring E]
[Algebra F L] [Algebra L E] [Algebra F L'] [Algebra L' E] [Algebra F E]
[IsScalarTower F L E] [IsScalarTower F L' E] (i : L ≃ₐ[F] L')
(hi : algebraMap L E = (algebraMap L' E) ∘ i) (S : Set E) :
(Algebra.adjoin L S).restrictScalars F = (Algebra.adjoin L' S).restrictScalars F := by
apply_fun Subalgebra.toSubsemiring using fun K K' h ↦ by rwa [SetLike.ext'_iff] at h ⊢
change Subsemiring.closure _ = Subsemiring.closure _
rw [hi, Set.range_comp, EquivLike.range_eq_univ, Set.image_univ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Prod",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.LinearAlgebra.Prod"
] | Mathlib/RingTheory/Adjoin/Basic.lean | Algebra.restrictScalars_adjoin_of_algEquiv | If `E / L / F` and `E / L' / F` are two ring extension towers, `L ≃ₐ[F] L'` is an isomorphism
compatible with `E / L` and `E / L'`, then for any subset `S` of `E`, `L[S]` and `L'[S]` are
equal as subalgebras of `E / F`. |
rank_sup_le_of_free : Module.rank R ↥(A ⊔ B) ≤ Module.rank R A * Module.rank R B := by
obtain ⟨ιA, bA⟩ := Free.exists_basis (R := R) (M := A)
obtain ⟨ιB, bB⟩ := Free.exists_basis (R := R) (M := B)
have h := Algebra.adjoin_union_coe_submodule R (A : Set S) (B : Set S)
rw [A.adjoin_eq_span_basis R bA, B.adjoin_eq_span_basis R bB, ← Algebra.sup_def,
Submodule.span_mul_span] at h
change Module.rank R ↥(toSubmodule (A ⊔ B)) ≤ _
rw [h, ← bA.mk_eq_rank'', ← bB.mk_eq_rank'']
refine (rank_span_le _).trans Cardinal.mk_mul_le |>.trans ?_
gcongr <;> exact Cardinal.mk_range_le | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Card",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.RingTheory.Adjoin.Basic"
] | Mathlib/RingTheory/Adjoin/Dimension.lean | rank_sup_le_of_free | If `A` and `B` are subalgebras of a commutative `R`-algebra `S`, both of them are
free `R`-algebras, then the rank of the rank of the subalgebra generated by `A` and `B`
over `R` is less than or equal to the product of that of `A` and `B`. |
finrank_sup_le_of_free : finrank R ↥(A ⊔ B) ≤ finrank R A * finrank R B := by
by_cases h : Module.Finite R A ∧ Module.Finite R B
· obtain ⟨_, _⟩ := h
simpa only [map_mul] using Cardinal.toNat_le_toNat (A.rank_sup_le_of_free B)
(Cardinal.mul_lt_aleph0 (rank_lt_aleph0 R A) (rank_lt_aleph0 R B))
wlog hA : ¬ Module.Finite R A generalizing A B
· have := this B A (fun h' ↦ h h'.symm) (not_and.1 h (of_not_not hA))
rwa [sup_comm, mul_comm] at this
rw [← rank_lt_aleph0_iff, not_lt] at hA
have := LinearMap.rank_le_of_injective _ <| Submodule.inclusion_injective <|
show toSubmodule A ≤ toSubmodule (A ⊔ B) by simp
rw [show finrank R A = 0 from Cardinal.toNat_apply_of_aleph0_le hA,
show finrank R ↥(A ⊔ B) = 0 from Cardinal.toNat_apply_of_aleph0_le (hA.trans this), zero_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Card",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.RingTheory.Adjoin.Basic"
] | Mathlib/RingTheory/Adjoin/Dimension.lean | finrank_sup_le_of_free | If `A` and `B` are subalgebras of a commutative `R`-algebra `S`, both of them are
free `R`-algebras, then the `Module.finrank` of the rank of the subalgebra generated by `A` and `B`
over `R` is less than or equal to the product of that of `A` and `B`. |
fg_trans (h1 : (adjoin R s).toSubmodule.FG) (h2 : (adjoin (adjoin R s) t).toSubmodule.FG) :
(adjoin R (s ∪ t)).toSubmodule.FG := by
rcases fg_def.1 h1 with ⟨p, hp, hp'⟩
rcases fg_def.1 h2 with ⟨q, hq, hq'⟩
refine fg_def.2 ⟨p * q, hp.mul hq, le_antisymm ?_ ?_⟩
· rw [span_le, Set.mul_subset_iff]
intro x hx y hy
change x * y ∈ adjoin R (s ∪ t)
refine Subalgebra.mul_mem _ ?_ ?_
· have : x ∈ Subalgebra.toSubmodule (adjoin R s) := by
rw [← hp']
exact subset_span hx
exact adjoin_mono Set.subset_union_left this
have : y ∈ Subalgebra.toSubmodule (adjoin (adjoin R s) t) := by
rw [← hq']
exact subset_span hy
change y ∈ adjoin R (s ∪ t)
rwa [adjoin_union_eq_adjoin_adjoin]
· intro r hr
change r ∈ adjoin R (s ∪ t) at hr
rw [adjoin_union_eq_adjoin_adjoin] at hr
change r ∈ Subalgebra.toSubmodule (adjoin (adjoin R s) t) at hr
rw [← hq', ← Set.image_id q, Finsupp.mem_span_image_iff_linearCombination (adjoin R s)] at hr
rcases hr with ⟨l, hlq, rfl⟩
have := @Finsupp.linearCombination_apply A A (adjoin R s)
rw [this, Finsupp.sum]
refine sum_mem ?_
intro z hz
change (l z).1 * _ ∈ _
have : (l z).1 ∈ Subalgebra.toSubmodule (adjoin R s) := (l z).2
rw [← hp', ← Set.image_id p, Finsupp.mem_span_image_iff_linearCombination R] at this
rcases this with ⟨l2, hlp, hl⟩
have := @Finsupp.linearCombination_apply A A R
rw [this] at hl
rw [← hl, Finsupp.sum_mul]
refine sum_mem ?_
intro t ht
change _ * _ ∈ _
rw [smul_mul_assoc]
refine smul_mem _ _ ?_
exact subset_span ⟨t, hlp ht, z, hlq hz, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_trans | null |
FG (S : Subalgebra R A) : Prop :=
∃ t : Finset A, Algebra.adjoin R ↑t = S | def | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | FG | A subalgebra `S` is finitely generated if there exists `t : Finset A` such that
`Algebra.adjoin R t = S`. |
fg_adjoin_finset (s : Finset A) : (Algebra.adjoin R (↑s : Set A)).FG :=
⟨s, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_adjoin_finset | null |
fg_def {S : Subalgebra R A} : S.FG ↔ ∃ t : Set A, Set.Finite t ∧ Algebra.adjoin R t = S :=
Iff.symm Set.exists_finite_iff_finset | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_def | null |
fg_bot : (⊥ : Subalgebra R A).FG :=
⟨∅, Finset.coe_empty ▸ Algebra.adjoin_empty R A⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_bot | null |
fg_of_fg_toSubmodule {S : Subalgebra R A} : S.toSubmodule.FG → S.FG :=
fun ⟨t, ht⟩ ↦ ⟨t, le_antisymm
(Algebra.adjoin_le fun x hx ↦ show x ∈ Subalgebra.toSubmodule S from ht ▸ subset_span hx) <|
show Subalgebra.toSubmodule S ≤ Subalgebra.toSubmodule (Algebra.adjoin R ↑t) from fun x hx ↦
span_le.mpr (fun _ hx ↦ Algebra.subset_adjoin hx)
(show x ∈ span R ↑t by
rw [ht]
exact hx)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_of_fg_toSubmodule | null |
fg_of_noetherian [IsNoetherian R A] (S : Subalgebra R A) : S.FG :=
fg_of_fg_toSubmodule (IsNoetherian.noetherian (Subalgebra.toSubmodule S)) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_of_noetherian | null |
fg_of_submodule_fg (h : (⊤ : Submodule R A).FG) : (⊤ : Subalgebra R A).FG :=
let ⟨s, hs⟩ := h
⟨s, toSubmodule.injective <| by
rw [Algebra.top_toSubmodule, eq_top_iff, ← hs, span_le]
exact Algebra.subset_adjoin⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_of_submodule_fg | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.