| Safe Haskell | None |
|---|---|
| Language | GHC2024 |
Proarrow.Category.Instance.Sub
Description
Full subcategories: the kind restricts a category to the objects satisfying
the predicate SUBCAT obob, with Sub wrapping the underlying arrows unchanged. This is how object
constraints beyond a kind's own Ob are imposed (e.g. the category of representable profunctors
in Proarrow.Category.Instance.Rep).
Synopsis
- data SUBCAT (ob :: OB k) = SUB k
- data Sub (p :: CAT k) (a :: SUBCAT ob) (b :: SUBCAT ob) where
- class c (UN ('SUB :: k -> SUBCAT ob) a) => On (c :: k -> Constraint) (ob :: OB k) (a :: SUBCAT ob)
- class ob (a ** b) => IsObMult (ob :: OB k) (a :: k) (b :: k)
- class ob (a && b) => IsObProd (ob :: OB k) (a :: k) (b :: k)
- class (Monoidal k, ob (Unit :: k), forall (a :: k) (b :: k). (ob a, ob b) => IsObMult ob a b) => SubMonoidal (ob :: OB k)
- data family Forget :: forall (ob :: OB k) -> SUBCAT ob +-> k
- type FUN j k = SUBCAT (Representable :: (j +-> k) -> Constraint)
- (!) :: forall {j} {k} (f :: FUN j k) (g :: FUN j k) (a :: j) (b :: j). (f ~> g) -> (a ~> b) -> (UN ('SUB :: (j +-> k) -> SUBCAT (Representable :: (j +-> k) -> Constraint)) f % a) ~> (UN ('SUB :: (j +-> k) -> SUBCAT (Representable :: (j +-> k) -> Constraint)) g % b)
- type ARROW k = FUN BOOL k
- commSquare :: forall {k} (f :: BOOL +-> k) (g :: BOOL +-> k) (a :: k) (b :: k) (c :: k) (d :: k). (a ~ (f % 'FLS), b ~ (f % 'TRU), c ~ (g % 'FLS), d ~ (g % 'TRU)) => (('SUB f :: SUBCAT (Representable :: (BOOL +-> k) -> Constraint)) ~> ('SUB g :: SUBCAT (Representable :: (BOOL +-> k) -> Constraint))) -> (a ~> b, b ~> d, a ~> c, c ~> d)
Documentation
data SUBCAT (ob :: OB k) Source Github #
Constructors
| SUB k |
Instances
| HasCofree ob => Representable (Corep (Forget ob) :: SUBCAT ob -> k -> Type) Source Github # | By creating the right adjoint to the forgetful functor, we obtain the forgetful-cofree adjunction. | ||||
Defined in Proarrow.Profunctor.Cofree Methods index :: forall (a :: SUBCAT ob) (b :: k). Corep (Forget ob) a b -> a ~> (Corep (Forget ob) % b) Source Github # tabulate :: forall (b :: k) (a :: SUBCAT ob). Ob b => (a ~> (Corep (Forget ob) % b)) -> Corep (Forget ob) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep (Forget ob) % a) ~> (Corep (Forget ob) % b) Source Github # repUniv :: forall (a :: k). Ob a => Corep (Forget ob) (Corep (Forget ob) % a) a Source Github # | |||||
| (CategoryOf j, CategoryOf k, HasTerminalObject (SUBCAT ob), HasBinaryProducts (SUBCAT ob), forall (p :: j +-> k) (q :: j +-> k). (ob p, ob q) => IsObProd ob p q, forall (p :: j +-> k) (q :: j +-> k). (ob p, ob q) => IsObExp ob p q) => Closed (PROD (SUBCAT ob)) Source Github # | And then the subcategory is closed, with the ambient exponential and nothing of its own,
just as its products are the ambient ones. | ||||
Defined in Proarrow.Profunctor.Instance.Exponential Methods withObExp :: forall (a :: PROD (SUBCAT ob)) (b :: PROD (SUBCAT ob)) r. (Ob a, Ob b) => (Ob (a ~~> b) => r) -> r Source Github # curry :: forall (a :: PROD (SUBCAT ob)) (b :: PROD (SUBCAT ob)) (c :: PROD (SUBCAT ob)). (Ob a, Ob b) => ((a ** b) ~> c) -> a ~> (b ~~> c) Source Github # apply :: forall (a :: PROD (SUBCAT ob)) (b :: PROD (SUBCAT ob)). (Ob a, Ob b) => ((a ~~> b) ** a) ~> b Source Github # (^^^) :: forall (a :: PROD (SUBCAT ob)) (b :: PROD (SUBCAT ob)) (x :: PROD (SUBCAT ob)) (y :: PROD (SUBCAT ob)). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github # | |||||
| (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => ElementaryTopos (PROD (SHEAVES t j k)) Source Github # | The topos of sheaves. Finite limits and colimits, cartesian closed, a subobject classifier, and image factorization, all defined above and none of them postulated. The exponential needs | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf | |||||
| (FiniteCat j, FiniteCat k) => ElementaryTopos (PROD (FINITARY j k)) Source Github # | Finitary profunctors between finite categories form an elementary topos: finite limits and colimits, cartesian closed, a subobject classifier, and image factorization. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos | |||||
| (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasSubobjectClassifier (PROD (SHEAVES t j k)) Source Github # | The classifier is the closed sieves, and an arrow is classified by | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Associated Types
| |||||
| (FiniteCat j, FiniteCat k) => HasSubobjectClassifier (PROD (FINITARY j k)) Source Github # | The subobject classifier is the profunctor of sieves, and an arrow classifies its graph. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Associated Types
| |||||
| HasBinaryCoproducts (SORTED s) Source Github # | The ports of both, those of the second numbered after those of the first. | ||||
Defined in Proarrow.Category.Instance.OpenHypergraph Methods withObCoprod :: forall (a :: SORTED s) (b :: SORTED s) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github # lft :: forall (a :: SORTED s) (b :: SORTED s). (Ob a, Ob b) => a ~> (a || b) Source Github # rgt :: forall (a :: SORTED s) (b :: SORTED s). (Ob a, Ob b) => b ~> (a || b) Source Github # (|||) :: forall (x :: SORTED s) (a :: SORTED s) (y :: SORTED s). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github # (+++) :: forall (a :: SORTED s) (b :: SORTED s) (x :: SORTED s) (y :: SORTED s). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github # | |||||
| HasInitialObject (SORTED s) Source Github # | No ports. | ||||
Defined in Proarrow.Category.Instance.OpenHypergraph Associated Types
| |||||
| HasPushouts (SORTED s) Source Github # | The pushout of | ||||
Defined in Proarrow.Category.Instance.OpenHypergraph Methods pushout :: forall (o :: SORTED s) (a :: SORTED s) (b :: SORTED s) r. (o ~> a) -> (o ~> b) -> (forall (p :: SORTED s). (a ~> p) -> (b ~> p) -> r) -> r Source Github # factorPushout :: forall (a :: SORTED s) (b :: SORTED s) (p :: SORTED s) (q :: SORTED s). (a ~> p) -> (b ~> p) -> (a ~> q) -> (b ~> q) -> p ~> q Source Github # | |||||
| CategoryOf k => MonoidalAction (RepAction :: k -> (RepSub k, k) -> Type) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.EndoProf Methods unitor :: forall (x :: k). Ob x => Act (RepAction :: k -> (RepSub k, k) -> Type) (Unit :: RepSub k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (RepAction :: k -> (RepSub k, k) -> Type) (Unit :: RepSub k) x Source Github # multiplicator :: forall (a :: RepSub k) (b :: RepSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (RepAction :: k -> (RepSub k, k) -> Type) (a ** b) x ~> Act (RepAction :: k -> (RepSub k, k) -> Type) a (Act (RepAction :: k -> (RepSub k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: RepSub k) (b :: RepSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (RepAction :: k -> (RepSub k, k) -> Type) a (Act (RepAction :: k -> (RepSub k, k) -> Type) b x) ~> Act (RepAction :: k -> (RepSub k, k) -> Type) (a ** b) x Source Github # | |||||
| CategoryOf k => MonoidalAction (TravAction :: k -> (TravSub k, k) -> Type) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.EndoProf Methods unitor :: forall (x :: k). Ob x => Act (TravAction :: k -> (TravSub k, k) -> Type) (Unit :: TravSub k) x ~> x Source Github # unitorInv :: forall (x :: k). Ob x => x ~> Act (TravAction :: k -> (TravSub k, k) -> Type) (Unit :: TravSub k) x Source Github # multiplicator :: forall (a :: TravSub k) (b :: TravSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (TravAction :: k -> (TravSub k, k) -> Type) (a ** b) x ~> Act (TravAction :: k -> (TravSub k, k) -> Type) a (Act (TravAction :: k -> (TravSub k, k) -> Type) b x) Source Github # multiplicatorInv :: forall (a :: TravSub k) (b :: TravSub k) (x :: k). (Ob a, Ob b, Ob x) => Act (TravAction :: k -> (TravSub k, k) -> Type) a (Act (TravAction :: k -> (TravSub k, k) -> Type) b x) ~> Act (TravAction :: k -> (TravSub k, k) -> Type) (a ** b) x Source Github # | |||||
| Alternative (Boxes l :: SORTED s -> Type) Source Github # | No boxes, and the boxes of both sides, the nodes of the second numbered after those of the first. | ||||
| Functor (Boxes l :: SORTED s -> Type) Source Github # | |||||
| EnrichedProfunctor v p => EnrichedProfunctor (Clone v) (Op p :: OPPOSITE j -> OPPOSITE k -> Type) Source Github # | |||||
Defined in Proarrow.Category.Enriched Methods withProObj :: forall (a :: OPPOSITE j) (b :: OPPOSITE k) r. (Ob a, Ob b) => (Ob (ProObj (Clone v) (Op p) a b) => r) -> r Source Github # underlying :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). Op p a b -> (Unit :: Clone v) ~> ProObj (Clone v) (Op p) a b Source Github # enriched :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). (Ob a, Ob b) => ((Unit :: Clone v) ~> ProObj (Clone v) (Op p) a b) -> Op p a b Source Github # rmap :: forall (a :: OPPOSITE j) (b :: OPPOSITE k) (c :: OPPOSITE k). (Ob a, Ob b, Ob c) => (HomObj (Clone v) b c ** ProObj (Clone v) (Op p) a b) ~> ProObj (Clone v) (Op p) a c Source Github # lmap :: forall (a :: OPPOSITE j) (b :: OPPOSITE k) (c :: OPPOSITE j). (Ob a, Ob b, Ob c) => (HomObj (Clone v) c a ** ProObj (Clone v) (Op p) a b) ~> ProObj (Clone v) (Op p) c b Source Github # | |||||
| SubMonoidal ob => Monoidal (SUBCAT ob) Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub Associated Types
Methods withOb2 :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github # leftUnitor :: forall (a :: SUBCAT ob). Ob a => ((Unit :: SUBCAT ob) ** a) ~> a Source Github # leftUnitorInv :: forall (a :: SUBCAT ob). Ob a => a ~> ((Unit :: SUBCAT ob) ** a) Source Github # rightUnitor :: forall (a :: SUBCAT ob). Ob a => (a ** (Unit :: SUBCAT ob)) ~> a Source Github # rightUnitorInv :: forall (a :: SUBCAT ob). Ob a => a ~> (a ** (Unit :: SUBCAT ob)) Source Github # associator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (c :: SUBCAT ob). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github # associatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (c :: SUBCAT ob). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github # | |||||
| (SymMonoidal k, SubMonoidal ob) => SymMonoidal (SUBCAT ob) Source Github # | |||||
| (SubMonoidal ob, CopyDiscard k) => CopyDiscard (SUBCAT ob) Source Github # | |||||
| (Enumerable j, Enumerable k) => HasEpiMonoFactorization (FINITARY j k) Source Github # | The image of a natural transformation is the equalizer of its cokernel pair. | ||||
| (CategoryOf j, CategoryOf k) => HasBinaryCoproducts (FINITARY j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Methods withObCoprod :: forall (a :: FINITARY j k) (b :: FINITARY j k) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github # lft :: forall (a :: FINITARY j k) (b :: FINITARY j k). (Ob a, Ob b) => a ~> (a || b) Source Github # rgt :: forall (a :: FINITARY j k) (b :: FINITARY j k). (Ob a, Ob b) => b ~> (a || b) Source Github # (|||) :: forall (x :: FINITARY j k) (a :: FINITARY j k) (y :: FINITARY j k). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github # (+++) :: forall (a :: FINITARY j k) (b :: FINITARY j k) (x :: FINITARY j k) (y :: FINITARY j k). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github # | |||||
| (Enumerable j, Enumerable k) => HasCoequalizers (FINITARY j k) Source Github # | Coequalizers: at each pair of objects, partition the indices by the equivalence relation the two natural transformations generate, and reify the table. Naturality makes the partition a congruence, so the quotient is again a profunctor. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos | |||||
| (CategoryOf j, CategoryOf k) => HasInitialObject (FINITARY j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Associated Types
| |||||
| (Enumerable j, Enumerable k) => HasPushouts (FINITARY j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Methods pushout :: forall (o :: FINITARY j k) (a :: FINITARY j k) (b :: FINITARY j k) r. (o ~> a) -> (o ~> b) -> (forall (p :: FINITARY j k). (a ~> p) -> (b ~> p) -> r) -> r Source Github # factorPushout :: forall (a :: FINITARY j k) (b :: FINITARY j k) (p :: FINITARY j k) (q :: FINITARY j k). (a ~> p) -> (b ~> p) -> (a ~> q) -> (b ~> q) -> p ~> q Source Github # | |||||
| CategoryOf k => CategoryOf (SUBCAT ob) Source Github # | The subcategory with objects with instances of the given constraint | ||||
Defined in Proarrow.Category.Instance.Sub | |||||
| (HasBinaryProducts k, forall (a :: k) (b :: k). (ob a, ob b) => IsObProd ob a b) => HasBinaryProducts (SUBCAT ob) Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub Methods withObProd :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github # fst :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => (a && b) ~> a Source Github # snd :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => (a && b) ~> b Source Github # (&&&) :: forall (a :: SUBCAT ob) (x :: SUBCAT ob) (y :: SUBCAT ob). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github # (***) :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: SUBCAT ob) (y :: SUBCAT ob). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github # | |||||
| (Enumerable j, Enumerable k) => HasEqualizers (FINITARY j k) Source Github # | Equalizers of finitary profunctors between finite categories: at each pair of objects, keep the indices on which the two natural transformations agree, and reify the table. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos | |||||
| (Enumerable j, Enumerable k) => HasPullbacks (FINITARY j k) Source Github # | Pullbacks are equalizers of products, and pushouts coequalizers of coproducts, all of which finitary profunctors have. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Methods pullback :: forall (o :: FINITARY j k) (a :: FINITARY j k) (b :: FINITARY j k) r. (a ~> o) -> (b ~> o) -> (forall (p :: FINITARY j k). (p ~> a) -> (p ~> b) -> r) -> r Source Github # factorPullback :: forall (a :: FINITARY j k) (b :: FINITARY j k) (p :: FINITARY j k) (q :: FINITARY j k). (p ~> a) -> (p ~> b) -> (q ~> a) -> (q ~> b) -> q ~> p Source Github # | |||||
| (HasTerminalObject k, ob (TerminalObject :: k)) => HasTerminalObject (SUBCAT ob) Source Github # | A full subcategory has the ambient finite products as soon as it contains them, as the
quantified constraint says. The projections and pairing are the ambient ones under There is no exponential at an arbitrary kind: neither | ||||
Defined in Proarrow.Category.Instance.Sub Associated Types
| |||||
| (FiniteCat j, FiniteCat k) => HasPushoutComplements (FINITARY j k) Source Github # | Pushout complements of finitary profunctors over any finite schema, so one instance gives double-pushout rewriting of graphs, typed graphs, or the rows of a database. The gluing condition has two halves:
| ||||
| (SubMonoidal ob, CopyDiscard k, Ob a) => CocommutativeComonoid (a :: SUBCAT ob) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.CopyDiscard | |||||
| (SubMonoidal ob, CopyDiscard k, Ob a) => Comonoid (a :: SUBCAT ob) Source Github # | |||||
| CategoryOf k => FunctorForRep (RepAction' :: (RepSub k, k) +-> k) Source Github # | |||||
| CategoryOf k => FunctorForRep (TravAction' :: (TravSub k, k) +-> k) Source Github # | |||||
| CategoryOf k => FunctorForRep (Forget ob :: SUBCAT ob +-> k) Source Github # | |||||
| HasFree ob => Corepresentable (Rep (Forget ob) :: k -> SUBCAT ob -> Type) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction. | ||||
Defined in Proarrow.Profunctor.Free Methods coindex :: forall (a :: k) (b :: SUBCAT ob). Rep (Forget ob) a b -> (Rep (Forget ob) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: SUBCAT ob). Ob a => ((Rep (Forget ob) %% a) ~> b) -> Rep (Forget ob) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Forget ob) %% a) ~> (Rep (Forget ob) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Forget ob) a (Rep (Forget ob) %% a) Source Github # | |||||
| (Monoidal k2, Monoidal (SUBCAT ob), MonoidalAction t) => MonoidalAction (SubAction ob t :: k1 -> (SUBCAT ob, k1) -> Type) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.Action Methods unitor :: forall (x :: k1). Ob x => Act (SubAction ob t) (Unit :: SUBCAT ob) x ~> x Source Github # unitorInv :: forall (x :: k1). Ob x => x ~> Act (SubAction ob t) (Unit :: SUBCAT ob) x Source Github # multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) (a ** b) x ~> Act (SubAction ob t) a (Act (SubAction ob t) b x) Source Github # multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) (x :: k1). (Ob a, Ob b, Ob x) => Act (SubAction ob t) a (Act (SubAction ob t) b x) ~> Act (SubAction ob t) (a ** b) x Source Github # | |||||
| (Monoidal k2, Monoidal (SUBCAT ob), Representable t) => FunctorForRep (SubAction' ob t :: (SUBCAT ob, k1) +-> k1) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.Action | |||||
| Applicative f => Strong (SubAction Traversable ApplyAction) (Star (Prelude f) :: Type -> Type -> Type) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Star Methods act :: forall (a :: SUBCAT Traversable) x y. Ob a => Star (Prelude f) x y -> Star (Prelude f) (Act (SubAction Traversable ApplyAction) a x) (Act (SubAction Traversable ApplyAction) a y) Source Github # | |||||
| Monoid m => EnrichedProfunctor (Clone k) (Mon :: MONOID m -> MONOID m -> Type) Source Github # | A monoid is a one object enriched category. | ||||
Defined in Proarrow.Category.Enriched Methods withProObj :: forall (a :: MONOID m) (b :: MONOID m) r. (Ob a, Ob b) => (Ob (ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a b) => r) -> r Source Github # underlying :: forall (a :: MONOID m) (b :: MONOID m). Mon a b -> (Unit :: Clone k) ~> ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a b Source Github # enriched :: forall (a :: MONOID m) (b :: MONOID m). (Ob a, Ob b) => ((Unit :: Clone k) ~> ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a b) -> Mon a b Source Github # rmap :: forall (a :: MONOID m) (b :: MONOID m) (c :: MONOID m). (Ob a, Ob b, Ob c) => (HomObj (Clone k) b c ** ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a b) ~> ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a c Source Github # lmap :: forall (a :: MONOID m) (b :: MONOID m) (c :: MONOID m). (Ob a, Ob b, Ob c) => (HomObj (Clone k) c a ** ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) a b) ~> ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) c b Source Github # | |||||
| (FiniteCat j, FiniteCat k, forall (p :: j +-> k). ob p => SubFinitary p) => Finitary (Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # |
The same holds for any full subcategory whose predicate implies | ||||
Defined in Proarrow.Category.Enriched.Finitary.Topos Methods size :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b -> Natural Source Github # fromIndex :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Natural -> Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b Source Github # elements :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => [Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b] Source Github # | |||||
| (MonoidalProfunctor p, SubMonoidal ob) => MonoidalProfunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |||||
| Profunctor p => Profunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub Methods dimap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob) (d :: SUBCAT ob). (c ~> a) -> (b ~> d) -> Sub p a b -> Sub p c d Source Github # lmap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob). (c ~> a) -> Sub p a b -> Sub p c b Source Github # rmap :: forall (b :: SUBCAT ob) (d :: SUBCAT ob) (a :: SUBCAT ob). (b ~> d) -> Sub p a b -> Sub p a d Source Github # (\\) :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. ((Ob a, Ob b) => r) -> Sub p a b -> r Source Github # | |||||
| (Representable p, forall (a :: k). ob a => ob (p % a)) => Representable (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub Methods index :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). Sub p a b -> a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # tabulate :: forall (b :: SUBCAT ob) (a :: SUBCAT ob). Ob b => (a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b)) -> Sub p a b Source Github # repMap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (a ~> b) -> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # repUniv :: forall (a :: SUBCAT ob). Ob a => Sub p ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) a Source Github # | |||||
| Profunctor j => Profunctor (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # | |||||
Defined in Proarrow.Adjunction Methods dimap :: forall (c :: COREPK b k) (a0 :: COREPK b k) (b0 :: REPK a k) (d :: REPK a k). (c ~> a0) -> (b0 ~> d) -> LimitAdj j a0 b0 -> LimitAdj j c d Source Github # lmap :: forall (c :: COREPK b k) (a0 :: COREPK b k) (b0 :: REPK a k). (c ~> a0) -> LimitAdj j a0 b0 -> LimitAdj j c b0 Source Github # rmap :: forall (b0 :: REPK a k) (d :: REPK a k) (a0 :: COREPK b k). (b0 ~> d) -> LimitAdj j a0 b0 -> LimitAdj j a0 d Source Github # (\\) :: forall (a0 :: COREPK b k) (b0 :: REPK a k) r. ((Ob a0, Ob b0) => r) -> LimitAdj j a0 b0 -> r Source Github # | |||||
| HasColimits j k => Corepresentable (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # | |||||
Defined in Proarrow.Adjunction Methods coindex :: forall (a0 :: COREPK b k) (b0 :: REPK a k). LimitAdj j a0 b0 -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> b0 Source Github # cotabulate :: forall (a0 :: COREPK b k) (b0 :: REPK a k). Ob a0 => (((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> b0) -> LimitAdj j a0 b0 Source Github # corepMap :: forall (a0 :: COREPK b k) (b0 :: COREPK b k). (a0 ~> b0) -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% b0) Source Github # corepUniv :: forall (a0 :: COREPK b k). Ob a0 => LimitAdj j a0 ((LimitAdj j :: COREPK b k -> REPK a k -> Type) %% a0) Source Github # | |||||
| HasLimits j k => Representable (LimitAdj j :: COREPK b k -> REPK a k -> Type) Source Github # |
| ||||
Defined in Proarrow.Adjunction Methods index :: forall (a0 :: COREPK b k) (b0 :: REPK a k). LimitAdj j a0 b0 -> a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github # tabulate :: forall (b0 :: REPK a k) (a0 :: COREPK b k). Ob b0 => (a0 ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0)) -> LimitAdj j a0 b0 Source Github # repMap :: forall (a0 :: REPK a k) (b0 :: REPK a k). (a0 ~> b0) -> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) ~> ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % b0) Source Github # repUniv :: forall (a0 :: REPK a k). Ob a0 => LimitAdj j ((LimitAdj j :: COREPK b k -> REPK a k -> Type) % a0) a0 Source Github # | |||||
| Promonad p => Promonad (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |||||
| HasFree (On Monoid Semigroup) Source Github # | |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasEpiMonoFactorization (SHEAVES t j k) Source Github # | The image of an arrow of sheaves, by the same cokernel-pair construction as in | ||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasBinaryCoproducts (SHEAVES t j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods withObCoprod :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github # lft :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k). (Ob a, Ob b) => a ~> (a || b) Source Github # rgt :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k). (Ob a, Ob b) => b ~> (a || b) Source Github # (|||) :: forall (x :: SHEAVES t j k) (a :: SHEAVES t j k) (y :: SHEAVES t j k). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github # (+++) :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (x :: SHEAVES t j k) (y :: SHEAVES t j k). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github # | |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasCoequalizers (SHEAVES t j k) Source Github # | The quotient a coequalizer takes is | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods coequalize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (a ~> b) -> (a ~> b) -> (forall (c :: SHEAVES t j k). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (c :: SHEAVES t j k) (x :: SHEAVES t j k) (c' :: SHEAVES t j k). (x ~> c) -> (x ~> c') -> c ~> c' Source Github # | |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasInitialObject (SHEAVES t j k) Source Github # | Colimits are the presheaf colimits, sheafified: take the The initial sheaf need not be the initial presheaf. | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Associated Types
| |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasPushouts (SHEAVES t j k) Source Github # | Not the default coproduct-then-coequalizer, which would sheafify the coproduct and then
sheafify the quotient of that. Each | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods pushout :: forall (o :: SHEAVES t j k) (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (o ~> a) -> (o ~> b) -> (forall (p :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> r) -> r Source Github # factorPushout :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (p :: SHEAVES t j k) (q :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> (a ~> q) -> (b ~> q) -> p ~> q Source Github # | |||||
| (Site t k, Enumerable j, Enumerable k) => HasEqualizers (SHEAVES t j k) Source Github # | Equalizers as in | ||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf | |||||
| (Site t k, Enumerable j, Enumerable k) => HasPullbacks (SHEAVES t j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods pullback :: forall (o :: SHEAVES t j k) (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (a ~> o) -> (b ~> o) -> (forall (p :: SHEAVES t j k). (p ~> a) -> (p ~> b) -> r) -> r Source Github # factorPullback :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (p :: SHEAVES t j k) (q :: SHEAVES t j k). (p ~> a) -> (p ~> b) -> (q ~> a) -> (q ~> b) -> q ~> p Source Github # | |||||
| type (Rep (Forget ob) :: k -> SUBCAT ob -> Type) %% (a :: k) Source Github # | |||||
| type (Corep (Forget ob) :: SUBCAT ob -> k -> Type) % (a :: k) Source Github # | |||||
| type Omega Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf type Omega = 'PR ('SUB (ClosedSieve t :: k -> j -> Type) :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))) | |||||
| type Omega Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos | |||||
| type InitialObject Source Github # | |||||
Defined in Proarrow.Category.Instance.OpenHypergraph | |||||
| type (p :: PROD (SUBCAT ob)) ~~> (q :: PROD (SUBCAT ob)) Source Github # | |||||
Defined in Proarrow.Profunctor.Instance.Exponential | |||||
| type (a :: SORTED s) || (b :: SORTED s) Source Github # | |||||
| type ProObj (Clone v) (Op p :: OPPOSITE j -> OPPOSITE k -> Type) ('OP a :: OPPOSITE j) ('OP b :: OPPOSITE k) Source Github # | |||||
| type Unit Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub | |||||
| type InitialObject Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos | |||||
| type (~>) Source Github # | |||||
| type TerminalObject Source Github # | |||||
Defined in Proarrow.Category.Instance.Sub | |||||
| type Ob (a :: SUBCAT ob) Source Github # | |||||
| type (a :: SUBCAT ob) ** (b :: SUBCAT ob) Source Github # | |||||
| type (a :: SUBCAT (Finitary :: (j +-> k) -> Constraint)) || (b :: SUBCAT (Finitary :: (j +-> k) -> Constraint)) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Topos type (a :: SUBCAT (Finitary :: (j +-> k) -> Constraint)) || (b :: SUBCAT (Finitary :: (j +-> k) -> Constraint)) = 'SUB (UN ('SUB :: (j +-> k) -> SUBCAT (Finitary :: (j +-> k) -> Constraint)) a :+: UN ('SUB :: (j +-> k) -> SUBCAT (Finitary :: (j +-> k) -> Constraint)) b) :: SUBCAT (Finitary :: (j +-> k) -> Constraint) | |||||
| type (a :: SUBCAT ob) && (b :: SUBCAT ob) Source Github # | |||||
| type (RepAction' :: (RepSub k, k) +-> k) @ ('('SUB ('E p) :: SUBCAT (OnE (Representable :: (k +-> k) -> Constraint)), x) :: (SUBCAT (OnE (Representable :: (k +-> k) -> Constraint)), k)) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.EndoProf type (RepAction' :: (RepSub k, k) +-> k) @ ('('SUB ('E p) :: SUBCAT (OnE (Representable :: (k +-> k) -> Constraint)), x) :: (SUBCAT (OnE (Representable :: (k +-> k) -> Constraint)), k)) = p % x | |||||
| type (TravAction' :: (TravSub k, k) +-> k) @ ('('SUB ('E p) :: SUBCAT (OnE ((Representable :: (k +-> k) -> Constraint) :&&: (Traversable :: (k +-> k) -> Constraint))), x) :: (SUBCAT (OnE ((Representable :: (k +-> k) -> Constraint) :&&: (Traversable :: (k +-> k) -> Constraint))), k)) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.EndoProf type (TravAction' :: (TravSub k, k) +-> k) @ ('('SUB ('E p) :: SUBCAT (OnE ((Representable :: (k +-> k) -> Constraint) :&&: (Traversable :: (k +-> k) -> Constraint))), x) :: (SUBCAT (OnE ((Representable :: (k +-> k) -> Constraint) :&&: (Traversable :: (k +-> k) -> Constraint))), k)) = p % x | |||||
| type (Forget ob :: SUBCAT ob +-> k) @ (a :: SUBCAT ob) Source Github # | |||||
| type (SubAction' ob t :: (SUBCAT ob, k2) +-> k2) @ ('('SUB a :: SUBCAT ob, x) :: (SUBCAT ob, k2)) Source Github # | |||||
Defined in Proarrow.Category.Monoidal.Action | |||||
| type ProObj (Clone k) (Mon :: MONOID m -> MONOID m -> Type) ('M :: MONOID m) ('M :: MONOID m) Source Github # | |||||
| type (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % (a :: SUBCAT ob) Source Github # | |||||
| type (LimitAdj j :: COREPK b k -> REPK a k -> Type) %% (c :: COREPK b k) Source Github # | |||||
| type (LimitAdj j :: COREPK b k -> REPK a k -> Type) % (r :: REPK a k) Source Github # | |||||
| type Free (On Monoid Semigroup) ('SUB a :: SUBCAT Semigroup) Source Github # | |||||
| type InitialObject Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf type InitialObject = 'SUB (Sheafify t (InitialProfunctor :: k -> j -> Type)) :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)) | |||||
| type (a :: SHEAVES t j k) || (b :: SHEAVES t j k) Source Github # | |||||
Defined in Proarrow.Category.Enriched.Finitary.Sheaf type (a :: SHEAVES t j k) || (b :: SHEAVES t j k) = 'SUB (Sheafify t (UN ('SUB :: (j +-> k) -> SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))) a :+: UN ('SUB :: (j +-> k) -> SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))) b)) :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)) | |||||
data Sub (p :: CAT k) (a :: SUBCAT ob) (b :: SUBCAT ob) where Source Github #
Wraps an arrow whose endpoints satisfy the predicate ob: the arrows of the full
subcategory SUBCAT.
Constructors
| Sub | |
Instances
| (FiniteCat j, FiniteCat k, forall (p :: j +-> k). ob p => SubFinitary p) => Finitary (Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # |
The same holds for any full subcategory whose predicate implies |
Defined in Proarrow.Category.Enriched.Finitary.Topos Methods size :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b -> Natural Source Github # fromIndex :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => Natural -> Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b Source Github # elements :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (Ob a, Ob b) => [Sub (Prof :: (j +-> k) -> (j +-> k) -> Type) a b] Source Github # | |
| (MonoidalProfunctor p, SubMonoidal ob) => MonoidalProfunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
| Profunctor p => Profunctor (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Sub Methods dimap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob) (d :: SUBCAT ob). (c ~> a) -> (b ~> d) -> Sub p a b -> Sub p c d Source Github # lmap :: forall (c :: SUBCAT ob) (a :: SUBCAT ob) (b :: SUBCAT ob). (c ~> a) -> Sub p a b -> Sub p c b Source Github # rmap :: forall (b :: SUBCAT ob) (d :: SUBCAT ob) (a :: SUBCAT ob). (b ~> d) -> Sub p a b -> Sub p a d Source Github # (\\) :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) r. ((Ob a, Ob b) => r) -> Sub p a b -> r Source Github # | |
| (Representable p, forall (a :: k). ob a => ob (p % a)) => Representable (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
Defined in Proarrow.Category.Instance.Sub Methods index :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). Sub p a b -> a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # tabulate :: forall (b :: SUBCAT ob) (a :: SUBCAT ob). Ob b => (a ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b)) -> Sub p a b Source Github # repMap :: forall (a :: SUBCAT ob) (b :: SUBCAT ob). (a ~> b) -> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) ~> ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % b) Source Github # repUniv :: forall (a :: SUBCAT ob). Ob a => Sub p ((Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % a) a Source Github # | |
| Promonad p => Promonad (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) Source Github # | |
| type (Sub p :: SUBCAT ob -> SUBCAT ob -> Type) % (a :: SUBCAT ob) Source Github # | |
class c (UN ('SUB :: k -> SUBCAT ob) a) => On (c :: k -> Constraint) (ob :: OB k) (a :: SUBCAT ob) Source Github #
class ob (a ** b) => IsObMult (ob :: OB k) (a :: k) (b :: k) Source Github #
Instances
| ob (a ** b) => IsObMult (ob :: k -> Constraint) (a :: k) (b :: k) Source Github # | |
Defined in Proarrow.Category.Instance.Sub | |
class ob (a && b) => IsObProd (ob :: OB k) (a :: k) (b :: k) Source Github #
The same for the product: that the subcategory contains the products of its objects, as a class with a single instance so that it can be the head of a quantified constraint.
Instances
| ob (a && b) => IsObProd (ob :: k -> Constraint) (a :: k) (b :: k) Source Github # | |
Defined in Proarrow.Category.Instance.Sub | |
class (Monoidal k, ob (Unit :: k), forall (a :: k) (b :: k). (ob a, ob b) => IsObMult ob a b) => SubMonoidal (ob :: OB k) Source Github #
Instances
| (Monoidal k, ob (Unit :: k), forall (a :: k) (b :: k). (ob a, ob b) => IsObMult ob a b) => SubMonoidal (ob :: k -> Constraint) Source Github # | |
Defined in Proarrow.Category.Instance.Sub | |
data family Forget :: forall (ob :: OB k) -> SUBCAT ob +-> k Source Github #
Instances
| HasCofree ob => Representable (Corep (Forget ob) :: SUBCAT ob -> k -> Type) Source Github # | By creating the right adjoint to the forgetful functor, we obtain the forgetful-cofree adjunction. |
Defined in Proarrow.Profunctor.Cofree Methods index :: forall (a :: SUBCAT ob) (b :: k). Corep (Forget ob) a b -> a ~> (Corep (Forget ob) % b) Source Github # tabulate :: forall (b :: k) (a :: SUBCAT ob). Ob b => (a ~> (Corep (Forget ob) % b)) -> Corep (Forget ob) a b Source Github # repMap :: forall (a :: k) (b :: k). (a ~> b) -> (Corep (Forget ob) % a) ~> (Corep (Forget ob) % b) Source Github # repUniv :: forall (a :: k). Ob a => Corep (Forget ob) (Corep (Forget ob) % a) a Source Github # | |
| CategoryOf k => FunctorForRep (Forget ob :: SUBCAT ob +-> k) Source Github # | |
| HasFree ob => Corepresentable (Rep (Forget ob) :: k -> SUBCAT ob -> Type) Source Github # | By creating the left adjoint to the forgetful functor, we obtain the free-forgetful adjunction. |
Defined in Proarrow.Profunctor.Free Methods coindex :: forall (a :: k) (b :: SUBCAT ob). Rep (Forget ob) a b -> (Rep (Forget ob) %% a) ~> b Source Github # cotabulate :: forall (a :: k) (b :: SUBCAT ob). Ob a => ((Rep (Forget ob) %% a) ~> b) -> Rep (Forget ob) a b Source Github # corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Rep (Forget ob) %% a) ~> (Rep (Forget ob) %% b) Source Github # corepUniv :: forall (a :: k). Ob a => Rep (Forget ob) a (Rep (Forget ob) %% a) Source Github # | |
| type (Rep (Forget ob) :: k -> SUBCAT ob -> Type) %% (a :: k) Source Github # | |
| type (Corep (Forget ob) :: SUBCAT ob -> k -> Type) % (a :: k) Source Github # | |
| type (Forget ob :: SUBCAT ob +-> k) @ (a :: SUBCAT ob) Source Github # | |
type FUN j k = SUBCAT (Representable :: (j +-> k) -> Constraint) Source Github #
(!) :: forall {j} {k} (f :: FUN j k) (g :: FUN j k) (a :: j) (b :: j). (f ~> g) -> (a ~> b) -> (UN ('SUB :: (j +-> k) -> SUBCAT (Representable :: (j +-> k) -> Constraint)) f % a) ~> (UN ('SUB :: (j +-> k) -> SUBCAT (Representable :: (j +-> k) -> Constraint)) g % b) Source Github #
commSquare :: forall {k} (f :: BOOL +-> k) (g :: BOOL +-> k) (a :: k) (b :: k) (c :: k) (d :: k). (a ~ (f % 'FLS), b ~ (f % 'TRU), c ~ (g % 'FLS), d ~ (g % 'TRU)) => (('SUB f :: SUBCAT (Representable :: (BOOL +-> k) -> Constraint)) ~> ('SUB g :: SUBCAT (Representable :: (BOOL +-> k) -> Constraint))) -> (a ~> b, b ~> d, a ~> c, c ~> d) Source Github #