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 ⌀ |
|---|---|---|---|---|---|---|
@[simps]
curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G :=
have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
apply ActionCategory.cases
intros
rfl
{ toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
map_one' := by
dsimp
... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | curry | Given `G` acting on `X`, a functor from the corresponding action groupoid to a group `H`
can be curried to a group homomorphism `G →* (X → H) ⋊ G`. |
@[simps]
uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
ActionCategory G X ⥤ SingleObj H where
obj _ := ()
map {_ b} f := (F f.val).left b.back
map_id x := by
dsimp
rw [F.map_one]
rfl
map_comp f g := by
cases g using ActionCategory.cases
simp [SingleObj.comp_... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.SingleObj",
"Mathlib.GroupTheory.GroupAction.Quotient",
"Mathlib.GroupTheory.SemidirectProduct"
] | Mathlib/CategoryTheory/Action.lean | uncurry | Given `G` acting on `X`, a group homomorphism `φ : G →* (X → H) ⋊ G` can be uncurried to
a functor from the action groupoid to `H`, provided that `φ g = (_, g)` for all `g`. |
@[nolint unusedArguments]
IsPushout.IsVanKampen (_ : IsPushout f g h i) : Prop :=
∀ ⦃W' X' Y' Z' : C⦄ (f' : W' ⟶ X') (g' : W' ⟶ Y') (h' : X' ⟶ Z') (i' : Y' ⟶ Z') (αW : W' ⟶ W)
(αX : X' ⟶ X) (αY : Y' ⟶ Y) (αZ : Z' ⟶ Z) (_ : IsPullback f' αW αX f)
(_ : IsPullback g' αW αY g) (_ : CommSq h' αX αZ h) (_ : CommSq ... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen | A convenience formulation for a pushout being a van Kampen colimit.
See `IsPushout.isVanKampen_iff` below. |
IsPushout.IsVanKampen.flip {H : IsPushout f g h i} (H' : H.IsVanKampen) :
H.flip.IsVanKampen := by
introv W' hf hg hh hi w
simpa only [IsPushout.flip_iff, IsPullback.flip_iff, and_comm] using
H' g' f' i' h' αW αY αX αZ hg hf hi hh w.flip | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen.flip | null |
IsPushout.isVanKampen_iff (H : IsPushout f g h i) :
H.IsVanKampen ↔ IsVanKampenColimit (PushoutCocone.mk h i H.w) := by
constructor
· intro H F' c' α fα eα hα
refine Iff.trans ?_
((H (F'.map WalkingSpan.Hom.fst) (F'.map WalkingSpan.Hom.snd) (c'.ι.app _) (c'.ι.app _)
(α.app _) (α.app _) (α.... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.isVanKampen_iff | null |
is_coprod_iff_isPushout {X E Y YE : C} (c : BinaryCofan X E) (hc : IsColimit c) {f : X ⟶ Y}
{iY : Y ⟶ YE} {fE : c.pt ⟶ YE} (H : CommSq f c.inl iY fE) :
Nonempty (IsColimit (BinaryCofan.mk (c.inr ≫ fE) iY)) ↔ IsPushout f c.inl iY fE := by
constructor
· rintro ⟨h⟩
refine ⟨H, ⟨Limits.PushoutCocone.isColimi... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | is_coprod_iff_isPushout | null |
IsPushout.isVanKampen_inl {W E X Z : C} (c : BinaryCofan W E) [FinitaryExtensive C]
[HasPullbacks C] (hc : IsColimit c) (f : W ⟶ X) (h : X ⟶ Z) (i : c.pt ⟶ Z)
(H : IsPushout f c.inl h i) : H.IsVanKampen := by
obtain ⟨hc₁⟩ := (is_coprod_iff_isPushout c hc H.1).mpr H
introv W' hf hg hh hi w
obtain ⟨hc₂⟩ := ... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.isVanKampen_inl | null |
IsPushout.IsVanKampen.isPullback_of_mono_left [Mono f] {H : IsPushout f g h i}
(H' : H.IsVanKampen) : IsPullback f g h i :=
((H' (𝟙 _) g g (𝟙 Y) (𝟙 _) f (𝟙 _) i (IsKernelPair.id_of_mono f)
(IsPullback.of_vert_isIso ⟨by simp⟩) H.1.flip ⟨rfl⟩ ⟨by simp⟩).mp
(IsPushout.of_horiz_isIso ⟨by simp⟩)).1.flip | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen.isPullback_of_mono_left | null |
IsPushout.IsVanKampen.isPullback_of_mono_right [Mono g] {H : IsPushout f g h i}
(H' : H.IsVanKampen) : IsPullback f g h i :=
((H' f (𝟙 _) (𝟙 _) f (𝟙 _) (𝟙 _) g h (IsPullback.of_vert_isIso ⟨by simp⟩)
(IsKernelPair.id_of_mono g) ⟨rfl⟩ H.1 ⟨by simp⟩).mp
(IsPushout.of_vert_isIso ⟨by simp⟩)).2 | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen.isPullback_of_mono_right | null |
IsPushout.IsVanKampen.mono_of_mono_left [Mono f] {H : IsPushout f g h i}
(H' : H.IsVanKampen) : Mono i :=
IsKernelPair.mono_of_isIso_fst
((H' (𝟙 _) g g (𝟙 Y) (𝟙 _) f (𝟙 _) i (IsKernelPair.id_of_mono f)
(IsPullback.of_vert_isIso ⟨by simp⟩) H.1.flip ⟨rfl⟩ ⟨by simp⟩).mp
(IsPushout.of_horiz_isIs... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen.mono_of_mono_left | null |
IsPushout.IsVanKampen.mono_of_mono_right [Mono g] {H : IsPushout f g h i}
(H' : H.IsVanKampen) : Mono h :=
IsKernelPair.mono_of_isIso_fst
((H' f (𝟙 _) (𝟙 _) f (𝟙 _) (𝟙 _) g h (IsPullback.of_vert_isIso ⟨by simp⟩)
(IsKernelPair.id_of_mono g) ⟨rfl⟩ H.1 ⟨by simp⟩).mp
(IsPushout.of_vert_isIso ⟨by... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | IsPushout.IsVanKampen.mono_of_mono_right | null |
Adhesive (C : Type u) [Category.{v} C] : Prop where
[hasPullback_of_mono_left : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
[hasPushout_of_mono_left : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
van_kampen : ∀ {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} [... | class | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive | A category is adhesive if it has pushouts and pullbacks along monomorphisms,
and such pushouts are van Kampen. |
Adhesive.van_kampen' [Adhesive C] [Mono g] (H : IsPushout f g h i) : H.IsVanKampen :=
(Adhesive.van_kampen H.flip).flip | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive.van_kampen' | null |
Adhesive.isPullback_of_isPushout_of_mono_left [Adhesive C] (H : IsPushout f g h i)
[Mono f] : IsPullback f g h i :=
(Adhesive.van_kampen H).isPullback_of_mono_left | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive.isPullback_of_isPushout_of_mono_left | null |
Adhesive.isPullback_of_isPushout_of_mono_right [Adhesive C] (H : IsPushout f g h i)
[Mono g] : IsPullback f g h i :=
(Adhesive.van_kampen' H).isPullback_of_mono_right | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive.isPullback_of_isPushout_of_mono_right | null |
Adhesive.mono_of_isPushout_of_mono_left [Adhesive C] (H : IsPushout f g h i) [Mono f] :
Mono i :=
(Adhesive.van_kampen H).mono_of_mono_left | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive.mono_of_isPushout_of_mono_left | null |
Adhesive.mono_of_isPushout_of_mono_right [Adhesive C] (H : IsPushout f g h i) [Mono g] :
Mono h :=
(Adhesive.van_kampen' H).mono_of_mono_right | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Adhesive.mono_of_isPushout_of_mono_right | null |
Type.adhesive : Adhesive (Type u) :=
⟨fun {_ _ _ _ f _ _ _ _} H =>
(IsPushout.isVanKampen_inl _ (Types.isCoprodOfMono f) _ _ _ H.flip).flip⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | Type.adhesive | null |
adhesive_functor [Adhesive C] [HasPullbacks C] [HasPushouts C] :
Adhesive (D ⥤ C) := by
constructor
intro W X Y Z f g h i hf H
rw [IsPushout.isVanKampen_iff]
apply isVanKampenColimit_of_evaluation
intro x
refine (IsVanKampenColimit.precompose_isIso_iff (diagramIsoSpan _).inv).mp ?_
refine IsVanKampenC... | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | adhesive_functor | null |
adhesive_of_preserves_and_reflects (F : C ⥤ D) [Adhesive D]
[H₁ : ∀ {X Y S : C} (f : X ⟶ S) (g : Y ⟶ S) [Mono f], HasPullback f g]
[H₂ : ∀ {X Y S : C} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
[PreservesLimitsOfShape WalkingCospan F]
[ReflectsLimitsOfShape WalkingCospan F]
[PreservesColimits... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | adhesive_of_preserves_and_reflects | null |
adhesive_of_preserves_and_reflects_isomorphism (F : C ⥤ D)
[Adhesive D] [HasPullbacks C] [HasPushouts C]
[PreservesLimitsOfShape WalkingCospan F]
[PreservesColimitsOfShape WalkingSpan F]
[F.ReflectsIsomorphisms] :
Adhesive C := by
haveI : ReflectsLimitsOfShape WalkingCospan F :=
reflectsLimits... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | adhesive_of_preserves_and_reflects_isomorphism | null |
adhesive_of_reflective [HasPullbacks D] [Adhesive C] [HasPullbacks C] [HasPushouts C]
[H₂ : ∀ {X Y S : D} (f : S ⟶ X) (g : S ⟶ Y) [Mono f], HasPushout f g]
{Gl : C ⥤ D} {Gr : D ⥤ C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful]
[PreservesLimitsOfShape WalkingCospan Gl] :
Adhesive D := by
have := adj.leftAdj... | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Shapes.KernelPair",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono"
] | Mathlib/CategoryTheory/Adhesive.lean | adhesive_of_reflective | null |
Balanced : Prop where
isIso_of_mono_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f], IsIso f | class | CategoryTheory | [
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Balanced.lean | Balanced | A category is called balanced if any morphism that is both monic and epic is an isomorphism. |
isIso_of_mono_of_epi [Balanced C] {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f] : IsIso f :=
Balanced.isIso_of_mono_of_epi _ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Balanced.lean | isIso_of_mono_of_epi | null |
isIso_iff_mono_and_epi [Balanced C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ Mono f ∧ Epi f :=
⟨fun _ => ⟨inferInstance, inferInstance⟩, fun ⟨_, _⟩ => isIso_of_mono_of_epi _⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Balanced.lean | isIso_iff_mono_and_epi | null |
balanced_opposite [Balanced C] : Balanced Cᵒᵖ :=
{ isIso_of_mono_of_epi := fun f fmono fepi => by
rw [← Quiver.Hom.op_unop f]
exact isIso_of_op _ } | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Balanced.lean | balanced_opposite | null |
@[ext]
CatCommSq (T : C₁ ⥤ C₂) (L : C₁ ⥤ C₃) (R : C₂ ⥤ C₄) (B : C₃ ⥤ C₄) where
/-- Assuming `[CatCommSq T L R B]`, `iso T L R B` is the isomorphism `T ⋙ R ≅ L ⋙ B`
given by the 2-commutative square. -/
iso (T) (L) (R) (B) : T ⋙ R ≅ L ⋙ B
variable (T : C₁ ⥤ C₂) (L : C₁ ⥤ C₃) (R : C₂ ⥤ C₄) (B : C₃ ⥤ C₄) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | CatCommSq | `CatCommSq T L R B` expresses that there is a 2-commutative square of functors, where
the functors `T`, `L`, `R` and `B` are respectively the left, top, right and bottom functors
of the square. |
@[simps!]
vId : CatCommSq T (𝟭 C₁) (𝟭 C₂) T where
iso := (Functor.leftUnitor _) ≪≫ (Functor.rightUnitor _).symm | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vId | The vertical identity `CatCommSq` |
@[simps!]
hId : CatCommSq (𝟭 C₁) L L (𝟭 C₃) where
iso := (Functor.rightUnitor _) ≪≫ (Functor.leftUnitor _).symm
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hId | The horizontal identity `CatCommSq` |
iso_hom_naturality [h : CatCommSq T L R B] {x y : C₁} (f : x ⟶ y) :
R.map (T.map f) ≫ (iso T L R B).hom.app y = (iso T L R B).hom.app x ≫ B.map (L.map f) :=
(iso T L R B).hom.naturality f
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | iso_hom_naturality | null |
iso_inv_naturality [h : CatCommSq T L R B] {x y : C₁} (f : x ⟶ y) :
B.map (L.map f) ≫ (iso T L R B).inv.app y = (iso T L R B).inv.app x ≫ R.map (T.map f) :=
(iso T L R B).inv.naturality f | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | iso_inv_naturality | null |
@[simps!]
hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
(B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) where
iso := associator _ _ _ ≪≫ isoWhiskerLeft T₁ (iso T₂ V₂ V₃ B₂) ≪≫
(associator _ _ _).symm ≪≫ ... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hComp | Horizontal composition of 2-commutative squares |
hComp' {T₁ : C₁ ⥤ C₂} {T₂ : C₂ ⥤ C₃} {V₁ : C₁ ⥤ C₄} {V₂ : C₂ ⥤ C₅} {V₃ : C₃ ⥤ C₆}
{B₁ : C₄ ⥤ C₅} {B₂ : C₅ ⥤ C₆} (S₁ : CatCommSq T₁ V₁ V₂ B₁) (S₂ : CatCommSq T₂ V₂ V₃ B₂) :
CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂) :=
letI := S₁
letI := S₂
hComp _ _ _ V₂ _ _ _ | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hComp' | A variant of `hComp` where both squares can be explicitly provided. |
@[simps!]
vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
(R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ where
iso := (associator _ _ _).symm ≪≫ isoWhiskerRight (iso H₁ L₁ R₁ H₂) R₂ ≪≫
associator _ _ _ ... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vComp | Vertical composition of 2-commutative squares |
vComp' {L₁ : C₁ ⥤ C₂} {L₂ : C₂ ⥤ C₃} {H₁ : C₁ ⥤ C₄} {H₂ : C₂ ⥤ C₅} {H₃ : C₃ ⥤ C₆}
{R₁ : C₄ ⥤ C₅} {R₂ : C₅ ⥤ C₆} (S₁ : CatCommSq H₁ L₁ R₁ H₂) (S₂ : CatCommSq H₂ L₂ R₂ H₃) :
CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃ :=
letI := S₁
letI := S₂
vComp _ _ _ H₂ _ _ _ | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vComp' | A variant of `vComp` where both squares can be explicitly provided. |
@[simps!]
hInv (_ : CatCommSq T.functor L R B.functor) : CatCommSq T.inverse R L B.inverse where
iso := isoWhiskerLeft _ (L.rightUnitor.symm ≪≫ isoWhiskerLeft L B.unitIso ≪≫
(associator _ _ _).symm ≪≫
isoWhiskerRight (iso T.functor L R B.functor).symm B.inverse ≪≫
associator _ _ _ ) ≪≫ (associator ... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hInv | Horizontal inverse of a 2-commutative square |
hInv_hInv (h : CatCommSq T.functor L R B.functor) :
hInv T.symm R L B.symm (hInv T L R B h) = h := by
ext X
rw [← cancel_mono (B.functor.map (L.map (T.unitIso.hom.app X)))]
rw [← Functor.comp_map]
erw [← h.iso.hom.naturality (T.unitIso.hom.app X)]
rw [hInv_iso_hom_app]
simp only [Equivalence.symm_functo... | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hInv_hInv | null |
hInvEquiv : CatCommSq T.functor L R B.functor ≃ CatCommSq T.inverse R L B.inverse where
toFun := hInv T L R B
invFun := hInv T.symm R L B.symm
left_inv := hInv_hInv T L R B
right_inv := hInv_hInv T.symm R L B.symm | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | hInvEquiv | In a square of categories, when the top and bottom functors are part
of equivalence of categories, it is equivalent to show 2-commutativity for
the functors of these equivalences or for their inverses. |
@[simps!]
vInv (_ : CatCommSq T L.functor R.functor B) : CatCommSq B L.inverse R.inverse T where
iso := isoWhiskerRight (B.leftUnitor.symm ≪≫ isoWhiskerRight L.counitIso.symm B ≪≫
associator _ _ _ ≪≫
isoWhiskerLeft L.inverse (iso T L.functor R.functor B).symm) R.inverse ≪≫
associator _ _ _ ≪≫ isoWhi... | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vInv | Vertical inverse of a 2-commutative square |
vInv_vInv (h : CatCommSq T L.functor R.functor B) :
vInv B L.symm R.symm T (vInv T L R B h) = h := by
ext X
rw [vInv_iso_hom_app]
dsimp
rw [vInv_iso_inv_app]
rw [← cancel_mono (B.map (L.functor.map (NatTrans.app L.unitIso.hom X)))]
rw [← Functor.comp_map]
dsimp
simp only [Functor.map_comp, Equivalen... | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vInv_vInv | null |
vInvEquiv : CatCommSq T L.functor R.functor B ≃ CatCommSq B L.inverse R.inverse T where
toFun := vInv T L R B
invFun := vInv B L.symm R.symm T
left_inv := vInv_vInv T L R B
right_inv := vInv_vInv B L.symm R.symm T | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/CatCommSq.lean | vInvEquiv | In a square of categories, when the left and right functors are part
of equivalence of categories, it is equivalent to show 2-commutativity for
the functors of these equivalences or for their inverses. |
@[simps]
codiscreteEquiv {α : Type u} : Codiscrete α ≃ α where
toFun := Codiscrete.as
invFun := Codiscrete.mk
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | codiscreteEquiv | A wrapper for promoting any type to a category,
with a unique morphisms between any two objects of the category.
-/
@[ext, aesop safe cases (rule_sets := [CategoryTheory])]
structure Codiscrete (α : Type u) where
/-- A wrapper for promoting any type to a category,
with a unique morphisms between any two objects of ... |
functor (F : C → A) : C ⥤ Codiscrete A where
obj := Codiscrete.mk ∘ F
map _ := ⟨⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | functor | Any function `C → A` lifts to a functor `C ⥤ Codiscrete A`. |
invFunctor (F : C ⥤ Codiscrete A) : C → A := Codiscrete.as ∘ F.obj | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | invFunctor | The underlying function `C → A` of a functor `C ⥤ Codiscrete A`. |
natTrans {F G : C ⥤ Codiscrete A} : F ⟶ G where
app _ := ⟨⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | natTrans | Given two functors to a codiscrete category, there is a trivial natural transformation. |
natIso {F G : C ⥤ Codiscrete A} : F ≅ G where
hom := natTrans
inv := natTrans | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | natIso | Given two functors into a codiscrete category, the trivial natural transformation is an
natural isomorphism. |
@[simps!]
natIsoFunctor {F : C ⥤ Codiscrete A} : F ≅ functor (Codiscrete.as ∘ F.obj) := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | natIsoFunctor | Every functor `F` to a codiscrete category is naturally isomorphic {(actually, equal)} to
`Codiscrete.as ∘ F.obj`. |
functorOfFun {A B : Type*} (f : A → B) : Codiscrete A ⥤ Codiscrete B :=
functor (f ∘ Codiscrete.as)
open Opposite | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | functorOfFun | A function induces a functor between codiscrete categories. |
oppositeEquivalence (A : Type*) : (Codiscrete A)ᵒᵖ ≌ Codiscrete A where
functor := functor (fun x ↦ Codiscrete.as x.unop)
inverse := (functor (fun x ↦ Codiscrete.as x.unop)).rightOp
unitIso := NatIso.ofComponents (fun _ => by exact Iso.refl _)
counitIso := natIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | oppositeEquivalence | A codiscrete category is equivalent to its opposite category. |
functorToCat : Type u ⥤ Cat.{0,u} where
obj A := Cat.of (Codiscrete A)
map := functorOfFun
open Adjunction Cat | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | functorToCat | `Codiscrete.functorToCat` turns a type into a codiscrete category. |
equivFunctorToCodiscrete {C : Type u} [Category.{v} C] {A : Type w} :
(C → A) ≃ (C ⥤ Codiscrete A) where
toFun := functor
invFun := invFunctor | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | equivFunctorToCodiscrete | For a category `C` and type `A`, there is an equivalence between functions `objects.obj C ⟶ A`
and functors `C ⥤ Codiscrete A`. |
adj : objects ⊣ functorToCat := mkOfHomEquiv {
homEquiv := fun _ _ => equivFunctorToCodiscrete
homEquiv_naturality_left_symm := fun _ _ => rfl
homEquiv_naturality_right := fun _ _ => rfl } | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | adj | The functor that turns a type into a codiscrete category is right adjoint to the objects
functor. |
unitApp (C : Type u) [Category.{v} C] : C ⥤ Codiscrete C := functor id | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | unitApp | Components of the unit of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat`. |
counitApp (A : Type u) : Codiscrete A → A := Codiscrete.as | def | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | counitApp | Components of the counit of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat` |
adj_unit_app (X : Cat.{0, u}) :
adj.unit.app X = unitApp X := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | adj_unit_app | null |
adj_counit_app (A : Type u) :
adj.counit.app A = counitApp A := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | adj_counit_app | null |
left_triangle_components (C : Type u) [Category.{v} C] :
(counitApp C).comp (unitApp C).obj = id :=
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | left_triangle_components | Left triangle equality of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat`,
as a universe polymorphic statement. |
right_triangle_components (X : Type u) :
unitApp (Codiscrete X) ⋙ functorOfFun (counitApp X) = 𝟭 (Codiscrete X) :=
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Pi.Basic",
"Mathlib.Data.ULift",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Adjunction.Basic"
] | Mathlib/CategoryTheory/CodiscreteCategory.lean | right_triangle_components | Right triangle equality of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat`,
stated using a composition of functors. |
nonempty_sections_of_finite_cofiltered_system.init {J : Type u} [SmallCategory J]
[IsCofilteredOrEmpty J] (F : J ⥤ Type u) [hf : ∀ j, Finite (F.obj j)]
[hne : ∀ j, Nonempty (F.obj j)] : F.sections.Nonempty := by
let F' : J ⥤ TopCat := F ⋙ TopCat.discrete
haveI : ∀ j, DiscreteTopology (F'.obj j) := fun _ => ... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | nonempty_sections_of_finite_cofiltered_system.init | This bootstraps `nonempty_sections_of_finite_inverse_system`. In this version,
the `F` functor is between categories of the same universe, and it is an easy
corollary to `TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system`. |
nonempty_sections_of_finite_cofiltered_system {J : Type u} [Category.{w} J]
[IsCofilteredOrEmpty J] (F : J ⥤ Type v) [∀ j : J, Finite (F.obj j)]
[∀ j : J, Nonempty (F.obj j)] : F.sections.Nonempty := by
let J' : Type max w v u := AsSmall.{max w v} J
let down : J' ⥤ J := AsSmall.down
let F' : J' ⥤ Type max... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | nonempty_sections_of_finite_cofiltered_system | The cofiltered limit of nonempty finite types is nonempty.
See `nonempty_sections_of_finite_inverse_system` for a specialization to inverse limits. |
nonempty_sections_of_finite_inverse_system {J : Type u} [Preorder J] [IsDirected J (· ≤ ·)]
(F : Jᵒᵖ ⥤ Type v) [∀ j : Jᵒᵖ, Finite (F.obj j)] [∀ j : Jᵒᵖ, Nonempty (F.obj j)] :
F.sections.Nonempty := nonempty_sections_of_finite_cofiltered_system F | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | nonempty_sections_of_finite_inverse_system | The inverse limit of nonempty finite types is nonempty.
See `nonempty_sections_of_finite_cofiltered_system` for a generalization to cofiltered limits.
That version applies in almost all cases, and the only difference is that this version
allows `J` to be empty.
This may be regarded as a generalization of Kőnig's lemm... |
eventualRange (j : J) :=
⋂ (i) (f : i ⟶ j), range (F.map f) | def | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eventualRange | The eventual range of the functor `F : J ⥤ Type v` at index `j : J` is the intersection
of the ranges of all maps `F.map f` with `i : J` and `f : i ⟶ j`. |
mem_eventualRange_iff {x : F.obj j} :
x ∈ F.eventualRange j ↔ ∀ ⦃i⦄ (f : i ⟶ j), x ∈ range (F.map f) :=
mem_iInter₂ | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | mem_eventualRange_iff | null |
IsMittagLeffler : Prop :=
∀ j : J, ∃ (i : _) (f : i ⟶ j), ∀ ⦃k⦄ (g : k ⟶ j), range (F.map f) ⊆ range (F.map g) | def | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | IsMittagLeffler | The functor `F : J ⥤ Type v` satisfies the Mittag-Leffler condition if for all `j : J`,
there exists some `i : J` and `f : i ⟶ j` such that for all `k : J` and `g : k ⟶ j`, the range
of `F.map f` is contained in that of `F.map g`;
in other words (see `isMittagLeffler_iff_eventualRange`), the eventual range at `j` is at... |
isMittagLeffler_iff_eventualRange :
F.IsMittagLeffler ↔ ∀ j : J, ∃ (i : _) (f : i ⟶ j), F.eventualRange j = range (F.map f) :=
forall_congr' fun _ =>
exists₂_congr fun _ _ =>
⟨fun h => (iInter₂_subset _ _).antisymm <| subset_iInter₂ h, fun h => h ▸ iInter₂_subset⟩ | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | isMittagLeffler_iff_eventualRange | null |
IsMittagLeffler.subset_image_eventualRange (h : F.IsMittagLeffler) (f : j ⟶ i) :
F.eventualRange i ⊆ F.map f '' F.eventualRange j := by
obtain ⟨k, g, hg⟩ := F.isMittagLeffler_iff_eventualRange.1 h j
rw [hg]; intro x hx
obtain ⟨x, rfl⟩ := F.mem_eventualRange_iff.1 hx (g ≫ f)
exact ⟨_, ⟨x, rfl⟩, by rw [map_co... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | IsMittagLeffler.subset_image_eventualRange | null |
eventualRange_eq_range_precomp (f : i ⟶ j) (g : j ⟶ k)
(h : F.eventualRange k = range (F.map g)) : F.eventualRange k = range (F.map <| f ≫ g) := by
apply subset_antisymm
· apply iInter₂_subset
· rw [h, F.map_comp]
apply range_comp_subset_range | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eventualRange_eq_range_precomp | null |
isMittagLeffler_of_surjective (h : ∀ ⦃i j : J⦄ (f : i ⟶ j), (F.map f).Surjective) :
F.IsMittagLeffler :=
fun j => ⟨j, 𝟙 j, fun k g => by rw [map_id, types_id, range_id, (h g).range_eq]⟩ | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | isMittagLeffler_of_surjective | null |
@[simps]
toPreimages : J ⥤ Type v where
obj j := ⋂ f : j ⟶ i, F.map f ⁻¹' s
map g := MapsTo.restrict (F.map g) _ _ fun x h => by
rw [mem_iInter] at h ⊢
intro f
rw [← mem_preimage, preimage_preimage, mem_preimage]
convert h (g ≫ f); rw [F.map_comp]; rfl
map_id j := by
simp +unfoldPartialApp onl... | def | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toPreimages | The subfunctor of `F` obtained by restricting to the preimages of a set `s ∈ F.obj i`. |
toPreimages_finite [∀ j, Finite (F.obj j)] : ∀ j, Finite ((F.toPreimages s).obj j) :=
fun _ => Subtype.finite
variable [IsCofilteredOrEmpty J] | instance | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toPreimages_finite | null |
eventualRange_mapsTo (f : j ⟶ i) :
(F.eventualRange j).MapsTo (F.map f) (F.eventualRange i) := fun x hx => by
rw [mem_eventualRange_iff] at hx ⊢
intro k f'
obtain ⟨l, g, g', he⟩ := cospan f f'
obtain ⟨x, rfl⟩ := hx g
rw [← map_comp_apply, he, F.map_comp]
exact ⟨_, rfl⟩ | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eventualRange_mapsTo | null |
IsMittagLeffler.eq_image_eventualRange (h : F.IsMittagLeffler) (f : j ⟶ i) :
F.eventualRange i = F.map f '' F.eventualRange j :=
(h.subset_image_eventualRange F f).antisymm <| mapsTo_iff_image_subset.1
(F.eventualRange_mapsTo f) | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | IsMittagLeffler.eq_image_eventualRange | null |
eventualRange_eq_iff {f : i ⟶ j} :
F.eventualRange j = range (F.map f) ↔
∀ ⦃k⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map <| g ≫ f) := by
rw [subset_antisymm_iff, eventualRange, and_iff_right (iInter₂_subset _ _), subset_iInter₂_iff]
refine ⟨fun h k g => h _ _, fun h j' f' => ?_⟩
obtain ⟨k, g, g', he⟩ ... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eventualRange_eq_iff | null |
isMittagLeffler_iff_subset_range_comp : F.IsMittagLeffler ↔ ∀ j : J, ∃ (i : _) (f : i ⟶ j),
∀ ⦃k⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map <| g ≫ f) := by
simp_rw [isMittagLeffler_iff_eventualRange, eventualRange_eq_iff] | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | isMittagLeffler_iff_subset_range_comp | null |
IsMittagLeffler.toPreimages (h : F.IsMittagLeffler) : (F.toPreimages s).IsMittagLeffler :=
(isMittagLeffler_iff_subset_range_comp _).2 fun j => by
obtain ⟨j₁, g₁, f₁, -⟩ := IsCofilteredOrEmpty.cone_objs i j
obtain ⟨j₂, f₂, h₂⟩ := F.isMittagLeffler_iff_eventualRange.1 h j₁
refine ⟨j₂, f₂ ≫ f₁, fun j₃ f₃ =>... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | IsMittagLeffler.toPreimages | null |
isMittagLeffler_of_exists_finite_range
(h : ∀ j : J, ∃ (i : _) (f : i ⟶ j), (range <| F.map f).Finite) : F.IsMittagLeffler := by
intro j
obtain ⟨i, hi, hf⟩ := h j
obtain ⟨m, ⟨i, f, hm⟩, hmin⟩ := Finset.wellFoundedLT.wf.has_min
{ s : Finset (F.obj j) | ∃ (i : _) (f : i ⟶ j), ↑s = range (F.map f) }
⟨_, ... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | isMittagLeffler_of_exists_finite_range | null |
@[simps]
toEventualRanges : J ⥤ Type v where
obj j := F.eventualRange j
map f := (F.eventualRange_mapsTo f).restrict _ _ _
map_id i := by
simp +unfoldPartialApp only [MapsTo.restrict, Subtype.map, F.map_id]
ext
rfl
map_comp _ _ := by
simp +unfoldPartialApp only [MapsTo.restrict, Subtype.map, F.m... | def | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toEventualRanges | The subfunctor of `F` obtained by restricting to the eventual range at each index. |
toEventualRanges_finite [∀ j, Finite (F.obj j)] : ∀ j, Finite (F.toEventualRanges.obj j) :=
fun _ => Subtype.finite | instance | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toEventualRanges_finite | null |
toEventualRangesSectionsEquiv : F.toEventualRanges.sections ≃ F.sections where
toFun s := ⟨_, fun f => Subtype.coe_inj.2 <| s.prop f⟩
invFun s :=
⟨fun _ => ⟨_, mem_iInter₂.2 fun _ f => ⟨_, s.prop f⟩⟩, fun f => Subtype.ext <| s.prop f⟩ | def | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toEventualRangesSectionsEquiv | The sections of the functor `F : J ⥤ Type v` are in bijection with the sections of
`F.toEventualRanges`. |
surjective_toEventualRanges (h : F.IsMittagLeffler) ⦃i j⦄ (f : i ⟶ j) :
(F.toEventualRanges.map f).Surjective := fun ⟨x, hx⟩ => by
obtain ⟨y, hy, rfl⟩ := h.subset_image_eventualRange F f hx
exact ⟨⟨y, hy⟩, rfl⟩ | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | surjective_toEventualRanges | If `F` satisfies the Mittag-Leffler condition, its restriction to eventual ranges is a
surjective functor. |
toEventualRanges_nonempty (h : F.IsMittagLeffler) [∀ j : J, Nonempty (F.obj j)] (j : J) :
Nonempty (F.toEventualRanges.obj j) := by
let ⟨i, f, h⟩ := F.isMittagLeffler_iff_eventualRange.1 h j
rw [toEventualRanges_obj, h]
infer_instance | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toEventualRanges_nonempty | If `F` is nonempty at each index and Mittag-Leffler, then so is `F.toEventualRanges`. |
thin_diagram_of_surjective (Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), (F.map f).Surjective) {i j}
(f g : i ⟶ j) : F.map f = F.map g :=
let ⟨k, φ, hφ⟩ := IsCofilteredOrEmpty.cone_maps f g
(Fsur φ).injective_comp_right <| by simp_rw [← types_comp, ← F.map_comp, hφ] | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | thin_diagram_of_surjective | If `F` has all arrows surjective, then it "factors through a poset". |
toPreimages_nonempty_of_surjective [hFn : ∀ j : J, Nonempty (F.obj j)]
(Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), (F.map f).Surjective) (hs : s.Nonempty) (j) :
Nonempty ((F.toPreimages s).obj j) := by
simp only [toPreimages_obj, nonempty_coe_sort, nonempty_iInter, mem_preimage]
obtain h | ⟨⟨ji⟩⟩ := isEmpty_or_nonempt... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | toPreimages_nonempty_of_surjective | null |
eval_section_injective_of_eventually_injective {j}
(Finj : ∀ (i) (f : i ⟶ j), (F.map f).Injective) (i) (f : i ⟶ j) :
(fun s : F.sections => s.val j).Injective := by
refine fun s₀ s₁ h => Subtype.ext <| funext fun k => ?_
obtain ⟨m, mi, mk, _⟩ := IsCofilteredOrEmpty.cone_objs i k
dsimp at h
rw [← s₀.prop... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eval_section_injective_of_eventually_injective | null |
eval_section_surjective_of_surjective (i : J) :
(fun s : F.sections => s.val i).Surjective := fun x => by
let s : Set (F.obj i) := {x}
haveI := F.toPreimages_nonempty_of_surjective s Fsur (singleton_nonempty x)
obtain ⟨sec, h⟩ := nonempty_sections_of_finite_cofiltered_system (F.toPreimages s)
refine ⟨⟨fun j... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eval_section_surjective_of_surjective | null |
eventually_injective [Nonempty J] [Finite F.sections] :
∃ j, ∀ (i) (f : i ⟶ j), (F.map f).Injective := by
haveI : ∀ j, Fintype (F.obj j) := fun j => Fintype.ofFinite (F.obj j)
haveI : Fintype F.sections := Fintype.ofFinite F.sections
have card_le : ∀ j, Fintype.card (F.obj j) ≤ Fintype.card F.sections :=
... | theorem | CategoryTheory | [
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] | Mathlib/CategoryTheory/CofilteredSystem.lean | eventually_injective | null |
CommSq {W X Y Z : C} (f : W ⟶ X) (g : W ⟶ Y) (h : X ⟶ Z) (i : Y ⟶ Z) : Prop where
/-- The square commutes. -/
w : f ≫ h = g ≫ i := by cat_disch
attribute [reassoc] CommSq.w | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | CommSq | The proposition that a square
```
W ---f---> X
| |
g h
| |
v v
Y ---i---> Z
```
is a commuting square. |
flip (p : CommSq f g h i) : CommSq g f i h :=
⟨p.w.symm⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | flip | null |
of_arrow {f g : Arrow C} (h : f ⟶ g) : CommSq f.hom h.left h.right g.hom :=
⟨h.w.symm⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | of_arrow | null |
op (p : CommSq f g h i) : CommSq i.op h.op g.op f.op :=
⟨by simp only [← op_comp, p.w]⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | op | The commutative square in the opposite category associated to a commutative square. |
unop {W X Y Z : Cᵒᵖ} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (p : CommSq f g h i) :
CommSq i.unop h.unop g.unop f.unop :=
⟨by simp only [← unop_comp, p.w]⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | unop | The commutative square associated to a commutative square in the opposite category. |
vert_inv {g : W ≅ Y} {h : X ≅ Z} (p : CommSq f g.hom h.hom i) :
CommSq i g.inv h.inv f :=
⟨by rw [Iso.comp_inv_eq, Category.assoc, Iso.eq_inv_comp, p.w]⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | vert_inv | null |
horiz_inv {f : W ≅ X} {i : Y ≅ Z} (p : CommSq f.hom g h i.hom) :
CommSq f.inv h g i.inv :=
flip (vert_inv (flip p)) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | horiz_inv | null |
horiz_comp {W X X' Y Z Z' : C} {f : W ⟶ X} {f' : X ⟶ X'} {g : W ⟶ Y} {h : X ⟶ Z}
{h' : X' ⟶ Z'} {i : Y ⟶ Z} {i' : Z ⟶ Z'} (hsq₁ : CommSq f g h i) (hsq₂ : CommSq f' h h' i') :
CommSq (f ≫ f') g h' (i ≫ i') :=
⟨by rw [← Category.assoc, Category.assoc, ← hsq₁.w, hsq₂.w, Category.assoc]⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | horiz_comp | The horizontal composition of two commutative squares as below is a commutative square.
```
W ---f---> X ---f'--> X'
| | |
g h h'
| | |
v v v
Y ---i---> Z ---i'--> Z'
``` |
vert_comp {W X Y Y' Z Z' : C} {f : W ⟶ X} {g : W ⟶ Y} {g' : Y ⟶ Y'} {h : X ⟶ Z}
{h' : Z ⟶ Z'} {i : Y ⟶ Z} {i' : Y' ⟶ Z'} (hsq₁ : CommSq f g h i) (hsq₂ : CommSq i g' h' i') :
CommSq f (g ≫ g') (h ≫ h') i' :=
flip (horiz_comp (flip hsq₁) (flip hsq₂)) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | vert_comp | The vertical composition of two commutative squares as below is a commutative square.
```
W ---f---> X
| |
g h
| |
v v
Y ---i---> Z
| |
g' h'
| |
v v
Y'---i'--> Z'
``` |
eq_of_mono {f : W ⟶ X} {g : W ⟶ X} {i : X ⟶ Y} [Mono i] (sq : CommSq f g i i) : f = g :=
(cancel_mono i).1 sq.w | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | eq_of_mono | null |
eq_of_epi {f : W ⟶ X} {h : X ⟶ Y} {i : X ⟶ Y} [Epi f] (sq : CommSq f f h i) : h = i :=
(cancel_epi f).1 sq.w | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | eq_of_epi | null |
map_commSq (s : CommSq f g h i) : CommSq (F.map f) (F.map g) (F.map h) (F.map i) :=
⟨by simpa using congr_arg (fun k : W ⟶ Z => F.map k) s.w⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | map_commSq | null |
@[ext]
LiftStruct (sq : CommSq f i p g) where
/-- The lift. -/
l : B ⟶ X
/-- The upper left triangle commutes. -/
fac_left : i ≫ l = f := by cat_disch
/-- The lower right triangle commutes. -/
fac_right : l ≫ p = g := by cat_disch | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | LiftStruct | Now we consider a square:
```
A ---f---> X
| |
i p
| |
v v
B ---g---> Y
```
The datum of a lift in a commutative square, i.e. an up-right-diagonal
morphism which makes both triangles commute. |
@[simps]
op {sq : CommSq f i p g} (l : LiftStruct sq) : LiftStruct sq.op where
l := l.l.op
fac_left := by rw [← op_comp, l.fac_right]
fac_right := by rw [← op_comp, l.fac_left] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | op | A `LiftStruct` for a commutative square gives a `LiftStruct` for the
corresponding square in the opposite category. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.