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 ⌀ |
|---|---|---|---|---|---|---|
trStAct {k : K} (q : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ) :
StAct K Γ σ k → TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ
| StAct.push f => (write fun a s ↦ (a.1, update a.2 k <| some <| f s)) <| move Dir.right q
| StAct.peek f => move Dir.left <| (load fun a s ↦ f s (a.2 k)) <| move Dir.right q
| StAct.pop f =>
branch (fun a _ ↦ a.1) (load (fun _ s ↦ f s none) q)
(move Dir.left <|
(load fun a s ↦ f s (a.2 k)) <| write (fun a _ ↦ (a.1, update a.2 k none)) q) | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trStAct | The program corresponding to state transitions at the end of a stack. Here we start out just
after the top of the stack, and should end just after the new top of the stack. |
trInit (k : K) (L : List (Γ k)) : List (Γ' K Γ) :=
let L' : List (Γ' K Γ) := L.reverse.map fun a ↦ (false, update (fun _ ↦ none) k (some a))
(true, L'.headI.2) :: L'.tail | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trInit | The initial state for the TM2 emulator, given an initial TM2 state. All stacks start out empty
except for the input stack, and the stack bottom mark is set at the head. |
step_run {k : K} (q : TM2.Stmt Γ Λ σ) (v : σ) (S : ∀ k, List (Γ k)) : ∀ s : StAct K Γ σ k,
TM2.stepAux (stRun s q) v S = TM2.stepAux q (stVar v (S k) s) (update S k (stWrite v (S k) s))
| StAct.push _ => rfl
| StAct.peek f => by unfold stWrite; rw [Function.update_eq_self]; rfl
| StAct.pop _ => rfl | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | step_run | null |
trNormal : TM2.Stmt Γ Λ σ → TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ
| TM2.Stmt.push k f q => goto fun _ _ ↦ go k (StAct.push f) q
| TM2.Stmt.peek k f q => goto fun _ _ ↦ go k (StAct.peek f) q
| TM2.Stmt.pop k f q => goto fun _ _ ↦ go k (StAct.pop f) q
| TM2.Stmt.load a q => load (fun _ ↦ a) (trNormal q)
| TM2.Stmt.branch f q₁ q₂ => branch (fun _ ↦ f) (trNormal q₁) (trNormal q₂)
| TM2.Stmt.goto l => goto fun _ s ↦ normal (l s)
| TM2.Stmt.halt => halt | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trNormal | The translation of TM2 statements to TM1 statements. regular actions have direct equivalents,
but stack actions are deferred by going to the corresponding `go` state, so that we can find the
appropriate stack top. |
trNormal_run {k : K} (s : StAct K Γ σ k) (q : TM2.Stmt Γ Λ σ) :
trNormal (stRun s q) = goto fun _ _ ↦ go k s q := by
cases s <;> rfl | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trNormal_run | null |
noncomputable trStmts₁ : TM2.Stmt Γ Λ σ → Finset (Λ' K Γ Λ σ)
| TM2.Stmt.push k f q => {go k (StAct.push f) q, ret q} ∪ trStmts₁ q
| TM2.Stmt.peek k f q => {go k (StAct.peek f) q, ret q} ∪ trStmts₁ q
| TM2.Stmt.pop k f q => {go k (StAct.pop f) q, ret q} ∪ trStmts₁ q
| TM2.Stmt.load _ q => trStmts₁ q
| TM2.Stmt.branch _ q₁ q₂ => trStmts₁ q₁ ∪ trStmts₁ q₂
| _ => ∅ | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trStmts₁ | The set of machine states accessible from an initial TM2 statement. |
trStmts₁_run {k : K} {s : StAct K Γ σ k} {q : TM2.Stmt Γ Λ σ} :
open scoped Classical in
trStmts₁ (stRun s q) = {go k s q, ret q} ∪ trStmts₁ q := by
cases s <;> simp only [trStmts₁, stRun] | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trStmts₁_run | null |
tr_respects_aux₂ [DecidableEq K] {k : K} {q : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ} {v : σ}
{S : ∀ k, List (Γ k)} {L : ListBlank (∀ k, Option (Γ k))}
(hL : ∀ k, L.map (proj k) = ListBlank.mk ((S k).map some).reverse) (o : StAct K Γ σ k) :
let v' := stVar v (S k) o
let Sk' := stWrite v (S k) o
let S' := update S k Sk'
∃ L' : ListBlank (∀ k, Option (Γ k)),
(∀ k, L'.map (proj k) = ListBlank.mk ((S' k).map some).reverse) ∧
TM1.stepAux (trStAct q o) v
((Tape.move Dir.right)^[(S k).length] (Tape.mk' ∅ (addBottom L))) =
TM1.stepAux q v' ((Tape.move Dir.right)^[(S' k).length] (Tape.mk' ∅ (addBottom L'))) := by
simp only [Function.update_self]; cases o with simp only [stWrite, stVar, trStAct, TM1.stepAux]
| push f =>
have := Tape.write_move_right_n fun a : Γ' K Γ ↦ (a.1, update a.2 k (some (f v)))
refine
⟨_, fun k' ↦ ?_, by
rw [Tape.move_right_n_head, List.length, Tape.mk'_nth_nat, this]
erw [addBottom_modifyNth fun a ↦ update a k (some (f v))]
rw [Nat.add_one, iterate_succ']
rfl⟩
refine ListBlank.ext fun i ↦ ?_
rw [ListBlank.nth_map, ListBlank.nth_modifyNth, proj, PointedMap.mk_val]
by_cases h' : k' = k
· subst k'
split_ifs with h
<;> simp only [List.reverse_cons, Function.update_self, ListBlank.nth_mk, List.map]
· rw [List.getI_eq_getElem _, List.getElem_append_right] <;>
simp only [List.length_append, List.length_reverse, List.length_map, ← h,
Nat.sub_self, List.length_singleton, List.getElem_singleton,
le_refl, Nat.lt_succ_self]
rw [← proj_map_nth, hL, ListBlank.nth_mk]
rcases lt_or_gt_of_ne h with h | h
· rw [List.getI_append]
simpa only [List.length_map, List.length_reverse] using h
· rw [List.getI_eq_default, List.getI_eq_default] <;>
simp only [Nat.add_one_le_iff, h, List.length, le_of_lt, List.length_reverse,
List.length_append, List.length_map]
· split_ifs <;> rw [Function.update_of_ne h', ← proj_map_nth, hL]
rw [Function.update_of_ne h']
| peek f =>
rw [Function.update_eq_self]
use L, hL; rw [Tape.move_left_right]; congr
cases e : S k; · rfl
rw [List.length_cons, iterate_succ', Function.comp, Tape.move_right_left,
Tape.move_right_n_head, Tape.mk'_nth_nat, addBottom_nth_snd, stk_nth_val _ (hL k), e,
List.reverse_cons, ← List.length_reverse, List.getElem?_concat_length]
rfl
| pop f =>
rcases e : S k with - | ⟨hd, tl⟩
· simp only [Tape.mk'_head, ListBlank.head_cons, Tape.move_left_mk', List.length,
Tape.write_mk', List.head?, iterate_zero_apply, List.tail_nil]
... | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_respects_aux₂ | null |
tr : Λ' K Γ Λ σ → TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ
| normal q => trNormal (M q)
| go k s q =>
branch (fun a _ ↦ (a.2 k).isNone) (trStAct (goto fun _ _ ↦ ret q) s)
(move Dir.right <| goto fun _ _ ↦ go k s q)
| ret q => branch (fun a _ ↦ a.1) (trNormal q) (move Dir.left <| goto fun _ _ ↦ ret q) | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr | The TM2 emulator machine states written as a TM1 program.
This handles the `go` and `ret` states, which shuttle to and from a stack top. |
TrCfg : TM2.Cfg Γ Λ σ → TM1.Cfg (Γ' K Γ) (Λ' K Γ Λ σ) σ → Prop
| mk {q : Option Λ} {v : σ} {S : ∀ k, List (Γ k)} (L : ListBlank (∀ k, Option (Γ k))) :
(∀ k, L.map (proj k) = ListBlank.mk ((S k).map some).reverse) →
TrCfg ⟨q, v, S⟩ ⟨q.map normal, v, Tape.mk' ∅ (addBottom L)⟩ | inductive | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | TrCfg | The relation between TM2 configurations and TM1 configurations of the TM2 emulator. |
tr_respects_aux₁ {k} (o q v) {S : List (Γ k)} {L : ListBlank (∀ k, Option (Γ k))}
(hL : L.map (proj k) = ListBlank.mk (S.map some).reverse) (n) (H : n ≤ S.length) :
Reaches₀ (TM1.step (tr M)) ⟨some (go k o q), v, Tape.mk' ∅ (addBottom L)⟩
⟨some (go k o q), v, (Tape.move Dir.right)^[n] (Tape.mk' ∅ (addBottom L))⟩ := by
induction n with
| zero => rfl
| succ n IH =>
apply (IH (le_of_lt H)).tail
rw [iterate_succ_apply']
simp only [TM1.step, TM1.stepAux, tr, Tape.mk'_nth_nat, Tape.move_right_n_head,
addBottom_nth_snd, Option.mem_def]
rw [stk_nth_val _ hL, List.getElem?_eq_getElem]
· rfl
· rwa [List.length_reverse] | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_respects_aux₁ | null |
tr_respects_aux₃ {q v} {L : ListBlank (∀ k, Option (Γ k))} (n) : Reaches₀ (TM1.step (tr M))
⟨some (ret q), v, (Tape.move Dir.right)^[n] (Tape.mk' ∅ (addBottom L))⟩
⟨some (ret q), v, Tape.mk' ∅ (addBottom L)⟩ := by
induction n with
| zero => rfl
| succ n IH =>
refine Reaches₀.head ?_ IH
simp only [Option.mem_def, TM1.step]
rw [Option.some_inj, tr, TM1.stepAux, Tape.move_right_n_head, Tape.mk'_nth_nat,
addBottom_nth_succ_fst, TM1.stepAux, iterate_succ', Function.comp_apply, Tape.move_right_left]
rfl | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_respects_aux₃ | null |
tr_respects_aux {q v T k} {S : ∀ k, List (Γ k)}
(hT : ∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse)
(o : StAct K Γ σ k)
(IH : ∀ {v : σ} {S : ∀ k : K, List (Γ k)} {T : ListBlank (∀ k, Option (Γ k))},
(∀ k, ListBlank.map (proj k) T = ListBlank.mk ((S k).map some).reverse) →
∃ b, TrCfg (TM2.stepAux q v S) b ∧
Reaches (TM1.step (tr M)) (TM1.stepAux (trNormal q) v (Tape.mk' ∅ (addBottom T))) b) :
∃ b, TrCfg (TM2.stepAux (stRun o q) v S) b ∧ Reaches (TM1.step (tr M))
(TM1.stepAux (trNormal (stRun o q)) v (Tape.mk' ∅ (addBottom T))) b := by
simp only [trNormal_run, step_run]
have hgo := tr_respects_aux₁ M o q v (hT k) _ le_rfl
obtain ⟨T', hT', hrun⟩ := tr_respects_aux₂ (Λ := Λ) hT o
have := hgo.tail' rfl
rw [tr, TM1.stepAux, Tape.move_right_n_head, Tape.mk'_nth_nat, addBottom_nth_snd,
stk_nth_val _ (hT k), List.getElem?_eq_none (le_of_eq List.length_reverse),
Option.isNone, cond, hrun, TM1.stepAux] at this
obtain ⟨c, gc, rc⟩ := IH hT'
refine ⟨c, gc, (this.to₀.trans (tr_respects_aux₃ M _) c (TransGen.head' rfl ?_)).to_reflTransGen⟩
rw [tr, TM1.stepAux, Tape.mk'_head, addBottom_head_fst]
exact rc
attribute [local simp] Respects TM2.step TM2.stepAux trNormal | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_respects_aux | null |
tr_respects : Respects (TM2.step M) (TM1.step (tr M)) TrCfg := by
intro c₁ c₂ h
obtain @⟨- | l, v, S, L, hT⟩ := h; · constructor
rsuffices ⟨b, c, r⟩ : ∃ b, _ ∧ Reaches (TM1.step (tr M)) _ _
· exact ⟨b, c, TransGen.head' rfl r⟩
simp only [tr]
generalize M l = N
induction N using stmtStRec generalizing v S L hT with
| run k s q IH => exact tr_respects_aux M hT s @IH
| load a _ IH => exact IH _ hT
| branch p q₁ q₂ IH₁ IH₂ =>
unfold TM2.stepAux trNormal TM1.stepAux
beta_reduce
cases p v <;> [exact IH₂ _ hT; exact IH₁ _ hT]
| goto => exact ⟨_, ⟨_, hT⟩, ReflTransGen.refl⟩
| halt => exact ⟨_, ⟨_, hT⟩, ReflTransGen.refl⟩ | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_respects | null |
trCfg_init (k) (L : List (Γ k)) : TrCfg (TM2.init k L)
(TM1.init (trInit k L) : TM1.Cfg (Γ' K Γ) (Λ' K Γ Λ σ) σ) := by
rw [(_ : TM1.init _ = _)]
· refine ⟨ListBlank.mk (L.reverse.map fun a ↦ update default k (some a)), fun k' ↦ ?_⟩
refine ListBlank.ext fun i ↦ ?_
rw [ListBlank.map_mk, ListBlank.nth_mk, List.getI_eq_iget_getElem?, List.map_map]
have : ((proj k').f ∘ fun a => update (β := fun k => Option (Γ k)) default k (some a))
= fun a => (proj k').f (update (β := fun k => Option (Γ k)) default k (some a)) := rfl
rw [this, List.getElem?_map, proj, PointedMap.mk_val]
simp only []
by_cases h : k' = k
· subst k'
simp only [Function.update_self]
rw [ListBlank.nth_mk, List.getI_eq_iget_getElem?, ← List.map_reverse, List.getElem?_map]
· simp only [Function.update_of_ne h]
rw [ListBlank.nth_mk, List.getI_eq_iget_getElem?, List.map, List.reverse_nil]
cases L.reverse[i]? <;> rfl
· rw [trInit, TM1.init]
congr <;> cases L.reverse <;> try rfl
simp only [List.map_map, List.tail_cons, List.map]
rfl | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trCfg_init | null |
tr_eval_dom (k) (L : List (Γ k)) :
(TM1.eval (tr M) (trInit k L)).Dom ↔ (TM2.eval M k L).Dom :=
Turing.tr_eval_dom (tr_respects M) (trCfg_init k L) | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_eval_dom | null |
tr_eval (k) (L : List (Γ k)) {L₁ L₂} (H₁ : L₁ ∈ TM1.eval (tr M) (trInit k L))
(H₂ : L₂ ∈ TM2.eval M k L) :
∃ (S : ∀ k, List (Γ k)) (L' : ListBlank (∀ k, Option (Γ k))),
addBottom L' = L₁ ∧
(∀ k, L'.map (proj k) = ListBlank.mk ((S k).map some).reverse) ∧ S k = L₂ := by
obtain ⟨c₁, h₁, rfl⟩ := (Part.mem_map_iff _).1 H₁
obtain ⟨c₂, h₂, rfl⟩ := (Part.mem_map_iff _).1 H₂
obtain ⟨_, ⟨L', hT⟩, h₃⟩ := Turing.tr_eval (tr_respects M) (trCfg_init k L) h₂
cases Part.mem_unique h₁ h₃
exact ⟨_, L', by simp only [Tape.mk'_right₀], hT, rfl⟩ | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_eval | null |
noncomputable trSupp (S : Finset Λ) : Finset (Λ' K Γ Λ σ) :=
S.biUnion fun l ↦ insert (normal l) (trStmts₁ (M l))
open scoped Classical in | def | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | trSupp | The support of a set of TM2 states in the TM2 emulator. |
tr_supports {S} (ss : TM2.Supports M S) : TM1.Supports (tr M) (trSupp M S) :=
⟨Finset.mem_biUnion.2 ⟨_, ss.1, Finset.mem_insert.2 <| Or.inl rfl⟩, fun l' h ↦ by
suffices ∀ (q) (_ : TM2.SupportsStmt S q) (_ : ∀ x ∈ trStmts₁ q, x ∈ trSupp M S),
TM1.SupportsStmt (trSupp M S) (trNormal q) ∧
∀ l' ∈ trStmts₁ q, TM1.SupportsStmt (trSupp M S) (tr M l') by
rcases Finset.mem_biUnion.1 h with ⟨l, lS, h⟩
have :=
this _ (ss.2 l lS) fun x hx ↦ Finset.mem_biUnion.2 ⟨_, lS, Finset.mem_insert_of_mem hx⟩
rcases Finset.mem_insert.1 h with (rfl | h) <;> [exact this.1; exact this.2 _ h]
clear h l'
refine stmtStRec ?_ ?_ ?_ ?_ ?_
· intro _ s _ IH ss' sub -- stack op
rw [TM2to1.supports_run] at ss'
simp only [TM2to1.trStmts₁_run, Finset.mem_union, Finset.mem_insert, Finset.mem_singleton]
at sub
have hgo := sub _ (Or.inl <| Or.inl rfl)
have hret := sub _ (Or.inl <| Or.inr rfl)
obtain ⟨IH₁, IH₂⟩ := IH ss' fun x hx ↦ sub x <| Or.inr hx
refine ⟨by simp only [trNormal_run, TM1.SupportsStmt]; intros; exact hgo, fun l h ↦ ?_⟩
rw [trStmts₁_run] at h
simp only [Finset.mem_union, Finset.mem_insert, Finset.mem_singleton]
at h
rcases h with (⟨rfl | rfl⟩ | h)
· cases s
· exact ⟨fun _ _ ↦ hret, fun _ _ ↦ hgo⟩
· exact ⟨fun _ _ ↦ hret, fun _ _ ↦ hgo⟩
· exact ⟨⟨fun _ _ ↦ hret, fun _ _ ↦ hret⟩, fun _ _ ↦ hgo⟩
· unfold TM1.SupportsStmt TM2to1.tr
exact ⟨IH₁, fun _ _ ↦ hret⟩
· exact IH₂ _ h
· intro _ _ IH ss' sub -- load
unfold TM2to1.trStmts₁ at sub ⊢
exact IH ss' sub
· intro _ _ _ IH₁ IH₂ ss' sub -- branch
unfold TM2to1.trStmts₁ at sub
obtain ⟨IH₁₁, IH₁₂⟩ := IH₁ ss'.1 fun x hx ↦ sub x <| Finset.mem_union_left _ hx
obtain ⟨IH₂₁, IH₂₂⟩ := IH₂ ss'.2 fun x hx ↦ sub x <| Finset.mem_union_right _ hx
refine ⟨⟨IH₁₁, IH₂₁⟩, fun l h ↦ ?_⟩
rw [trStmts₁] at h
rcases Finset.mem_union.1 h with (h | h) <;> [exact IH₁₂ _ h; exact IH₂₂ _ h]
· intro _ ss' _ -- goto
simp only [trStmts₁, Finset.notMem_empty]; refine ⟨?_, fun _ ↦ False.elim⟩
exact fun _ v ↦ Finset.mem_biUnion.2 ⟨_, ss' v, Finset.mem_insert_self _ _⟩
· intro _ _ -- halt
simp only [trStmts₁, Finset.notMem_empty]
exact ⟨trivial, fun _ ↦ False.elim⟩⟩ | theorem | Computability | [
"Mathlib.Computability.Tape",
"Mathlib.Data.Fintype.Option",
"Mathlib.Data.Fintype.Prod",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.PFun",
"Mathlib.Computability.PostTuringMachine"
] | Mathlib/Computability/TuringMachine.lean | tr_supports | null |
hasExactColimitsOfShape [HasColimitsOfShape J A] [HasExactColimitsOfShape J A]
[HasFiniteLimits A] : HasExactColimitsOfShape J (Condensed.{u} A) := by
let e : Condensed.{u} A ≌ Sheaf (extensiveTopology Stonean.{u}) A :=
(StoneanCompHaus.equivalence A).symm.trans Presheaf.coherentExtensiveEquivalence
exact HasExactColimitsOfShape.domain_of_functor _ e.functor
set_option Elab.async false in -- TODO: universe levels from type are unified in proof | lemma | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.AB",
"Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Sheaf",
"Mathlib.CategoryTheory.Sites.Coherent.ExtensiveColimits",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/AB.lean | hasExactColimitsOfShape | null |
hasExactLimitsOfShape [HasLimitsOfShape J A] [HasExactLimitsOfShape J A]
[HasFiniteColimits A] : HasExactLimitsOfShape J (Condensed.{u} A) := by
let e : Condensed.{u} A ≌ Sheaf (extensiveTopology Stonean.{u}) A :=
(StoneanCompHaus.equivalence A).symm.trans Presheaf.coherentExtensiveEquivalence
exact HasExactLimitsOfShape.domain_of_functor _ e.functor | lemma | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.AB",
"Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Sheaf",
"Mathlib.CategoryTheory.Sites.Coherent.ExtensiveColimits",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/AB.lean | hasExactLimitsOfShape | null |
Condensed (C : Type w) [Category.{v} C] :=
Sheaf (coherentTopology CompHaus.{u}) C | def | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | Condensed | `Condensed.{u} C` is the category of condensed objects in a category `C`, which are
defined as sheaves on `CompHaus.{u}` with respect to the coherent Grothendieck topology. |
CondensedSet := Condensed.{u} (Type (u+1)) | abbrev | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | CondensedSet | Condensed sets (types) with the appropriate universe levels, i.e. `Type (u+1)`-valued
sheaves on `CompHaus.{u}`. |
@[simp]
id_val (X : Condensed.{u} C) : (𝟙 X : X ⟶ X).val = 𝟙 _ := rfl
@[simp] | lemma | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | id_val | null |
comp_val {X Y Z : Condensed.{u} C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).val = f.val ≫ g.val :=
rfl
@[ext] | lemma | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | comp_val | null |
hom_ext {X Y : Condensed.{u} C} (f g : X ⟶ Y) (h : ∀ S, f.val.app S = g.val.app S) :
f = g := by
apply Sheaf.hom_ext
ext
exact h _ | lemma | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | hom_ext | null |
@[simp]
hom_naturality_apply {X Y : CondensedSet.{u}} (f : X ⟶ Y) {S T : CompHausᵒᵖ} (g : S ⟶ T)
(x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) :=
NatTrans.naturality_apply f.val g x | lemma | Condensed | [
"Mathlib.CategoryTheory.Sites.Sheaf",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi"
] | Mathlib/Condensed/Basic.lean | hom_naturality_apply | null |
epi_iff_locallySurjective_on_compHaus : Epi f ↔
∀ (S : CompHaus) (y : ToType (Y.val.obj ⟨S⟩)),
(∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : ToType (X.val.obj ⟨S'⟩)),
f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) := by
rw [← isLocallySurjective_iff_epi', coherentTopology.isLocallySurjective_iff,
regularTopology.isLocallySurjective_iff]
simp_rw [((CompHaus.effectiveEpi_tfae _).out 0 2 :)]
set_option Elab.async false in -- TODO: universe levels from type are unified in proof
variable
[PreservesFiniteProducts (CategoryTheory.forget A)]
[∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A]
[(extensiveTopology Stonean).WEqualsLocallyBijective A]
[HasSheafify (extensiveTopology Stonean) A]
[(extensiveTopology Stonean.{u}).HasSheafCompose (CategoryTheory.forget A)]
[Balanced (Sheaf (extensiveTopology Stonean) A)] in | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_locallySurjective_on_compHaus | null |
epi_iff_surjective_on_stonean : Epi f ↔
∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) := by
rw [← (StoneanCompHaus.equivalence A).inverse.epi_map_iff_epi,
← Presheaf.coherentExtensiveEquivalence.functor.epi_map_iff_epi,
← isLocallySurjective_iff_epi']
exact extensiveTopology.isLocallySurjective_iff (D := A) _ | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_surjective_on_stonean | null |
epi_iff_locallySurjective_on_compHaus : Epi f ↔
∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
(∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) :=
Condensed.epi_iff_locallySurjective_on_compHaus _ f
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_locallySurjective_on_compHaus | null |
epi_iff_surjective_on_stonean : Epi f ↔
∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) :=
Condensed.epi_iff_surjective_on_stonean _ f | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_surjective_on_stonean | null |
epi_iff_locallySurjective_on_compHaus : Epi f ↔
∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
(∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) :=
Condensed.epi_iff_locallySurjective_on_compHaus _ f
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_locallySurjective_on_compHaus | null |
epi_iff_surjective_on_stonean : Epi f ↔
∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) :=
have : HasLimitsOfSize.{u, u + 1} (ModuleCat R) :=
hasLimitsOfSizeShrink.{u, u + 1, u + 1, u + 1} _
Condensed.epi_iff_surjective_on_stonean _ f | lemma | Condensed | [
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono",
"Mathlib.CategoryTheory.Sites.Coherent.LocallySurjective",
"Mathlib.CategoryTheory.Sites.EpiMono",
"Mathlib.Condensed.Equivalence",
"Mathlib.Condensed.Module"
] | Mathlib/Condensed/Epi.lean | epi_iff_surjective_on_stonean | null |
noncomputable
equivalence (A : Type*) [Category A]
[∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A] :
Sheaf (coherentTopology Stonean) A ≌ Condensed.{u} A :=
coherentTopology.equivalence' Stonean.toCompHaus A | def | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | equivalence | The equivalence from coherent sheaves on `Stonean` to coherent sheaves on `CompHaus`
(i.e. condensed sets). |
noncomputable stoneanToProfiniteEffectivePresentation (X : Profinite) :
Stonean.toProfinite.EffectivePresentation X where
p := X.presentation
f := Profinite.presentation.π X
effectiveEpi := ((Profinite.effectiveEpi_tfae _).out 0 1).mpr (inferInstance : Epi _) | def | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | stoneanToProfiniteEffectivePresentation | An effective presentation of an `X : Profinite` with respect to the inclusion functor from `Stonean` |
noncomputable
equivalence (A : Type*) [Category A]
[∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toProfinite.op) A] :
Sheaf (coherentTopology Stonean) A ≌ Sheaf (coherentTopology Profinite) A :=
coherentTopology.equivalence' Stonean.toProfinite A | def | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | equivalence | The equivalence from coherent sheaves on `Stonean` to coherent sheaves on `Profinite`. |
noncomputable
equivalence (A : Type*) [Category A]
[∀ X, HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A] :
Sheaf (coherentTopology Profinite) A ≌ Condensed.{u} A :=
coherentTopology.equivalence' profiniteToCompHaus A | def | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | equivalence | The equivalence from coherent sheaves on `Profinite` to coherent sheaves on `CompHaus`
(i.e. condensed sets). |
isSheafProfinite
[∀ Y, HasLimitsOfShape (StructuredArrow Y profiniteToCompHaus.{u}.op) A] :
Presheaf.IsSheaf (coherentTopology Profinite)
(profiniteToCompHaus.op ⋙ X.val) :=
((ProfiniteCompHaus.equivalence A).inverse.obj X).cond | lemma | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | isSheafProfinite | null |
isSheafStonean
[∀ Y, HasLimitsOfShape (StructuredArrow Y Stonean.toCompHaus.{u}.op) A] :
Presheaf.IsSheaf (coherentTopology Stonean)
(Stonean.toCompHaus.op ⋙ X.val) :=
((StoneanCompHaus.equivalence A).inverse.obj X).cond | lemma | Condensed | [
"Mathlib.Topology.Category.Profinite.EffectiveEpi",
"Mathlib.Topology.Category.Stonean.EffectiveEpi",
"Mathlib.Condensed.Basic",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison"
] | Mathlib/Condensed/Equivalence.lean | isSheafStonean | null |
noncomputable ofSheafStonean
[∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A]
(F : Stonean.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts F] :
Condensed A :=
StoneanCompHaus.equivalence A |>.functor.obj {
val := F
cond := by
rw [isSheaf_iff_preservesFiniteProducts_of_projective F]
exact ⟨fun _ ↦ inferInstance⟩ } | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafStonean | The condensed object associated to a finite-product-preserving presheaf on `Stonean`. |
noncomputable ofSheafForgetStonean
[∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A]
[HasForget A] [ReflectsFiniteProducts (CategoryTheory.forget A)]
(F : Stonean.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)] :
Condensed A :=
StoneanCompHaus.equivalence A |>.functor.obj {
val := F
cond := by
apply isSheaf_coherent_of_projective_of_comp F (CategoryTheory.forget A)
rw [isSheaf_iff_preservesFiniteProducts_of_projective]
exact ⟨fun _ ↦ inferInstance⟩ } | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafForgetStonean | The condensed object associated to a presheaf on `Stonean` whose postcomposition with the
forgetful functor preserves finite products. |
noncomputable ofSheafProfinite
[∀ X, HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A]
(F : Profinite.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts F]
(hF : EqualizerCondition F) : Condensed A :=
ProfiniteCompHaus.equivalence A |>.functor.obj {
val := F
cond := by
rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition F]
exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ } | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafProfinite | The condensed object associated to a presheaf on `Profinite` which preserves finite products and
satisfies the equalizer condition. |
noncomputable ofSheafForgetProfinite
[∀ X, HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A]
[HasForget A] [ReflectsFiniteLimits (CategoryTheory.forget A)]
(F : Profinite.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)]
(hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)) :
Condensed A :=
ProfiniteCompHaus.equivalence A |>.functor.obj {
val := F
cond := by
apply isSheaf_coherent_of_hasPullbacks_of_comp F (CategoryTheory.forget A)
rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition]
exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ } | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafForgetProfinite | The condensed object associated to a presheaf on `Profinite` whose postcomposition with the
forgetful functor preserves finite products and satisfies the equalizer condition. |
noncomputable ofSheafCompHaus
(F : CompHaus.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts F]
(hF : EqualizerCondition F) : Condensed A where
val := F
cond := by
rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition F]
exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafCompHaus | The condensed object associated to a presheaf on `CompHaus` which preserves finite products and
satisfies the equalizer condition. |
noncomputable ofSheafForgetCompHaus
[HasForget A] [ReflectsFiniteLimits (CategoryTheory.forget A)]
(F : CompHaus.{u}ᵒᵖ ⥤ A) [PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)]
(hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)) : Condensed A where
val := F
cond := by
apply isSheaf_coherent_of_hasPullbacks_of_comp F (CategoryTheory.forget A)
rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition]
exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | def | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafForgetCompHaus | The condensed object associated to a presheaf on `CompHaus` whose postcomposition with the
forgetful functor preserves finite products and satisfies the equalizer condition. |
equalizerCondition (X : Condensed A) : EqualizerCondition X.val :=
isSheaf_iff_preservesFiniteProducts_and_equalizerCondition X.val |>.mp X.cond |>.2 | theorem | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | equalizerCondition | A condensed object satisfies the equalizer condition. |
equalizerCondition_profinite (X : Sheaf (coherentTopology Profinite.{u}) A) :
EqualizerCondition X.val :=
isSheaf_iff_preservesFiniteProducts_and_equalizerCondition X.val |>.mp X.cond |>.2 | theorem | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | equalizerCondition_profinite | A condensed object preserves finite products. -/
noncomputable instance (X : Condensed A) : PreservesFiniteProducts X.val :=
isSheaf_iff_preservesFiniteProducts_and_equalizerCondition X.val |>.mp
X.cond |>.1
/-- A condensed object regarded as a sheaf on `Profinite` preserves finite products. -/
noncomputable instance (X : Sheaf (coherentTopology Profinite.{u}) A) :
PreservesFiniteProducts X.val :=
isSheaf_iff_preservesFiniteProducts_and_equalizerCondition X.val |>.mp
X.cond |>.1
/-- A condensed object regarded as a sheaf on `Profinite` satisfies the equalizer condition. |
noncomputable ofSheafStonean (F : Stonean.{u}ᵒᵖ ⥤ Type (u + 1)) [PreservesFiniteProducts F] :
CondensedSet :=
Condensed.ofSheafStonean F | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafStonean | A condensed object regarded as a sheaf on `Stonean` preserves finite products. -/
noncomputable instance (X : Sheaf (coherentTopology Stonean.{u}) A) :
PreservesFiniteProducts X.val :=
isSheaf_iff_preservesFiniteProducts_of_projective X.val |>.mp X.cond
end Condensed
namespace CondensedSet
/-- A `CondensedSet` version of `Condensed.ofSheafStonean`. |
noncomputable ofSheafProfinite (F : Profinite.{u}ᵒᵖ ⥤ Type (u + 1))
[PreservesFiniteProducts F] (hF : EqualizerCondition F) : CondensedSet :=
Condensed.ofSheafProfinite F hF | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafProfinite | A `CondensedSet` version of `Condensed.ofSheafProfinite`. |
noncomputable ofSheafCompHaus (F : CompHaus.{u}ᵒᵖ ⥤ Type (u + 1))
[PreservesFiniteProducts F] (hF : EqualizerCondition F) : CondensedSet :=
Condensed.ofSheafCompHaus F hF | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafCompHaus | A `CondensedSet` version of `Condensed.ofSheafCompHaus`. |
noncomputable ofSheafStonean (F : Stonean.{u}ᵒᵖ ⥤ ModuleCat.{u + 1} R)
[PreservesFiniteProducts F] : CondensedMod R :=
haveI : HasLimitsOfSize.{u, u + 1} (ModuleCat R) :=
hasLimitsOfSizeShrink.{u, u + 1, u + 1, u + 1} _
Condensed.ofSheafStonean F | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafStonean | A `CondensedMod` version of `Condensed.ofSheafStonean`. |
noncomputable ofSheafProfinite (F : Profinite.{u}ᵒᵖ ⥤ ModuleCat.{u + 1} R)
[PreservesFiniteProducts F] (hF : EqualizerCondition F) : CondensedMod R :=
haveI : HasLimitsOfSize.{u, u + 1} (ModuleCat R) :=
hasLimitsOfSizeShrink.{u, u + 1, u + 1, u + 1} _
Condensed.ofSheafProfinite F hF | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafProfinite | A `CondensedMod` version of `Condensed.ofSheafProfinite`. |
noncomputable ofSheafCompHaus (F : CompHaus.{u}ᵒᵖ ⥤ ModuleCat.{u + 1} R)
[PreservesFiniteProducts F] (hF : EqualizerCondition F) : CondensedMod R :=
Condensed.ofSheafCompHaus F hF | abbrev | Condensed | [
"Mathlib.Condensed.Module",
"Mathlib.Condensed.Equivalence"
] | Mathlib/Condensed/Explicit.lean | ofSheafCompHaus | A `CondensedMod` version of `Condensed.ofSheafCompHaus`. |
Condensed.ulift : Condensed.{u} (Type u) ⥤ CondensedSet.{u} :=
sheafCompose (coherentTopology CompHaus) uliftFunctor.{u+1, u} | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | Condensed.ulift | Increase the size of the target category of condensed sets. |
compHausToCondensed' : CompHaus.{u} ⥤ Condensed.{u} (Type u) :=
(coherentTopology CompHaus).yoneda | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | compHausToCondensed' | The functor from `CompHaus` to `Condensed.{u} (Type u)` given by the Yoneda sheaf. |
compHausToCondensed : CompHaus.{u} ⥤ CondensedSet.{u} :=
compHausToCondensed' ⋙ Condensed.ulift | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | compHausToCondensed | The yoneda presheaf as an actual condensed set. |
CompHaus.toCondensed (S : CompHaus.{u}) : CondensedSet.{u} := compHausToCondensed.obj S | abbrev | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | CompHaus.toCondensed | Dot notation for the value of `compHausToCondensed`. |
profiniteToCondensed : Profinite.{u} ⥤ CondensedSet.{u} :=
profiniteToCompHaus ⋙ compHausToCondensed | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | profiniteToCondensed | The yoneda presheaf as a condensed set, restricted to profinite spaces. |
Profinite.toCondensed (S : Profinite.{u}) : CondensedSet.{u} := profiniteToCondensed.obj S | abbrev | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | Profinite.toCondensed | Dot notation for the value of `profiniteToCondensed`. |
stoneanToCondensed : Stonean.{u} ⥤ CondensedSet.{u} :=
Stonean.toCompHaus ⋙ compHausToCondensed | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | stoneanToCondensed | The yoneda presheaf as a condensed set, restricted to Stonean spaces. |
Stonean.toCondensed (S : Stonean.{u}) : CondensedSet.{u} := stoneanToCondensed.obj S | abbrev | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Ulift",
"Mathlib.CategoryTheory.Sites.Coherent.CoherentSheaves",
"Mathlib.CategoryTheory.Sites.Whiskering",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.Stonean.Basic"
] | Mathlib/Condensed/Functors.lean | Stonean.toCondensed | Dot notation for the value of `stoneanToCondensed`. |
CondensedMod := Condensed.{u} (ModuleCat.{u + 1} R) | abbrev | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | CondensedMod | The category of condensed `R`-modules, defined as sheaves of `R`-modules over
`CompHaus` with respect to the coherent Grothendieck topology. |
Condensed.forget : CondensedMod R ⥤ CondensedSet := sheafCompose _ (CategoryTheory.forget _) | def | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.forget | The forgetful functor from condensed `R`-modules to condensed sets. |
noncomputable
Condensed.free : CondensedSet ⥤ CondensedMod R :=
Sheaf.composeAndSheafify _ (ModuleCat.free R) | def | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.free | The left adjoint to the forgetful functor. The *free condensed `R`-module* on a condensed set. |
noncomputable
Condensed.freeForgetAdjunction : free R ⊣ forget R := Sheaf.adjunction _ (ModuleCat.adj R) | def | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.freeForgetAdjunction | The condensed version of the free-forgetful adjunction. |
CondensedAb := CondensedMod.{u} (ULift ℤ) | abbrev | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | CondensedAb | The category of condensed abelian groups is defined as condensed `ℤ`-modules. |
Condensed.abForget : CondensedAb ⥤ CondensedSet := forget _ | abbrev | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.abForget | The forgetful functor from condensed abelian groups to condensed sets. |
noncomputable Condensed.freeAb : CondensedSet ⥤ CondensedAb := free _ | abbrev | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.freeAb | The free condensed abelian group on a condensed set. |
noncomputable Condensed.setAbAdjunction : freeAb ⊣ abForget := freeForgetAdjunction _ | abbrev | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | Condensed.setAbAdjunction | The free-forgetful adjunction for condensed abelian groups. |
hom_naturality_apply {X Y : CondensedMod.{u} R} (f : X ⟶ Y) {S T : CompHausᵒᵖ} (g : S ⟶ T)
(x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) :=
NatTrans.naturality_apply f.val g x | lemma | Condensed | [
"Mathlib.Algebra.Category.ModuleCat.Abelian",
"Mathlib.Algebra.Category.ModuleCat.Colimits",
"Mathlib.Algebra.Category.ModuleCat.FilteredColimits",
"Mathlib.Algebra.Category.ModuleCat.Adjunctions",
"Mathlib.CategoryTheory.Sites.Abelian",
"Mathlib.CategoryTheory.Sites.Adjunction",
"Mathlib.CategoryTheory... | Mathlib/Condensed/Module.lean | hom_naturality_apply | null |
finFree : FintypeCat.{u} ⥤ CondensedMod.{u} R :=
FintypeCat.toProfinite ⋙ profiniteToCondensed ⋙ free R | abbrev | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | finFree | The free condensed abelian group on a finite set. |
profiniteFree : Profinite.{u} ⥤ CondensedMod.{u} R :=
profiniteToCondensed ⋙ free R | abbrev | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | profiniteFree | The free condensed abelian group on a profinite space. |
profiniteSolid : Profinite.{u} ⥤ CondensedMod.{u} R :=
Functor.rightKanExtension FintypeCat.toProfinite (finFree R) | def | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | profiniteSolid | The functor sending a profinite space `S` to the condensed abelian group `R[S]^\solid`. |
profiniteSolidCounit : FintypeCat.toProfinite ⋙ profiniteSolid R ⟶ finFree R :=
Functor.rightKanExtensionCounit FintypeCat.toProfinite (finFree R) | def | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | profiniteSolidCounit | The natural transformation `FintypeCat.toProfinite ⋙ profiniteSolid R ⟶ finFree R`
which is part of the assertion that `profiniteSolid R` is the (pointwise) right
Kan extension of `finFree R` along `FintypeCat.toProfinite`. |
profiniteSolidIsPointwiseRightKanExtension :
(Functor.RightExtension.mk _ (profiniteSolidCounit R)).IsPointwiseRightKanExtension :=
Functor.isPointwiseRightKanExtensionOfIsRightKanExtension _ _ | def | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | profiniteSolidIsPointwiseRightKanExtension | The functor `Profinite.{u} ⥤ CondensedMod.{u} R` is a pointwise
right Kan extension of `finFree R : FintypeCat.{u} ⥤ CondensedMod.{u} R`
along `FintypeCat.toProfinite`. |
profiniteSolidification : profiniteFree R ⟶ profiniteSolid.{u} R :=
(profiniteSolid R).liftOfIsRightKanExtension (profiniteSolidCounit R) _ (𝟙 _) | def | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | profiniteSolidification | The natural transformation `R[S] ⟶ R[S]^\solid`. |
CondensedMod.IsSolid (A : CondensedMod.{u} R) : Prop where
isIso_solidification_map : ∀ X : Profinite.{u}, IsIso ((yoneda.obj A).map
((profiniteSolidification R).app X).op) | class | Condensed | [
"Mathlib.CategoryTheory.Functor.KanExtension.Pointwise",
"Mathlib.Condensed.Functors",
"Mathlib.Condensed.Limits"
] | Mathlib/Condensed/Solid.lean | CondensedMod.IsSolid | The predicate on condensed abelian groups describing the property of being solid. |
private CondensedSet.coinducingCoprod :
(Σ (i : (S : CompHaus.{u}) × X.val.obj ⟨S⟩), i.fst) → X.val.obj ⟨of PUnit⟩ :=
fun ⟨⟨_, i⟩, s⟩ ↦ X.val.map ((of PUnit.{u + 1}).const s).op i | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | CondensedSet.coinducingCoprod | Auxiliary definition to define the topology on `X(*)` for a condensed set `X`. |
CondensedSet.toTopCat : TopCat.{u + 1} := TopCat.of (X.val.obj ⟨of PUnit⟩) | abbrev | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | CondensedSet.toTopCat | Let `X` be a condensed set. We define a topology on `X(*)` as the quotient topology of
all the maps from compact Hausdorff `S` spaces to `X(*)`, corresponding to elements of `X(S)`.
In other words, the topology coinduced by the map `CondensedSet.coinducingCoprod` above. -/
local instance : TopologicalSpace (X.val.obj ⟨CompHaus.of PUnit⟩) :=
TopologicalSpace.coinduced (coinducingCoprod X) inferInstance
/-- The object part of the functor `CondensedSet ⥤ TopCat` |
continuous_coinducingCoprod {S : CompHaus.{u}} (x : X.val.obj ⟨S⟩) :
Continuous fun a ↦ (X.coinducingCoprod ⟨⟨S, x⟩, a⟩) := by
suffices ∀ (i : (T : CompHaus.{u}) × X.val.obj ⟨T⟩),
Continuous (fun (a : i.fst) ↦ X.coinducingCoprod ⟨i, a⟩) from this ⟨_, _⟩
rw [← continuous_sigma_iff]
apply continuous_coinduced_rng
variable {X} {Y : CondensedSet} (f : X ⟶ Y)
attribute [local instance] Types.instFunLike Types.instConcreteCategory in | lemma | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | continuous_coinducingCoprod | null |
@[simps!]
toTopCatMap : X.toTopCat ⟶ Y.toTopCat :=
TopCat.ofHom
{ toFun := f.val.app ⟨of PUnit⟩
continuous_toFun := by
rw [continuous_coinduced_dom]
apply continuous_sigma
intro ⟨S, x⟩
simp only [Function.comp_apply, coinducingCoprod]
rw [show (fun (a : S) ↦
f.val.app ⟨of PUnit⟩ (X.val.map ((of PUnit.{u + 1}).const a).op x)) = _
from funext fun a ↦ NatTrans.naturality_apply f.val ((of PUnit.{u + 1}).const a).op x]
exact continuous_coinducingCoprod Y _ } | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | toTopCatMap | The map part of the functor `CondensedSet ⥤ TopCat` |
@[simps]
condensedSetToTopCat : CondensedSet.{u} ⥤ TopCat.{u + 1} where
obj X := X.toTopCat
map f := toTopCatMap f | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | condensedSetToTopCat | The functor `CondensedSet ⥤ TopCat` |
noncomputable topCatAdjunctionCounit (X : TopCat.{u + 1}) : X.toCondensedSet.toTopCat ⟶ X :=
TopCat.ofHom
{ toFun x := x.1 PUnit.unit
continuous_toFun := by
rw [continuous_coinduced_dom]
continuity } | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunctionCounit | The counit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` |
@[simp] topCatAdjunctionCounit_hom_apply (X : TopCat) (x) :
DFunLike.coe (F := @ContinuousMap C(PUnit, X) X (_) _)
(TopCat.Hom.hom (topCatAdjunctionCounit X)) x =
x PUnit.unit := rfl | lemma | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunctionCounit_hom_apply | `simp`-normal form of the lemma that `@[simps]` would generate. |
noncomputable topCatAdjunctionCounitEquiv (X : TopCat.{u + 1}) :
X.toCondensedSet.toTopCat ≃ X where
toFun := topCatAdjunctionCounit X
invFun x := ContinuousMap.const _ x | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunctionCounitEquiv | The counit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` is always bijective,
but not an isomorphism in general (the inverse isn't continuous unless `X` is compactly generated). |
topCatAdjunctionCounit_bijective (X : TopCat.{u + 1}) :
Function.Bijective (topCatAdjunctionCounit X) :=
(topCatAdjunctionCounitEquiv X).bijective | lemma | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunctionCounit_bijective | null |
@[simps val_app val_app_apply]
noncomputable topCatAdjunctionUnit (X : CondensedSet.{u}) : X ⟶ X.toTopCat.toCondensedSet where
val := {
app := fun S x ↦ {
toFun := fun s ↦ X.val.map ((of PUnit.{u + 1}).const s).op x
continuous_toFun := by
suffices ∀ (i : (T : CompHaus.{u}) × X.val.obj ⟨T⟩),
Continuous (fun (a : i.fst) ↦ X.coinducingCoprod ⟨i, a⟩) from this ⟨_, _⟩
rw [← continuous_sigma_iff]
apply continuous_coinduced_rng }
naturality := fun _ _ _ ↦ by
ext
simp only [TopCat.toSheafCompHausLike_val_obj,
Opposite.op_unop, types_comp_apply, TopCat.toSheafCompHausLike_val_map,
← FunctorToTypes.map_comp_apply]
rfl } | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunctionUnit | The unit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` |
noncomputable topCatAdjunction : condensedSetToTopCat.{u} ⊣ topCatToCondensedSet where
unit.app := topCatAdjunctionUnit
counit.app := topCatAdjunctionCounit
left_triangle_components Y := by
ext
change Y.val.map (𝟙 _) _ = _
simp | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | topCatAdjunction | The adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` |
condensedSetToCompactlyGenerated : CondensedSet.{u} ⥤ CompactlyGenerated.{u, u + 1} where
obj X := CompactlyGenerated.of (condensedSetToTopCat.obj X)
map f := toTopCatMap f | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | condensedSetToCompactlyGenerated | The functor from condensed sets to topological spaces lands in compactly generated spaces. |
noncomputable compactlyGeneratedToCondensedSet :
CompactlyGenerated.{u, u + 1} ⥤ CondensedSet.{u} :=
compactlyGeneratedToTop ⋙ topCatToCondensedSet | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | compactlyGeneratedToCondensedSet | The functor from topological spaces to condensed sets restricted to compactly generated spaces. |
noncomputable compactlyGeneratedAdjunction :
condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet :=
topCatAdjunction.restrictFullyFaithful (iC := 𝟭 _) (iD := compactlyGeneratedToTop)
(Functor.FullyFaithful.id _) fullyFaithfulCompactlyGeneratedToTop
(Iso.refl _) (Iso.refl _) | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | compactlyGeneratedAdjunction | The adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` restricted to compactly generated
spaces. |
noncomputable compactlyGeneratedAdjunctionCounitHomeo
(X : TopCat.{u + 1}) [UCompactlyGeneratedSpace.{u} X] :
X.toCondensedSet.toTopCat ≃ₜ X where
toEquiv := topCatAdjunctionCounitEquiv X
continuous_toFun := (topCatAdjunctionCounit X).hom.continuous
continuous_invFun := by
apply continuous_from_uCompactlyGeneratedSpace
exact fun _ _ ↦ continuous_coinducingCoprod X.toCondensedSet _ | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | compactlyGeneratedAdjunctionCounitHomeo | The counit of the adjunction `condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet`
is a homeomorphism. |
noncomputable compactlyGeneratedAdjunctionCounitIso (X : CompactlyGenerated.{u, u + 1}) :
condensedSetToCompactlyGenerated.obj (compactlyGeneratedToCondensedSet.obj X) ≅ X :=
isoOfHomeo (compactlyGeneratedAdjunctionCounitHomeo X.toTop) | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | compactlyGeneratedAdjunctionCounitIso | The counit of the adjunction `condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet`
is an isomorphism. |
noncomputable fullyFaithfulCompactlyGeneratedToCondensedSet :
compactlyGeneratedToCondensedSet.FullyFaithful :=
compactlyGeneratedAdjunction.fullyFaithfulROfIsIsoCounit | def | Condensed | [
"Mathlib.Condensed.TopComparison",
"Mathlib.Topology.Category.CompactlyGenerated"
] | Mathlib/Condensed/TopCatAdjunction.lean | fullyFaithfulCompactlyGeneratedToCondensedSet | The functor from topological spaces to condensed sets restricted to compactly generated spaces
is fully faithful. |
factorsThrough_of_pullbackCondition {Z B : C} {π : Z ⟶ B} [HasPullback π π]
[PreservesLimit (cospan π π) G]
{a : C(G.obj Z, X)}
(ha : a ∘ (G.map (pullback.fst _ _)) = a ∘ (G.map (pullback.snd π π))) :
Function.FactorsThrough a (G.map π) := by
intro x y hxy
let xy : G.obj (pullback π π) := (PreservesPullback.iso G π π).inv <|
(TopCat.pullbackIsoProdSubtype (G.map π) (G.map π)).inv ⟨(x, y), hxy⟩
have ha' := congr_fun ha xy
dsimp at ha'
have h₁ : ∀ y, G.map (pullback.fst _ _) ((PreservesPullback.iso G π π).inv y) =
pullback.fst (G.map π) (G.map π) y := by
simp only [← PreservesPullback.iso_inv_fst]; intro y; rfl
have h₂ : ∀ y, G.map (pullback.snd _ _) ((PreservesPullback.iso G π π).inv y) =
pullback.snd (G.map π) (G.map π) y := by
simp only [← PreservesPullback.iso_inv_snd]; intro y; rfl
rw [h₁, h₂, TopCat.pullbackIsoProdSubtype_inv_fst_apply,
TopCat.pullbackIsoProdSubtype_inv_snd_apply] at ha'
simpa using ha' | theorem | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | factorsThrough_of_pullbackCondition | An auxiliary lemma to that allows us to use `IsQuotientMap.lift` in the proof of
`equalizerCondition_yonedaPresheaf`. |
equalizerCondition_yonedaPresheaf
[∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) G]
(hq : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], IsQuotientMap (G.map π)) :
EqualizerCondition (yonedaPresheaf G X) := by
apply EqualizerCondition.mk
intro Z B π _ _
refine ⟨fun a b h ↦ ?_, fun ⟨a, ha⟩ ↦ ?_⟩
· simp only [yonedaPresheaf, unop_op, Quiver.Hom.unop_op, Set.coe_setOf, MapToEqualizer,
Set.mem_setOf_eq, Subtype.mk.injEq, comp, ContinuousMap.mk.injEq] at h
simp only [yonedaPresheaf, unop_op]
ext x
obtain ⟨y, hy⟩ := (hq Z B π).surjective x
rw [← hy]
exact congr_fun h y
· simp only [yonedaPresheaf, comp, unop_op, Quiver.Hom.unop_op, Set.mem_setOf_eq,
ContinuousMap.mk.injEq] at ha
simp only [yonedaPresheaf, comp, unop_op, Quiver.Hom.unop_op, Set.coe_setOf,
MapToEqualizer, Set.mem_setOf_eq, Subtype.mk.injEq]
simp only [yonedaPresheaf, unop_op] at a
refine ⟨(hq Z B π).lift a (factorsThrough_of_pullbackCondition G X ha), ?_⟩
congr 1
exact DFunLike.ext'_iff.mp ((hq Z B π).lift_comp a (factorsThrough_of_pullbackCondition G X ha)) | theorem | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | equalizerCondition_yonedaPresheaf | If `G` preserves the relevant pullbacks and every effective epi in `C` is a quotient map (which is
the case when `C` is `CompHaus` or `Profinite`), then `yonedaPresheaf` satisfies the equalizer
condition which is required to be a sheaf for the regular topology. |
@[simps! val_obj val_map]
TopCat.toSheafCompHausLike :
have := CompHausLike.preregular hs
Sheaf (coherentTopology (CompHausLike.{u} P)) (Type (max u w)) where
val := yonedaPresheaf.{u, max u w} (CompHausLike.compHausLikeToTop.{u} P) X
cond := by
have := CompHausLike.preregular hs
rw [Presheaf.isSheaf_iff_preservesFiniteProducts_and_equalizerCondition]
refine ⟨inferInstance, ?_⟩
apply (config := { allowSynthFailures := true }) equalizerCondition_yonedaPresheaf
(CompHausLike.compHausLikeToTop.{u} P) X
intro Z B π he
apply IsQuotientMap.of_surjective_continuous (hs _ he) π.hom.continuous | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | TopCat.toSheafCompHausLike | If `G` preserves finite coproducts (which is the case when `C` is `CompHaus`, `Profinite` or
`Stonean`), then `yonedaPresheaf` preserves finite products, which is required to be a sheaf for
the extensive topology.
-/
noncomputable instance [PreservesFiniteCoproducts G] :
PreservesFiniteProducts (yonedaPresheaf G X) :=
have := preservesFiniteProducts_op G
⟨fun _ ↦ comp_preservesLimitsOfShape G.op (yonedaPresheaf' X)⟩
section
variable (P : TopCat.{u} → Prop) (X : TopCat.{max u w})
[CompHausLike.HasExplicitFiniteCoproducts.{0} P] [CompHausLike.HasExplicitPullbacks.{u} P]
(hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective f)
/--
The sheaf on `CompHausLike P` of continuous maps to a topological space. |
@[simps]
noncomputable topCatToSheafCompHausLike :
have := CompHausLike.preregular hs
TopCat.{max u w} ⥤ Sheaf (coherentTopology (CompHausLike.{u} P)) (Type (max u w)) where
obj X := X.toSheafCompHausLike P hs
map f := ⟨⟨fun _ g ↦ f.hom.comp g, by aesop⟩⟩ | def | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | topCatToSheafCompHausLike | `TopCat.toSheafCompHausLike` yields a functor from `TopCat.{max u w}` to
`Sheaf (coherentTopology (CompHausLike.{u} P)) (Type (max u w))`. |
noncomputable TopCat.toCondensedSet (X : TopCat.{u + 1}) : CondensedSet.{u} :=
toSheafCompHausLike.{u+1} _ X (fun _ _ _ ↦ ((CompHaus.effectiveEpi_tfae _).out 0 2).mp) | abbrev | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | TopCat.toCondensedSet | Associate to a `(u+1)`-small topological space the corresponding condensed set, given by
`yonedaPresheaf`. |
noncomputable topCatToCondensedSet : TopCat.{u+1} ⥤ CondensedSet.{u} :=
topCatToSheafCompHausLike.{u+1} _ (fun _ _ _ ↦ ((CompHaus.effectiveEpi_tfae _).out 0 2).mp) | abbrev | Condensed | [
"Mathlib.CategoryTheory.Limits.Preserves.Opposites",
"Mathlib.CategoryTheory.Sites.Coherent.SheafComparison",
"Mathlib.Condensed.Basic",
"Mathlib.Topology.Category.TopCat.Yoneda"
] | Mathlib/Condensed/TopComparison.lean | topCatToCondensedSet | `TopCat.toCondensedSet` yields a functor from `TopCat.{u+1}` to `CondensedSet.{u}`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.