{-# LANGUAGE AllowAmbiguousTypes #-}
module Proarrow.Category.Enriched.Finitary where
import Data.Kind (Constraint)
import Data.List (elemIndex, find, genericIndex, genericTake)
import Data.Maybe (isJust)
import Data.Type.Nat (snat)
import Data.Type.Nat qualified as N
import Data.Universe.Class qualified as U
import Data.Universe.Helpers qualified as U
import Numeric.Natural (Natural)
import Prelude (Maybe (..), compare, show, (+), (-), (<), (==))
import Prelude qualified as P
import Proarrow.Category.Enriched.Thin
( DecidableProfunctor (..)
, Decision (..)
, Enumerable (..)
, Finite (..)
, Indexed (..)
)
import Proarrow.Category.Instance.Bool (Booleans)
import Proarrow.Category.Instance.Opposite (OPPOSITE (..), Op (..))
import Proarrow.Category.Instance.Ordinal (LTE)
import Proarrow.Category.Instance.Product ((:**:) (..))
import Proarrow.Category.Instance.Unit (Unit (..))
import Proarrow.Core (CategoryOf (..), Hom, Profunctor (..), Promonad (..), type (+->))
import Proarrow.Functor (FunctorForRep (..), withMappedOb)
import Proarrow.Object (mapListOf)
import Proarrow.Profunctor.Corepresentable (Corep (..))
import Proarrow.Profunctor.Instance.Coproduct ((:+:) (..))
import Proarrow.Profunctor.Instance.Initial (InitialProfunctor)
import Proarrow.Profunctor.Instance.Product ((:*:) (..))
import Proarrow.Profunctor.Instance.Terminal (TerminalProfunctor (..))
import Proarrow.Tools.Laws (ProLaw (..), ProLaws (..), (=:=))
type Finitary :: forall {j} {k}. j +-> k -> Constraint
class (Profunctor p) => Finitary (p :: j +-> k) where
size :: (Ob (a :: k), Ob (b :: j)) => Natural
toIndex :: (Ob (a :: k), Ob (b :: j)) => p a b -> Natural
fromIndex :: (Ob (a :: k), Ob (b :: j)) => Natural -> p a b
elements :: (Ob (a :: k), Ob (b :: j)) => [p a b]
elements @a @b = (Natural -> p a b) -> [Natural] -> [p a b]
forall a b. (a -> b) -> [a] -> [b]
P.map (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex @p) (Natural -> [Natural]
indices (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b))
instance ProLaws Finitary where
proLaws :: [ProLaw Finitary]
proLaws = [String -> ProLawBody Finitary -> ProLaw Finitary
forall {j} {k} (c :: (j +-> k) -> Constraint).
String -> ProLawBody c -> ProLaw c
ProLaw String
"fromIndex . toIndex" \ @p @a @b p a b
p forall (x :: k) (y :: k). (Ob x, Ob y) => String -> m (x ~> y)
_ forall (x :: j) (y :: j). (Ob x, Ob y) => String -> m (x ~> y)
_ -> p a b
p p a b -> p a b -> m (ProEquation p)
forall {j} {k} (m :: Type -> Type) (p :: j +-> k) (a :: k)
(b :: j).
Applicative m =>
p a b -> p a b -> m (ProEquation p)
=:= forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex @p @a @b (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
p)]
indices :: Natural -> [Natural]
indices :: Natural -> [Natural]
indices Natural
n = Natural -> [Natural] -> [Natural]
forall i a. Integral i => i -> [a] -> [a]
genericTake Natural
n [Natural
0 ..]
sizes :: forall {j} {k} (p :: j +-> k). (Finitary p, Enumerable j, Enumerable k) => [Natural]
sizes :: forall {j} {k} (p :: j +-> k).
(Finitary p, Enumerable j, Enumerable k) =>
[Natural]
sizes = forall k r. Enumerable k => (forall (a :: k). Ob a => [r]) -> [r]
foreachOb @k \ @a -> forall k r. Enumerable k => (forall (a :: k). Ob a => [r]) -> [r]
foreachOb @j \ @b -> [forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b]
objIndex :: forall {k} (a :: k). (Enumerable k, Ob a) => Natural
objIndex :: forall {k} (a :: k). (Enumerable k, Ob a) => Natural
objIndex = forall k (a :: k) r.
(Enumerable k, Ob a) =>
(KnownIndex a => r) -> r
withIndex @k @a (SNat (Index a) -> Natural
forall (n :: Nat). SNat n -> Natural
N.snatToNatural (forall (n :: Nat). SNatI n => SNat n
snat @(Index a)))
foreachOb :: forall k r. (Enumerable k) => (forall (a :: k). (Ob a) => [r]) -> [r]
foreachOb :: forall k r. Enumerable k => (forall (a :: k). Ob a => [r]) -> [r]
foreachOb forall (a :: k). Ob a => [r]
f = [[r]] -> [r]
forall (t :: Type -> Type) a. Foldable t => t [a] -> [a]
P.concat ((forall (x :: k). KnownIndex x => [r])
-> ListOf KnownIndex (Objects k) -> [[r]]
forall {k} (c :: OB k) (xs :: [k]) r.
(forall (x :: k). c x => r) -> ListOf c xs -> [r]
mapListOf (\ @a -> forall k (a :: k) r.
(Enumerable k, KnownIndex a) =>
(Ob a => r) -> r
withOb @k @a (forall (a :: k). Ob a => [r]
f @a)) (forall k. Finite k => IndexedList (Objects k)
finite @k))
decidableSize :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (DecidableProfunctor p, Ob a, Ob b) => Natural
decidableSize :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural
decidableSize = case forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Decision p a b (Holds p a b)
forall (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Decision p a b (Holds p a b)
decide @p @a @b of
Yes p a b
_ -> Natural
1
Decision p a b (Holds p a b)
No -> Natural
0
decidableFromIndex
:: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (DecidableProfunctor p, Ob a, Ob b) => Natural -> p a b
decidableFromIndex :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural -> p a b
decidableFromIndex Natural
_ = case forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Decision p a b (Holds p a b)
forall (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Decision p a b (Holds p a b)
decide @p @a @b of
Yes p a b
x -> p a b
x
Decision p a b (Holds p a b)
No -> String -> p a b
forall a. HasCallStack => String -> a
P.error String
"fromIndex: the profunctor does not hold here"
newtype Elt (p :: j +-> k) (a :: k) (b :: j) = Elt {forall j k (p :: j +-> k) (a :: k) (b :: j). Elt p a b -> p a b
unElt :: p a b}
instance (Finitary p, Ob a, Ob b) => U.Universe (Elt (p :: j +-> k) a b) where
universe :: [Elt p a b]
universe = (p a b -> Elt p a b) -> [p a b] -> [Elt p a b]
forall a b. (a -> b) -> [a] -> [b]
P.map p a b -> Elt p a b
forall j k (p :: j +-> k) (a :: k) (b :: j). p a b -> Elt p a b
Elt (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @p)
instance (Finitary p, Ob a, Ob b) => U.Finite (Elt (p :: j +-> k) a b) where
cardinality :: Tagged (Elt p a b) Natural
cardinality = Natural -> Tagged (Elt p a b) Natural
forall {k} (s :: k) b. b -> Tagged s b
U.Tagged (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b)
instance (Finitary p) => P.Eq (Elt (p :: j +-> k) a b) where
Elt p a b
x == :: Elt p a b -> Elt p a b -> Bool
== Elt p a b
y = (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
x Natural -> Natural -> Bool
forall a. Eq a => a -> a -> Bool
== p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
y) ((Ob a, Ob b) => Bool) -> p a b -> Bool
forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ p a b
x
instance (Finitary p) => P.Ord (Elt (p :: j +-> k) a b) where
compare :: Elt p a b -> Elt p a b -> Ordering
compare (Elt p a b
x) (Elt p a b
y) = Natural -> Natural -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
x) (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
y) ((Ob a, Ob b) => Ordering) -> p a b -> Ordering
forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ p a b
x
instance (Finitary p) => P.Show (Elt (p :: j +-> k) a b) where
show :: Elt p a b -> String
show (Elt p a b
x) = Natural -> String
forall a. Show a => a -> String
P.show (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
x) ((Ob a, Ob b) => String) -> p a b -> String
forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> p a b -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ p a b
x
class (CategoryOf k, Finitary (Hom k)) => LocallyFinite k
instance (CategoryOf k, Finitary (Hom k)) => LocallyFinite k
factorThrough
:: forall {k} (x :: k) y a. (LocallyFinite k, Ob x, Ob y, Ob a) => x ~> a -> y ~> a -> Maybe (x ~> y)
factorThrough :: forall {k} (x :: k) (y :: k) (a :: k).
(LocallyFinite k, Ob x, Ob y, Ob a) =>
(x ~> a) -> (y ~> a) -> Maybe (x ~> y)
factorThrough x ~> a
g y ~> a
f = ((x ~> y) -> Bool) -> [x ~> y] -> Maybe (x ~> y)
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Maybe a
find (\x ~> y
h -> forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
forall (p :: k +-> k) (a :: k) (b :: k).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex @(Hom k) @x @a (y ~> a
f (y ~> a) -> (x ~> y) -> x ~> a
forall (b :: k) (c :: k) (a :: k). (b ~> c) -> (a ~> b) -> a ~> c
forall {k} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. x ~> y
h) Natural -> Natural -> Bool
forall a. Eq a => a -> a -> Bool
== Natural
gi) (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: k +-> k) (a :: k) (b :: k).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @(Hom k) @x @y)
where
gi :: Natural
gi = (x ~> a) -> Natural
forall (a :: k) (b :: k). (Ob a, Ob b) => Hom k a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex x ~> a
g
factorsThrough :: forall {k} (x :: k) y a. (LocallyFinite k, Ob x, Ob y, Ob a) => x ~> a -> y ~> a -> P.Bool
factorsThrough :: forall {k} (x :: k) (y :: k) (a :: k).
(LocallyFinite k, Ob x, Ob y, Ob a) =>
(x ~> a) -> (y ~> a) -> Bool
factorsThrough x ~> a
g y ~> a
f = Maybe (x ~> y) -> Bool
forall a. Maybe a -> Bool
isJust ((x ~> a) -> (y ~> a) -> Maybe (x ~> y)
forall {k} (x :: k) (y :: k) (a :: k).
(LocallyFinite k, Ob x, Ob y, Ob a) =>
(x ~> a) -> (y ~> a) -> Maybe (x ~> y)
factorThrough x ~> a
g y ~> a
f)
class (Enumerable k, Finitary (Hom k)) => FiniteCat k
instance (Enumerable k, Finitary (Hom k)) => FiniteCat k
finiteSize :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (U.Finite (p a b)) => Natural
finiteSize :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
Finite (p a b) =>
Natural
finiteSize = Tagged (p a b) Natural -> Natural
forall {k} (s :: k) b. Tagged s b -> b
U.unTagged (forall a. Finite a => Tagged a Natural
U.cardinality @(p a b))
finiteToIndex :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (U.Finite (p a b), P.Eq (p a b)) => p a b -> Natural
finiteToIndex :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finite (p a b), Eq (p a b)) =>
p a b -> Natural
finiteToIndex p a b
x = case p a b -> [p a b] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex p a b
x [p a b]
forall a. Finite a => [a]
U.universeF of
Just Int
i -> Int -> Natural
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Int
i
Maybe Int
Nothing -> String -> Natural
forall a. HasCallStack => String -> a
P.error String
"toIndex: not in the universe of the hom-set"
finiteFromIndex :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j). (U.Finite (p a b)) => Natural -> p a b
finiteFromIndex :: forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
Finite (p a b) =>
Natural -> p a b
finiteFromIndex Natural
i = [p a b] -> Natural -> p a b
forall i a. Integral i => [a] -> i -> a
genericIndex (forall a. Finite a => [a]
U.universeF @(p a b)) Natural
i
instance Finitary Unit where
size :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => Natural
size = Natural
1
toIndex :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => Unit a b -> Natural
toIndex Unit a b
Unit = Natural
0
fromIndex :: forall (a :: ()) (b :: ()). (Ob a, Ob b) => Natural -> Unit a b
fromIndex Natural
_ = Unit a b
Unit '() '()
Unit
instance Finitary Booleans where
size :: forall (a :: BOOL) (b :: BOOL). (Ob a, Ob b) => Natural
size @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural
forall (p :: BOOL +-> BOOL) (a :: BOOL) (b :: BOOL).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural
decidableSize @Booleans @a @b
toIndex :: forall (a :: BOOL) (b :: BOOL).
(Ob a, Ob b) =>
Booleans a b -> Natural
toIndex Booleans a b
_ = Natural
0
fromIndex :: forall (a :: BOOL) (b :: BOOL).
(Ob a, Ob b) =>
Natural -> Booleans a b
fromIndex @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural -> p a b
forall (p :: BOOL +-> BOOL) (a :: BOOL) (b :: BOOL).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural -> p a b
decidableFromIndex @Booleans @a @b
instance Finitary LTE where
size :: forall (a :: ORDINAL n) (b :: ORDINAL n). (Ob a, Ob b) => Natural
size @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural
forall (p :: ORDINAL n +-> ORDINAL n) (a :: ORDINAL n)
(b :: ORDINAL n).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural
decidableSize @LTE @a @b
toIndex :: forall (a :: ORDINAL n) (b :: ORDINAL n).
(Ob a, Ob b) =>
LTE a b -> Natural
toIndex LTE a b
_ = Natural
0
fromIndex :: forall (a :: ORDINAL n) (b :: ORDINAL n).
(Ob a, Ob b) =>
Natural -> LTE a b
fromIndex @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural -> p a b
forall (p :: ORDINAL n +-> ORDINAL n) (a :: ORDINAL n)
(b :: ORDINAL n).
(DecidableProfunctor p, Ob a, Ob b) =>
Natural -> p a b
decidableFromIndex @LTE @a @b
instance (CategoryOf j, CategoryOf k) => Finitary (TerminalProfunctor :: j +-> k) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size = Natural
1
toIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
TerminalProfunctor a b -> Natural
toIndex TerminalProfunctor a b
TerminalProfunctor = Natural
0
fromIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
Natural -> TerminalProfunctor a b
fromIndex Natural
_ = TerminalProfunctor a b
forall {j} {k} (a :: j) (b :: k).
(CategoryOf j, CategoryOf k, Ob a, Ob b) =>
TerminalProfunctor a b
TerminalProfunctor
pairIndex :: Natural -> Natural -> Natural -> Natural
pairIndex :: Natural -> Natural -> Natural -> Natural
pairIndex Natural
n Natural
i Natural
j = Natural
i Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
P.* Natural
n Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ Natural
j
unpairIndex :: Natural -> Natural -> (Natural, Natural)
unpairIndex :: Natural -> Natural -> (Natural, Natural)
unpairIndex Natural
0 Natural
_ = String -> (Natural, Natural)
forall a. HasCallStack => String -> a
P.error String
"fromIndex: a factor of the pair has no elements"
unpairIndex Natural
n Natural
i = Natural
i Natural -> Natural -> (Natural, Natural)
forall a. Integral a => a -> a -> (a, a)
`P.divMod` Natural
n
instance (Finitary p, Finitary q) => Finitary (p :*: q) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
P.* forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a @b
toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => (:*:) p q a b -> Natural
toIndex @a @b (p a b
x :*: q a b
y) = Natural -> Natural -> Natural -> Natural
pairIndex (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a @b) (p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
x) (q a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => q a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex q a b
y)
fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> (:*:) p q a b
fromIndex @a @b Natural
i = let (Natural
l, Natural
r) = Natural -> Natural -> (Natural, Natural)
unpairIndex (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a @b) Natural
i in Natural -> p a b
forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> p a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
l p a b -> q a b -> (:*:) p q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) (q :: j +-> k).
p a b -> q a b -> (:*:) p q a b
:*: Natural -> q a b
forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
r
elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [(:*:) p q a b]
elements @a @b = [p a b
x p a b -> q a b -> (:*:) p q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) (q :: j +-> k).
p a b -> q a b -> (:*:) p q a b
:*: q a b
y | p a b
x <- forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @p @a @b, q a b
y <- forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @q @a @b]
instance (Finitary p, Finitary q) => Finitary (p :**: q) where
size :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => Natural
size @'(a1, a2) @'(b1, b2) = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j1 +-> k1) (a :: k1) (b :: j1).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a1 @b1 Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
P.* forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j2 +-> k2) (a :: k2) (b :: j2).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a2 @b2
toIndex :: forall (a :: (k1, k2)) (b :: (j1, j2)).
(Ob a, Ob b) =>
(:**:) p q a b -> Natural
toIndex @'(_, a2) @'(_, b2) (p a1 b1
x :**: q a2 b2
y) = Natural -> Natural -> Natural -> Natural
pairIndex (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j2 +-> k2) (a :: k2) (b :: j2).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a2 @b2) (p a1 b1 -> Natural
forall (a :: k1) (b :: j1). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a1 b1
x) (q a2 b2 -> Natural
forall (a :: k2) (b :: j2). (Ob a, Ob b) => q a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex q a2 b2
y)
fromIndex :: forall (a :: (k1, k2)) (b :: (j1, j2)).
(Ob a, Ob b) =>
Natural -> (:**:) p q a b
fromIndex @'(_, a2) @'(_, b2) Natural
i = let (Natural
l, Natural
r) = Natural -> Natural -> (Natural, Natural)
unpairIndex (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j2 +-> k2) (a :: k2) (b :: j2).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a2 @b2) Natural
i in Natural -> p (Fst @ a) (Fst @ b)
forall (a :: k1) (b :: j1). (Ob a, Ob b) => Natural -> p a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
l p (Fst @ a) (Fst @ b)
-> q (Snd @ a) (Snd @ b)
-> (:**:) p q '(Fst @ a, Snd @ a) '(Fst @ b, Snd @ b)
forall {j1} {k1} {j2} {k2} (c :: j1 +-> k1) (a1 :: k1) (b1 :: j1)
(d :: j2 +-> k2) (a2 :: k2) (b2 :: j2).
c a1 b1 -> d a2 b2 -> (:**:) c d '(a1, a2) '(b1, b2)
:**: Natural -> q (Snd @ a) (Snd @ b)
forall (a :: k2) (b :: j2). (Ob a, Ob b) => Natural -> q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
r
elements :: forall (a :: (k1, k2)) (b :: (j1, j2)).
(Ob a, Ob b) =>
[(:**:) p q a b]
elements @'(a1, a2) @'(b1, b2) = [p (Fst @ a) (Fst @ b)
x p (Fst @ a) (Fst @ b)
-> q (Snd @ a) (Snd @ b)
-> (:**:) p q '(Fst @ a, Snd @ a) '(Fst @ b, Snd @ b)
forall {j1} {k1} {j2} {k2} (c :: j1 +-> k1) (a1 :: k1) (b1 :: j1)
(d :: j2 +-> k2) (a2 :: k2) (b2 :: j2).
c a1 b1 -> d a2 b2 -> (:**:) c d '(a1, a2) '(b1, b2)
:**: q (Snd @ a) (Snd @ b)
y | p (Fst @ a) (Fst @ b)
x <- forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j1 +-> k1) (a :: k1) (b :: j1).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @p @a1 @b1, q (Snd @ a) (Snd @ b)
y <- forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j2 +-> k2) (a :: k2) (b :: j2).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @q @a2 @b2]
instance (FunctorForRep f, LocallyFinite j) => Finitary (Corep (f :: k +-> j)) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size @a @b = forall {j} {k} (f :: j +-> k) (a :: j) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
forall (f :: k +-> j) (a :: k) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
withMappedOb @f @a (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> j) (a :: j) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @(Hom j) @(f @ a) @b)
toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Corep f a b -> Natural
toIndex (Corep (f @ a) ~> b
g) = ((f @ a) ~> b) -> Natural
forall (a :: j) (b :: j). (Ob a, Ob b) => (a ~> b) -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex (f @ a) ~> b
g ((Ob (f @ a), Ob b) => Natural) -> ((f @ a) ~> b) -> Natural
forall (a :: j) (b :: j) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ (f @ a) ~> b
g
fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> Corep f a b
fromIndex @a @_ Natural
i = forall {j} {k} (f :: j +-> k) (a :: j) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
forall (f :: k +-> j) (a :: k) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
withMappedOb @f @a (((f @ a) ~> b) -> Corep f a b
forall {j} {k} (a :: j) (f :: j +-> k) (b :: k).
Ob a =>
((f @ a) ~> b) -> Corep f a b
Corep (Natural -> (f @ a) ~> b
forall (a :: j) (b :: j). (Ob a, Ob b) => Natural -> a ~> b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
i))
elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [Corep f a b]
elements @a @b = forall {j} {k} (f :: j +-> k) (a :: j) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
forall (f :: k +-> j) (a :: k) r.
(FunctorForRep f, Ob a) =>
(Ob (f @ a) => r) -> r
withMappedOb @f @a ((((f @ a) ~> b) -> Corep f a b) -> [(f @ a) ~> b] -> [Corep f a b]
forall a b. (a -> b) -> [a] -> [b]
P.map ((f @ a) ~> b) -> Corep f a b
forall {j} {k} (a :: j) (f :: j +-> k) (b :: k).
Ob a =>
((f @ a) ~> b) -> Corep f a b
Corep (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j +-> j) (a :: j) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @(Hom j) @(f @ a) @b))
instance (Finitary p) => Finitary (Op p) where
size :: forall (a :: OPPOSITE j) (b :: OPPOSITE k). (Ob a, Ob b) => Natural
size @(OP a) @(OP b) = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @b @a
toIndex :: forall (a :: OPPOSITE j) (b :: OPPOSITE k).
(Ob a, Ob b) =>
Op p a b -> Natural
toIndex @(OP a) @(OP b) (Op p b1 a1
x) = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex @p @b @a p b1 a1
p (UN OP b) (UN OP a)
x
fromIndex :: forall (a :: OPPOSITE j) (b :: OPPOSITE k).
(Ob a, Ob b) =>
Natural -> Op p a b
fromIndex @(OP a) @(OP b) Natural
i = p (UN OP b) (UN OP a) -> Op p (OP (UN OP a)) (OP (UN OP b))
forall {j} {k} (p :: j +-> k) (b1 :: k) (a1 :: j).
p b1 a1 -> Op p (OP a1) (OP b1)
Op (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex @p @b @a Natural
i)
elements :: forall (a :: OPPOSITE j) (b :: OPPOSITE k).
(Ob a, Ob b) =>
[Op p a b]
elements @(OP a) @(OP b) = (p (UN OP b) (UN OP a) -> Op p a b)
-> [p (UN OP b) (UN OP a)] -> [Op p a b]
forall a b. (a -> b) -> [a] -> [b]
P.map p (UN OP b) (UN OP a) -> Op p a b
p (UN OP b) (UN OP a) -> Op p (OP (UN OP a)) (OP (UN OP b))
forall {j} {k} (p :: j +-> k) (b1 :: k) (a1 :: j).
p b1 a1 -> Op p (OP a1) (OP b1)
Op (forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
[p a b]
elements @p @b @a)
instance (CategoryOf j, CategoryOf k) => Finitary (InitialProfunctor :: j +-> k) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size = Natural
0
toIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
InitialProfunctor a b -> Natural
toIndex = \case {}
fromIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
Natural -> InitialProfunctor a b
fromIndex Natural
_ = String -> InitialProfunctor a b
forall a. HasCallStack => String -> a
P.error String
"fromIndex: the initial profunctor has no elements"
instance (Finitary p, Finitary q) => Finitary (p :+: q) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size @a @b = forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @q @a @b
toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => (:+:) p q a b -> Natural
toIndex @a @b = \case
InjL p a b
x -> p a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex p a b
x
InjR q a b
y -> forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ q a b -> Natural
forall (a :: k) (b :: j). (Ob a, Ob b) => q a b -> Natural
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
p a b -> Natural
toIndex q a b
y
fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> (:+:) p q a b
fromIndex @a @b Natural
i = if Natural
i Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
< forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b then p a b -> (:+:) p q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) (q :: j +-> k).
p a b -> (:+:) p q a b
InjL (Natural -> p a b
forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> p a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex Natural
i) else q a b -> (:+:) p q a b
forall {j} {k} (q :: j +-> k) (a :: k) (b :: j) (p :: j +-> k).
q a b -> (:+:) p q a b
InjR (Natural -> q a b
forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> q a b
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural -> p a b
fromIndex (Natural
i Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
- forall {j} {k} (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
forall (p :: j +-> k) (a :: k) (b :: j).
(Finitary p, Ob a, Ob b) =>
Natural
size @p @a @b))