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
⌀ |
|---|---|---|---|---|---|---|
iso_map_bijective : Function.Bijective (iso_map C J) := by
refine ⟨fun a b h ↦ ?_, fun a ↦ ?_⟩
· ext i
rw [Subtype.ext_iff] at h
by_cases hi : J i
· exact congr_fun h ⟨i, hi⟩
· rcases a with ⟨_, c, hc, rfl⟩
rcases b with ⟨_, d, hd, rfl⟩
simp only [Proj, if_neg hi]
· refine ⟨⟨fun i ↦ if hi : J i then a.val ⟨i, hi⟩ else false, ?_⟩, ?_⟩
· rcases a with ⟨_, y, hy, rfl⟩
exact ⟨y, hy, rfl⟩
· ext i
exact dif_pos i.prop
variable {C}
|
lemma
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
iso_map_bijective
| null |
noncomputable
spanFunctor [∀ (s : Finset I) (i : I), Decidable (i ∈ s)] (hC : IsCompact C) :
(Finset I)ᵒᵖ ⥤ Profinite.{u} where
obj s := @Profinite.of (π C (· ∈ (unop s))) _
(by rw [← isCompact_iff_compactSpace]; exact hC.image (continuous_proj _)) _ _
map h := @CompHausLike.ofHom _ _ _ (_) (_) (_) (_) (_) (_) (_) (_)
⟨(ProjRestricts C (leOfHom h.unop)), continuous_projRestricts _ _⟩
map_id J := by simp only [projRestricts_eq_id C (· ∈ (unop J))]; rfl
map_comp _ _ := by rw [← CompHausLike.ofHom_comp]; congr; dsimp; rw [projRestricts_eq_comp]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
spanFunctor
|
For a given compact subset `C` of `I → Bool`, `spanFunctor` is the functor from the poset of finsets
of `I` to `Profinite`, sending a finite subset set `J` to the image of `C` under the projection
`Proj J`.
|
noncomputable
spanCone [∀ (s : Finset I) (i : I), Decidable (i ∈ s)] (hC : IsCompact C) :
Cone (spanFunctor hC) where
pt := @Profinite.of C _ (by rwa [← isCompact_iff_compactSpace]) _ _
π :=
{ app := fun s ↦ TopCat.ofHom ⟨ProjRestrict C (· ∈ unop s), continuous_projRestrict _ _⟩
naturality := by
intro X Y h
simp only [Functor.const_obj_obj,
Functor.const_obj_map, Category.id_comp, ← projRestricts_comp_projRestrict C
(leOfHom h.unop)]
rfl }
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
spanCone
|
The limit cone on `spanFunctor` with point `C`.
|
noncomputable
spanCone_isLimit [∀ (s : Finset I) (i : I), Decidable (i ∈ s)] (hC : IsCompact C) :
CategoryTheory.Limits.IsLimit (spanCone hC) := by
refine (IsLimit.postcomposeHomEquiv (NatIso.ofComponents
(fun s ↦ (CompHausLike.isoOfBijective _ (iso_map_bijective C (· ∈ unop s)))) ?_) (spanCone hC))
(IsLimit.ofIsoLimit (indexCone_isLimit hC) (Cones.ext (Iso.refl _) ?_))
· intro ⟨s⟩ ⟨t⟩ ⟨⟨⟨f⟩⟩⟩
ext x
have : iso_map C (· ∈ t) ∘ ProjRestricts C f = IndexFunctor.map C f ∘ iso_map C (· ∈ s) := by
ext _ i; exact dif_pos i.prop
exact congr_fun this x
· intro ⟨s⟩
ext x
have : iso_map C (· ∈ s) ∘ ProjRestrict C (· ∈ s) = IndexFunctor.π_app C (· ∈ s) := by
ext _ i; exact dif_pos i.prop
erw [← this]
rfl
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
spanCone_isLimit
|
`spanCone` is a limit cone.
|
e (i : I) : LocallyConstant C ℤ where
toFun := fun f ↦ (if f.val i then 1 else 0)
isLocallyConstant := by
rw [IsLocallyConstant.iff_continuous]
exact (continuous_of_discreteTopology (f := fun (a : Bool) ↦ (if a then (1 : ℤ) else 0))).comp
((continuous_apply i).comp continuous_subtype_val)
variable [LinearOrder I]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
e
|
`e C i` is the locally constant map from `C : Set (I → Bool)` to `ℤ` sending `f` to 1 if
`f.val i = true`, and 0 otherwise.
|
Products (I : Type*) [LinearOrder I] := {l : List I // l.IsChain (· > ·)}
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
Products
|
`Products I` is the type of lists of decreasing elements of `I`, so a typical element is
`[i₁, i₂, ...]` with `i₁ > i₂ > ...`. We order `Products I` lexicographically, so `[] < [i₁, ...]`,
and `[i₁, i₂, ...] < [j₁, j₂, ...]` if either `i₁ < j₁`, or `i₁ = j₁` and `[i₂, ...] < [j₂, ...]`.
Terms `m = [i₁, i₂, ..., iᵣ]` of this type will be used to represent products of the form
`e C i₁ ··· e C iᵣ : LocallyConstant C ℤ` . The function associated to `m` is `m.eval`.
|
@[simp]
lt_iff_lex_lt (l m : Products I) : l < m ↔ List.Lex (· < ·) l.val m.val := by
simp
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
lt_iff_lex_lt
| null |
eval (l : Products I) := (l.1.map (e C)).prod
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval
|
The evaluation `e C i₁ ··· e C iᵣ : C → ℤ` of a formal product `[i₁, i₂, ..., iᵣ]`.
|
isGood (l : Products I) : Prop :=
l.eval C ∉ Submodule.span ℤ ((Products.eval C) '' {m | m < l})
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
isGood
|
The predicate on products which we prove picks out a basis of `LocallyConstant C ℤ`. We call such a
product "good".
|
rel_head!_of_mem [Inhabited I] {i : I} {l : Products I} (hi : i ∈ l.val) :
i ≤ l.val.head! :=
List.Sorted.le_head! (List.isChain_iff_pairwise.mp l.prop) hi
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
rel_head
| null |
head!_le_of_lt [Inhabited I] {q l : Products I} (h : q < l) (hq : q.val ≠ []) :
q.val.head! ≤ l.val.head! :=
List.head!_le_of_lt l.val q.val h hq
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
head
| null |
GoodProducts := {l : Products I | l.isGood C}
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
GoodProducts
|
The set of good products.
|
eval (l : {l : Products I // l.isGood C}) : LocallyConstant C ℤ :=
Products.eval C l.1
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval
|
Evaluation of good products.
|
injective : Function.Injective (eval C) := by
intro ⟨a, ha⟩ ⟨b, hb⟩ h
dsimp [eval] at h
by_contra! hne
cases hne.lt_or_gt with
| inl h' => apply hb; rw [← h]; exact Submodule.subset_span ⟨a, h', rfl⟩
| inr h' => apply ha; rw [h]; exact Submodule.subset_span ⟨b, h', rfl⟩
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
injective
| null |
range := Set.range (GoodProducts.eval C)
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
range
|
The image of the good products in the module `LocallyConstant C ℤ`.
|
noncomputable
equiv_range : GoodProducts C ≃ range C :=
Equiv.ofInjective (eval C) (injective C)
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
equiv_range
|
The type of good products is equivalent to its image.
|
equiv_toFun_eq_eval : (equiv_range C).toFun = Set.rangeFactorization (eval C) := rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
equiv_toFun_eq_eval
| null |
linearIndependent_iff_range : LinearIndependent ℤ (GoodProducts.eval C) ↔
LinearIndependent ℤ (fun (p : range C) ↦ p.1) := by
rw [← @Set.rangeFactorization_eq _ _ (GoodProducts.eval C), ← equiv_toFun_eq_eval C]
exact linearIndependent_equiv (equiv_range C)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
linearIndependent_iff_range
| null |
eval_eq (l : Products I) (x : C) :
l.eval C x = if ∀ i, i ∈ l.val → (x.val i = true) then 1 else 0 := by
change LocallyConstant.evalMonoidHom x (l.eval C) = _
rw [eval, map_list_prod]
split_ifs with h
· simp only [List.map_map]
apply List.prod_eq_one
simp only [List.mem_map, Function.comp_apply]
rintro _ ⟨i, hi, rfl⟩
exact if_pos (h i hi)
· simp only [List.map_map, List.prod_eq_zero_iff, List.mem_map, Function.comp_apply]
push_neg at h
convert h with i
dsimp [LocallyConstant.evalMonoidHom, e]
simp only [ite_eq_right_iff, one_ne_zero]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval_eq
| null |
evalFacProp {l : Products I} (J : I → Prop)
(h : ∀ a, a ∈ l.val → J a) [∀ j, Decidable (J j)] :
l.eval (π C J) ∘ ProjRestrict C J = l.eval C := by
ext x
dsimp [ProjRestrict]
rw [Products.eval_eq, Products.eval_eq]
simp +contextual [h, Proj]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
evalFacProp
| null |
evalFacProps {l : Products I} (J K : I → Prop)
(h : ∀ a, a ∈ l.val → J a) [∀ j, Decidable (J j)] [∀ j, Decidable (K j)]
(hJK : ∀ i, J i → K i) :
l.eval (π C J) ∘ ProjRestricts C hJK = l.eval (π C K) := by
have : l.eval (π C J) ∘ Homeomorph.setCongr (proj_eq_of_subset C J K hJK) =
l.eval (π (π C K) J) := by
ext; simp [Homeomorph.setCongr, Products.eval_eq]
rw [ProjRestricts, ← Function.comp_assoc, this, ← evalFacProp (π C K) J h]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
evalFacProps
| null |
prop_of_isGood {l : Products I} (J : I → Prop) [∀ j, Decidable (J j)]
(h : l.isGood (π C J)) : ∀ a, a ∈ l.val → J a := by
intro i hi
by_contra h'
apply h
suffices eval (π C J) l = 0 by
rw [this]
exact Submodule.zero_mem _
ext ⟨_, _, _, rfl⟩
rw [eval_eq, if_neg fun h ↦ ?_, LocallyConstant.zero_apply]
simpa [Proj, h'] using h i hi
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
prop_of_isGood
| null |
GoodProducts.span_iff_products [WellFoundedLT I] :
⊤ ≤ Submodule.span ℤ (Set.range (eval C)) ↔
⊤ ≤ Submodule.span ℤ (Set.range (Products.eval C)) := by
refine ⟨fun h ↦ le_trans h (span_mono (fun a ⟨b, hb⟩ ↦ ⟨b.val, hb⟩)), fun h ↦ le_trans h ?_⟩
rw [span_le]
rintro f ⟨l, rfl⟩
let L : Products I → Prop := fun m ↦ m.eval C ∈ span ℤ (Set.range (GoodProducts.eval C))
suffices L l by assumption
apply IsWellFounded.induction (· < · : Products I → Products I → Prop)
intro l h
dsimp
by_cases hl : l.isGood C
· apply subset_span
exact ⟨⟨l, hl⟩, rfl⟩
· simp only [Products.isGood, not_not] at hl
suffices Products.eval C '' {m | m < l} ⊆ span ℤ (Set.range (GoodProducts.eval C)) by
rw [← span_le] at this
exact this hl
rintro a ⟨m, hm, rfl⟩
exact h m hm
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
GoodProducts.span_iff_products
|
The good products span `LocallyConstant C ℤ` if and only all the products do.
|
ord (i : I) : Ordinal := Ordinal.typein ((· < ·) : I → I → Prop) i
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
ord
|
A term of `I` regarded as an ordinal.
|
noncomputable
term {o : Ordinal} (ho : o < Ordinal.type ((· < ·) : I → I → Prop)) : I :=
Ordinal.enum ((· < ·) : I → I → Prop) ⟨o, ho⟩
variable {I}
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
term
|
An ordinal regarded as a term of `I`.
|
term_ord_aux {i : I} (ho : ord I i < Ordinal.type ((· < ·) : I → I → Prop)) :
term I ho = i := by
simp only [term, ord, Ordinal.enum_typein]
@[simp]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
term_ord_aux
| null |
ord_term_aux {o : Ordinal} (ho : o < Ordinal.type ((· < ·) : I → I → Prop)) :
ord I (term I ho) = o := by
simp only [ord, term, Ordinal.typein_enum]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
ord_term_aux
| null |
ord_term {o : Ordinal} (ho : o < Ordinal.type ((· < ·) : I → I → Prop)) (i : I) :
ord I i = o ↔ term I ho = i := by
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· subst h
exact term_ord_aux ho
· subst h
exact ord_term_aux ho
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
ord_term
| null |
contained (o : Ordinal) : Prop := ∀ f, f ∈ C → ∀ (i : I), f i = true → ord I i < o
variable (I) in
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
contained
|
A predicate saying that `C` is "small" enough to satisfy the inductive hypothesis.
|
P (o : Ordinal) : Prop :=
o ≤ Ordinal.type (· < · : I → I → Prop) →
(∀ (C : Set (I → Bool)), IsClosed C → contained C o →
LinearIndependent ℤ (GoodProducts.eval C))
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
P
|
The predicate on ordinals which we prove by induction, see `GoodProducts.P0`,
`GoodProducts.Plimit` and `GoodProducts.linearIndependentAux` in the section `Induction` below
|
Products.prop_of_isGood_of_contained {l : Products I} (o : Ordinal) (h : l.isGood C)
(hsC : contained C o) (i : I) (hi : i ∈ l.val) : ord I i < o := by
by_contra h'
apply h
suffices eval C l = 0 by simp [this]
ext x
simp only [eval_eq, LocallyConstant.coe_zero, Pi.zero_apply, ite_eq_right_iff, one_ne_zero]
contrapose! h'
exact hsC x.val x.prop i (h'.1 i hi)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
Products.prop_of_isGood_of_contained
| null |
contained_eq_proj (o : Ordinal) (h : contained C o) :
C = π C (ord I · < o) := by
have := proj_prop_eq_self C (ord I · < o)
simp only [ne_eq, Bool.not_eq_false, π] at this
exact (this (fun i x hx ↦ h x hx i)).symm
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
contained_eq_proj
| null |
isClosed_proj (o : Ordinal) (hC : IsClosed C) : IsClosed (π C (ord I · < o)) :=
(continuous_proj (ord I · < o)).isClosedMap C hC
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
isClosed_proj
| null |
contained_proj (o : Ordinal) : contained (π C (ord I · < o)) o := by
intro x ⟨_, _, h⟩ j hj
aesop (add simp Proj)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
contained_proj
| null |
@[simps!]
noncomputable
πs (o : Ordinal) : LocallyConstant (π C (ord I · < o)) ℤ →ₗ[ℤ] LocallyConstant C ℤ :=
LocallyConstant.comapₗ ℤ ⟨(ProjRestrict C (ord I · < o)), (continuous_projRestrict _ _)⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
πs
|
The `ℤ`-linear map induced by precomposition of the projection `C → π C (ord I · < o)`.
|
coe_πs (o : Ordinal) (f : LocallyConstant (π C (ord I · < o)) ℤ) :
πs C o f = f ∘ ProjRestrict C (ord I · < o) := by
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
coe_πs
| null |
injective_πs (o : Ordinal) : Function.Injective (πs C o) :=
LocallyConstant.comap_injective ⟨_, (continuous_projRestrict _ _)⟩
(Set.surjective_mapsTo_image_restrict _ _)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
injective_πs
| null |
@[simps!]
noncomputable
πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) :
LocallyConstant (π C (ord I · < o₁)) ℤ →ₗ[ℤ] LocallyConstant (π C (ord I · < o₂)) ℤ :=
LocallyConstant.comapₗ ℤ ⟨(ProjRestricts C (fun _ hh ↦ lt_of_lt_of_le hh h)),
(continuous_projRestricts _ _)⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
πs'
|
The `ℤ`-linear map induced by precomposition of the projection
`π C (ord I · < o₂) → π C (ord I · < o₁)` for `o₁ ≤ o₂`.
|
coe_πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) (f : LocallyConstant (π C (ord I · < o₁)) ℤ) :
(πs' C h f).toFun = f.toFun ∘ (ProjRestricts C (fun _ hh ↦ lt_of_lt_of_le hh h)) := by
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
coe_πs'
| null |
injective_πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) : Function.Injective (πs' C h) :=
LocallyConstant.comap_injective ⟨_, (continuous_projRestricts _ _)⟩
(surjective_projRestricts _ fun _ hi ↦ lt_of_lt_of_le hi h)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
injective_πs'
| null |
lt_ord_of_lt {l m : Products I} {o : Ordinal} (h₁ : m < l)
(h₂ : ∀ i ∈ l.val, ord I i < o) : ∀ i ∈ m.val, ord I i < o :=
List.Sorted.lt_ord_of_lt (List.isChain_iff_pairwise.mp l.2)
(List.isChain_iff_pairwise.mp m.2) h₁ h₂
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
lt_ord_of_lt
| null |
eval_πs {l : Products I} {o : Ordinal} (hlt : ∀ i ∈ l.val, ord I i < o) :
πs C o (l.eval (π C (ord I · < o))) = l.eval C := by
simpa only [← LocallyConstant.coe_inj] using evalFacProp C (ord I · < o) hlt
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval_πs
| null |
eval_πs' {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
(hlt : ∀ i ∈ l.val, ord I i < o₁) :
πs' C h (l.eval (π C (ord I · < o₁))) = l.eval (π C (ord I · < o₂)) := by
rw [← LocallyConstant.coe_inj, ← LocallyConstant.toFun_eq_coe]
exact evalFacProps C (fun (i : I) ↦ ord I i < o₁) (fun (i : I) ↦ ord I i < o₂) hlt
(fun _ hh ↦ lt_of_lt_of_le hh h)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval_πs'
| null |
eval_πs_image {l : Products I} {o : Ordinal}
(hl : ∀ i ∈ l.val, ord I i < o) : eval C '' { m | m < l } =
(πs C o) '' (eval (π C (ord I · < o)) '' { m | m < l }) := by
ext f
simp only [Set.mem_image, Set.mem_setOf_eq, exists_exists_and_eq_and]
apply exists_congr; intro m
apply and_congr_right; intro hm
rw [eval_πs C (lt_ord_of_lt hm hl)]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval_πs_image
| null |
eval_πs_image' {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
(hl : ∀ i ∈ l.val, ord I i < o₁) : eval (π C (ord I · < o₂)) '' { m | m < l } =
(πs' C h) '' (eval (π C (ord I · < o₁)) '' { m | m < l }) := by
ext f
simp only [Set.mem_image, Set.mem_setOf_eq, exists_exists_and_eq_and]
apply exists_congr; intro m
apply and_congr_right; intro hm
rw [eval_πs' C h (lt_ord_of_lt hm hl)]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
eval_πs_image'
| null |
head_lt_ord_of_isGood [Inhabited I] {l : Products I} {o : Ordinal}
(h : l.isGood (π C (ord I · < o))) (hn : l.val ≠ []) : ord I (l.val.head!) < o :=
prop_of_isGood C (ord I · < o) h l.val.head! (List.head!_mem_self hn)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
head_lt_ord_of_isGood
| null |
isGood_mono {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
(hl : l.isGood (π C (ord I · < o₁))) : l.isGood (π C (ord I · < o₂)) := by
intro hl'
apply hl
rwa [eval_πs_image' C h (prop_of_isGood C _ hl), ← eval_πs' C h (prop_of_isGood C _ hl),
Submodule.apply_mem_span_image_iff_mem_span (injective_πs' C h)] at hl'
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.SetTheory.Ordinal.Basic",
"Mathlib.Topology.Category.Profinite.Product",
"Mathlib.Topology.LocallyConstant.Algebra"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Basic.lean
|
isGood_mono
|
If `l` is good w.r.t. `π C (ord I · < o₁)` and `o₁ ≤ o₂`, then it is good w.r.t.
`π C (ord I · < o₂)`
|
GoodProducts.P0 : P I 0 := fun _ C _ hsC ↦ by
have : C ⊆ {(fun _ ↦ false)} := fun c hc ↦ by
ext x; exact Bool.eq_false_iff.mpr (fun ht ↦ (Ordinal.not_lt_zero (ord I x)) (hsC c hc x ht))
rw [Set.subset_singleton_iff_eq] at this
cases this
· subst C
exact linearIndependentEmpty
· subst C
exact linearIndependentSingleton
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
GoodProducts.P0
| null |
GoodProducts.Plimit (o : Ordinal) (ho : Order.IsSuccLimit o) :
(∀ (o' : Ordinal), o' < o → P I o') → P I o := by
intro h hho C hC hsC
rw [linearIndependent_iff_union_smaller C ho hsC, linearIndependent_subtype_iff]
exact linearIndepOn_iUnion_of_directed
(Monotone.directed_le fun _ _ h ↦ GoodProducts.smaller_mono C h) fun ⟨o', ho'⟩ ↦
(linearIndependent_iff_smaller _ _).mp (h o' ho' (ho'.le.trans hho)
(π C (ord I · < o')) (isClosed_proj _ _ hC) (contained_proj _ _))
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
GoodProducts.Plimit
| null |
GoodProducts.linearIndependentAux (μ : Ordinal) : P I μ := by
refine Ordinal.limitRecOn μ P0 (fun o h ho C hC hsC ↦ ?_)
(fun o ho h ↦ (GoodProducts.Plimit o ho (fun o' ho' ↦ (h o' ho'))))
have ho' : o < Ordinal.type (· < · : I → I → Prop) :=
lt_of_lt_of_le (Order.lt_succ _) ho
rw [linearIndependent_iff_sum C hsC ho']
refine ModuleCat.linearIndependent_leftExact (succ_exact C hC hsC ho') ?_ ?_ (succ_mono C o)
(square_commutes C ho')
· exact h (le_of_lt ho') (π C (ord I · < o)) (isClosed_proj C o hC) (contained_proj C o)
· exact linearIndependent_comp_of_eval C hC hsC ho' (span (π C (ord I · < o))
(isClosed_proj C o hC)) (h (le_of_lt ho') (C' C ho') (isClosed_C' C hC ho')
(contained_C' C ho'))
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
GoodProducts.linearIndependentAux
| null |
GoodProducts.linearIndependent (hC : IsClosed C) :
LinearIndependent ℤ (GoodProducts.eval C) :=
GoodProducts.linearIndependentAux (Ordinal.type (· < · : I → I → Prop)) (le_refl _)
C hC (fun _ _ _ _ ↦ Ordinal.typein_lt_type _ _)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
GoodProducts.linearIndependent
| null |
noncomputable
GoodProducts.Basis (hC : IsClosed C) :
Basis (GoodProducts C) ℤ (LocallyConstant C ℤ) :=
Basis.mk (GoodProducts.linearIndependent C hC) (GoodProducts.span C hC)
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
GoodProducts.Basis
|
`GoodProducts C` as a `ℤ`-basis for `LocallyConstant C ℤ`.
|
Nobeling_aux : Module.Free ℤ (LocallyConstant S ℤ) := Module.Free.of_equiv'
(Module.Free.of_basis <| GoodProducts.Basis _ hι.isClosed_range) (LocallyConstant.congrLeftₗ ℤ
hι.isEmbedding.toHomeomorph).symm
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
Nobeling_aux
|
Given a profinite set `S` and a closed embedding `S → (I → Bool)`, the `ℤ`-module
`LocallyConstant C ℤ` is free.
|
noncomputable
Nobeling.ι : S → ({C : Set S // IsClopen C} → Bool) := fun s C => decide (s ∈ C.1)
open scoped Classical in
|
def
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
Nobeling.ι
|
The embedding `S → (I → Bool)` where `I` is the set of clopens of `S`.
|
Nobeling.isClosedEmbedding : IsClosedEmbedding (Nobeling.ι S) := by
apply Continuous.isClosedEmbedding
· dsimp +unfoldPartialApp [ι]
refine continuous_pi ?_
intro C
rw [← IsLocallyConstant.iff_continuous]
refine ((IsLocallyConstant.tfae _).out 0 3).mpr ?_
rintro ⟨⟩
· refine IsClopen.isOpen (isClopen_compl_iff.mp ?_)
convert C.2
ext x
simp only [Set.mem_compl_iff, Set.mem_preimage, Set.mem_singleton_iff,
decide_eq_false_iff_not, not_not]
· refine IsClopen.isOpen ?_
convert C.2
ext x
simp only [Set.mem_preimage, Set.mem_singleton_iff, decide_eq_true_eq]
· intro a b h
by_contra hn
obtain ⟨C, hC, hh⟩ := exists_isClopen_of_totally_separated hn
apply hh.2 ∘ of_decide_eq_true
dsimp +unfoldPartialApp [ι] at h
rw [← congr_fun h ⟨C, hC⟩]
exact decide_eq_true hh.1
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
Nobeling.isClosedEmbedding
|
The map `Nobeling.ι` is a closed embedding.
|
LocallyConstant.freeOfProfinite (S : Profinite.{u}) :
Module.Free ℤ (LocallyConstant S ℤ) := by
obtain ⟨_, _⟩ := exists_wellOrder {C : Set S // IsClopen C}
exact @Nobeling_aux {C : Set S // IsClopen C} _ _ S (Nobeling.ι S) (Nobeling.isClosedEmbedding S)
|
instance
|
Topology
|
[
"Mathlib.Algebra.Category.ModuleCat.Free",
"Mathlib.Topology.Category.Profinite.Nobeling.Span",
"Mathlib.Topology.Category.Profinite.Nobeling.Successor",
"Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Induction.lean
|
LocallyConstant.freeOfProfinite
|
**Nöbeling's theorem**. The `ℤ`-module `LocallyConstant S ℤ` is free for every
`S : Profinite`.
|
noncomputable
πJ : LocallyConstant (π C (· ∈ s)) ℤ →ₗ[ℤ] LocallyConstant C ℤ :=
LocallyConstant.comapₗ ℤ ⟨_, (continuous_projRestrict C (· ∈ s))⟩
|
def
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
πJ
|
The `ℤ`-linear map induced by precomposition of the projection `C → π C (· ∈ s)`.
|
eval_eq_πJ (l : Products I) (hl : l.isGood (π C (· ∈ s))) :
l.eval C = πJ C s (l.eval (π C (· ∈ s))) := by
ext f
simp only [πJ, LocallyConstant.comapₗ, LinearMap.coe_mk, AddHom.coe_mk,
LocallyConstant.coe_comap, Function.comp_apply]
exact (congr_fun (Products.evalFacProp C (· ∈ s) (Products.prop_of_isGood C (· ∈ s) hl)) _).symm
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
eval_eq_πJ
| null |
noncomputable
spanFinBasis (x : π C (· ∈ s)) : LocallyConstant (π C (· ∈ s)) ℤ where
toFun := fun y ↦ if y = x then 1 else 0
isLocallyConstant :=
haveI : DiscreteTopology (π C (· ∈ s)) := Finite.instDiscreteTopology
IsLocallyConstant.of_discrete _
open scoped Classical in
|
def
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
spanFinBasis
|
`π C (· ∈ s)` is finite for a finite set `s`. -/
noncomputable
instance : Fintype (π C (· ∈ s)) := by
let f : π C (· ∈ s) → (s → Bool) := fun x j ↦ x.val j.val
refine Fintype.ofInjective f ?_
intro ⟨_, x, hx, rfl⟩ ⟨_, y, hy, rfl⟩ h
ext i
by_cases hi : i ∈ s
· exact congrFun h ⟨i, hi⟩
· simp only [Proj, if_neg hi]
open scoped Classical in
/-- The Kronecker delta as a locally constant map from `π C (· ∈ s)` to `ℤ`.
|
spanFinBasis.span : ⊤ ≤ Submodule.span ℤ (Set.range (spanFinBasis C s)) := by
intro f _
rw [Finsupp.mem_span_range_iff_exists_finsupp]
use Finsupp.onFinset (Finset.univ) f.toFun (fun _ _ ↦ Finset.mem_univ _)
ext x
change LocallyConstant.evalₗ ℤ x _ = _
simp only [zsmul_eq_mul, map_finsuppSum, LocallyConstant.evalₗ_apply,
LocallyConstant.coe_mul, Pi.mul_apply, spanFinBasis, LocallyConstant.coe_mk, mul_ite, mul_one,
mul_zero, Finsupp.sum_ite_eq, Finsupp.mem_support_iff, ne_eq, ite_not]
split_ifs with h <;> [exact h.symm; rfl]
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
spanFinBasis.span
| null |
factors (x : π C (· ∈ s)) : List (LocallyConstant (π C (· ∈ s)) ℤ) :=
List.map (fun i ↦ if x.val i = true then e (π C (· ∈ s)) i else (1 - (e (π C (· ∈ s)) i)))
(s.sort (· ≥ ·))
|
def
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
factors
|
A certain explicit list of locally constant maps. The theorem `factors_prod_eq_basis` shows that the
product of the elements in this list is the delta function `spanFinBasis C s x`.
|
list_prod_apply {I} (C : Set (I → Bool)) (x : C) (l : List (LocallyConstant C ℤ)) :
l.prod x = (l.map (LocallyConstant.evalMonoidHom x)).prod := by
rw [← map_list_prod (LocallyConstant.evalMonoidHom x) l, LocallyConstant.evalMonoidHom_apply]
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
list_prod_apply
| null |
factors_prod_eq_basis_of_eq {x y : (π C fun x ↦ x ∈ s)} (h : y = x) :
(factors C s x).prod y = 1 := by
rw [list_prod_apply (π C (· ∈ s)) y _]
apply List.prod_eq_one
simp only [h, List.mem_map, LocallyConstant.evalMonoidHom, factors]
rintro _ ⟨a, ⟨b, _, rfl⟩, rfl⟩
dsimp
split_ifs with hh
· rw [e, LocallyConstant.coe_mk, if_pos hh]
· rw [LocallyConstant.sub_apply, e, LocallyConstant.coe_mk, LocallyConstant.coe_mk, if_neg hh]
simp only [LocallyConstant.toFun_eq_coe, LocallyConstant.coe_one, Pi.one_apply, sub_zero]
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
factors_prod_eq_basis_of_eq
| null |
e_mem_of_eq_true {x : (π C (· ∈ s))} {a : I} (hx : x.val a = true) :
e (π C (· ∈ s)) a ∈ factors C s x := by
rcases x with ⟨_, z, hz, rfl⟩
simp only [factors, List.mem_map, Finset.mem_sort]
refine ⟨a, ?_, if_pos hx⟩
aesop (add simp Proj)
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
e_mem_of_eq_true
| null |
one_sub_e_mem_of_false {x y : (π C (· ∈ s))} {a : I} (ha : y.val a = true)
(hx : x.val a = false) : 1 - e (π C (· ∈ s)) a ∈ factors C s x := by
simp only [factors, List.mem_map, Finset.mem_sort]
use a
simp only [hx]
rcases y with ⟨_, z, hz, rfl⟩
aesop (add simp Proj)
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
one_sub_e_mem_of_false
| null |
factors_prod_eq_basis_of_ne {x y : (π C (· ∈ s))} (h : y ≠ x) :
(factors C s x).prod y = 0 := by
rw [list_prod_apply (π C (· ∈ s)) y _]
apply List.prod_eq_zero
simp only [List.mem_map]
obtain ⟨a, ha⟩ : ∃ a, y.val a ≠ x.val a := by contrapose! h; ext; apply h
cases hx : x.val a
· rw [hx, ne_eq, Bool.not_eq_false] at ha
refine ⟨1 - (e (π C (· ∈ s)) a), ⟨one_sub_e_mem_of_false _ _ ha hx, ?_⟩⟩
rw [e, LocallyConstant.evalMonoidHom_apply, LocallyConstant.sub_apply,
LocallyConstant.coe_one, Pi.one_apply, LocallyConstant.coe_mk, if_pos ha, sub_self]
· refine ⟨e (π C (· ∈ s)) a, ⟨e_mem_of_eq_true _ _ hx, ?_⟩⟩
rw [hx] at ha
rw [LocallyConstant.evalMonoidHom_apply, e, LocallyConstant.coe_mk, if_neg ha]
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
factors_prod_eq_basis_of_ne
| null |
factors_prod_eq_basis (x : π C (· ∈ s)) :
(factors C s x).prod = spanFinBasis C s x := by
ext y
dsimp [spanFinBasis]
split_ifs with h <;> [exact factors_prod_eq_basis_of_eq _ _ h;
exact factors_prod_eq_basis_of_ne _ _ h]
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
factors_prod_eq_basis
|
If `s` is finite, the product of the elements of the list `factors C s x`
is the delta function at `x`.
|
GoodProducts.finsuppSum_mem_span_eval {a : I} {as : List I}
(ha : List.IsChain (· > ·) (a :: as)) {c : Products I →₀ ℤ}
(hc : (c.support : Set (Products I)) ⊆ {m | m.val ≤ as}) :
(Finsupp.sum c fun a_1 b ↦ e (π C (· ∈ s)) a * b • Products.eval (π C (· ∈ s)) a_1) ∈
Submodule.span ℤ (Products.eval (π C (· ∈ s)) '' {m | m.val ≤ a :: as}) := by
apply Submodule.finsuppSum_mem
intro m hm
have hsm := (LinearMap.mulLeft ℤ (e (π C (· ∈ s)) a)).map_smul
dsimp at hsm
rw [hsm]
apply Submodule.smul_mem
apply Submodule.subset_span
have hmas : m.val ≤ as := by
apply hc
simpa only [Finset.mem_coe, Finsupp.mem_support_iff] using hm
refine ⟨⟨a :: m.val, ha.cons_of_le m.prop hmas⟩, ⟨List.cons_le_cons a hmas, ?_⟩⟩
simp only [Products.eval, List.map, List.prod_cons]
@[deprecated (since := "2025-04-06")]
alias GoodProducts.finsupp_sum_mem_span_eval := GoodProducts.finsuppSum_mem_span_eval
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
GoodProducts.finsuppSum_mem_span_eval
| null |
GoodProducts.spanFin [WellFoundedLT I] :
⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (· ∈ s)))) := by
rw [span_iff_products]
refine le_trans (spanFinBasis.span C s) ?_
rw [Submodule.span_le]
rintro _ ⟨x, rfl⟩
rw [← factors_prod_eq_basis]
let l := s.sort (· ≥ ·)
dsimp [factors]
suffices l.IsChain (· > ·) → (l.map (fun i ↦ if x.val i = true then e (π C (· ∈ s)) i
else (1 - (e (π C (· ∈ s)) i)))).prod ∈
Submodule.span ℤ ((Products.eval (π C (· ∈ s))) '' {m | m.val ≤ l}) from
Submodule.span_mono (Set.image_subset_range _ _) (this (Finset.sort_sorted_gt _).isChain)
induction l with
| nil =>
intro _
apply Submodule.subset_span
exact ⟨⟨[], List.isChain_nil⟩,⟨Or.inl rfl, rfl⟩⟩
| cons a as ih =>
rw [List.map_cons, List.prod_cons]
intro ha
specialize ih (by rw [List.isChain_cons'] at ha; exact ha.2)
rw [Finsupp.mem_span_image_iff_linearCombination] at ih
simp only [Finsupp.mem_supported, Finsupp.linearCombination_apply] at ih
obtain ⟨c, hc, hc'⟩ := ih
rw [← hc']; clear hc'
have hmap := fun g ↦ map_finsuppSum (LinearMap.mulLeft ℤ (e (π C (· ∈ s)) a)) c g
dsimp at hmap ⊢
split_ifs
· rw [hmap]
exact finsuppSum_mem_span_eval _ _ ha hc
· noncomm_ring
rw [hmap]
apply Submodule.add_mem
· apply Submodule.finsuppSum_mem
intro m hm
apply Submodule.smul_mem
apply Submodule.subset_span
refine ⟨m, ⟨?_, rfl⟩⟩
simp only [Set.mem_setOf_eq]
have hmas : m.val ≤ as :=
hc (by simpa only [Finset.mem_coe, Finsupp.mem_support_iff] using hm)
refine le_trans hmas ?_
cases as with
| nil => exact (List.nil_lt_cons a []).le
| cons b bs =>
apply le_of_lt
rw [List.isChain_cons_cons] at ha
exact (List.lt_iff_lex_lt _ _).mp (List.Lex.rel ha.1)
· apply Submodule.smul_mem
exact finsuppSum_mem_span_eval _ _ ha hc
...
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
GoodProducts.spanFin
|
If `s` is a finite subset of `I`, then the good products span.
|
fin_comap_jointlySurjective
(hC : IsClosed C)
(f : LocallyConstant C ℤ) : ∃ (s : Finset I)
(g : LocallyConstant (π C (· ∈ s)) ℤ), f = g.comap ⟨(ProjRestrict C (· ∈ s)),
continuous_projRestrict _ _⟩ := by
obtain ⟨J, g, h⟩ := @Profinite.exists_locallyConstant (Finset I)ᵒᵖ _ _ _
(spanCone hC.isCompact) ℤ
(spanCone_isLimit hC.isCompact) f
exact ⟨(Opposite.unop J), g, h⟩
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
fin_comap_jointlySurjective
| null |
GoodProducts.span [WellFoundedLT I] (hC : IsClosed C) :
⊤ ≤ Submodule.span ℤ (Set.range (eval C)) := by
rw [span_iff_products]
intro f _
obtain ⟨K, f', rfl⟩ : ∃ K f', f = πJ C K f' := fin_comap_jointlySurjective C hC f
refine Submodule.span_mono ?_ <| Submodule.apply_mem_span_image_of_mem_span (πJ C K) <|
spanFin C K (Submodule.mem_top : f' ∈ ⊤)
rintro l ⟨y, ⟨m, rfl⟩, rfl⟩
exact ⟨m.val, eval_eq_πJ C K m.val m.prop⟩
|
theorem
|
Topology
|
[
"Mathlib.Data.Finset.Sort",
"Mathlib.Tactic.NoncommRing",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Span.lean
|
GoodProducts.span
|
The good products span all of `LocallyConstant C ℤ` if `C` is closed.
|
C0 := C ∩ {f | f (term I ho) = false}
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
C0
|
The subset of `C` consisting of those elements whose `o`-th entry is `false`.
|
C1 := C ∩ {f | f (term I ho) = true}
include hC in
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
C1
|
The subset of `C` consisting of those elements whose `o`-th entry is `true`.
|
isClosed_C0 : IsClosed (C0 C ho) := by
refine hC.inter ?_
have h : Continuous (fun (f : I → Bool) ↦ f (term I ho)) := continuous_apply (term I ho)
exact IsClosed.preimage h (t := {false}) (isClosed_discrete _)
include hC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
isClosed_C0
| null |
isClosed_C1 : IsClosed (C1 C ho) := by
refine hC.inter ?_
have h : Continuous (fun (f : I → Bool) ↦ f (term I ho)) := continuous_apply (term I ho)
exact IsClosed.preimage h (t := {true}) (isClosed_discrete _)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
isClosed_C1
| null |
contained_C1 : contained (π (C1 C ho) (ord I · < o)) o :=
contained_proj _ _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
contained_C1
| null |
union_C0C1_eq : (C0 C ho) ∪ (C1 C ho) = C := by
ext x
simp only [C0, C1, Set.mem_union, Set.mem_inter_iff, Set.mem_setOf_eq,
← and_or_left, and_iff_left_iff_imp, Bool.dichotomy (x (term I ho)), implies_true]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
union_C0C1_eq
| null |
C' := C0 C ho ∩ π (C1 C ho) (ord I · < o)
include hC in
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
C'
|
The intersection of `C0` and the projection of `C1`. We will apply the inductive hypothesis to
this set.
|
isClosed_C' : IsClosed (C' C ho) :=
IsClosed.inter (isClosed_C0 _ hC _) (isClosed_proj _ _ (isClosed_C1 _ hC _))
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
isClosed_C'
| null |
contained_C' : contained (C' C ho) o := fun f hf i hi ↦ contained_C1 C ho f hf.2 i hi
variable (o)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
contained_C'
| null |
noncomputable
SwapTrue : (I → Bool) → I → Bool :=
fun f i ↦ if ord I i = o then true else f i
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
SwapTrue
|
Swapping the `o`-th coordinate to `true`.
|
continuous_swapTrue : Continuous (SwapTrue o : (I → Bool) → I → Bool) := by
dsimp +unfoldPartialApp [SwapTrue]
apply continuous_pi
intro i
apply Continuous.comp'
· apply continuous_bot
· apply continuous_apply
variable {o}
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
continuous_swapTrue
| null |
swapTrue_mem_C1 (f : π (C1 C ho) (ord I · < o)) :
SwapTrue o f.val ∈ C1 C ho := by
obtain ⟨f, g, hg, rfl⟩ := f
convert hg
dsimp +unfoldPartialApp [SwapTrue]
ext i
split_ifs with h
· rw [ord_term ho] at h
simpa only [← h] using hg.2.symm
· simp only [Proj, ite_eq_left_iff, not_lt, @eq_comm _ false, ← Bool.not_eq_true]
specialize hsC g hg.1 i
intro h'
contrapose! hsC
exact ⟨hsC, Order.succ_le_of_lt (h'.lt_of_ne' h)⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
swapTrue_mem_C1
| null |
CC'₀ : C' C ho → C := fun g ↦ ⟨g.val,g.prop.1.1⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
CC'₀
|
The first way to map `C'` into `C`.
|
noncomputable
CC'₁ : C' C ho → C :=
fun g ↦ ⟨SwapTrue o g.val, (swapTrue_mem_C1 C hsC ho ⟨g.val,g.prop.2⟩).1⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
CC'₁
|
The second way to map `C'` into `C`.
|
continuous_CC'₀ : Continuous (CC'₀ C ho) := Continuous.subtype_mk continuous_subtype_val _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
continuous_CC'₀
| null |
continuous_CC'₁ : Continuous (CC'₁ C hsC ho) :=
Continuous.subtype_mk (Continuous.comp (continuous_swapTrue o) continuous_subtype_val) _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
continuous_CC'₁
| null |
noncomputable
Linear_CC'₀ : LocallyConstant C ℤ →ₗ[ℤ] LocallyConstant (C' C ho) ℤ :=
LocallyConstant.comapₗ ℤ ⟨(CC'₀ C ho), (continuous_CC'₀ C ho)⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Linear_CC'₀
|
The `ℤ`-linear map induced by precomposing with `CC'₀`
|
noncomputable
Linear_CC'₁ : LocallyConstant C ℤ →ₗ[ℤ] LocallyConstant (C' C ho) ℤ :=
LocallyConstant.comapₗ ℤ ⟨(CC'₁ C hsC ho), (continuous_CC'₁ C hsC ho)⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Linear_CC'₁
|
The `ℤ`-linear map induced by precomposing with `CC'₁`
|
noncomputable
Linear_CC' : LocallyConstant C ℤ →ₗ[ℤ] LocallyConstant (C' C ho) ℤ :=
Linear_CC'₁ C hsC ho - Linear_CC'₀ C ho
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Linear_CC'
|
The difference between `Linear_CC'₁` and `Linear_CC'₀`.
|
CC_comp_zero : ∀ y, (Linear_CC' C hsC ho) ((πs C o) y) = 0 := by
intro y
ext x
dsimp [Linear_CC', Linear_CC'₀, Linear_CC'₁, LocallyConstant.sub_apply]
simp only [sub_eq_zero]
congr 1
ext i
dsimp [CC'₀, CC'₁, ProjRestrict, Proj]
apply if_ctx_congr Iff.rfl _ (fun _ ↦ rfl)
simp only [SwapTrue, ite_eq_right_iff]
intro h₁ h₂
exact (h₁.ne h₂).elim
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
CC_comp_zero
| null |
C0_projOrd {x : I → Bool} (hx : x ∈ C0 C ho) : Proj (ord I · < o) x = x := by
ext i
simp only [Proj, ite_eq_left_iff, not_lt]
intro hi
rcases hi.lt_or_eq with hi | hi
· specialize hsC x hx.1 i
rw [← not_imp_not] at hsC
simp only [not_lt, Bool.not_eq_true, Order.succ_le_iff] at hsC
exact (hsC hi).symm
· simp only [C0, Set.mem_inter_iff, Set.mem_setOf_eq] at hx
rw [eq_comm, ord_term ho] at hi
rw [← hx.2, hi]
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
C0_projOrd
| null |
C1_projOrd {x : I → Bool} (hx : x ∈ C1 C ho) : SwapTrue o (Proj (ord I · < o) x) = x := by
ext i
dsimp [SwapTrue, Proj]
split_ifs with hi h
· rw [ord_term ho] at hi
rw [← hx.2, hi]
· rfl
· simp only [not_lt] at h
have h' : o < ord I i := lt_of_le_of_ne h (Ne.symm hi)
specialize hsC x hx.1 i
rw [← not_imp_not] at hsC
simp only [not_lt, Bool.not_eq_true, Order.succ_le_iff] at hsC
exact (hsC h').symm
include hC in
open scoped Classical in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
C1_projOrd
| null |
CC_exact {f : LocallyConstant C ℤ} (hf : Linear_CC' C hsC ho f = 0) :
∃ y, πs C o y = f := by
dsimp [Linear_CC', Linear_CC'₀, Linear_CC'₁] at hf
simp only [sub_eq_zero, ← LocallyConstant.coe_inj] at hf
let C₀C : C0 C ho → C := fun x ↦ ⟨x.val, x.prop.1⟩
have h₀ : Continuous C₀C := Continuous.subtype_mk continuous_induced_dom _
let C₁C : π (C1 C ho) (ord I · < o) → C :=
fun x ↦ ⟨SwapTrue o x.val, (swapTrue_mem_C1 C hsC ho x).1⟩
have h₁ : Continuous C₁C := Continuous.subtype_mk
((continuous_swapTrue o).comp continuous_subtype_val) _
refine ⟨LocallyConstant.piecewise' ?_ (isClosed_C0 C hC ho)
(isClosed_proj _ o (isClosed_C1 C hC ho)) (f.comap ⟨C₀C, h₀⟩) (f.comap ⟨C₁C, h₁⟩) ?_, ?_⟩
· rintro _ ⟨y, hyC, rfl⟩
simp only [Set.mem_union]
rw [← union_C0C1_eq C ho] at hyC
refine hyC.imp (fun hyC ↦ ?_) (fun hyC ↦ ⟨y, hyC, rfl⟩)
rwa [C0_projOrd C hsC ho hyC]
· intro x hx
simpa only [h₀, h₁, LocallyConstant.coe_comap] using (congrFun hf ⟨x, hx⟩).symm
· ext ⟨x, hx⟩
rw [← union_C0C1_eq C ho] at hx
rcases hx with hx₀ | hx₁
· have hx₀' : ProjRestrict C (ord I · < o) ⟨x, hx⟩ = x := by
simpa only [ProjRestrict, Set.MapsTo.val_restrict_apply] using C0_projOrd C hsC ho hx₀
simp only [C₀C, πs_apply_apply, hx₀', hx₀, LocallyConstant.piecewise'_apply_left,
LocallyConstant.coe_comap, ContinuousMap.coe_mk, Function.comp_apply]
· have hx₁' : (ProjRestrict C (ord I · < o) ⟨x, hx⟩).val ∈ π (C1 C ho) (ord I · < o) := by
simpa only [ProjRestrict, Set.MapsTo.val_restrict_apply] using ⟨x, hx₁, rfl⟩
simp only [C₁C, πs_apply_apply, LocallyConstant.coe_comap,
Function.comp_apply, hx₁', LocallyConstant.piecewise'_apply_right]
congr
simp only [ContinuousMap.coe_mk, Subtype.mk.injEq]
exact C1_projOrd C hsC ho hx₁
variable (o) in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
CC_exact
| null |
succ_mono : CategoryTheory.Mono (ModuleCat.ofHom (πs C o)) := by
rw [ModuleCat.mono_iff_injective]
exact injective_πs _ _
include hC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
succ_mono
| null |
succ_exact :
(ShortComplex.mk (ModuleCat.ofHom (πs C o)) (ModuleCat.ofHom (Linear_CC' C hsC ho))
(by ext : 2; apply CC_comp_zero)).Exact := by
rw [ShortComplex.moduleCat_exact_iff]
intro f
exact CC_exact C hC hsC ho
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
succ_exact
| null |
MaxProducts : Set (Products I) := {l | l.isGood C ∧ term I ho ∈ l.val}
include hsC in
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
MaxProducts
|
The `GoodProducts` in `C` that contain `o` (they necessarily start with `o`, see
`GoodProducts.head!_eq_o_of_maxProducts`)
|
union_succ : GoodProducts C = GoodProducts (π C (ord I · < o)) ∪ MaxProducts C ho := by
ext l
simp only [GoodProducts, MaxProducts, Set.mem_union, Set.mem_setOf_eq]
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· by_cases hh : term I ho ∈ l.val
· exact Or.inr ⟨h, hh⟩
· left
intro he
apply h
have h' := Products.prop_of_isGood_of_contained C _ h hsC
simp only [Order.lt_succ_iff] at h'
simp only at hh
have hh' : ∀ a ∈ l.val, ord I a < o := by
intro a ha
refine (h' a ha).lt_of_ne ?_
rw [ne_eq, ord_term ho a]
rintro rfl
contradiction
rwa [Products.eval_πs_image C hh', ← Products.eval_πs C hh',
Submodule.apply_mem_span_image_iff_mem_span (injective_πs _ _)]
· refine h.elim (fun hh ↦ ?_) And.left
have := Products.isGood_mono C (Order.lt_succ o).le hh
rwa [contained_eq_proj C (Order.succ o) hsC]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
union_succ
| null |
sum_to : (GoodProducts (π C (ord I · < o))) ⊕ (MaxProducts C ho) → Products I :=
Sum.elim Subtype.val Subtype.val
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
sum_to
|
The inclusion map from the sum of `GoodProducts (π C (ord I · < o))` and
`(MaxProducts C ho)` to `Products I`.
|
injective_sum_to : Function.Injective (sum_to C ho) := by
refine Function.Injective.sumElim Subtype.val_injective Subtype.val_injective
(fun ⟨a,ha⟩ ⟨b,hb⟩ ↦ (fun (hab : a = b) ↦ ?_))
rw [← hab] at hb
have ha' := Products.prop_of_isGood C _ ha (term I ho) hb.2
simp only [ord_term_aux, lt_self_iff_false] at ha'
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
injective_sum_to
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.