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
ext1
· ext b
exact F_map_eq.symm.trans (F.map_id b)
rfl
map_mul' := by
intro g h
ext b
· exact F_map_eq.symm.trans (F.map_comp (homOfPair (g⁻¹ • b) h) (homOfPair b g))
rfl } | 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_as_mul, sane]
rfl | 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 i' αY αZ i)
(_ : CommSq f' g' h' i'), IsPushout f' g' h' i' ↔ IsPullback h' αX αZ h ∧ IsPullback i' αY αZ i | 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 _) (α.app _) fα (by convert hα WalkingSpan.Hom.fst)
(by convert hα WalkingSpan.Hom.snd) ?_ ?_ ?_).trans ?_)
· have : F'.map WalkingSpan.Hom.fst ≫ c'.ι.app WalkingSpan.left =
F'.map WalkingSpan.Hom.snd ≫ c'.ι.app WalkingSpan.right := by
simp only [Cocone.w]
rw [(IsColimit.equivOfNatIsoOfIso (diagramIsoSpan F') c' (PushoutCocone.mk _ _ this)
_).nonempty_congr]
· exact ⟨fun h => ⟨⟨this⟩, h⟩, fun h => h.2⟩
· refine Cocones.ext (Iso.refl c'.pt) ?_
rintro (_ | _ | _) <;> dsimp <;>
simp only [c'.w, Category.id_comp, Category.comp_id]
· exact ⟨NatTrans.congr_app eα.symm _⟩
· exact ⟨NatTrans.congr_app eα.symm _⟩
· exact ⟨by simp⟩
constructor
· rintro ⟨h₁, h₂⟩ (_ | _ | _)
· rw [← c'.w WalkingSpan.Hom.fst]; exact (hα WalkingSpan.Hom.fst).paste_horiz h₁
exacts [h₁, h₂]
· intro h; exact ⟨h _, h _⟩
· introv H W' hf hg hh hi w
refine
Iff.trans ?_ ((H w.cocone ⟨by rintro (_ | _ | _); exacts [αW, αX, αY], ?_⟩ αZ ?_ ?_).trans ?_)
rotate_left
· rintro i _ (_ | _ | _)
· dsimp; simp only [Functor.map_id, Category.comp_id, Category.id_comp]
exacts [hf.w, hg.w]
· ext (_ | _ | _)
· dsimp
rw [PushoutCocone.condition_zero, Category.assoc]
erw [hh.w]
rw [hf.w_assoc]
exacts [hh.w.symm, hi.w.symm]
· rintro i _ (_ | _ | _)
· dsimp; simp_rw [Functor.map_id]
exact IsPullback.of_horiz_isIso ⟨by rw [Category.comp_id, Category.id_comp]⟩
exacts [hf, hg]
· constructor
· intro h; exact ⟨h WalkingCospan.left, h WalkingCospan.right⟩
· rintro ⟨h₁, h₂⟩ (_ | _ | _)
· dsimp; rw [PushoutCocone.condition_zero]; exact hf.paste_horiz h₁
exacts [h₁, h₂]
· exact ⟨fun h => h.2, fun h => ⟨w, h⟩⟩ | 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.isColimitAux' _ ?_⟩⟩
intro s
dsimp
refine ⟨h.desc (BinaryCofan.mk (c.inr ≫ s.inr) s.inl), h.fac _ ⟨WalkingPair.right⟩, ?_, ?_⟩
· apply BinaryCofan.IsColimit.hom_ext hc
· rw [← H.w_assoc]; erw [h.fac _ ⟨WalkingPair.right⟩]; exact s.condition
· rw [← Category.assoc]; exact h.fac _ ⟨WalkingPair.left⟩
· intro m e₁ e₂
apply BinaryCofan.IsColimit.hom_ext h
· dsimp
rw [Category.assoc, e₂, eq_comm]; exact h.fac _ ⟨WalkingPair.left⟩
· refine e₁.trans (Eq.symm ?_); exact h.fac _ _
· refine fun H => ⟨?_⟩
fapply Limits.BinaryCofan.isColimitMk
· exact fun s => H.isColimit.desc (PushoutCocone.mk s.inr _ <|
(hc.fac (BinaryCofan.mk (f ≫ s.inr) s.inl) ⟨WalkingPair.left⟩).symm)
· intro s
rw [Category.assoc]
erw [H.isColimit.fac _ WalkingSpan.right]
erw [hc.fac]
rfl
· intro s; exact H.isColimit.fac _ WalkingSpan.left
· intro s m e₁ e₂
apply PushoutCocone.IsColimit.hom_ext H.isColimit
· symm; exact (H.isColimit.fac _ WalkingSpan.left).trans e₂.symm
· rw [H.isColimit.fac _ WalkingSpan.right]
apply BinaryCofan.IsColimit.hom_ext hc
· erw [hc.fac]
erw [← H.w_assoc]
rw [e₂]
rfl
· refine ((Category.assoc _ _ _).symm.trans e₁).trans ?_; symm; exact hc.fac _ _ | 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₂⟩ := ((BinaryCofan.isVanKampen_iff _).mp (FinitaryExtensive.vanKampen c hc)
(BinaryCofan.mk _ (pullback.fst _ _)) _ _ _ hg.w.symm pullback.condition.symm).mpr
⟨hg, IsPullback.of_hasPullback αY c.inr⟩
refine (is_coprod_iff_isPushout _ hc₂ w).symm.trans ?_
refine ((BinaryCofan.isVanKampen_iff _).mp (FinitaryExtensive.vanKampen _ hc₁)
(BinaryCofan.mk _ _) (pullback.snd _ _) _ _ ?_ hh.w.symm).trans ?_
· dsimp; rw [← pullback.condition_assoc, Category.assoc, hi.w]
constructor
· rintro ⟨hc₃, hc₄⟩
refine ⟨hc₄, ?_⟩
let Y'' := pullback αZ i
let cmp : Y' ⟶ Y'' := pullback.lift i' αY hi.w
have e₁ : (g' ≫ cmp) ≫ pullback.snd _ _ = αW ≫ c.inl := by
rw [Category.assoc, pullback.lift_snd, hg.w]
have e₂ : (pullback.fst _ _ ≫ cmp : pullback αY c.inr ⟶ _) ≫ pullback.snd _ _ =
pullback.snd _ _ ≫ c.inr := by
rw [Category.assoc, pullback.lift_snd, pullback.condition]
obtain ⟨hc₄⟩ := ((BinaryCofan.isVanKampen_iff _).mp (FinitaryExtensive.vanKampen c hc)
(BinaryCofan.mk _ _) αW _ _ e₁.symm e₂.symm).mpr <| by
constructor
· apply IsPullback.of_right _ e₁ (IsPullback.of_hasPullback _ _)
rw [Category.assoc, pullback.lift_fst, ← H.w, ← w.w]; exact hf.paste_horiz hc₄
· apply IsPullback.of_right _ e₂ (IsPullback.of_hasPullback _ _)
rw [Category.assoc, pullback.lift_fst]; exact hc₃
rw [← Category.id_comp αZ, ← show cmp ≫ pullback.snd _ _ = αY from pullback.lift_snd _ _ _]
apply IsPullback.paste_vert _ (IsPullback.of_hasPullback αZ i)
have : cmp = (hc₂.coconePointUniqueUpToIso hc₄).hom := by
apply BinaryCofan.IsColimit.hom_ext hc₂
exacts [(hc₂.comp_coconePointUniqueUpToIso_hom hc₄ ⟨WalkingPair.left⟩).symm,
(hc₂.comp_coconePointUniqueUpToIso_hom hc₄ ⟨WalkingPair.right⟩).symm]
rw [this]
exact IsPullback.of_vert_isIso ⟨by rw [← this, Category.comp_id, pullback.lift_fst]⟩
· rintro ⟨hc₃, hc₄⟩
exact ⟨(IsPullback.of_hasPullback αY c.inr).paste_horiz hc₄, 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_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.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 simp⟩)).1 | 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} [Mono f]
(H : IsPushout f g h i), H.IsVanKampen
attribute [instance] Adhesive.hasPullback_of_mono_left Adhesive.hasPushout_of_mono_left | 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 IsVanKampenColimit.of_iso ?_ (PushoutCocone.isoMk _).symm
refine (IsPushout.isVanKampen_iff (H.map ((evaluation _ _).obj x))).mp ?_
apply Adhesive.van_kampen | 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]
[PreservesColimitsOfShape WalkingSpan F]
[ReflectsColimitsOfShape WalkingSpan F] :
Adhesive C := by
apply Adhesive.mk (hasPullback_of_mono_left := H₁) (hasPushout_of_mono_left := H₂)
intro W X Y Z f g h i hf H
rw [IsPushout.isVanKampen_iff]
refine IsVanKampenColimit.of_mapCocone F ?_
refine (IsVanKampenColimit.precompose_isIso_iff (diagramIsoSpan _).inv).mp ?_
refine IsVanKampenColimit.of_iso ?_ (PushoutCocone.isoMk _).symm
refine (IsPushout.isVanKampen_iff (H.map F)).mp ?_
apply Adhesive.van_kampen | 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 :=
reflectsLimitsOfShape_of_reflectsIsomorphisms
haveI : ReflectsColimitsOfShape WalkingSpan F :=
reflectsColimitsOfShape_of_reflectsIsomorphisms
exact adhesive_of_preserves_and_reflects F | 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.leftAdjoint_preservesColimits
have := adj.rightAdjoint_preservesLimits
apply Adhesive.mk (hasPushout_of_mono_left := H₂)
intro W X Y Z f g h i _ H
have := Adhesive.van_kampen (IsPushout.of_hasPushout (Gr.map f) (Gr.map g))
rw [IsPushout.isVanKampen_iff] at this ⊢
refine (IsVanKampenColimit.precompose_isIso_iff
(Functor.isoWhiskerLeft _ (asIso adj.counit) ≪≫ Functor.rightUnitor _).hom).mp ?_
refine ((this.precompose_isIso (spanCompIso _ _ _).hom).map_reflective adj).of_iso
(IsColimit.uniqueUpToIso ?_ ?_)
· exact isColimitOfPreserves Gl ((IsColimit.precomposeHomEquiv _ _).symm <| pushoutIsPushout _ _)
· exact (IsColimit.precomposeHomEquiv _ _).symm H.isColimit | 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 ≪≫ isoWhiskerRight (iso T₁ V₁ V₂ B₁) B₂ ≪≫
associator _ _ _ | 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 _ _ _ ≪≫ isoWhiskerLeft L₁ (iso H₂ L₂ R₂ H₃) ≪≫
(associator _ _ _).symm | 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 _ _ _).symm ≪≫
isoWhiskerRight T.counitIso _ ≪≫ leftUnitor _ | 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_functor]
rw [hInv_iso_inv_app]
dsimp
simp only [Functor.comp_obj, assoc, ← Functor.map_comp, Iso.inv_hom_id_app,
Equivalence.counitInv_app_functor, Functor.map_id]
simp only [Functor.map_comp, Equivalence.fun_inv_map, assoc,
Equivalence.counitInv_functor_comp, comp_id, Iso.inv_hom_id_app_assoc] | 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 _ _ _ ≪≫ isoWhiskerLeft _ (associator _ _ _) ≪≫
(associator _ _ _ ).symm ≪≫ isoWhiskerLeft _ R.unitIso.symm ≪≫
rightUnitor _ | 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, Equivalence.fun_inv_map, Functor.comp_obj,
Functor.id_obj, assoc, Iso.inv_hom_id_app_assoc, Iso.inv_hom_id_app, comp_id]
rw [← B.map_comp, L.counit_app_functor, ← L.functor.map_comp, ← NatTrans.comp_app,
Iso.inv_hom_id, NatTrans.id_app, L.functor.map_id]
simp only [Functor.comp_obj]
rw [B.map_id]
rw [comp_id, R.counit_app_functor,
← R.functor.map_comp_assoc, ← R.functor.map_comp_assoc, assoc, ← NatTrans.comp_app,
Iso.hom_inv_id, NatTrans.id_app]
simp | 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 the category. -/
as : α
@[simp]
theorem Codiscrete.mk_as {α : Type u} (X : Codiscrete α) : Codiscrete.mk X.as = X := rfl
/-- `Codiscrete α` is equivalent to the original type `α`. |
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 _ => ⟨rfl⟩
haveI : ∀ j, Finite (F'.obj j) := hf
haveI : ∀ j, Nonempty (F'.obj j) := hne
obtain ⟨⟨u, hu⟩⟩ := TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system.{u} F'
exact ⟨u, hu⟩ | 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 u v w := down ⋙ F ⋙ uliftFunctor.{max u w, v}
haveI : ∀ i, Nonempty (F'.obj i) := fun i => ⟨⟨Classical.arbitrary (F.obj (down.obj i))⟩⟩
haveI : ∀ i, Finite (F'.obj i) := fun i => Finite.of_equiv (F.obj (down.obj i)) Equiv.ulift.symm
cases isEmpty_or_nonempty J
· fconstructor <;> apply isEmptyElim
haveI : IsCofiltered J := ⟨⟩
obtain ⟨u, hu⟩ := nonempty_sections_of_finite_cofiltered_system.init F'
use fun j => (u ⟨j⟩).down
intro j j' f
have h := @hu (⟨j⟩ : J') (⟨j'⟩ : J') (ULift.up f)
simp only [F', down, AsSmall.down, Functor.comp_map, uliftFunctor_map] at h
simp_rw [← h] | 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 lemma.
To specialize: given a locally finite connected graph, take `Jᵒᵖ` to be `ℕ` and
`F j` to be length-`j` paths that start from an arbitrary fixed vertex.
Elements of `F.sections` can be read off as infinite rays in the graph. |
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 attained
by some `f : i ⟶ j`. |
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_comp_apply]⟩ | 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 only [MapsTo.restrict, Subtype.map, F.map_id]
ext
rfl
map_comp f g := by
simp +unfoldPartialApp only [MapsTo.restrict, Subtype.map, F.map_comp]
rfl | 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⟩ := cospan f f'
refine (h g).trans ?_
rw [he, F.map_comp]
apply range_comp_subset_range | 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₃ => ?_⟩
rintro _ ⟨⟨x, hx⟩, rfl⟩
have : F.map f₂ x ∈ F.eventualRange j₁ := by
rw [h₂]
exact ⟨_, rfl⟩
obtain ⟨y, hy, h₃⟩ := h.subset_image_eventualRange F (f₃ ≫ f₂) this
refine ⟨⟨y, mem_iInter.2 fun g₂ => ?_⟩, Subtype.ext ?_⟩
· obtain ⟨j₄, f₄, h₄⟩ := IsCofilteredOrEmpty.cone_maps g₂ ((f₃ ≫ f₂) ≫ g₁)
obtain ⟨y, rfl⟩ := F.mem_eventualRange_iff.1 hy f₄
rw [← map_comp_apply] at h₃
rw [mem_preimage, ← map_comp_apply, h₄, ← Category.assoc, map_comp_apply, h₃,
← map_comp_apply]
apply mem_iInter.1 hx
· simp_rw [toPreimages_map, MapsTo.val_restrict_apply]
rw [← Category.assoc, map_comp_apply, h₃, map_comp_apply] | 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) }
⟨_, i, hi, hf.coe_toFinset⟩
refine ⟨i, f, fun k g =>
(directedOn_range.mp <| F.ranges_directed j).is_bot_of_is_min ⟨⟨i, f⟩, rfl⟩ ?_ _ ⟨⟨k, g⟩, rfl⟩⟩
rintro _ ⟨⟨k', g'⟩, rfl⟩ hl
refine (eq_of_le_of_not_lt hl ?_).ge
have := hmin _ ⟨k', g', (m.finite_toSet.subset <| hm.substr hl).coe_toFinset⟩
rwa [Finset.lt_iff_ssubset, ← Finset.coe_ssubset, Set.Finite.coe_toFinset, hm] at this | 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.map_comp]
rfl | 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_nonempty (j ⟶ i)
· exact ⟨(hFn j).some, fun ji => h.elim ji⟩
· obtain ⟨y, ys⟩ := hs
obtain ⟨x, rfl⟩ := Fsur ji y
exact ⟨x, fun ji' => (F.thin_diagram_of_surjective Fsur ji' ji).symm ▸ ys⟩ | 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 (mi ≫ f), ← s₁.prop (mi ≫ f)] at h
rw [← s₀.prop mk, ← s₁.prop mk]
exact congr_arg _ (Finj m (mi ≫ f) h) | 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 => (sec j).val, fun jk => by simpa [Subtype.ext_iff] using h jk⟩, ?_⟩
· have := (sec i).prop
simp only [mem_iInter, mem_preimage] at this
have := this (𝟙 i)
rwa [map_id_apply] at this | 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 :=
fun j => Fintype.card_le_of_surjective _ (F.eval_section_surjective_of_surjective Fsur j)
let fn j := Fintype.card F.sections - Fintype.card (F.obj j)
refine ⟨fn.argmin,
fun i f => ((Fintype.bijective_iff_surjective_and_card _).2
⟨Fsur f, le_antisymm ?_ (Fintype.card_le_of_surjective _ <| Fsur f)⟩).1⟩
rw [← Nat.sub_le_sub_iff_left (card_le i)]
apply fn.argmin_le | 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.