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 (... | 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.b... | 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.Stm... | 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' := ... | 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' ∅ (addBott... | 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 [... | 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) →
... | 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 ... | 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, ... | 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⟩ := (Pa... | 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' ∈ trSt... | 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 H... | 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 HasExac... | 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... | 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.isLocally... | 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.instFunL... | 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.instFunL... | 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]
... | 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 |>.func... | 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_preserve... | 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... | 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_o... | 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 ins... |
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`... |
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 ⟨... |
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_coind... | 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... | 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⟩),
... | 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_uCompa... | 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 π π) := (Preserves... | 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... | 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.isShea... | 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)... |
@[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.