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
⌀ |
|---|---|---|---|---|---|---|
sum_to_range :
Set.range (sum_to C ho) = GoodProducts (π C (ord I · < o)) ∪ MaxProducts C ho := by
have h : Set.range (sum_to C ho) = _ ∪ _ := Set.Sum.elim_range _ _; rw [h]; congr <;> ext l
· exact ⟨fun ⟨m,hm⟩ ↦ by rw [← hm]; exact m.prop, fun hl ↦ ⟨⟨l,hl⟩, rfl⟩⟩
· exact ⟨fun ⟨m,hm⟩ ↦ by rw [← hm]; exact m.prop, fun hl ↦ ⟨⟨l,hl⟩, rfl⟩⟩
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
sum_to_range
| null |
noncomputable
sum_equiv (hsC : contained C (Order.succ o)) (ho : o < Ordinal.type (· < · : I → I → Prop)) :
GoodProducts (π C (ord I · < o)) ⊕ (MaxProducts C ho) ≃ GoodProducts C :=
calc _ ≃ Set.range (sum_to C ho) := Equiv.ofInjective (sum_to C ho) (injective_sum_to C ho)
_ ≃ _ := Equiv.setCongr <| by rw [sum_to_range C ho, union_succ C hsC ho]
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
sum_equiv
|
The equivalence from the sum of `GoodProducts (π C (ord I · < o))` and
`(MaxProducts C ho)` to `GoodProducts C`.
|
sum_equiv_comp_eval_eq_elim : eval C ∘ (sum_equiv C hsC ho).toFun =
(Sum.elim (fun (l : GoodProducts (π C (ord I · < o))) ↦ Products.eval C l.1)
(fun (l : MaxProducts C ho) ↦ Products.eval C l.1)) := by
ext ⟨_, _⟩ <;> [rfl; rfl]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
sum_equiv_comp_eval_eq_elim
| null |
SumEval : GoodProducts (π C (ord I · < o)) ⊕ MaxProducts C ho →
LocallyConstant C ℤ :=
Sum.elim (fun l ↦ l.1.eval C) (fun l ↦ l.1.eval C)
include hsC in
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
SumEval
|
Let
`N := LocallyConstant (π C (ord I · < o)) ℤ`
`M := LocallyConstant C ℤ`
`P := LocallyConstant (C' C ho) ℤ`
`ι := GoodProducts (π C (ord I · < o))`
`ι' := GoodProducts (C' C ho')`
`v : ι → N := GoodProducts.eval (π C (ord I · < o))`
Then `SumEval C ho` is the map `u` in the diagram below. It is linearly independent if and only if
`GoodProducts.eval C` is, see `linearIndependent_iff_sum`. The top row is the exact sequence given
by `succ_exact` and `succ_mono`. The left square commutes by `GoodProducts.square_commutes`.
```
0 --→ N --→ M --→ P
↑ ↑ ↑
v| u| |
ι → ι ⊕ ι' ← ι'
```
|
linearIndependent_iff_sum :
LinearIndependent ℤ (eval C) ↔ LinearIndependent ℤ (SumEval C ho) := by
rw [← linearIndependent_equiv (sum_equiv C hsC ho), SumEval,
← sum_equiv_comp_eval_eq_elim C hsC ho]
exact Iff.rfl
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
linearIndependent_iff_sum
| null |
span_sum : Set.range (eval C) = Set.range (Sum.elim
(fun (l : GoodProducts (π C (ord I · < o))) ↦ Products.eval C l.1)
(fun (l : MaxProducts C ho) ↦ Products.eval C l.1)) := by
rw [← sum_equiv_comp_eval_eq_elim C hsC ho, Equiv.toFun_as_coe,
EquivLike.range_comp (e := sum_equiv C hsC ho)]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
span_sum
| null |
square_commutes : SumEval C ho ∘ Sum.inl =
ModuleCat.ofHom (πs C o) ∘ eval (π C (ord I · < o)) := by
ext l
dsimp [SumEval]
rw [← Products.eval_πs C (Products.prop_of_isGood _ _ l.prop)]
simp [eval]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
square_commutes
| null |
swapTrue_eq_true (x : I → Bool) : SwapTrue o x (term I ho) = true := by
simp only [SwapTrue, ord_term_aux, ite_true]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
swapTrue_eq_true
| null |
mem_C'_eq_false : ∀ x, x ∈ C' C ho → x (term I ho) = false := by
rintro x ⟨_, y, _, rfl⟩
simp only [Proj, ord_term_aux, lt_self_iff_false, ite_false]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
mem_C'_eq_false
| null |
Products.Tail (l : Products I) : Products I :=
⟨l.val.tail, List.IsChain.tail l.prop⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Products.Tail
|
`List.tail` as a `Products`.
|
Products.max_eq_o_cons_tail [Inhabited I] (l : Products I) (hl : l.val ≠ [])
(hlh : l.val.head! = term I ho) : l.val = term I ho :: l.Tail.val := by
rw [← List.cons_head!_tail hl, hlh]
simp [Tail]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Products.max_eq_o_cons_tail
| null |
Products.max_eq_o_cons_tail' [Inhabited I] (l : Products I) (hl : l.val ≠ [])
(hlh : l.val.head! = term I ho) (hlc : List.IsChain (· > ·) (term I ho :: l.Tail.val)) :
l = ⟨term I ho :: l.Tail.val, hlc⟩ := by
simp_rw [← max_eq_o_cons_tail ho l hl hlh, Subtype.coe_eta]
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Products.max_eq_o_cons_tail'
| null |
GoodProducts.head!_eq_o_of_maxProducts [Inhabited I] (l : ↑(MaxProducts C ho)) :
l.val.val.head! = term I ho := by
rw [eq_comm, ← ord_term ho]
have hm := l.prop.2
have := Products.prop_of_isGood_of_contained C _ l.prop.1 hsC l.val.val.head!
(List.head!_mem_self (List.ne_nil_of_mem hm))
simp only [Order.lt_succ_iff] at this
refine eq_of_le_of_not_lt this (not_lt.mpr ?_)
have h : ord I (term I ho) ≤ ord I l.val.val.head! := by
simp only [ord, Ordinal.typein_le_typein, not_lt]
exact Products.rel_head!_of_mem hm
rwa [ord_term_aux] at h
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
GoodProducts.head
| null |
GoodProducts.max_eq_o_cons_tail (l : MaxProducts C ho) :
l.val.val = (term I ho) :: l.val.Tail.val :=
have : Inhabited I := ⟨term I ho⟩
Products.max_eq_o_cons_tail ho l.val (List.ne_nil_of_mem l.prop.2)
(head!_eq_o_of_maxProducts _ hsC ho l)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
GoodProducts.max_eq_o_cons_tail
| null |
Products.evalCons {I} [LinearOrder I] {C : Set (I → Bool)} {l : List I} {a : I}
(hla : (a::l).IsChain (· > ·)) : Products.eval C ⟨a::l,hla⟩ =
(e C a) * Products.eval C ⟨l,List.IsChain.sublist hla (List.tail_sublist (a::l))⟩ := by
simp only [eval.eq_1, List.map, List.prod_cons]
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Products.evalCons
| null |
Products.max_eq_eval [Inhabited I] (l : Products I) (hl : l.val ≠ [])
(hlh : l.val.head! = term I ho) :
Linear_CC' C hsC ho (l.eval C) = l.Tail.eval (C' C ho) := by
have hlc : ((term I ho) :: l.Tail.val).IsChain (· > ·) := by
rw [← max_eq_o_cons_tail ho l hl hlh]; exact l.prop
rw [max_eq_o_cons_tail' ho l hl hlh hlc, Products.evalCons]
ext x
simp only [Linear_CC', Linear_CC'₁, LocallyConstant.comapₗ, Linear_CC'₀, Subtype.coe_eta,
LinearMap.sub_apply, LinearMap.coe_mk, AddHom.coe_mk, LocallyConstant.sub_apply,
LocallyConstant.coe_comap, LocallyConstant.coe_mul, ContinuousMap.coe_mk, Function.comp_apply,
Pi.mul_apply]
rw [CC'₁, CC'₀, Products.eval_eq, Products.eval_eq, Products.eval_eq]
simp only [mul_ite, mul_one, mul_zero]
have hi' : ∀ i, i ∈ l.Tail.val → (x.val i = SwapTrue o x.val i) := by
intro i hi
simp only [SwapTrue, @eq_comm _ (x.val i), ite_eq_right_iff, ord_term ho]
rintro rfl
exact ((List.IsChain.rel_cons hlc hi).ne rfl).elim
have H : (∀ i, i ∈ l.Tail.val → (x.val i = true)) =
(∀ i, i ∈ l.Tail.val → (SwapTrue o x.val i = true)) := by
apply forall_congr; intro i; apply forall_congr; intro hi; rw [hi' i hi]
simp only [H]
split_ifs with h₁ h₂ h₃ <;> try (dsimp [e])
· rw [if_pos (swapTrue_eq_true _ _), if_neg]
· rfl
· simp [mem_C'_eq_false C ho x x.prop]
· push_neg at h₂; obtain ⟨i, hi⟩ := h₂; exfalso; rw [hi' i hi.1] at hi; exact hi.2 (h₁ i hi.1)
· push_neg at h₁; obtain ⟨i, hi⟩ := h₁; exfalso; rw [← hi' i hi.1] at hi; exact hi.2 (h₃ i hi.1)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
Products.max_eq_eval
| null |
max_eq_eval (l : MaxProducts C ho) :
Linear_CC' C hsC ho (l.val.eval C) = l.val.Tail.eval (C' C ho) :=
have : Inhabited I := ⟨term I ho⟩
Products.max_eq_eval _ _ _ _ (List.ne_nil_of_mem l.prop.2)
(head!_eq_o_of_maxProducts _ hsC ho l)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
max_eq_eval
| null |
max_eq_eval_unapply :
(Linear_CC' C hsC ho) ∘ (fun (l : MaxProducts C ho) ↦ Products.eval C l.val) =
(fun l ↦ l.val.Tail.eval (C' C ho)) := by
ext1 l
exact max_eq_eval _ _ _ _
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
max_eq_eval_unapply
| null |
isChain_cons_of_lt (l : MaxProducts C ho)
(q : Products I) (hq : q < l.val.Tail) :
List.IsChain (fun x x_1 ↦ x > x_1) (term I ho :: q.val) := by
have : Inhabited I := ⟨term I ho⟩
rw [List.isChain_iff_pairwise]
simp only [gt_iff_lt, List.pairwise_cons]
refine ⟨fun a ha ↦ lt_of_le_of_lt (Products.rel_head!_of_mem ha) ?_,
List.isChain_iff_pairwise.mp q.prop⟩
refine lt_of_le_of_lt (Products.head!_le_of_lt hq (q.val.ne_nil_of_mem ha)) ?_
by_cases hM : l.val.Tail.val = []
· rw [Products.lt_iff_lex_lt, hM] at hq
simp only [List.not_lex_nil] at hq
· have := l.val.prop
rw [max_eq_o_cons_tail C hsC ho l, List.isChain_iff_pairwise] at this
exact List.rel_of_pairwise_cons this (List.head!_mem_self hM)
@[deprecated (since := "2025-09-24")] alias chain'_cons_of_lt := isChain_cons_of_lt
include hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
isChain_cons_of_lt
| null |
good_lt_maxProducts (q : GoodProducts (π C (ord I · < o)))
(l : MaxProducts C ho) : List.Lex (· < ·) q.val.val l.val.val := by
have : Inhabited I := ⟨term I ho⟩
by_cases h : q.val.val = []
· rw [h, max_eq_o_cons_tail C hsC ho l]
exact List.Lex.nil
· rw [← List.cons_head!_tail h, max_eq_o_cons_tail C hsC ho l]
apply List.Lex.rel
rw [← Ordinal.typein_lt_typein (· < ·)]
simp only [term, Ordinal.typein_enum]
exact Products.prop_of_isGood C _ q.prop q.val.val.head! (List.head!_mem_self h)
include hC hsC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
good_lt_maxProducts
| null |
maxTail_isGood (l : MaxProducts C ho)
(h₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (ord I · < o))))) :
l.val.Tail.isGood (C' C ho) := by
have : Inhabited I := ⟨term I ho⟩
intro h
rw [Finsupp.mem_span_image_iff_linearCombination, ← max_eq_eval C hsC ho] at h
obtain ⟨m, ⟨hmmem, hmsum⟩⟩ := h
rw [Finsupp.linearCombination_apply] at hmsum
have : (Linear_CC' C hsC ho) (l.val.eval C) = (Linear_CC' C hsC ho)
(Finsupp.sum m fun i a ↦ a • ((term I ho :: i.1).map (e C)).prod) := by
rw [← hmsum]
simp only [map_finsuppSum]
apply Finsupp.sum_congr
intro q hq
rw [LinearMap.map_smul]
rw [Finsupp.mem_supported] at hmmem
have hx'' : q < l.val.Tail := hmmem hq
have : ∃ (p : Products I), p.val ≠ [] ∧ p.val.head! = term I ho ∧ q = p.Tail :=
⟨⟨term I ho :: q.val, isChain_cons_of_lt C hsC ho l q hx''⟩,
⟨List.cons_ne_nil _ _, by simp only [List.head!_cons],
by simp only [Products.Tail, List.tail_cons, Subtype.coe_eta]⟩⟩
obtain ⟨p, hp⟩ := this
rw [hp.2.2, ← Products.max_eq_eval C hsC ho p hp.1 hp.2.1]
dsimp [Products.eval]
rw [Products.max_eq_o_cons_tail ho p hp.1 hp.2.1, List.map_cons, List.prod_cons]
have hse := succ_exact C hC hsC ho
rw [ShortComplex.moduleCat_exact_iff_range_eq_ker] at hse
dsimp [ModuleCat.ofHom] at hse
rw [← LinearMap.sub_mem_ker_iff, ← hse] at this
obtain ⟨(n : LocallyConstant (π C (ord I · < o)) ℤ), hn⟩ := this
rw [eq_sub_iff_add_eq] at hn
have hn' := h₁ (Submodule.mem_top : n ∈ ⊤)
rw [Finsupp.mem_span_range_iff_exists_finsupp] at hn'
obtain ⟨w,hc⟩ := hn'
rw [← hc, map_finsuppSum] at hn
apply l.prop.1
rw [← hn]
apply Submodule.add_mem
· apply Submodule.finsuppSum_mem
intro q _
rw [LinearMap.map_smul]
apply Submodule.smul_mem
apply Submodule.subset_span
dsimp only [eval]
rw [Products.eval_πs C (Products.prop_of_isGood _ _ q.prop)]
refine ⟨q.val, ⟨?_, rfl⟩⟩
simp only [Products.lt_iff_lex_lt, Set.mem_setOf_eq]
exact good_lt_maxProducts C hsC ho q l
· apply Submodule.finsuppSum_mem
intro q hq
apply Submodule.smul_mem
...
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
maxTail_isGood
|
Removing the leading `o` from a term of `MaxProducts C` yields a list which `isGood` with respect to
`C'`.
|
noncomputable
MaxToGood
(h₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (ord I · < o))))) :
MaxProducts C ho → GoodProducts (C' C ho) :=
fun l ↦ ⟨l.val.Tail, maxTail_isGood C hC hsC ho l h₁⟩
|
def
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
MaxToGood
|
Given `l : MaxProducts C ho`, its `Tail` is a `GoodProducts (C' C ho)`.
|
maxToGood_injective
(h₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (ord I · < o))))) :
(MaxToGood C hC hsC ho h₁).Injective := by
intro m n h
apply Subtype.ext ∘ Subtype.ext
rw [Subtype.ext_iff] at h
dsimp [MaxToGood] at h
rw [max_eq_o_cons_tail C hsC ho m, max_eq_o_cons_tail C hsC ho n, h]
include hC in
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
maxToGood_injective
| null |
linearIndependent_comp_of_eval
(h₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (ord I · < o))))) :
LinearIndependent ℤ (eval (C' C ho)) →
LinearIndependent ℤ (ModuleCat.ofHom (Linear_CC' C hsC ho) ∘ SumEval C ho ∘ Sum.inr) := by
dsimp [SumEval, ModuleCat.ofHom]
rw [max_eq_eval_unapply C hsC ho]
intro h
let f := MaxToGood C hC hsC ho h₁
have hf : f.Injective := maxToGood_injective C hC hsC ho h₁
have hh : (fun l ↦ Products.eval (C' C ho) l.val.Tail) = eval (C' C ho) ∘ f := rfl
rw [hh]
exact h.comp f hf
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/Successor.lean
|
linearIndependent_comp_of_eval
| null |
GoodProducts.linearIndependentEmpty {I} [LinearOrder I] :
LinearIndependent ℤ (eval (∅ : Set (I → Bool))) := linearIndependent_empty_type
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
GoodProducts.linearIndependentEmpty
| null |
Products.nil : Products I := ⟨[], by simp only [List.isChain_nil]⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
Products.nil
|
The empty list as a `Products`
|
Products.lt_nil_empty {I} [LinearOrder I] : { m : Products I | m < Products.nil } = ∅ := by
ext ⟨m, hm⟩
refine ⟨fun h ↦ ?_, by tauto⟩
simp only [Set.mem_setOf_eq, lt_iff_lex_lt, nil, List.not_lex_nil] at h
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
Products.lt_nil_empty
| null |
Products.isGood_nil {I} [LinearOrder I] :
Products.isGood ({fun _ ↦ false} : Set (I → Bool)) Products.nil := by
intro h
simp [Products.eval, Products.nil] at h
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
Products.isGood_nil
| null |
Products.span_nil_eq_top {I} [LinearOrder I] :
Submodule.span ℤ (eval ({fun _ ↦ false} : Set (I → Bool)) '' {nil}) = ⊤ := by
rw [Set.image_singleton, eq_top_iff]
intro f _
rw [Submodule.mem_span_singleton]
refine ⟨f default, ?_⟩
simp only [eval, List.map, List.prod_nil, zsmul_eq_mul, mul_one, Products.nil]
ext x
obtain rfl : x = default := by simp only [Set.default_coe_singleton, eq_iff_true_of_subsingleton]
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
Products.span_nil_eq_top
| null |
smaller (o : Ordinal) : Set (LocallyConstant C ℤ) :=
(πs C o) '' (range (π C (ord I · < o)))
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
smaller
|
There is a unique `GoodProducts` for the singleton `{fun _ ↦ false}`. -/
noncomputable
instance : Unique { l // Products.isGood ({fun _ ↦ false} : Set (I → Bool)) l } where
default := ⟨Products.nil, Products.isGood_nil⟩
uniq := by
intro ⟨⟨l, hl⟩, hll⟩
ext
apply Subtype.ext
apply (List.lex_nil_or_eq_nil l (r := (· < ·))).resolve_left
intro _
apply hll
have he : {Products.nil} ⊆ {m | m < ⟨l,hl⟩} := by
simpa only [Products.nil, Products.lt_iff_lex_lt, Set.singleton_subset_iff, Set.mem_setOf_eq]
grw [← he]
rw [Products.span_nil_eq_top]
exact Submodule.mem_top
instance (α : Type*) [TopologicalSpace α] : NoZeroSMulDivisors ℤ (LocallyConstant α ℤ) := by
constructor
intro c f h
rw [or_iff_not_imp_left]
intro hc
ext x
apply mul_right_injective₀ hc
simp [LocallyConstant.ext_iff] at h
simpa [LocallyConstant.ext_iff] using h x
theorem GoodProducts.linearIndependentSingleton {I} [LinearOrder I] :
LinearIndependent ℤ (eval ({fun _ ↦ false} : Set (I → Bool))) := by
refine linearIndependent_unique (eval ({fun _ ↦ false} : Set (I → Bool))) ?_
simp [eval, Products.eval, Products.nil, default]
end Zero
variable [WellFoundedLT I]
section Limit
/-!
## The limit case of the induction
We relate linear independence in `LocallyConstant (π C (ord I · < o')) ℤ` with linear independence
in `LocallyConstant C ℤ`, where `contained C o` and `o' < o`.
When `o` is a limit ordinal, we prove that the good products in `LocallyConstant C ℤ` are linearly
independent if and only if a certain directed union is linearly independent. Each term in this
directed union is in bijection with the good products w.r.t. `π C (ord I · < o')` for an ordinal
`o' < o`, and these are linearly independent by the inductive hypothesis.
### Main definitions
* `GoodProducts.smaller` is the image of good products coming from a smaller ordinal.
* `GoodProducts.range_equiv`: The image of the `GoodProducts` in `C` is equivalent to the union of
`smaller C o'` over all ordinals `o' < o`.
### Main results
* `Products.limitOrdinal`: for `o` a limit ordinal such that `contained C o`, a product `l` is good
w.r.t. `C` iff it there exists an ordinal `o' < o` such that `l` is good w.r.t.
`π C (ord I · < o')`.
* `GoodProducts.linearIndependent_iff_union_smaller` is the result mentioned above, that the good
products are linearly independent iff a directed union is.
-/
namespace GoodProducts
/--
The image of the `GoodProducts` for `π C (ord I · < o)` in `LocallyConstant C ℤ`. The name `smaller`
refers to the setting in which we will use this, when we are mapping in `GoodProducts` from a
smaller set, i.e. when `o` is a smaller ordinal than the one `C` is "contained" in.
|
noncomputable
range_equiv_smaller_toFun (o : Ordinal) (x : range (π C (ord I · < o))) : smaller C o :=
⟨πs C o ↑x, x.val, x.property, rfl⟩
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
range_equiv_smaller_toFun
|
The map from the image of the `GoodProducts` in `LocallyConstant (π C (ord I · < o)) ℤ` to
`smaller C o`
|
range_equiv_smaller_toFun_bijective (o : Ordinal) :
Function.Bijective (range_equiv_smaller_toFun C o) := by
dsimp +unfoldPartialApp [range_equiv_smaller_toFun]
refine ⟨fun a b hab ↦ ?_, fun ⟨a, b, hb⟩ ↦ ?_⟩
· ext1
simp only [Subtype.mk.injEq] at hab
exact injective_πs C o hab
· use ⟨b, hb.1⟩
simpa only [Subtype.mk.injEq] using hb.2
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
range_equiv_smaller_toFun_bijective
| null |
noncomputable
range_equiv_smaller (o : Ordinal) : range (π C (ord I · < o)) ≃ smaller C o :=
Equiv.ofBijective (range_equiv_smaller_toFun C o) (range_equiv_smaller_toFun_bijective C o)
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
range_equiv_smaller
|
The equivalence from the image of the `GoodProducts` in `LocallyConstant (π C (ord I · < o)) ℤ` to
`smaller C o`
|
smaller_factorization (o : Ordinal) :
(fun (p : smaller C o) ↦ p.1) ∘ (range_equiv_smaller C o).toFun =
(πs C o) ∘ (fun (p : range (π C (ord I · < o))) ↦ p.1) := by rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
smaller_factorization
| null |
linearIndependent_iff_smaller (o : Ordinal) :
LinearIndependent ℤ (GoodProducts.eval (π C (ord I · < o))) ↔
LinearIndependent ℤ (fun (p : smaller C o) ↦ p.1) := by
rw [GoodProducts.linearIndependent_iff_range,
← LinearMap.linearIndependent_iff (πs C o)
(LinearMap.ker_eq_bot_of_injective (injective_πs _ _)), ← smaller_factorization C o]
exact linearIndependent_equiv _
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
linearIndependent_iff_smaller
| null |
smaller_mono {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) : smaller C o₁ ⊆ smaller C o₂ := by
rintro f ⟨g, hg, rfl⟩
simp only [smaller, Set.mem_image]
use πs' C h g
obtain ⟨⟨l, gl⟩, rfl⟩ := hg
refine ⟨?_, ?_⟩
· use ⟨l, Products.isGood_mono C h gl⟩
ext x
rw [eval, ← Products.eval_πs' _ h (Products.prop_of_isGood C _ gl), eval]
· rw [← LocallyConstant.coe_inj, coe_πs C o₂, ← LocallyConstant.toFun_eq_coe, coe_πs',
Function.comp_assoc, projRestricts_comp_projRestrict C _, coe_πs]
rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
smaller_mono
| null |
Products.limitOrdinal (l : Products I) : l.isGood (π C (ord I · < o)) ↔
∃ (o' : Ordinal), o' < o ∧ l.isGood (π C (ord I · < o')) := by
refine ⟨fun h ↦ ?_, fun ⟨o', ⟨ho', hl⟩⟩ ↦ isGood_mono C (le_of_lt ho') hl⟩
use Finset.sup l.val.toFinset (fun a ↦ Order.succ (ord I a))
have hslt : Finset.sup l.val.toFinset (fun a ↦ Order.succ (ord I a)) < o := by
simp only [Finset.sup_lt_iff ho.bot_lt, List.mem_toFinset]
exact fun b hb ↦ ho.succ_lt (prop_of_isGood C (ord I · < o) h b hb)
refine ⟨hslt, fun he ↦ h ?_⟩
have hlt : ∀ i ∈ l.val, ord I i < Finset.sup l.val.toFinset (fun a ↦ Order.succ (ord I a)) := by
intro i hi
simp only [Finset.lt_sup_iff, List.mem_toFinset, Order.lt_succ_iff]
exact ⟨i, hi, le_rfl⟩
rwa [eval_πs_image' C (le_of_lt hslt) hlt, ← eval_πs' C (le_of_lt hslt) hlt,
Submodule.apply_mem_span_image_iff_mem_span (injective_πs' C _)]
variable (hsC : contained C o)
include hsC
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
Products.limitOrdinal
| null |
GoodProducts.union : range C = ⋃ (e : {o' // o' < o}), (smaller C e.val) := by
ext p
simp only [smaller, range, Set.mem_iUnion, Set.mem_image, Set.mem_range, Subtype.exists]
refine ⟨fun hp ↦ ?_, fun hp ↦ ?_⟩
· obtain ⟨l, hl, rfl⟩ := hp
rw [contained_eq_proj C o hsC, Products.limitOrdinal C ho] at hl
obtain ⟨o', ho'⟩ := hl
refine ⟨o', ho'.1, eval (π C (ord I · < o')) ⟨l, ho'.2⟩, ⟨l, ho'.2, rfl⟩, ?_⟩
exact Products.eval_πs C (Products.prop_of_isGood C _ ho'.2)
· obtain ⟨o', h, _, ⟨l, hl, rfl⟩, rfl⟩ := hp
refine ⟨l, ?_, (Products.eval_πs C (Products.prop_of_isGood C _ hl)).symm⟩
rw [contained_eq_proj C o hsC]
exact Products.isGood_mono C (le_of_lt h) hl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
GoodProducts.union
| null |
GoodProducts.range_equiv : range C ≃ ⋃ (e : {o' // o' < o}), (smaller C e.val) :=
Equiv.setCongr (union C ho hsC)
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
GoodProducts.range_equiv
|
The image of the `GoodProducts` in `C` is equivalent to the union of `smaller C o'` over all
ordinals `o' < o`.
|
GoodProducts.range_equiv_factorization :
(fun (p : ⋃ (e : {o' // o' < o}), (smaller C e.val)) ↦ p.1) ∘ (range_equiv C ho hsC).toFun =
(fun (p : range C) ↦ (p.1 : LocallyConstant C ℤ)) := rfl
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
GoodProducts.range_equiv_factorization
| null |
GoodProducts.linearIndependent_iff_union_smaller :
LinearIndependent ℤ (GoodProducts.eval C) ↔
LinearIndependent ℤ (fun (p : ⋃ (e : {o' // o' < o}), (smaller C e.val)) ↦ p.1) := by
rw [GoodProducts.linearIndependent_iff_range, ← range_equiv_factorization C ho hsC]
exact linearIndependent_equiv (range_equiv C ho hsC)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearIndependent.Basic",
"Mathlib.Topology.Category.Profinite.Nobeling.Basic"
] |
Mathlib/Topology/Category/Profinite/Nobeling/ZeroLimit.lean
|
GoodProducts.linearIndependent_iff_union_smaller
| null |
limitCone (F : J ⥤ TopCat.{max v u}) : Cone F where
pt := TopCat.of { u : ∀ j : J, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j }
π :=
{ app := fun j => ofHom
{ toFun := fun u => u.val j
continuous_toFun := Continuous.comp (continuous_apply _) (continuous_subtype_val) }
naturality := fun X Y f => by
ext a
exact (a.2 f).symm }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
limitCone
|
A choice of limit cone for a functor `F : J ⥤ TopCat`.
Generally you should just use `limit.cone F`, unless you need the actual definition
(which is in terms of `Types.limitCone`).
|
limitConeIsLimit (F : J ⥤ TopCat.{max v u}) : IsLimit (limitCone.{v,u} F) where
lift S := ofHom
{ toFun := fun x =>
⟨fun _ => S.π.app _ x, fun f => by
dsimp
rw [← S.w f]
rfl⟩
continuous_toFun :=
Continuous.subtype_mk (continuous_pi fun j => (S.π.app j).hom.2) fun x i j f => by
dsimp
rw [← S.w f]
rfl }
uniq S m h := by
ext a
simp [← h]
rfl
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
limitConeIsLimit
|
The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
|
conePtOfConeForget : Type _ := c.pt
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
conePtOfConeForget
|
Given a functor `F : J ⥤ TopCat` and a cone `c : Cone (F ⋙ forget)`
of the underlying functor to types, this is the type `c.pt`
with the infimum of the induced topologies by the maps `c.π.app j`.
|
topologicalSpaceConePtOfConeForget :
TopologicalSpace (conePtOfConeForget c) :=
(⨅ j, (F.obj j).str.induced (c.π.app j))
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topologicalSpaceConePtOfConeForget
| null |
@[simps pt π_app]
coneOfConeForget : Cone F where
pt := of (conePtOfConeForget c)
π :=
{ app j := ofHom (ContinuousMap.mk (c.π.app j) (by
rw [continuous_iff_le_induced]
exact iInf_le (fun j ↦ (F.obj j).str.induced (c.π.app j)) j))
naturality j j' φ := by
ext
apply congr_fun (c.π.naturality φ) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
coneOfConeForget
|
Given a functor `F : J ⥤ TopCat` and a cone `c : Cone (F ⋙ forget)`
of the underlying functor to types, this is a cone for `F` whose point is
`c.pt` with the infimum of the induced topologies by the maps `c.π.app j`.
|
isLimitConeOfForget (c : Cone (F ⋙ forget)) (hc : IsLimit c) :
IsLimit (coneOfConeForget c) := by
refine IsLimit.ofFaithful forget (ht := hc)
(fun s ↦ ofHom (ContinuousMap.mk (hc.lift ((forget).mapCone s)) ?_)) (fun _ ↦ rfl)
rw [continuous_iff_coinduced_le]
dsimp [topologicalSpaceConePtOfConeForget]
rw [le_iInf_iff]
intro j
rw [coinduced_le_iff_le_induced, induced_compose]
convert continuous_iff_le_induced.1 (s.π.app j).hom.continuous
exact hc.fac ((forget).mapCone s) j
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isLimitConeOfForget
|
Given a functor `F : J ⥤ TopCat` and a cone `c : Cone (F ⋙ forget)`
of the underlying functor to types, the limit of `F` is `c.pt` equipped
with the infimum of the induced topologies by the maps `c.π.app j`.
|
induced_of_isLimit :
c.pt.str = ⨅ j, (F.obj j).str.induced (c.π.app j) := by
let c' := coneOfConeForget ((forget).mapCone c)
let hc' : IsLimit c' := isLimitConeOfForget _ (isLimitOfPreserves forget hc)
let e := IsLimit.conePointUniqueUpToIso hc' hc
have he (j : J) : e.inv ≫ c'.π.app j = c.π.app j :=
IsLimit.conePointUniqueUpToIso_inv_comp hc' hc j
apply (homeoOfIso e.symm).induced_eq.symm.trans
dsimp [coneOfConeForget_pt, c', topologicalSpaceConePtOfConeForget]
conv_rhs => simp only [← he]
simp [← induced_compose, homeoOfIso, c']
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
induced_of_isLimit
| null |
limit_topology [HasLimit F] :
(limit F).str = ⨅ j, (F.obj j).str.induced (limit.π F j) :=
induced_of_isLimit _ (limit.isLimit _)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
limit_topology
| null |
hasLimit_iff_small_sections :
HasLimit F ↔ Small.{u} ((F ⋙ forget).sections) := by
rw [← Types.hasLimit_iff_small_sections]
constructor <;> intro
· infer_instance
· exact ⟨⟨_, isLimitConeOfForget _ (limit.isLimit _)⟩⟩
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
hasLimit_iff_small_sections
| null |
topCat_hasLimitsOfShape (J : Type v) [Category J] [Small.{u} J] :
HasLimitsOfShape J TopCat.{u} where
has_limit := fun F => by
rw [hasLimit_iff_small_sections]
infer_instance
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasLimitsOfShape
| null |
topCat_hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} TopCat.{u} where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasLimitsOfSize
| null |
topCat_hasLimits : HasLimits TopCat.{u} :=
TopCat.topCat_hasLimitsOfSize.{u, u}
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasLimits
| null |
forget_preservesLimitsOfSize :
PreservesLimitsOfSize.{w, v} (forget : TopCat.{u} ⥤ _) where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
forget_preservesLimitsOfSize
| null |
forget_preservesLimits : PreservesLimits (forget : TopCat.{u} ⥤ _) where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
forget_preservesLimits
| null |
coconePtOfCoconeForget : Type _ := c.pt
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
coconePtOfCoconeForget
|
Given a functor `F : J ⥤ TopCat` and a cocone `c : Cocone (F ⋙ forget)`
of the underlying cocone of types, this is the type `c.pt`
with the supremum of the topologies that are coinduced by the maps `c.ι.app j`.
|
topologicalSpaceCoconePtOfCoconeForget :
TopologicalSpace (coconePtOfCoconeForget c) :=
(⨆ j, (F.obj j).str.coinduced (c.ι.app j))
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topologicalSpaceCoconePtOfCoconeForget
| null |
@[simps pt ι_app]
coconeOfCoconeForget : Cocone F where
pt := of (coconePtOfCoconeForget c)
ι :=
{ app j := ofHom (ContinuousMap.mk (c.ι.app j) (by
rw [continuous_iff_coinduced_le]
exact le_iSup (fun j ↦ (F.obj j).str.coinduced (c.ι.app j)) j))
naturality j j' φ := by
ext
apply congr_fun (c.ι.naturality φ) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
coconeOfCoconeForget
|
Given a functor `F : J ⥤ TopCat` and a cocone `c : Cocone (F ⋙ forget)`
of the underlying cocone of types, this is a cocone for `F` whose point is
`c.pt` with the supremum of the coinduced topologies by the maps `c.ι.app j`.
|
isColimitCoconeOfForget (c : Cocone (F ⋙ forget)) (hc : IsColimit c) :
IsColimit (coconeOfCoconeForget c) := by
refine IsColimit.ofFaithful forget (ht := hc)
(fun s ↦ ofHom (ContinuousMap.mk (hc.desc ((forget).mapCocone s)) ?_)) (fun _ ↦ rfl)
rw [continuous_iff_le_induced]
dsimp [topologicalSpaceCoconePtOfCoconeForget]
rw [iSup_le_iff]
intro j
rw [coinduced_le_iff_le_induced, induced_compose]
convert continuous_iff_le_induced.1 (s.ι.app j).hom.continuous
exact hc.fac ((forget).mapCocone s) j
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isColimitCoconeOfForget
|
Given a functor `F : J ⥤ TopCat` and a cocone `c : Cocone (F ⋙ forget)`
of the underlying cocone of types, the colimit of `F` is `c.pt` equipped
with the supremum of the coinduced topologies by the maps `c.ι.app j`.
|
coinduced_of_isColimit :
c.pt.str = ⨆ j, (F.obj j).str.coinduced (c.ι.app j) := by
let c' := coconeOfCoconeForget ((forget).mapCocone c)
let hc' : IsColimit c' := isColimitCoconeOfForget _ (isColimitOfPreserves forget hc)
let e := IsColimit.coconePointUniqueUpToIso hc' hc
have he (j : J) : c'.ι.app j ≫ e.hom = c.ι.app j :=
IsColimit.comp_coconePointUniqueUpToIso_hom hc' hc j
apply (homeoOfIso e).coinduced_eq.symm.trans
dsimp [coconeOfCoconeForget_pt, c', topologicalSpaceCoconePtOfCoconeForget]
simp only [coinduced_iSup]
conv_rhs => simp only [← he]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
coinduced_of_isColimit
| null |
isOpen_iff_of_isColimit (X : Set c.pt) :
IsOpen X ↔ ∀ (j : J), IsOpen (c.ι.app j ⁻¹' X) := by
trans (⨆ (j : J), (F.obj j).str.coinduced (c.ι.app j)).IsOpen X
· rw [← coinduced_of_isColimit c hc, isOpen_fold]
· simp only [← isOpen_coinduced]
apply isOpen_iSup_iff
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isOpen_iff_of_isColimit
| null |
isClosed_iff_of_isColimit (X : Set c.pt) :
IsClosed X ↔ ∀ (j : J), IsClosed (c.ι.app j ⁻¹' X) := by
simp only [← isOpen_compl_iff, isOpen_iff_of_isColimit _ hc,
Functor.const_obj_obj, Set.preimage_compl]
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isClosed_iff_of_isColimit
| null |
continuous_iff_of_isColimit {X : Type u'} [TopologicalSpace X] (f : c.pt → X) :
Continuous f ↔ ∀ (j : J), Continuous (f ∘ c.ι.app j) := by
simp only [continuous_def, isOpen_iff_of_isColimit _ hc]
tauto
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
continuous_iff_of_isColimit
| null |
colimit_topology (F : J ⥤ TopCat.{u}) [HasColimit F] :
(colimit F).str = ⨆ j, (F.obj j).str.coinduced (colimit.ι F j) :=
coinduced_of_isColimit _ (colimit.isColimit _)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
colimit_topology
| null |
colimit_isOpen_iff (F : J ⥤ TopCat.{u}) [HasColimit F]
(U : Set ((colimit F : _) : Type u)) :
IsOpen U ↔ ∀ j, IsOpen (colimit.ι F j ⁻¹' U) := by
apply isOpen_iff_of_isColimit _ (colimit.isColimit _)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
colimit_isOpen_iff
| null |
hasColimit_iff_small_colimitType :
HasColimit F ↔ Small.{u} (F ⋙ forget).ColimitType := by
rw [← Types.hasColimit_iff_small_colimitType]
constructor <;> intro
· infer_instance
· exact ⟨⟨_, isColimitCoconeOfForget _ (colimit.isColimit _)⟩⟩
@[deprecated (since := "2025-04-01")] alias hasColimit_iff_small_quot :=
hasColimit_iff_small_colimitType
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
hasColimit_iff_small_colimitType
| null |
topCat_hasColimitsOfShape (J : Type v) [Category J] [Small.{u} J] :
HasColimitsOfShape J TopCat.{u} where
has_colimit := fun F => by
rw [hasColimit_iff_small_colimitType]
infer_instance
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasColimitsOfShape
| null |
topCat_hasColimitsOfSize [UnivLE.{v, u}] : HasColimitsOfSize.{w, v} TopCat.{u} where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasColimitsOfSize
| null |
topCat_hasColimits : HasColimits TopCat.{u} :=
TopCat.topCat_hasColimitsOfSize.{u, u}
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
topCat_hasColimits
| null |
forget_preservesColimitsOfSize :
PreservesColimitsOfSize.{w, v} (forget : TopCat.{u} ⥤ _) where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
forget_preservesColimitsOfSize
| null |
forget_preservesColimits : PreservesColimits (forget : TopCat.{u} ⥤ Type u) where
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
forget_preservesColimits
| null |
isTerminalPUnit : IsTerminal (TopCat.of PUnit.{u + 1}) :=
haveI : ∀ X, Unique (X ⟶ TopCat.of PUnit.{u + 1}) := fun X =>
⟨⟨ofHom ⟨fun _ => PUnit.unit, continuous_const⟩⟩, fun f => by ext⟩
Limits.IsTerminal.ofUnique _
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isTerminalPUnit
|
The terminal object of `Top` is `PUnit`.
|
terminalIsoPUnit : ⊤_ TopCat.{u} ≅ TopCat.of PUnit :=
terminalIsTerminal.uniqueUpToIso isTerminalPUnit
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
terminalIsoPUnit
|
The terminal object of `Top` is `PUnit`.
|
isInitialPEmpty : IsInitial (TopCat.of PEmpty.{u + 1}) :=
haveI : ∀ X, Unique (TopCat.of PEmpty.{u + 1} ⟶ X) := fun X =>
⟨⟨ofHom ⟨fun x => x.elim, by continuity⟩⟩, fun f => by ext ⟨⟩⟩
Limits.IsInitial.ofUnique _
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
isInitialPEmpty
|
The initial object of `Top` is `PEmpty`.
|
initialIsoPEmpty : ⊥_ TopCat.{u} ≅ TopCat.of PEmpty :=
initialIsInitial.uniqueUpToIso isInitialPEmpty
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Adjunctions",
"Mathlib.CategoryTheory.Limits.Types.Limits",
"Mathlib.CategoryTheory.Limits.Types.Colimits",
"Mathlib.CategoryTheory.Limits.Shapes.Terminal",
"Mathlib.CategoryTheory.Adjunction.Limits"
] |
Mathlib/Topology/Category/TopCat/Limits/Basic.lean
|
initialIsoPEmpty
|
The initial object of `Top` is `PEmpty`.
|
isTopologicalBasis_cofiltered_limit (hC : IsLimit C) (T : ∀ j, Set (Set (F.obj j)))
(hT : ∀ j, IsTopologicalBasis (T j)) (univ : ∀ i : J, Set.univ ∈ T i)
(inter : ∀ (i) (U1 U2 : Set (F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i)
(compat : ∀ (i j : J) (f : i ⟶ j) (V : Set (F.obj j)) (_hV : V ∈ T j), F.map f ⁻¹' V ∈ T i) :
IsTopologicalBasis
{U : Set C.pt | ∃ (j : _) (V : Set (F.obj j)), V ∈ T j ∧ U = C.π.app j ⁻¹' V} := by
classical
convert IsTopologicalBasis.iInf_induced hT fun j (x : C.pt) => C.π.app j x using 1
· exact induced_of_isLimit C hC
ext U0
constructor
· rintro ⟨j, V, hV, rfl⟩
let U : ∀ i, Set (F.obj i) := fun i => if h : i = j then by rw [h]; exact V else Set.univ
refine ⟨U, {j}, ?_, ?_⟩
· simp only [Finset.mem_singleton]
rintro i rfl
simpa [U]
· simp [U]
· rintro ⟨U, G, h1, h2⟩
obtain ⟨j, hj⟩ := IsCofiltered.inf_objs_exists G
let g : ∀ e ∈ G, j ⟶ e := fun _ he => (hj he).some
let Vs : J → Set (F.obj j) := fun e => if h : e ∈ G then F.map (g e h) ⁻¹' U e else Set.univ
let V : Set (F.obj j) := ⋂ (e : J) (_he : e ∈ G), Vs e
refine ⟨j, V, ?_, ?_⟩
· -- An intermediate claim used to apply induction along `G : Finset J` later on.
have :
∀ (S : Set (Set (F.obj j))) (E : Finset J) (P : J → Set (F.obj j)) (_univ : Set.univ ∈ S)
(_inter : ∀ A B : Set (F.obj j), A ∈ S → B ∈ S → A ∩ B ∈ S)
(_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), (⋂ (e) (_he : e ∈ E), P e) ∈ S := by
intro S E
induction E using Finset.induction_on with
| empty =>
intro P he _hh
simpa
| insert a E _ha hh1 =>
intro hh2 hh3 hh4 hh5
rw [Finset.set_biInter_insert]
refine hh4 _ _ (hh5 _ (Finset.mem_insert_self _ _)) (hh1 _ hh3 hh4 ?_)
intro e he
exact hh5 e (Finset.mem_insert_of_mem he)
refine this _ _ _ (univ _) (inter _) ?_
intro e he
dsimp [Vs]
rw [dif_pos he]
exact compat j e (g e he) (U e) (h1 e he)
· -- conclude...
rw [h2]
change _ = (C.π.app j)⁻¹' ⋂ (e : J) (_ : e ∈ G), Vs e
rw [Set.preimage_iInter]
apply congrArg
ext1 e
...
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Filtered.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Cofiltered.lean
|
isTopologicalBasis_cofiltered_limit
|
Given a *compatible* collection of topological bases for the factors in a cofiltered limit
which contain `Set.univ` and are closed under intersections, the induced *naive* collection
of sets in the limit is, in fact, a topological basis.
|
private FiniteDiagramArrow {J : Type u} [SmallCategory J] (G : Finset J) :=
Σ' (X Y : J) (_ : X ∈ G) (_ : Y ∈ G), X ⟶ Y
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
FiniteDiagramArrow
| null |
private FiniteDiagram (J : Type u) [SmallCategory J] :=
Σ G : Finset J, Finset (FiniteDiagramArrow G)
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
FiniteDiagram
| null |
partialSections {J : Type u} [SmallCategory J] (F : J ⥤ TopCat.{v}) {G : Finset J}
(H : Finset (FiniteDiagramArrow G)) : Set (∀ j, F.obj j) :=
{u | ∀ {f : FiniteDiagramArrow G} (_ : f ∈ H), F.map f.2.2.2.2 (u f.1) = u f.2.1}
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
partialSections
|
Partial sections of a cofiltered limit are sections when restricted to
a finite subset of objects and morphisms of `J`.
|
partialSections.nonempty [IsCofilteredOrEmpty J] [h : ∀ j : J, Nonempty (F.obj j)]
{G : Finset J} (H : Finset (FiniteDiagramArrow G)) : (partialSections F H).Nonempty := by
classical
cases isEmpty_or_nonempty J
· exact ⟨isEmptyElim, fun {j} => IsEmpty.elim' inferInstance j.1⟩
haveI : IsCofiltered J := ⟨⟩
use fun j : J =>
if hj : j ∈ G then F.map (IsCofiltered.infTo G H hj) (h (IsCofiltered.inf G H)).some
else (h _).some
rintro ⟨X, Y, hX, hY, f⟩ hf
dsimp only
rwa [dif_pos hX, dif_pos hY, ← comp_app, ← F.map_comp, @IsCofiltered.infTo_commutes _ _ _ G H]
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
partialSections.nonempty
| null |
partialSections.directed :
Directed Superset fun G : FiniteDiagram J => partialSections F G.2 := by
classical
intro A B
let ιA : FiniteDiagramArrow A.1 → FiniteDiagramArrow (A.1 ⊔ B.1) := fun f =>
⟨f.1, f.2.1, Finset.mem_union_left _ f.2.2.1, Finset.mem_union_left _ f.2.2.2.1, f.2.2.2.2⟩
let ιB : FiniteDiagramArrow B.1 → FiniteDiagramArrow (A.1 ⊔ B.1) := fun f =>
⟨f.1, f.2.1, Finset.mem_union_right _ f.2.2.1, Finset.mem_union_right _ f.2.2.2.1, f.2.2.2.2⟩
refine ⟨⟨A.1 ⊔ B.1, A.2.image ιA ⊔ B.2.image ιB⟩, ?_, ?_⟩
· rintro u hu f hf
have : ιA f ∈ A.2.image ιA ⊔ B.2.image ιB := by
apply Finset.mem_union_left
rw [Finset.mem_image]
exact ⟨f, hf, rfl⟩
exact hu this
· rintro u hu f hf
have : ιB f ∈ A.2.image ιA ⊔ B.2.image ιB := by
apply Finset.mem_union_right
rw [Finset.mem_image]
exact ⟨f, hf, rfl⟩
exact hu this
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
partialSections.directed
| null |
partialSections.closed [∀ j : J, T2Space (F.obj j)] {G : Finset J}
(H : Finset (FiniteDiagramArrow G)) : IsClosed (partialSections F H) := by
have :
partialSections F H =
⋂ (f : FiniteDiagramArrow G) (_ : f ∈ H), {u | F.map f.2.2.2.2 (u f.1) = u f.2.1} := by
ext1
simp only [Set.mem_iInter, Set.mem_setOf_eq]
rfl
rw [this]
apply isClosed_biInter
intro f _
apply isClosed_eq <;> fun_prop
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
partialSections.closed
| null |
nonempty_limitCone_of_compact_t2_cofiltered_system (F : J ⥤ TopCat.{max v u})
[IsCofilteredOrEmpty J]
[∀ j : J, Nonempty (F.obj j)] [∀ j : J, CompactSpace (F.obj j)] [∀ j : J, T2Space (F.obj j)] :
Nonempty (TopCat.limitCone F).pt := by
classical
obtain ⟨u, hu⟩ :=
IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed (fun G => partialSections F _)
(partialSections.directed F) (fun G => partialSections.nonempty F _)
(fun G => IsClosed.isCompact (partialSections.closed F _)) fun G =>
partialSections.closed F _
use u
intro X Y f
let G : FiniteDiagram J := ⟨{X, Y}, {⟨X, Y, by grind, by grind, f⟩}⟩
exact hu _ ⟨G, rfl⟩ (Finset.mem_singleton_self _)
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Filtered.Basic",
"Mathlib.Topology.Category.TopCat.Limits.Basic"
] |
Mathlib/Topology/Category/TopCat/Limits/Konig.lean
|
nonempty_limitCone_of_compact_t2_cofiltered_system
|
Cofiltered limits of nonempty compact Hausdorff spaces are nonempty topological spaces.
|
piπ {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) : TopCat.of (∀ i, α i) ⟶ α i :=
ofHom ⟨fun f => f i, continuous_apply i⟩
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piπ
|
The projection from the product as a bundled continuous map.
|
@[simps! pt π_app]
piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α :=
Fan.mk (TopCat.of (∀ i, α i)) (piπ.{v,u} α)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piFan
|
The explicit fan of a family of topological spaces given by the pi type.
|
piFanIsLimit {ι : Type v} (α : ι → TopCat.{max v u}) : IsLimit (piFan α) where
lift S := ofHom
{ toFun := fun s i => S.π.app ⟨i⟩ s
continuous_toFun := continuous_pi (fun i => (S.π.app ⟨i⟩).hom.2) }
uniq := by
intro S m h
ext x
funext i
simp [ContinuousMap.coe_mk, ← h ⟨i⟩]
fac _ _ := rfl
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piFanIsLimit
|
The constructed fan is indeed a limit
|
piIsoPi {ι : Type v} (α : ι → TopCat.{max v u}) : ∏ᶜ α ≅ TopCat.of (∀ i, α i) :=
(limit.isLimit _).conePointUniqueUpToIso (piFanIsLimit.{v, u} α)
@[reassoc (attr := simp)]
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piIsoPi
|
The product is homeomorphic to the product of the underlying spaces,
equipped with the product topology.
|
piIsoPi_inv_π {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
(piIsoPi α).inv ≫ Pi.π α i = piπ α i := by simp [piIsoPi]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piIsoPi_inv_π
| null |
piIsoPi_inv_π_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : ∀ i, α i) :
(Pi.π α i :) ((piIsoPi α).inv x) = x i :=
ConcreteCategory.congr_hom (piIsoPi_inv_π α i) x
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piIsoPi_inv_π_apply
| null |
piIsoPi_hom_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι)
(x : (∏ᶜ α : TopCat.{max v u})) : (piIsoPi α).hom x i = (Pi.π α i :) x := by
have := piIsoPi_inv_π α i
rw [Iso.inv_comp_eq] at this
exact ConcreteCategory.congr_hom this x
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
piIsoPi_hom_apply
| null |
sigmaι {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) : α i ⟶ TopCat.of (Σ i, α i) := by
refine ofHom (ContinuousMap.mk ?_ ?_)
· dsimp
apply Sigma.mk i
· dsimp; continuity
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaι
|
The inclusion to the coproduct as a bundled continuous map.
|
@[simps! pt ι_app]
sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α :=
Cofan.mk (TopCat.of (Σ i, α i)) (sigmaι α)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaCofan
|
The explicit cofan of a family of topological spaces given by the sigma type.
|
sigmaCofanIsColimit {ι : Type v} (β : ι → TopCat.{max v u}) : IsColimit (sigmaCofan β) where
desc S := ofHom
{ toFun := fun (s : of (Σ i, β i)) => S.ι.app ⟨s.1⟩ s.2
continuous_toFun := by continuity }
uniq := by
intro S m h
ext ⟨i, x⟩
simp only [← h]
congr
fac s j := by
cases j
cat_disch
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaCofanIsColimit
|
The constructed cofan is indeed a colimit
|
sigmaIsoSigma {ι : Type v} (α : ι → TopCat.{max v u}) : ∐ α ≅ TopCat.of (Σ i, α i) :=
(colimit.isColimit _).coconePointUniqueUpToIso (sigmaCofanIsColimit.{v, u} α)
@[reassoc (attr := simp)]
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaIsoSigma
|
The coproduct is homeomorphic to the disjoint union of the topological spaces.
|
sigmaIsoSigma_hom_ι {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
Sigma.ι α i ≫ (sigmaIsoSigma α).hom = sigmaι α i := by simp [sigmaIsoSigma]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaIsoSigma_hom_ι
| null |
sigmaIsoSigma_hom_ι_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
(sigmaIsoSigma α).hom ((Sigma.ι α i :) x) = Sigma.mk i x :=
ConcreteCategory.congr_hom (sigmaIsoSigma_hom_ι α i) x
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaIsoSigma_hom_ι_apply
| null |
sigmaIsoSigma_inv_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
(sigmaIsoSigma α).inv ⟨i, x⟩ = (Sigma.ι α i :) x := by
rw [← sigmaIsoSigma_hom_ι_apply, ← comp_app, ← comp_app, Iso.hom_inv_id,
Category.comp_id]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
sigmaIsoSigma_inv_apply
| null |
prodFst {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ X :=
ofHom { toFun := Prod.fst }
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodFst
|
The first projection from the product.
|
prodSnd {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ Y :=
ofHom { toFun := Prod.snd }
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodSnd
|
The second projection from the product.
|
prodBinaryFan (X Y : TopCat.{u}) : BinaryFan X Y :=
BinaryFan.mk prodFst prodSnd
|
def
|
Topology
|
[
"Mathlib.Topology.Category.TopCat.EpiMono",
"Mathlib.Topology.Category.TopCat.Limits.Basic",
"Mathlib.CategoryTheory.Limits.Shapes.Products",
"Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.Topology.Homeomorph.Lemmas"
] |
Mathlib/Topology/Category/TopCat/Limits/Products.lean
|
prodBinaryFan
|
The explicit binary cofan of `X, Y` given by `X × Y`.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.