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
⌀ |
|---|---|---|---|---|---|---|
isClopen_sphere {r : ValueGroupWithZero R} (hr : r ≠ 0) :
IsClopen {x | v x = r} := by
have h : {x : R | v x = r} = {x | v x ≤ r} \ {x | v x < r} := by
ext x
simp [← le_antisymm_iff]
rw [h]
exact IsClopen.diff (isClopen_closedBall hr) (isClopen_ball _)
@[deprecated (since := "2025-08-01")]
alias _root_.ValuativeTopology.isClopen_sphere := isClopen_sphere
|
theorem
|
Topology
|
[
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology"
] |
Mathlib/Topology/Algebra/Valued/ValuativeRel.lean
|
isClopen_sphere
| null |
isOpen_sphere {r : ValueGroupWithZero R} (hr : r ≠ 0) :
IsOpen {x | v x = r} :=
isClopen_sphere hr |>.isOpen
@[deprecated (since := "2025-08-01")]
alias _root_.ValuativeTopology.isOpen_sphere := isOpen_sphere
open WithZeroTopology in
|
lemma
|
Topology
|
[
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology"
] |
Mathlib/Topology/Algebra/Valued/ValuativeRel.lean
|
isOpen_sphere
| null |
continuous_valuation : Continuous v := by
simp only [continuous_iff_continuousAt, ContinuousAt]
rintro x
by_cases hx : v x = 0
· simpa [hx, (hasBasis_nhds _).tendsto_iff WithZeroTopology.hasBasis_nhds_zero,
Valuation.map_sub_of_right_eq_zero _ hx] using fun i hi ↦ ⟨.mk0 i hi, fun y ↦ id⟩
· simpa [(hasBasis_nhds _).tendsto_iff (WithZeroTopology.hasBasis_nhds_of_ne_zero hx)]
using ⟨.mk0 (v x) hx, fun _ ↦ Valuation.map_eq_of_sub_lt _⟩
|
lemma
|
Topology
|
[
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology"
] |
Mathlib/Topology/Algebra/Valued/ValuativeRel.lean
|
continuous_valuation
| null |
Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
(h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
have key : v x = v y := Valuation.map_eq_of_sub_lt v hyp2
have x_ne : x ≠ 0 := by
intro h
apply y_ne
rw [h, v.map_zero] at key
exact v.zero_iff.1 key.symm
have decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹ := by
rw [mul_sub_left_distrib, sub_mul, mul_assoc, show y * y⁻¹ = 1 from mul_inv_cancel₀ y_ne,
show x⁻¹ * x = 1 from inv_mul_cancel₀ x_ne, mul_one, one_mul]
calc
v (x⁻¹ - y⁻¹) = v (x⁻¹ * (y - x) * y⁻¹) := by rw [decomp]
_ = v x⁻¹ * (v <| y - x) * v y⁻¹ := by repeat' rw [Valuation.map_mul]
_ = (v x)⁻¹ * (v <| y - x) * (v y)⁻¹ := by rw [map_inv₀, map_inv₀]
_ = (v <| y - x) * (v y * v y)⁻¹ := by rw [mul_assoc, mul_comm, key, mul_assoc, mul_inv_rev]
_ = (v <| y - x) * (v y * v y)⁻¹ := rfl
_ = (v <| x - y) * (v y * v y)⁻¹ := by rw [Valuation.map_sub_swap]
_ < γ := hyp1'
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
Valuation.inversion_estimate
| null |
Valuation.inversion_estimate' {x y r s : K} (y_ne : y ≠ 0) (hr : r ≠ 0) (hs : s ≠ 0)
(h : v (x - y) < min ((v s / v r) * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) * v r < v s := by
have hr' : 0 < v r := by simp [zero_lt_iff, hr]
let γ : Γ₀ˣ := .mk0 (v s / v r) (by simp [hs, hr])
calc
v (x⁻¹ - y⁻¹) * v r < γ * v r := by gcongr; exact Valuation.inversion_estimate v y_ne h
_ = v s := div_mul_cancel₀ _ (by simpa)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
Valuation.inversion_estimate'
| null |
noncomputable extension : hat K → Γ₀ :=
Completion.isDenseInducing_coe.extend (v : K → Γ₀)
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
extension
|
The topology coming from a valuation on a division ring makes it a topological division ring
[BouAC, VI.5.1 middle of Proposition 1] -/
instance (priority := 100) Valued.isTopologicalDivisionRing [Valued K Γ₀] :
IsTopologicalDivisionRing K :=
{ (by infer_instance : IsTopologicalRing K) with
continuousAt_inv₀ := by
intro x x_ne s s_in
obtain ⟨γ, hs⟩ := Valued.mem_nhds.mp s_in; clear s_in
rw [mem_map, Valued.mem_nhds]
change ∃ γ : Γ₀ˣ, { y : K | (v (y - x) : Γ₀) < γ } ⊆ { x : K | x⁻¹ ∈ s }
have vx_ne := (Valuation.ne_zero_iff <| v).mpr x_ne
let γ' := Units.mk0 _ vx_ne
use min (γ * (γ' * γ')) γ'
intro y y_in
apply hs
simp only [mem_setOf_eq] at y_in
rw [Units.min_val, Units.val_mul, Units.val_mul] at y_in
exact Valuation.inversion_estimate _ x_ne y_in }
/-- A valued division ring is separated. -/
instance (priority := 100) ValuedRing.separated [Valued K Γ₀] : T0Space K := by
suffices T2Space K by infer_instance
apply IsTopologicalAddGroup.t2Space_of_zero_sep
intro x x_ne
refine ⟨{ k | v k < v x }, ?_, fun h => lt_irrefl _ h⟩
rw [Valued.mem_nhds]
have vx_ne := (Valuation.ne_zero_iff <| v).mpr x_ne
let γ' := Units.mk0 _ vx_ne
exact ⟨γ', fun y hy => by simpa using hy⟩
section
open WithZeroTopology
open Valued
theorem Valued.continuous_valuation [Valued K Γ₀] : Continuous (v : K → Γ₀) := by
rw [continuous_iff_continuousAt]
intro x
rcases eq_or_ne x 0 with (rfl | h)
· rw [ContinuousAt, map_zero, WithZeroTopology.tendsto_zero]
intro γ hγ
rw [Filter.Eventually, Valued.mem_nhds_zero]
use Units.mk0 γ hγ; rfl
· have v_ne : (v x : Γ₀) ≠ 0 := (Valuation.ne_zero_iff _).mpr h
rw [ContinuousAt, WithZeroTopology.tendsto_of_ne_zero v_ne]
apply Valued.loc_const v_ne
end
end ValuationTopologicalDivisionRing
end DivisionRing
namespace Valued
open UniformSpace
variable {K : Type*} [Field K] {Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
local notation "hat " => Completion
/-- A valued field is completable. -/
instance (priority := 100) completable : CompletableTopField K :=
{ ValuedRing.separated with
nice := by
rintro F hF h0
have : ∃ γ₀ : Γ₀ˣ, ∃ M ∈ F, ∀ x ∈ M, (γ₀ : Γ₀) ≤ v x := by
rcases Filter.inf_eq_bot_iff.mp h0 with ⟨U, U_in, M, M_in, H⟩
rcases Valued.mem_nhds_zero.mp U_in with ⟨γ₀, hU⟩
exists γ₀, M, M_in
intro x xM
apply le_of_not_gt _
intro hyp
have : x ∈ U ∩ M := ⟨hU hyp, xM⟩
rwa [H] at this
rcases this with ⟨γ₀, M₀, M₀_in, H₀⟩
rw [Valued.cauchy_iff] at hF ⊢
refine ⟨hF.1.map _, ?_⟩
replace hF := hF.2
intro γ
rcases hF (min (γ * γ₀ * γ₀) γ₀) with ⟨M₁, M₁_in, H₁⟩
clear hF
use (fun x : K => x⁻¹) '' (M₀ ∩ M₁)
constructor
· rw [mem_map]
apply mem_of_superset (Filter.inter_mem M₀_in M₁_in)
exact subset_preimage_image _ _
· rintro _ ⟨x, ⟨x_in₀, x_in₁⟩, rfl⟩ _ ⟨y, ⟨_, y_in₁⟩, rfl⟩
simp only
specialize H₁ x x_in₁ y y_in₁
replace x_in₀ := H₀ x x_in₀
clear H₀
apply Valuation.inversion_estimate
· have : (v x : Γ₀) ≠ 0 := by
intro h
rw [h] at x_in₀
simp at x_in₀
exact (Valuation.ne_zero_iff _).mp this
· refine lt_of_lt_of_le H₁ ?_
rw [Units.min_val]
apply min_le_min _ x_in₀
rw [mul_assoc]
have : ((γ₀ * γ₀ : Γ₀ˣ) : Γ₀) ≤ v x * v x :=
calc
↑γ₀ * ↑γ₀ ≤ ↑γ₀ * v x := mul_le_mul_left' x_in₀ ↑γ₀
_ ≤ _ := mul_le_mul_right' x_in₀ (v x)
rw [Units.val_mul]
exact mul_le_mul_left' this γ }
open WithZeroTopology
lemma valuation_isClosedMap : IsClosedMap (v : K → Γ₀) := by
refine IsClosedMap.of_nonempty ?_
intro U hU hU'
simp only [← isOpen_compl_iff, isOpen_iff_mem_nhds, mem_compl_iff, mem_nhds, subset_compl_comm,
compl_setOf, not_lt] at hU
simp only [isClosed_iff, mem_image, map_eq_zero, exists_eq_right, ne_eq, image_subset_iff]
refine (em _).imp_right fun h ↦ ?_
obtain ⟨γ, h⟩ := hU _ h
simp only [sub_zero] at h
refine ⟨γ, γ.ne_zero, h.trans ?_⟩
intro
simp
/-- The extension of the valuation of a valued field to the completion of the field.
|
continuous_extension : Continuous (Valued.extension : hat K → Γ₀) := by
refine Completion.isDenseInducing_coe.continuous_extend ?_
intro x₀
rcases eq_or_ne x₀ 0 with (rfl | h)
· refine ⟨0, ?_⟩
erw [← Completion.isDenseInducing_coe.isInducing.nhds_eq_comap]
exact Valued.continuous_valuation.tendsto' 0 0 (map_zero v)
· have preimage_one : v ⁻¹' {(1 : Γ₀)} ∈ 𝓝 (1 : K) := by
have : (v (1 : K) : Γ₀) ≠ 0 := by
rw [Valuation.map_one]
exact zero_ne_one.symm
convert Valued.loc_const this
ext x
rw [Valuation.map_one, mem_preimage, mem_singleton_iff, mem_setOf_eq]
obtain ⟨V, V_in, hV⟩ : ∃ V ∈ 𝓝 (1 : hat K), ∀ x : K, (x : hat K) ∈ V → (v x : Γ₀) = 1 := by
rwa [Completion.isDenseInducing_coe.nhds_eq_comap, mem_comap] at preimage_one
have : ∃ V' ∈ 𝓝 (1 : hat K), (0 : hat K) ∉ V' ∧ ∀ (x) (_ : x ∈ V') (y) (_ : y ∈ V'),
x * y⁻¹ ∈ V := by
have : Tendsto (fun p : hat K × hat K => p.1 * p.2⁻¹) ((𝓝 1) ×ˢ (𝓝 1)) (𝓝 1) := by
rw [← nhds_prod_eq]
conv =>
congr
rfl
rfl
rw [← one_mul (1 : hat K)]
refine
Tendsto.mul continuous_fst.continuousAt (Tendsto.comp ?_ continuous_snd.continuousAt)
convert (continuousAt_inv₀ (zero_ne_one.symm : 1 ≠ (0 : hat K))).tendsto
exact inv_one.symm
rcases tendsto_prod_self_iff.mp this V V_in with ⟨U, U_in, hU⟩
let hatKstar := ({0}ᶜ : Set <| hat K)
have : hatKstar ∈ 𝓝 (1 : hat K) := compl_singleton_mem_nhds zero_ne_one.symm
use U ∩ hatKstar, Filter.inter_mem U_in this
constructor
· rintro ⟨_, h'⟩
rw [mem_compl_singleton_iff] at h'
exact h' rfl
· rintro x ⟨hx, _⟩ y ⟨hy, _⟩
apply hU <;> assumption
rcases this with ⟨V', V'_in, zeroV', hV'⟩
have nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀ := by
have l : Function.LeftInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ := by
intro x
simp only [mul_assoc, mul_inv_cancel₀ h, mul_one]
have r : Function.RightInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ := by
intro x
simp only [mul_assoc, inv_mul_cancel₀ h, mul_one]
have c : Continuous fun x : hat K => x * x₀⁻¹ := continuous_id.mul continuous_const
rw [image_eq_preimage_of_inverse l r]
rw [← mul_inv_cancel₀ h] at V'_in
exact c.continuousAt V'_in
...
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
continuous_extension
| null |
extension_extends (x : K) : extension (x : hat K) = v x := by
refine Completion.isDenseInducing_coe.extend_eq_of_tendsto ?_
rw [← Completion.isDenseInducing_coe.nhds_eq_comap]
exact Valued.continuous_valuation.continuousAt
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
extension_extends
| null |
noncomputable extensionValuation : Valuation (hat K) Γ₀ where
toFun := Valued.extension
map_zero' := by
rw [← v.map_zero (R := K), ← Valued.extension_extends (0 : K)]
rfl
map_one' := by
rw [← Completion.coe_one, Valued.extension_extends (1 : K)]
exact Valuation.map_one _
map_mul' x y := by
apply Completion.induction_on₂ x y
(p := fun x y => extension (x * y) = extension x * extension y)
· have c1 : Continuous fun x : hat K × hat K => Valued.extension (x.1 * x.2) :=
Valued.continuous_extension.comp (continuous_fst.mul continuous_snd)
have c2 : Continuous fun x : hat K × hat K => Valued.extension x.1 * Valued.extension x.2 :=
(Valued.continuous_extension.comp continuous_fst).mul
(Valued.continuous_extension.comp continuous_snd)
exact isClosed_eq c1 c2
· intro x y
norm_cast
exact Valuation.map_mul _ _ _
map_add_le_max' x y := by
rw [le_max_iff]
apply Completion.induction_on₂ x y
(p := fun x y => extension (x + y) ≤ extension x ∨ extension (x + y) ≤ extension y)
· have cont : Continuous (Valued.extension : hat K → Γ₀) := Valued.continuous_extension
exact
(isClosed_le (cont.comp continuous_add) <| cont.comp continuous_fst).union
(isClosed_le (cont.comp continuous_add) <| cont.comp continuous_snd)
· intro x y
norm_cast
rw [← le_max_iff]
exact v.map_add x y
@[simp]
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
extensionValuation
|
the extension of a valuation on a division ring to its completion.
|
extensionValuation_apply_coe (x : K) :
Valued.extensionValuation (x : hat K) = v x :=
extension_extends x
@[simp]
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
extensionValuation_apply_coe
| null |
extension_eq_zero_iff {x : hat K} :
extension x = 0 ↔ x = 0 := by
suffices extensionValuation x = 0 ↔ x = 0 from this
simp
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
extension_eq_zero_iff
| null |
continuous_extensionValuation : Continuous (Valued.extensionValuation : hat K → Γ₀) :=
continuous_extension
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
continuous_extensionValuation
| null |
exists_coe_eq_v (x : hat K) : ∃ r : K, extensionValuation x = v r := by
rcases eq_or_ne x 0 with (rfl | h)
· use 0
exact extensionValuation_apply_coe 0
· refine Completion.denseRange_coe.induction_on x ?_ (by simp)
simpa [eq_comm] using
valuation_isClosedMap.isClosed_range.preimage continuous_extensionValuation
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
exists_coe_eq_v
| null |
closure_coe_completion_v_lt {γ : Γ₀ˣ} :
closure ((↑) '' { x : K | v x < (γ : Γ₀) }) =
{ x : hat K | extensionValuation x < (γ : Γ₀) } := by
ext x
let γ₀ := extensionValuation x
suffices γ₀ ≠ 0 → (x ∈ closure ((↑) '' { x : K | v x < (γ : Γ₀) }) ↔ γ₀ < (γ : Γ₀)) by
rcases eq_or_ne γ₀ 0 with h | h
· simp only [(Valuation.zero_iff _).mp h, mem_setOf_eq, Valuation.map_zero, Units.zero_lt,
iff_true]
apply subset_closure
exact ⟨0, by simp only [mem_setOf_eq, Valuation.map_zero, Units.zero_lt, true_and]; rfl⟩
· exact this h
intro h
have hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x :=
continuous_extension.continuousAt.preimage_mem_nhds
(WithZeroTopology.singleton_mem_nhds_of_ne_zero h)
rw [mem_closure_iff_nhds']
refine ⟨fun hx => ?_, fun hx s hs => ?_⟩
· obtain ⟨⟨-, y, hy₁ : v y < (γ : Γ₀), rfl⟩, hy₂⟩ := hx _ hγ₀
replace hy₂ : v y = γ₀ := by simpa using hy₂
rwa [← hy₂]
· obtain ⟨y, hy₁, hy₂⟩ := Completion.denseRange_coe.mem_nhds (inter_mem hγ₀ hs)
replace hy₁ : v y = γ₀ := by simpa using hy₁
rw [← hy₁] at hx
exact ⟨⟨y, ⟨y, hx, rfl⟩⟩, hy₂⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
closure_coe_completion_v_lt
| null |
closure_coe_completion_v_mul_v_lt {r s : K} (hr : r ≠ 0) (hs : s ≠ 0) :
closure ((↑) '' { x : K | v x * v r < v s }) =
{ x : hat K | extensionValuation x * v r < v s } := by
have hrs : v s / v r ≠ 0 := by simp [hr, hs]
convert closure_coe_completion_v_lt (γ := .mk0 _ hrs) using 3
all_goals simp [← lt_div_iff₀, zero_lt_iff, hr]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
closure_coe_completion_v_mul_v_lt
| null |
noncomputable valuedCompletion : Valued (hat K) Γ₀ where
v := extensionValuation
is_topological_valuation s := by
suffices
HasBasis (𝓝 (0 : hat K)) (fun _ => True) fun γ : Γ₀ˣ => { x | extensionValuation x < γ } by
rw [this.mem_iff]
exact exists_congr fun γ => by simp
simp_rw [← closure_coe_completion_v_lt]
exact (hasBasis_nhds_zero K Γ₀).hasBasis_of_isDenseInducing Completion.isDenseInducing_coe
@[simp]
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
valuedCompletion
| null |
valuedCompletion_apply (x : K) : Valued.v (x : hat K) = v x :=
extension_extends x
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
valuedCompletion_apply
| null |
valuedCompletion_surjective_iff :
Function.Surjective (v : hat K → Γ₀) ↔ Function.Surjective (v : K → Γ₀) := by
constructor <;> intro h γ <;> obtain ⟨a, ha⟩ := h γ
· induction a using Completion.induction_on
· by_cases H : ∃ x : K, (v : K → Γ₀) x = γ
· simp [H]
· simp only [H, imp_false]
rcases eq_or_ne γ 0 with rfl | hγ
· simp at H
· convert isClosed_univ.sdiff (isOpen_sphere (hat K) hγ) using 1
ext x
simp
· exact ⟨_, by simpa using ha⟩
· exact ⟨a, by simp [ha]⟩
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
valuedCompletion_surjective_iff
| null |
@[reducible]
integer : Subring K := (vK.v).integer
@[inherit_doc]
scoped notation "𝒪[" K "]" => Valued.integer K
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
integer
|
A `Valued` version of `Valuation.integer`, enabling the notation `𝒪[K]` for the
valuation integers of a valued field `K`.
|
@[reducible]
maximalIdeal : Ideal 𝒪[K] := IsLocalRing.maximalIdeal 𝒪[K]
@[inherit_doc]
scoped notation "𝓂[" K "]" => maximalIdeal K
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
maximalIdeal
|
An abbreviation for `IsLocalRing.maximalIdeal 𝒪[K]` of a valued field `K`, enabling the notation
`𝓂[K]` for the maximal ideal in `𝒪[K]` of a valued field `K`.
|
@[reducible]
ResidueField := IsLocalRing.ResidueField (𝒪[K])
@[inherit_doc]
scoped notation "𝓀[" K "]" => ResidueField K
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.Topology.Algebra.WithZeroTopology",
"Mathlib.Topology.Algebra.UniformField"
] |
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
ResidueField
|
An abbreviation for `IsLocalRing.ResidueField 𝒪[K]` of a `Valued` instance, enabling the
notation `𝓀[K]` for the residue field of a valued field `K`.
|
@[nolint unusedArguments]
WithVal [Ring R] : Valuation R Γ₀ → Type _ := fun _ => R
|
def
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
WithVal
|
Type synonym for a ring equipped with the topology coming from a valuation.
|
equiv : WithVal v ≃+* R := RingEquiv.refl _
|
def
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
equiv
|
Canonical ring equivalence between `WithVal v` and `R`.
|
apply_equiv (r : WithVal v) : v (equiv v r) = Valued.v r := rfl
@[simp] theorem apply_symm_equiv (r : R) : Valued.v ((equiv v).symm r) = v r := rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
apply_equiv
| null |
Completion := UniformSpace.Completion (WithVal v)
|
abbrev
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
Completion
|
The completion of a field with respect to a valuation.
|
@[simps!]
withValEquiv (R : Type*) [CommRing R] [Algebra R K] [IsIntegralClosure R ℤ K] :
𝓞 (WithVal v) ≃+* R := NumberField.RingOfIntegers.equiv R
|
def
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
withValEquiv
|
The ring equivalence between `𝓞 (WithVal v)` and an integral closure of
`ℤ` in `K`.
|
@[simps! apply]
Rat.ringOfIntegersWithValEquiv (v : Valuation ℚ Γ₀) : 𝓞 (WithVal v) ≃+* ℤ :=
NumberField.RingOfIntegers.withValEquiv v ℤ
|
def
|
Topology
|
[
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Valued.ValuationTopology",
"Mathlib.NumberTheory.NumberField.Basic"
] |
Mathlib/Topology/Algebra/Valued/WithVal.lean
|
Rat.ringOfIntegersWithValEquiv
|
The ring of integers of `WithVal v`, when `v` is a valuation on `ℚ`, is
equivalent to `ℤ`.
|
tendsto_zero_pow_of_v_lt_one [MulArchimedean Γ₀] [Valued R Γ₀] {x : R} (hx : v x < 1) :
Tendsto (fun n : ℕ ↦ x ^ n) atTop (𝓝 0) := by
simp only [(hasBasis_nhds_zero _ _).tendsto_right_iff, mem_setOf_eq, map_pow, eventually_atTop,
forall_const]
intro y
obtain ⟨n, hn⟩ := exists_pow_lt₀ hx y
refine ⟨n, fun m hm ↦ ?_⟩
refine hn.trans_le' ?_
exact pow_le_pow_right_of_le_one' hx.le hm
|
lemma
|
Topology
|
[
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.Topology.Algebra.Valued.ValuationTopology"
] |
Mathlib/Topology/Algebra/Valued/WithZeroMulInt.lean
|
tendsto_zero_pow_of_v_lt_one
| null |
tendsto_zero_pow_of_le_exp_neg_one [Valued R ℤᵐ⁰] {x : R} (hx : v x ≤ exp (-1)) :
Tendsto (fun n : ℕ ↦ x ^ n) atTop (𝓝 0) := by
refine tendsto_zero_pow_of_v_lt_one (hx.trans_lt ?_)
rw [← exp_zero, exp_lt_exp]
simp
|
lemma
|
Topology
|
[
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.Topology.Algebra.Valued.ValuationTopology"
] |
Mathlib/Topology/Algebra/Valued/WithZeroMulInt.lean
|
tendsto_zero_pow_of_le_exp_neg_one
|
In a `ℤᵐ⁰`-valued ring, powers of `x` tend to zero if `v x ≤ exp (-1)`.
|
exists_pow_lt_of_le_exp_neg_one [Valued R ℤᵐ⁰] {x : R} (hx : v x ≤ exp (-1)) (γ : ℤᵐ⁰ˣ) :
∃ n, v x ^ n < γ := by
refine exists_pow_lt₀ (hx.trans_lt ?_) _
rw [← exp_zero, exp_lt_exp]
simp
|
lemma
|
Topology
|
[
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.Topology.Algebra.Valued.ValuationTopology"
] |
Mathlib/Topology/Algebra/Valued/WithZeroMulInt.lean
|
exists_pow_lt_of_le_exp_neg_one
| null |
@[pp_with_univ]
ProfiniteGrp where
/-- The underlying profinite topological space. -/
toProfinite : Profinite
/-- The group structure. -/
[group : Group toProfinite]
/-- The above data together form a topological group. -/
[topologicalGroup : IsTopologicalGroup toProfinite]
|
structure
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp
|
The category of profinite groups. A term of this type consists of a profinite
set with a topological group structure.
|
@[pp_with_univ]
ProfiniteAddGrp where
/-- The underlying profinite topological space. -/
toProfinite : Profinite
/-- The additive group structure. -/
[addGroup : AddGroup toProfinite]
/-- The above data together form a topological additive group. -/
[topologicalAddGroup : IsTopologicalAddGroup toProfinite]
attribute [to_additive] ProfiniteGrp
@[to_additive]
|
structure
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteAddGrp
|
The category of profinite additive groups. A term of this type consists of a profinite
set with a topological additive group structure.
|
@[to_additive /-- Construct a term of `ProfiniteAddGrp` from a type endowed with the structure of a
compact and totally disconnected topological additive group.
(The condition of being Hausdorff can be omitted here because totally disconnected implies that {0}
is a closed set, thus implying Hausdorff in a topological additive group.) -/]
ProfiniteGrp.of (G : Type u) [Group G] [TopologicalSpace G] [IsTopologicalGroup G]
[CompactSpace G] [TotallyDisconnectedSpace G] : ProfiniteGrp.{u} where
toProfinite := .of G
group := ‹_›
topologicalGroup := ‹_›
@[to_additive]
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp.of
|
Construct a term of `ProfiniteGrp` from a type endowed with the structure of a
compact and totally disconnected topological group.
(The condition of being Hausdorff can be omitted here because totally disconnected implies that {1}
is a closed set, thus implying Hausdorff in a topological group.)
|
ProfiniteGrp.coe_of (G : Type u) [Group G] [TopologicalSpace G] [IsTopologicalGroup G]
[CompactSpace G] [TotallyDisconnectedSpace G] : (ProfiniteGrp.of G : Type u) = G :=
rfl
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp.coe_of
| null |
@[ext]
ProfiniteAddGrp.Hom (A B : ProfiniteAddGrp.{u}) where
private mk ::
/-- The underlying `ContinuousAddMonoidHom`. -/
hom' : A →ₜ+ B
|
structure
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteAddGrp.Hom
|
The type of morphisms in `ProfiniteAddGrp`.
|
@[to_additive existing (attr := ext)]
ProfiniteGrp.Hom (A B : ProfiniteGrp.{u}) where
private mk ::
/-- The underlying `ContinuousMonoidHom`. -/
hom' : A →ₜ* B
@[to_additive]
|
structure
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp.Hom
|
The type of morphisms in `ProfiniteGrp`.
|
@[to_additive /-- The underlying `ContinuousAddMonoidHom`. -/]
ProfiniteGrp.Hom.hom {M N : ProfiniteGrp.{u}} (f : ProfiniteGrp.Hom M N) :
M →ₜ* N :=
ConcreteCategory.hom (C := ProfiniteGrp) f
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp.Hom.hom
|
The underlying `ContinuousMonoidHom`.
|
@[to_additive /-- Typecheck a `ContinuousAddMonoidHom` as a morphism in `ProfiniteAddGrp`. -/]
ProfiniteGrp.ofHom {X Y : Type u} [Group X] [TopologicalSpace X] [IsTopologicalGroup X]
[CompactSpace X] [TotallyDisconnectedSpace X] [Group Y] [TopologicalSpace Y]
[IsTopologicalGroup Y] [CompactSpace Y] [TotallyDisconnectedSpace Y]
(f : X →ₜ* Y) : ProfiniteGrp.of X ⟶ ProfiniteGrp.of Y :=
ConcreteCategory.ofHom f
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ProfiniteGrp.ofHom
|
Typecheck a `ContinuousMonoidHom` as a morphism in `ProfiniteGrp`.
|
@[to_additive (attr := simp)]
hom_id {A : ProfiniteGrp.{u}} : (𝟙 A : A ⟶ A).hom = ContinuousMonoidHom.id A := rfl
/- Provided for rewriting. -/
@[to_additive]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
hom_id
| null |
id_apply (A : ProfiniteGrp.{u}) (a : A) :
(𝟙 A : A ⟶ A) a = a := by simp
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
id_apply
| null |
hom_comp {A B C : ProfiniteGrp.{u}} (f : A ⟶ B) (g : B ⟶ C) :
(f ≫ g).hom = g.hom.comp f.hom := rfl
/- Provided for rewriting. -/
@[to_additive]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
hom_comp
| null |
comp_apply {A B C : ProfiniteGrp.{u}} (f : A ⟶ B) (g : B ⟶ C) (a : A) :
(f ≫ g) a = g (f a) := by
simp only [hom_comp, ContinuousMonoidHom.comp_toFun]
@[to_additive (attr := ext)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
comp_apply
| null |
hom_ext {A B : ProfiniteGrp.{u}} {f g : A ⟶ B} (hf : f.hom = g.hom) : f = g :=
Hom.ext hf
variable {X Y Z : Type u} [Group X] [TopologicalSpace X] [IsTopologicalGroup X]
[CompactSpace X] [TotallyDisconnectedSpace X] [Group Y] [TopologicalSpace Y]
[IsTopologicalGroup Y] [CompactSpace Y] [TotallyDisconnectedSpace Y] [Group Z]
[TopologicalSpace Z] [IsTopologicalGroup Z] [CompactSpace Z] [TotallyDisconnectedSpace Z]
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
hom_ext
| null |
hom_ofHom (f : X →ₜ* Y) : (ofHom f).hom = f := rfl
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
hom_ofHom
| null |
ofHom_hom {A B : ProfiniteGrp.{u}} (f : A ⟶ B) :
ofHom (Hom.hom f) = f := rfl
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofHom_hom
| null |
ofHom_id : ofHom (ContinuousMonoidHom.id X) = 𝟙 (of X) := rfl
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofHom_id
| null |
ofHom_comp (f : X →ₜ* Y) (g : Y →ₜ* Z) :
ofHom (g.comp f) = ofHom f ≫ ofHom g :=
rfl
@[to_additive]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofHom_comp
| null |
ofHom_apply (f : X →ₜ* Y) (x : X) : ofHom f x = f x := rfl
@[to_additive]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofHom_apply
| null |
inv_hom_apply {A B : ProfiniteGrp.{u}} (e : A ≅ B) (x : A) : e.inv (e.hom x) = x := by
simp
@[to_additive]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
inv_hom_apply
| null |
hom_inv_apply {A B : ProfiniteGrp.{u}} (e : A ≅ B) (x : B) : e.hom (e.inv x) = x := by
simp
@[to_additive (attr := simp)]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
hom_inv_apply
| null |
coe_id (X : ProfiniteGrp) : (𝟙 X : X → X) = id :=
rfl
@[to_additive (attr := simp)]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
coe_id
| null |
coe_comp {X Y Z : ProfiniteGrp} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g : X → Z) = g ∘ f :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
coe_comp
| null |
@[to_additive /-- Construct a term of `ProfiniteAddGrp` from a type endowed with the structure of a
profinite topological additive group. -/]
ofProfinite (G : Profinite) [Group G] [IsTopologicalGroup G] :
ProfiniteGrp := of G
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofProfinite
|
Construct a term of `ProfiniteGrp` from a type endowed with the structure of a
profinite topological group.
|
@[to_additive /-- The pi-type of profinite additive groups is a
profinite additive group. -/]
pi {α : Type u} (β : α → ProfiniteGrp) : ProfiniteGrp :=
let pitype := Profinite.pi fun (a : α) => (β a).toProfinite
letI (a : α): Group (β a).toProfinite := (β a).group
letI : Group pitype := Pi.group
letI : IsTopologicalGroup pitype := Pi.topologicalGroup
ofProfinite pitype
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
pi
|
The pi-type of profinite groups is a profinite group.
|
@[to_additive /-- A `FiniteAddGrp` when given the discrete topology can be considered as a
profinite additive group. -/]
ofFiniteGrp (G : FiniteGrp) : ProfiniteGrp :=
letI : TopologicalSpace G := ⊥
letI : DiscreteTopology G := ⟨rfl⟩
letI : IsTopologicalGroup G := {}
of G
@[to_additive]
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofFiniteGrp
|
A `FiniteGrp` when given the discrete topology can be considered as a profinite group.
|
@[to_additive /-- A closed additive subgroup of a profinite additive group is profinite. -/]
ofClosedSubgroup {G : ProfiniteGrp} (H : ClosedSubgroup G) : ProfiniteGrp :=
letI : CompactSpace H := inferInstance
of H.1
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofClosedSubgroup
|
A closed subgroup of a profinite group is profinite.
|
@[to_additive /-- A topological additive group that has a `ContinuousAddEquiv` to a
profinite additive group is profinite. -/]
ofContinuousMulEquiv {G : ProfiniteGrp.{u}} {H : Type v} [TopologicalSpace H]
[Group H] [IsTopologicalGroup H] (e : G ≃ₜ* H) : ProfiniteGrp.{v} :=
let _ : CompactSpace H := Homeomorph.compactSpace e.toHomeomorph
let _ : TotallyDisconnectedSpace H := Homeomorph.totallyDisconnectedSpace e.toHomeomorph
.of H
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ofContinuousMulEquiv
|
A topological group that has a `ContinuousMulEquiv` to a profinite group is profinite.
|
ContinuousMulEquiv.toProfiniteGrpIso {X Y : ProfiniteGrp} (e : X ≃ₜ* Y) : X ≅ Y where
hom := ofHom e
inv := ofHom e.symm
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
ContinuousMulEquiv.toProfiniteGrpIso
|
Build an isomorphism in the category `ProfiniteGrp` from
a `ContinuousMulEquiv` between `ProfiniteGrp`s.
|
@[to_additive /-- Auxiliary construction to obtain the additive group structure on the limit of
profinite additive groups. -/]
limitConePtAux : Subgroup (Π j : J, F.obj j) where
carrier := {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), F.map π (x i) = x j}
mul_mem' hx hy _ _ π := by simp only [Pi.mul_apply, map_mul, hx π, hy π]
one_mem' := by simp only [Set.mem_setOf_eq, Pi.one_apply, map_one, implies_true]
inv_mem' h _ _ π := by simp only [Pi.inv_apply, map_inv, h π]
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limitConePtAux
|
The functor mapping a profinite group to its underlying profinite space. -/
@[to_additive]
instance : HasForget₂ ProfiniteGrp Profinite where
forget₂ := {
obj G := G.toProfinite
map f := CompHausLike.ofHom _ ⟨f, by continuity⟩}
@[to_additive]
instance : (forget₂ ProfiniteGrp Profinite).Faithful := {
map_injective := fun {_ _} _ _ h =>
ConcreteCategory.hom_ext _ _ (CategoryTheory.congr_fun h) }
instance : (forget₂ ProfiniteGrp Profinite).ReflectsIsomorphisms where
reflects {X Y} f _ := by
let i := asIso ((forget₂ ProfiniteGrp Profinite).map f)
let e : X ≃ₜ* Y :=
{ CompHausLike.homeoOfIso i with
map_mul' := map_mul f.hom }
exact (ContinuousMulEquiv.toProfiniteGrpIso e).isIso_hom
instance : (forget ProfiniteGrp.{u}).ReflectsIsomorphisms :=
CategoryTheory.reflectsIsomorphisms_comp (forget₂ ProfiniteGrp Profinite) (forget Profinite)
end ProfiniteGrp
/-!
# Limits in the category of profinite groups
In this section, we construct limits in the category of profinite groups.
* `ProfiniteGrp.limitCone` : The explicit limit cone in `ProfiniteGrp`.
* `ProfiniteGrp.limitConeIsLimit`: `ProfiniteGrp.limitCone` is a limit cone.
## TODO
* Figure out the reason that is causing `to_additive` to fail in most part of this section
and generate the additive version correctly.
-/
section Limits
namespace ProfiniteGrp
variable {J : Type v} [SmallCategory J] (F : J ⥤ ProfiniteGrp.{max v u})
/-- Auxiliary construction to obtain the group structure on the limit of profinite groups.
|
limitCone : Limits.Cone F where
pt := ofProfinite (Profinite.limitCone (F ⋙ (forget₂ ProfiniteGrp Profinite))).pt
π :=
{ app := fun j => ⟨{
toFun := fun x => x.1 j
map_one' := rfl
map_mul' := fun x y => rfl
continuous_toFun := by
exact (continuous_apply j).comp (continuous_iff_le_induced.mpr fun U a => a) }⟩
naturality := fun i j f => by
simp only [Functor.const_obj_obj, Functor.comp_obj,
Functor.const_obj_map, Category.id_comp, Functor.comp_map]
congr
exact funext fun x => (x.2 f).symm }
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limitCone
|
The explicit limit cone in `ProfiniteGrp`.
|
limitConeIsLimit : Limits.IsLimit (limitCone F) where
lift cone := ofHom
{ ((Profinite.limitConeIsLimit (F ⋙ (forget₂ ProfiniteGrp Profinite))).lift
((forget₂ ProfiniteGrp Profinite).mapCone cone)).hom with
map_one' := Subtype.ext (funext fun j ↦ map_one (cone.π.app j).hom)
map_mul' := fun _ _ ↦ Subtype.ext (funext fun j ↦ map_mul (cone.π.app j).hom _ _) }
uniq cone m h := by
apply (forget₂ ProfiniteGrp Profinite).map_injective
simpa using (Profinite.limitConeIsLimit (F ⋙ (forget₂ ProfiniteGrp Profinite))).uniq
((forget₂ ProfiniteGrp Profinite).mapCone cone) ((forget₂ ProfiniteGrp Profinite).map m)
(fun j ↦ congrArg (forget₂ ProfiniteGrp Profinite).map (h j))
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limitConeIsLimit
|
`ProfiniteGrp.limitCone` is a limit cone.
|
limit : ProfiniteGrp := ProfiniteGrp.of (ProfiniteGrp.limitConePtAux F)
@[ext]
|
abbrev
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limit
|
The abbreviation for the limit of `ProfiniteGrp`s.
|
limit_ext (x y : limit F) (hxy : ∀ j, x.val j = y.val j) : x = y :=
Subtype.ext (funext hxy)
@[simp]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limit_ext
| null |
limit_one_val (j : J) : (1 : limit F).val j = 1 :=
rfl
@[simp]
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limit_one_val
| null |
limit_mul_val (x y : limit F) (j : J) : (x * y).val j = x.val j * y.val j :=
rfl
|
lemma
|
Topology
|
[
"Mathlib.Algebra.Category.Grp.FiniteGrp",
"Mathlib.Topology.Algebra.Group.ClosedSubgroup",
"Mathlib.Topology.Algebra.ContinuousMonoidHom",
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Separation.Connected"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Basic.lean
|
limit_mul_val
| null |
toFiniteQuotientFunctor (P : ProfiniteGrp) : OpenNormalSubgroup P ⥤ FiniteGrp where
obj := fun H => FiniteGrp.of (P ⧸ H.toSubgroup)
map := fun fHK => FiniteGrp.ofHom (QuotientGroup.map _ _ (.id _) (leOfHom fHK))
map_id _ := ConcreteCategory.ext <| QuotientGroup.map_id _
map_comp f g := ConcreteCategory.ext <| (QuotientGroup.map_comp_map
_ _ _ (.id _) (.id _) (leOfHom f) (leOfHom g)).symm
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toFiniteQuotientFunctor
|
The functor from `OpenNormalSubgroup P` to `FiniteGrp` sending `U` to `P ⧸ U`,
where `P : ProfiniteGrp`.
|
toLimit_fun (P : ProfiniteGrp.{u}) : P →*
limit (toFiniteQuotientFunctor P ⋙ forget₂ FiniteGrp ProfiniteGrp) where
toFun p := ⟨fun _ => QuotientGroup.mk p, fun _ ↦ fun _ _ ↦ rfl⟩
map_one' := Subtype.val_inj.mp rfl
map_mul' _ _ := Subtype.val_inj.mp rfl
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toLimit_fun
|
The `MonoidHom` from a profinite group `P` to the projective limit of its quotients by
open normal subgroups ordered by inclusion
|
toLimit_fun_continuous (P : ProfiniteGrp.{u}) : Continuous (toLimit_fun P) := by
apply continuous_induced_rng.mpr (continuous_pi _)
intro H
dsimp only [Functor.comp_obj, CompHausLike.coe_of, Functor.comp_map,
CompHausLike.toCompHausLike_map, CompHausLike.compHausLikeToTop_map, Set.mem_setOf_eq,
toLimit_fun, MonoidHom.coe_mk, OneHom.coe_mk, Function.comp_apply]
apply Continuous.mk
intro s _
rw [← (Set.biUnion_preimage_singleton QuotientGroup.mk s)]
refine isOpen_iUnion (fun i ↦ isOpen_iUnion (fun _ ↦ ?_))
convert IsOpen.leftCoset H.toOpenSubgroup.isOpen' (Quotient.out i)
ext x
simp only [Set.mem_preimage, Set.mem_singleton_iff]
nth_rw 1 [← QuotientGroup.out_eq' i, eq_comm, QuotientGroup.eq]
exact Iff.symm (Set.mem_smul_set_iff_inv_smul_mem)
|
lemma
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toLimit_fun_continuous
| null |
toLimit (P : ProfiniteGrp.{u}) : P ⟶
limit (toFiniteQuotientFunctor P ⋙ forget₂ FiniteGrp ProfiniteGrp) :=
ofHom { toLimit_fun P with
continuous_toFun := toLimit_fun_continuous P }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toLimit
|
The morphism in the category of `ProfiniteGrp` from a profinite group `P` to
the projective limit of its quotients by open normal subgroups ordered by inclusion
|
denseRange_toLimit (P : ProfiniteGrp.{u}) : DenseRange (toLimit P) := by
apply dense_iff_inter_open.mpr
rintro U ⟨s, hsO, hsv⟩ ⟨⟨spc, hspc⟩, uDefaultSpec⟩
simp_rw [← hsv, Set.mem_preimage] at uDefaultSpec
rcases (isOpen_pi_iff.mp hsO) _ uDefaultSpec with ⟨J, fJ, hJ1, hJ2⟩
let M := iInf (fun (j : J) => j.1.1.1)
have hM : M.Normal := Subgroup.normal_iInf_normal fun j => j.1.isNormal'
have hMOpen : IsOpen (M : Set P) := by
rw [Subgroup.coe_iInf]
exact isOpen_iInter_of_finite fun i => i.1.1.isOpen'
let m : OpenNormalSubgroup P := { M with isOpen' := hMOpen }
rcases QuotientGroup.mk'_surjective M (spc m) with ⟨origin, horigin⟩
use (toLimit P) origin
refine ⟨?_, origin, rfl⟩
rw [← hsv]
apply hJ2
intro a a_in_J
let M_to_Na : m ⟶ a := (iInf_le (fun (j : J) => j.1.1.1) ⟨a, a_in_J⟩).hom
rw [← (P.toLimit origin).property M_to_Na]
change (P.toFiniteQuotientFunctor.map M_to_Na) (QuotientGroup.mk' M origin) ∈ _
rw [horigin]
exact Set.mem_of_eq_of_mem (hspc M_to_Na) (hJ1 a a_in_J).2
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
denseRange_toLimit
|
An auxiliary result, superseded by `toLimit_surjective`
|
toLimit_surjective (P : ProfiniteGrp.{u}) : Function.Surjective (toLimit P) := by
have : IsClosed (Set.range P.toLimit) :=
P.toLimit.hom.continuous_toFun.isClosedMap.isClosed_range
rw [← Set.range_eq_univ, ← closure_eq_iff_isClosed.mpr this,
Dense.closure_eq (denseRange_toLimit P)]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toLimit_surjective
| null |
toLimit_injective (P : ProfiniteGrp.{u}) : Function.Injective (toLimit P) := by
change Function.Injective (toLimit P).hom.toMonoidHom
rw [← MonoidHom.ker_eq_bot_iff, Subgroup.eq_bot_iff_forall]
intro x h
by_contra xne1
rcases exist_openNormalSubgroup_sub_open_nhds_of_one (isOpen_compl_singleton)
(Set.mem_compl_singleton_iff.mpr fun a => xne1 a.symm) with ⟨H, hH⟩
exact hH ((QuotientGroup.eq_one_iff x).mp (congrFun (Subtype.val_inj.mpr h) H)) rfl
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
toLimit_injective
| null |
noncomputable continuousMulEquivLimittoFiniteQuotientFunctor (P : ProfiniteGrp.{u}) :
P ≃ₜ* (limit (toFiniteQuotientFunctor P ⋙ forget₂ FiniteGrp ProfiniteGrp)) := {
(Continuous.homeoOfEquivCompactToT2
(f := Equiv.ofBijective _ ⟨toLimit_injective P, toLimit_surjective P⟩)
P.toLimit.hom.continuous_toFun) with
map_mul' := (toLimit P).hom.map_mul' }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
continuousMulEquivLimittoFiniteQuotientFunctor
|
The topological group isomorphism between a profinite group and the projective limit of
its quotients by open normal subgroups
|
isIso_toLimit (P : ProfiniteGrp.{u}) : IsIso (toLimit P) := by
rw [CategoryTheory.ConcreteCategory.isIso_iff_bijective]
exact ⟨toLimit_injective P, toLimit_surjective P⟩
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
isIso_toLimit
| null |
noncomputable isoLimittoFiniteQuotientFunctor (P : ProfiniteGrp.{u}) :
P ≅ (limit (toFiniteQuotientFunctor P ⋙ forget₂ FiniteGrp ProfiniteGrp)) :=
ContinuousMulEquiv.toProfiniteGrpIso (continuousMulEquivLimittoFiniteQuotientFunctor P)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne"
] |
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
isoLimittoFiniteQuotientFunctor
|
The isomorphism in the category of profinite group between a profinite group and
the projective limit of its quotients by open normal subgroups
|
ContinuousAlternatingMap (R M N ι : Type*) [Semiring R] [AddCommMonoid M] [Module R M]
[TopologicalSpace M] [AddCommMonoid N] [Module R N] [TopologicalSpace N] extends
ContinuousMultilinearMap R (fun _ : ι => M) N, M [⋀^ι]→ₗ[R] N where
|
structure
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
ContinuousAlternatingMap
|
A continuous alternating map from `ι → M` to `N`, denoted `M [⋀^ι]→L[R] N`,
is a continuous map that is
- multilinear : `f (update m i (c • x)) = c • f (update m i x)` and
`f (update m i (x + y)) = f (update m i x) + f (update m i y)`;
- alternating : `f v = 0` whenever `v` has two equal coordinates.
|
@[simps!]
codRestrict (f : M [⋀^ι]→L[R] N) (p : Submodule R N) (h : ∀ v, f v ∈ p) : M [⋀^ι]→L[R] p :=
{ f.toAlternatingMap.codRestrict p h with toContinuousMultilinearMap := f.1.codRestrict p h }
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
codRestrict
|
Projection to `ContinuousMultilinearMap`s. -/
add_decl_doc ContinuousAlternatingMap.toContinuousMultilinearMap
/-- Projection to `AlternatingMap`s. -/
add_decl_doc ContinuousAlternatingMap.toAlternatingMap
@[inherit_doc]
notation M " [⋀^" ι "]→L[" R "] " N:100 => ContinuousAlternatingMap R M N ι
namespace ContinuousAlternatingMap
section Semiring
variable {R M M' N N' ι : Type*} [Semiring R] [AddCommMonoid M] [Module R M] [TopologicalSpace M]
[AddCommMonoid M'] [Module R M'] [TopologicalSpace M'] [AddCommMonoid N] [Module R N]
[TopologicalSpace N] [AddCommMonoid N'] [Module R N'] [TopologicalSpace N'] {n : ℕ}
(f g : M [⋀^ι]→L[R] N)
theorem toContinuousMultilinearMap_injective :
Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)
| ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
theorem range_toContinuousMultilinearMap :
Set.range
(toContinuousMultilinearMap :
M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N) =
{f | ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → f v = 0} :=
Set.ext fun f => ⟨fun ⟨g, hg⟩ => hg ▸ g.2, fun h => ⟨⟨f, h⟩, rfl⟩⟩
instance funLike : FunLike (M [⋀^ι]→L[R] N) (ι → M) N where
coe f := f.toFun
coe_injective' _ _ h := toContinuousMultilinearMap_injective <| DFunLike.ext' h
instance continuousMapClass : ContinuousMapClass (M [⋀^ι]→L[R] N) (ι → M) N where
map_continuous f := f.cont
initialize_simps_projections ContinuousAlternatingMap (toFun → apply)
@[continuity]
theorem coe_continuous : Continuous f := f.cont
@[simp]
theorem coe_toContinuousMultilinearMap : ⇑f.toContinuousMultilinearMap = f :=
rfl
@[simp]
theorem coe_mk (f : ContinuousMultilinearMap R (fun _ : ι => M) N) (h) : ⇑(mk f h) = f :=
rfl
-- not a `simp` lemma because this projection is a reducible call to `mk`, so `simp` can prove
-- this lemma
theorem coe_toAlternatingMap : ⇑f.toAlternatingMap = f := rfl
@[ext]
theorem ext {f g : M [⋀^ι]→L[R] N} (H : ∀ x, f x = g x) : f = g :=
DFunLike.ext _ _ H
theorem toAlternatingMap_injective :
Injective (toAlternatingMap : (M [⋀^ι]→L[R] N) → (M [⋀^ι]→ₗ[R] N)) := fun f g h =>
DFunLike.ext' <| by convert DFunLike.ext'_iff.1 h
@[simp]
theorem range_toAlternatingMap :
Set.range (toAlternatingMap : M [⋀^ι]→L[R] N → (M [⋀^ι]→ₗ[R] N)) =
{f : M [⋀^ι]→ₗ[R] N | Continuous f} :=
Set.ext fun f => ⟨fun ⟨g, hg⟩ => hg ▸ g.cont, fun h => ⟨{ f with cont := h }, DFunLike.ext' rfl⟩⟩
@[simp]
theorem map_update_add [DecidableEq ι] (m : ι → M) (i : ι) (x y : M) :
f (update m i (x + y)) = f (update m i x) + f (update m i y) :=
f.map_update_add' m i x y
@[simp]
theorem map_update_smul [DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M) :
f (update m i (c • x)) = c • f (update m i x) :=
f.map_update_smul' m i c x
theorem map_coord_zero {m : ι → M} (i : ι) (h : m i = 0) : f m = 0 :=
f.toMultilinearMap.map_coord_zero i h
@[simp]
theorem map_update_zero [DecidableEq ι] (m : ι → M) (i : ι) : f (update m i 0) = 0 :=
f.toMultilinearMap.map_update_zero m i
@[simp]
theorem map_zero [Nonempty ι] : f 0 = 0 :=
f.toMultilinearMap.map_zero
theorem map_eq_zero_of_eq (v : ι → M) {i j : ι} (h : v i = v j) (hij : i ≠ j) : f v = 0 :=
f.map_eq_zero_of_eq' v i j h hij
theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 :=
f.toAlternatingMap.map_eq_zero_of_not_injective v hv
/-- Restrict the codomain of a continuous alternating map to a submodule.
|
@[simp]
coe_zero : ⇑(0 : M [⋀^ι]→L[R] N) = 0 :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
coe_zero
| null |
toContinuousMultilinearMap_zero : (0 : M [⋀^ι]→L[R] N).toContinuousMultilinearMap = 0 :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toContinuousMultilinearMap_zero
| null |
toAlternatingMap_zero : (0 : M [⋀^ι]→L[R] N).toAlternatingMap = 0 :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toAlternatingMap_zero
| null |
@[simp]
coe_smul (f : M [⋀^ι]→L[A] N) (c : R') : ⇑(c • f) = c • ⇑f :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
coe_smul
| null |
smul_apply (f : M [⋀^ι]→L[A] N) (c : R') (v : ι → M) : (c • f) v = c • f v :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
smul_apply
| null |
toContinuousMultilinearMap_smul (c : R') (f : M [⋀^ι]→L[A] N) :
(c • f).toContinuousMultilinearMap = c • f.toContinuousMultilinearMap :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toContinuousMultilinearMap_smul
| null |
toAlternatingMap_smul (c : R') (f : M [⋀^ι]→L[A] N) :
(c • f).toAlternatingMap = c • f.toAlternatingMap :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toAlternatingMap_smul
| null |
@[simp]
coe_add : ⇑(f + g) = ⇑f + ⇑g :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
coe_add
| null |
add_apply (v : ι → M) : (f + g) v = f v + g v :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
add_apply
| null |
toContinuousMultilinearMap_add (f g : M [⋀^ι]→L[R] N) : (f + g).1 = f.1 + g.1 :=
rfl
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toContinuousMultilinearMap_add
| null |
toAlternatingMap_add (f g : M [⋀^ι]→L[R] N) :
(f + g).toAlternatingMap = f.toAlternatingMap + g.toAlternatingMap :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toAlternatingMap_add
| null |
addCommMonoid : AddCommMonoid (M [⋀^ι]→L[R] N) :=
toContinuousMultilinearMap_injective.addCommMonoid _ rfl (fun _ _ => rfl) fun _ _ => rfl
|
instance
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
addCommMonoid
| null |
applyAddHom (v : ι → M) : M [⋀^ι]→L[R] N →+ N :=
⟨⟨fun f => f v, rfl⟩, fun _ _ => rfl⟩
@[simp]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
applyAddHom
|
Evaluation of a `ContinuousAlternatingMap` at a vector as an `AddMonoidHom`.
|
sum_apply {α : Type*} (f : α → M [⋀^ι]→L[R] N) (m : ι → M) {s : Finset α} :
(∑ a ∈ s, f a) m = ∑ a ∈ s, f a m :=
map_sum (applyAddHom m) f s
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
sum_apply
| null |
@[simps]
toMultilinearAddHom : M [⋀^ι]→L[R] N →+ ContinuousMultilinearMap R (fun _ : ι => M) N :=
⟨⟨fun f => f.1, rfl⟩, fun _ _ => rfl⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toMultilinearAddHom
|
Projection to `ContinuousMultilinearMap`s as a bundled `AddMonoidHom`.
|
@[simps! apply]
toContinuousLinearMap [DecidableEq ι] (m : ι → M) (i : ι) : M →L[R] N :=
f.1.toContinuousLinearMap m i
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
toContinuousLinearMap
|
If `f` is a continuous alternating map, then `f.toContinuousLinearMap m i` is the continuous
linear map obtained by fixing all coordinates but `i` equal to those of `m`, and varying the
`i`-th coordinate.
|
@[simps!]
prod (f : M [⋀^ι]→L[R] N) (g : M [⋀^ι]→L[R] N') : M [⋀^ι]→L[R] (N × N') :=
⟨f.1.prod g.1, (f.toAlternatingMap.prod g.toAlternatingMap).map_eq_zero_of_eq⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
prod
|
The Cartesian product of two continuous alternating maps, as a continuous alternating map.
|
pi {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)] [∀ i, TopologicalSpace (M' i)]
[∀ i, Module R (M' i)] (f : ∀ i, M [⋀^ι]→L[R] M' i) : M [⋀^ι]→L[R] ∀ i, M' i :=
⟨ContinuousMultilinearMap.pi fun i => (f i).1,
(AlternatingMap.pi fun i => (f i).toAlternatingMap).map_eq_zero_of_eq⟩
@[simp]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
pi
|
Combine a family of continuous alternating maps with the same domain and codomains `M' i` into a
continuous alternating map taking values in the space of functions `Π i, M' i`.
|
coe_pi {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
[∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] (f : ∀ i, M [⋀^ι]→L[R] M' i) :
⇑(pi f) = fun m j => f j m :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
coe_pi
| null |
pi_apply {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
[∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)] (f : ∀ i, M [⋀^ι]→L[R] M' i) (m : ι → M)
(j : ι') : pi f m j = f j m :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
pi_apply
| null |
@[simps! apply_apply symm_apply_apply apply_toContinuousMultilinearMap]
ofSubsingleton [Subsingleton ι] (i : ι) :
(M →L[R] N) ≃ M [⋀^ι]→L[R] N where
toFun f :=
{ AlternatingMap.ofSubsingleton R M N i f with
toContinuousMultilinearMap := ContinuousMultilinearMap.ofSubsingleton R M N i f }
invFun f := (ContinuousMultilinearMap.ofSubsingleton R M N i).symm f.1
right_inv _ := toContinuousMultilinearMap_injective <|
(ContinuousMultilinearMap.ofSubsingleton R M N i).apply_symm_apply _
@[simp]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
ofSubsingleton
|
The natural equivalence between continuous linear maps from `M` to `N`
and continuous 1-multilinear alternating maps from `M` to `N`.
|
ofSubsingleton_toAlternatingMap [Subsingleton ι] (i : ι) (f : M →L[R] N) :
(ofSubsingleton R M N i f).toAlternatingMap = AlternatingMap.ofSubsingleton R M N i f :=
rfl
variable (ι) {N}
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
ofSubsingleton_toAlternatingMap
| null |
@[simps! toContinuousMultilinearMap apply]
constOfIsEmpty [IsEmpty ι] (m : N) : M [⋀^ι]→L[R] N :=
{ AlternatingMap.constOfIsEmpty R M ι m with
toContinuousMultilinearMap := ContinuousMultilinearMap.constOfIsEmpty R (fun _ => M) m }
@[simp]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.Alternating.Basic",
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.Multilinear.Basic"
] |
Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
|
constOfIsEmpty
|
The constant map is alternating when `ι` is empty.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.