{-# LANGUAGE AllowAmbiguousTypes #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module Proarrow.Category.Enriched.Finitary.Sheaf where
import Data.List (find, genericIndex, genericLength, sort)
import Data.Map.Strict qualified as M
import Data.Maybe (fromMaybe, isJust, listToMaybe, mapMaybe)
import Numeric.Natural (Natural)
import Prelude (type (~))
import Prelude qualified as P
import Proarrow.Category.Enriched.Finitary
( Finitary (..)
, FiniteCat
, LocallyFinite
, factorThrough
, factorsThrough
, foreachOb
)
import Proarrow.Category.Enriched.Finitary.Topos
( FINITARY
, KnownTables
, Reindex
, Retabulation (..)
, Tabulated
, coequalizeNat
, equalizeNat
, factorThroughEqualizer
, familyIndex
, fromTabulated
, graphSieve
, natDomain
, natElements
, natIndex
, natKey
, natPositionsBy
, natTable
, preimageMaybe
, sieveTable
, toTabulated
, withSubobject
, withTables
)
import Proarrow.Category.Enriched.Thin (Enumerable)
import Proarrow.Category.Instance.Opposite (OPPOSITE (..))
import Proarrow.Category.Instance.Prof (Prof (..))
import Proarrow.Category.Instance.Sub (SUBCAT (..), Sub (..))
import Proarrow.Category.Sheaf
( Coverage
, Factors (..)
, HasFiniteCovers (..)
, PulledBack (..)
, Sheaf (..)
, Site (..)
, SomeCover (..)
, SomeLeg (..)
, StableSite (..)
)
import Proarrow.Category.Topos (ElementaryTopos, HasEpiMonoFactorization, HasSubobjectClassifier (..))
import Proarrow.Colimit.BinaryCoproduct (HasBinaryCoproducts (..))
import Proarrow.Colimit.Coequalizer (HasCoequalizers (..))
import Proarrow.Colimit.Initial (HasInitialObject (..))
import Proarrow.Colimit.Pushout (HasPushouts (..))
import Proarrow.Core
( CategoryOf (..)
, Kind
, OB
, Profunctor (..)
, Promonad (..)
, UN
, (//)
, (\\)
, type (+->)
, type (:&&:)
, type (:~>)
)
import Proarrow.Limit.BinaryProduct (PROD (..), Prod (..))
import Proarrow.Limit.Equalizer (HasEqualizers (..))
import Proarrow.Limit.Pullback (HasPullbacks)
import Proarrow.Profunctor.Instance.Coproduct ((:+:) (..))
import Proarrow.Profunctor.Instance.Exponential ((:~>:) (..))
import Proarrow.Profunctor.Instance.Initial (InitialProfunctor)
import Proarrow.Profunctor.Instance.Sieve (Sieve (..), maximalSieve, sieveMeet)
import Proarrow.Profunctor.Instance.Terminal (TerminalProfunctor (..))
import Proarrow.Profunctor.Instance.Yoneda (Yo (..))
generatedSieve
:: forall t {j} {k} (a :: k) (b :: j) c
. (Site t k, LocallyFinite k, CategoryOf j, Ob a, Ob b)
=> Cover t k a c
-> Sieve a b
generatedSieve :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j) (c :: Coverage).
(Site t k, LocallyFinite k, CategoryOf j, Ob a, Ob b) =>
Cover t k a c -> Sieve a b
generatedSieve Cover t k a c
c = (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
Sieve \c ~> a
g b ~> d
_ -> (SomeLeg t k a c -> Bool) -> [SomeLeg t k a c] -> Bool
forall (t :: Coverage -> Coverage) (a :: Coverage).
Foldable t =>
(a -> Bool) -> t a -> Bool
P.any (\(SomeLeg Leg t k a c x
l) -> let f :: x ~> a
f = Leg t k a c x -> x ~> a
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k a c x
l in (c ~> a) -> (x ~> a) -> Bool
forall {k :: Coverage} (x :: k) (y :: k) (a :: k).
(LocallyFinite k, Ob x, Ob y, Ob a) =>
(x ~> a) -> (y ~> a) -> Bool
factorsThrough c ~> a
g x ~> a
f ((Ob x, Ob a) => Bool) -> (x ~> a) -> Bool
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ x ~> a
f ((Ob c, Ob a) => Bool) -> (c ~> a) -> Bool
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ c ~> a
g) (Cover t k a c -> [SomeLeg t k a c]
forall (a :: k) (c :: Coverage). Cover t k a c -> [SomeLeg t k a c]
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage).
Site t k =>
Cover t k a c -> [SomeLeg t k a c]
legs Cover t k a c
c)
isMaximal :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> P.Bool
isMaximal :: forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isMaximal Sieve a b
s = [Bool] -> Bool
forall (t :: Coverage -> Coverage). Foldable t => t Bool -> Bool
P.and (Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s)
contains :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> Sieve a b -> P.Bool
contains :: forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b -> Bool
contains Sieve a b
s = \Sieve a b
s' -> [Bool] -> Bool
forall (t :: Coverage -> Coverage). Foldable t => t Bool -> Bool
P.and ((Bool -> Bool -> Bool) -> [Bool] -> [Bool] -> [Bool]
forall (a :: Coverage) (b :: Coverage) (c :: Coverage).
(a -> b -> c) -> [a] -> [b] -> [c]
P.zipWith (\Bool
x Bool
y -> Bool -> Bool
P.not Bool
y Bool -> Bool -> Bool
P.|| Bool
x) [Bool]
ts (Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s'))
where
ts :: [Bool]
ts = Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s
isCovering
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k)
=> Sieve a b
-> P.Bool
isCovering :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isCovering Sieve a b
s = Sieve a b -> Bool
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isMaximal Sieve a b
s Bool -> Bool -> Bool
P.|| Maybe (SomeCover t k a) -> Bool
forall (a :: Coverage). Maybe a -> Bool
isJust (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, CategoryOf j) =>
Sieve a b -> Maybe (SomeCover t k a)
coveringCover @t Sieve a b
s)
coveringCover
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, CategoryOf j)
=> Sieve a b
-> P.Maybe (SomeCover t k a)
coveringCover :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, CategoryOf j) =>
Sieve a b -> Maybe (SomeCover t k a)
coveringCover (Sieve forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s) = (SomeCover t k a -> Bool)
-> [SomeCover t k a] -> Maybe (SomeCover t k a)
forall (t :: Coverage -> Coverage) (a :: Coverage).
Foldable t =>
(a -> Bool) -> t a -> Maybe a
find (\(SomeCover Cover t k a c
c) -> (SomeLeg t k a c -> Bool) -> [SomeLeg t k a c] -> Bool
forall (t :: Coverage -> Coverage) (a :: Coverage).
Foldable t =>
(a -> Bool) -> t a -> Bool
P.all (\(SomeLeg Leg t k a c x
l) -> (x ~> a) -> (b ~> b) -> Bool
forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s (Leg t k a c x -> x ~> a
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k a c x
l) b ~> b
forall (a :: j). Ob a => a ~> a
forall {k :: Coverage} (p :: CAT k) (a :: k).
(Promonad p, Ob a) =>
p a a
id) (Cover t k a c -> [SomeLeg t k a c]
forall (a :: k) (c :: Coverage). Cover t k a c -> [SomeLeg t k a c]
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage).
Site t k =>
Cover t k a c -> [SomeLeg t k a c]
legs Cover t k a c
c)) (forall (t :: Coverage) (k :: Coverage) (a :: k).
(HasFiniteCovers t k, Ob a) =>
[SomeCover t k a]
covers @t @k @a)
closure
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k)
=> Sieve a b
-> Sieve a b
closure :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b
closure s :: Sieve a b
s@Sieve{} = (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
Sieve \c ~> a
g b ~> d
h -> forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isCovering @t ((c ~> a) -> (b ~> d) -> Sieve a b -> Sieve c d
forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> Sieve a b -> Sieve c d
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j) (d :: j).
Profunctor p =>
(c ~> a) -> (b ~> d) -> p a b -> p c d
dimap c ~> a
g b ~> d
h Sieve a b
s) ((Ob c, Ob a) => Bool) -> (c ~> a) -> Bool
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ c ~> a
g ((Ob b, Ob d) => Bool) -> (b ~> d) -> Bool
forall (a :: j) (b :: j) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ b ~> d
h
isClosed
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k)
=> Sieve a b
-> P.Bool
isClosed :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isClosed Sieve a b
s = Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b
closure @t Sieve a b
s) [Bool] -> [Bool] -> Bool
forall (a :: Coverage). Eq a => a -> a -> Bool
P.== Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s
lawvereTierney
:: forall t j k. (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => (Omega :: PROD (FINITARY j k)) ~> Omega
lawvereTierney :: forall (t :: Coverage) (j :: Coverage) (k :: Coverage).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Omega ~> Omega
lawvereTierney = Sub Prof (SUB Sieve) (SUB Sieve)
-> Prod (Sub Prof) (PR (SUB Sieve)) (PR (SUB Sieve))
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a1 :: k)
(b1 :: j).
p a1 b1 -> Prod p (PR a1) (PR b1)
Prod (Prof Sieve Sieve -> Sub Prof (SUB Sieve) (SUB Sieve)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((Sieve :~> Sieve) -> Prof Sieve Sieve
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \s :: Sieve a b
s@Sieve{} -> forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b
closure @t Sieve a b
s))
isSheaf
:: forall t {j} {k} (p :: j +-> k)
. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k)
=> P.Bool
isSheaf :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) =>
Bool
isSheaf =
[Bool] -> Bool
forall (t :: Coverage -> Coverage). Foldable t => t Bool -> Bool
P.and
( forall (k :: Coverage) (r :: Coverage).
Enumerable k =>
(forall (a :: k). Ob a => [r]) -> [r]
foreachOb @k \ @a ->
let cs :: [SomeCover t k a]
cs = forall (t :: Coverage) (k :: Coverage) (a :: k).
(HasFiniteCovers t k, Ob a) =>
[SomeCover t k a]
covers @t @k @a
in forall (k :: Coverage) (r :: Coverage).
Enumerable k =>
(forall (a :: k). Ob a => [r]) -> [r]
foreachOb @j \ @b -> [forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j) (c :: Coverage).
(Site t k, Finitary p, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Cover t k a c -> Bool
sheafAt @t @p @a @b Cover t k a c
c | SomeCover Cover t k a c
c <- [SomeCover t k a]
cs]
)
sheafAt
:: forall t {j} {k} (p :: j +-> k) (a :: k) (b :: j) c
. (Site t k, Finitary p, FiniteCat j, FiniteCat k, Ob a, Ob b)
=> Cover t k a c
-> P.Bool
sheafAt :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j) (c :: Coverage).
(Site t k, Finitary p, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Cover t k a c -> Bool
sheafAt Cover t k a c
c = Sieve a b
-> (forall (q :: j +-> k).
Finitary q =>
(q :~> Yo a (OP b)) -> Bool)
-> Bool
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j) (c :: Coverage).
(Site t k, LocallyFinite k, CategoryOf j, Ob a, Ob b) =>
Cover t k a c -> Sieve a b
generatedSieve @t @a @b Cover t k a c
c) \ @q q :~> Yo a (OP b)
incl ->
[[Natural]] -> [[Natural]]
forall (a :: Coverage). Ord a => [a] -> [a]
sort [forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
(p :~> q) -> [Natural]
forall (p :: j +-> k) (q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
(p :~> q) -> [Natural]
natTable @q @p (\q a b
y -> case q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl q a b
y of Yo a ~> a
g b1 ~> b
h -> (a ~> a) -> (b ~> b) -> p a b -> p a b
forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> p a b -> p c d
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j) (d :: j).
Profunctor p =>
(c ~> a) -> (b ~> d) -> p a b -> p c d
dimap a ~> a
g b ~> b
b1 ~> b
h p a b
x) | p a b
x <- forall {j :: Coverage} {k :: Coverage} (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]
[[Natural]] -> [[Natural]] -> Bool
forall (a :: Coverage). Eq a => a -> a -> Bool
P.== [[Natural]] -> [[Natural]]
forall (a :: Coverage). Ord a => [a] -> [a]
sort (forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[[Natural]]
forall (p :: j +-> k) (q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[[Natural]]
natElements @q @p)
withSieve
:: forall {j} {k} (a :: k) (b :: j) r
. (FiniteCat j, FiniteCat k)
=> Sieve a b
-> (forall q. (Finitary q) => (q :~> Yo a (OP b)) -> r)
-> r
withSieve :: forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (Sieve forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s) forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r
k =
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Bool)
-> (forall (q :: j +-> k). Finitary q => (FIN q ~> FIN p) -> r)
-> r
-> r
forall (p :: j +-> k) (r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Bool)
-> (forall (q :: j +-> k). Finitary q => (FIN q ~> FIN p) -> r)
-> r
-> r
withSubobject @(Yo a (OP b))
(\(Yo a ~> a
g b1 ~> b
h) -> (a ~> a) -> (b ~> b) -> Bool
forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s a ~> a
g b ~> b
b1 ~> b
h)
(\ @q (Sub (Prof q :~> Yo a (OP b)
incl)) -> forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r
k @q q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl)
([Char] -> r
forall a. HasCallStack => [Char] -> a
P.error [Char]
"withSieve: not a sieve")
withTabulatedSheaf
:: forall t {j} {k} (p :: j +-> k) r
. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k)
=> ( forall {lm} {rm} (tab :: j +-> k)
. (tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab)
=> (p :~> tab)
-> (tab :~> p)
-> r
)
-> r
-> r
withTabulatedSheaf :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (r :: Coverage).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) =>
(forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r)
-> r -> r
withTabulatedSheaf forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
ok r
notSheaf = forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]).
KnownTables j k lm rm =>
r)
-> r
forall (p :: j +-> k) (r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]).
KnownTables j k lm rm =>
r)
-> r
withTables @p \ @lm @rm ->
if forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) =>
Bool
isSheaf @t @(Tabulated t lm rm :: j +-> k)
then forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
forall (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
ok @(Tabulated t lm rm) p a b -> Tabulated t lm rm a b
p :~> Tabulated t lm rm
forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]) (p :: j +-> k).
Finitary p =>
p :~> Tabulated t lm rm
toTabulated Tabulated t lm rm a b -> p a b
Tabulated t lm rm :~> p
forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]) (p :: j +-> k).
Finitary p =>
Tabulated t lm rm :~> p
fromTabulated
else r
notSheaf
withSheafTables
:: forall t {j} {k} (p :: j +-> k) r
. (Sheaf t p, Finitary p, FiniteCat j, FiniteCat k)
=> ( forall {lm} {rm} (tab :: j +-> k)
. (tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab)
=> (p :~> tab)
-> (tab :~> p)
-> r
)
-> r
withSheafTables :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (r :: Coverage).
(Sheaf t p, Finitary p, FiniteCat j, FiniteCat k) =>
(forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r)
-> r
withSheafTables forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
ok = forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]).
KnownTables j k lm rm =>
r)
-> r
forall (p :: j +-> k) (r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]).
KnownTables j k lm rm =>
r)
-> r
withTables @p \ @lm @rm -> forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
forall (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r
ok @(Tabulated t lm rm) p a b -> Tabulated t lm rm a b
p :~> Tabulated t lm rm
forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]) (p :: j +-> k).
Finitary p =>
p :~> Tabulated t lm rm
toTabulated Tabulated t lm rm a b -> p a b
Tabulated t lm rm :~> p
forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(lm :: [[[[Nat]]]]) (rm :: [[[[Nat]]]]) (p :: j +-> k).
Finitary p =>
Tabulated t lm rm :~> p
fromTabulated
factorLocally
:: forall t {j} {k} (p :: j +-> k) q
. (HasFiniteCovers t k, CategoryOf j, Profunctor p, Sheaf t q)
=> (forall c d. (Ob c, Ob d) => p c d -> P.Maybe (q c d))
-> p :~> q
factorLocally :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Profunctor p, Sheaf t q) =>
(forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d))
-> p :~> q
factorLocally forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d)
f p a b
y =
p a b
y p a b -> ((Ob a, Ob b) => q a b) -> q a b
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// case p a b -> Maybe (q a b)
forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d)
f p a b
y of
P.Just q a b
v -> q a b
v
Maybe (q a b)
P.Nothing -> case forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, CategoryOf j) =>
Sieve a b -> Maybe (SomeCover t k a)
coveringCover @t (p a b -> Sieve a b
forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Sieve a b
domainSieve p a b
y) of
P.Just (SomeCover Cover t k a c
c) ->
forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(p :: j +-> k) (a :: k) (c :: Coverage) (b :: j).
(Sheaf t p, Ob a, Ob b) =>
Cover t k a c -> (forall (x :: k). Leg t k a c x -> p x b) -> p a b
forall (t :: Coverage) (p :: j +-> k) (a :: k) (c :: Coverage)
(b :: j).
(Sheaf t p, Ob a, Ob b) =>
Cover t k a c -> (forall (x :: k). Leg t k a c x -> p x b) -> p a b
glue @t Cover t k a c
c \Leg t k a c x
l -> q x b -> Maybe (q x b) -> q x b
forall (a :: Coverage). a -> Maybe a -> a
fromMaybe ([Char] -> q x b
forall a. HasCallStack => [Char] -> a
P.error [Char]
"factorLocally: a leg outside the domain") (p x b -> Maybe (q x b)
forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d)
f ((x ~> a) -> p a b -> p x b
forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j).
Profunctor p =>
(c ~> a) -> p a b -> p c b
lmap (Leg t k a c x -> x ~> a
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k a c x
l) p a b
y) ((Ob x, Ob a) => Maybe (q x b)) -> (x ~> a) -> Maybe (q x b)
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ Leg t k a c x -> x ~> a
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k a c x
l)
Maybe (SomeCover t k a)
P.Nothing -> [Char] -> q a b
forall a. HasCallStack => [Char] -> a
P.error [Char]
"factorLocally: the partial transformation is not defined on a cover of this element"
where
domainSieve :: forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Sieve a b
domainSieve :: forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> Sieve a b
domainSieve p a b
x = (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
Sieve \c ~> a
g b ~> d
_ -> Maybe (q c b) -> Bool
forall (a :: Coverage). Maybe a -> Bool
isJust (p c b -> Maybe (q c b)
forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d)
f ((c ~> a) -> p a b -> p c b
forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j).
Profunctor p =>
(c ~> a) -> p a b -> p c b
lmap c ~> a
g p a b
x)) ((Ob c, Ob a) => Bool) -> (c ~> a) -> Bool
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ c ~> a
g
factorThroughLocalEpi
:: forall t {j} {k} (c :: j +-> k) x c'
. (HasFiniteCovers t k, CategoryOf j, Finitary c, Finitary x, Sheaf t c')
=> (x :~> c)
-> (x :~> c')
-> c :~> c'
factorThroughLocalEpi :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(c :: j +-> k) (x :: j +-> k) (c' :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Finitary c, Finitary x,
Sheaf t c') =>
(x :~> c) -> (x :~> c') -> c :~> c'
factorThroughLocalEpi x :~> c
proj x :~> c'
h = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Profunctor p, Sheaf t q) =>
(forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d))
-> p :~> q
factorLocally @t \c c d
y -> (x c d -> c' c d) -> Maybe (x c d) -> Maybe (c' c d)
forall (a :: Coverage) (b :: Coverage).
(a -> b) -> Maybe a -> Maybe b
forall (f :: Coverage -> Coverage) (a :: Coverage) (b :: Coverage).
Functor f =>
(a -> b) -> f a -> f b
P.fmap x c d -> c' c d
x :~> c'
h ((x c d -> c c d) -> c c d -> Maybe (x c d)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k) (a :: k) (b :: j).
(Finitary p, Finitary q, Ob a, Ob b) =>
(p a b -> q a b) -> q a b -> Maybe (p a b)
preimageMaybe x c d -> c c d
x :~> c
proj c c d
y)
type Plus :: forall {j} {k}. Coverage -> j +-> k -> j +-> k
data Plus t p a b where
Plus :: (Ob a, Ob b) => (forall c d. c ~> a -> b ~> d -> P.Maybe (p c d)) -> Plus t p a b
instance (CategoryOf j, CategoryOf k) => Profunctor (Plus t p :: j +-> k) where
dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> Plus t p a b -> Plus t p c d
dimap c ~> a
l b ~> d
r (Plus forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f) = c ~> a
l (c ~> a) -> ((Ob c, Ob a) => Plus t p c d) -> Plus t p c d
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// b ~> d
r (b ~> d) -> ((Ob b, Ob d) => Plus t p c d) -> Plus t p c d
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// (forall (c :: k) (d :: j). (c ~> c) -> (d ~> d) -> Maybe (p c d))
-> Plus t p c d
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j)
(p :: j +-> k) (t :: Coverage).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
Plus \c ~> c
g d ~> d
h -> (c ~> a) -> (b ~> d) -> Maybe (p c d)
forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f (c ~> a
l (c ~> a) -> (c ~> c) -> c ~> a
forall (b :: k) (c :: k) (a :: k). (b ~> c) -> (a ~> b) -> a ~> c
forall {k :: Coverage} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. c ~> c
g) (d ~> d
h (d ~> d) -> (b ~> d) -> b ~> d
forall (b :: j) (c :: j) (a :: j). (b ~> c) -> (a ~> b) -> a ~> c
forall {k :: Coverage} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. b ~> d
r)
(Ob a, Ob b) => r
r \\ :: forall (a :: k) (b :: j) (r :: Coverage).
((Ob a, Ob b) => r) -> Plus t p a b -> r
\\ Plus{} = r
(Ob a, Ob b) => r
r
support :: Plus t p :~> Sieve
support :: forall {k1 :: Coverage} {k :: Coverage} (t :: Coverage)
(p :: k1 +-> k) (a :: k) (b :: k1).
Plus t p a b -> Sieve a b
support (Plus forall (c :: k) (d :: k1). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f) = (forall (c :: k) (d :: k1). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
Sieve \c ~> a
g b ~> d
h -> Maybe (p c d) -> Bool
forall (a :: Coverage). Maybe a -> Bool
isJust ((c ~> a) -> (b ~> d) -> Maybe (p c d)
forall (c :: k) (d :: k1). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f c ~> a
g b ~> d
h)
isDense
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k)
=> Sieve a b
-> P.Bool
isDense :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isDense Sieve a b
s = Sieve a b -> Bool
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isMaximal (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b
closure @t Sieve a b
s)
leastDenseSieve
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b)
=> Sieve a b
leastDenseSieve :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Sieve a b
leastDenseSieve
| forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isDense @t Sieve a b
s = Sieve a b
s
| Bool
P.otherwise = [Char] -> Sieve a b
forall a. HasCallStack => [Char] -> a
P.error [Char]
"leastDenseSieve: the dense sieves have no least one -- the covers do not compose"
where
s :: Sieve a b
s = (Sieve a b -> Sieve a b -> Sieve a b)
-> Sieve a b -> [Sieve a b] -> Sieve a b
forall (a :: Coverage) (b :: Coverage).
(a -> b -> b) -> b -> [a] -> b
forall (t :: Coverage -> Coverage) (a :: Coverage) (b :: Coverage).
Foldable t =>
(a -> b -> b) -> b -> t a -> b
P.foldr Sieve a b -> Sieve a b -> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
Sieve a b -> Sieve a b -> Sieve a b
sieveMeet Sieve a b
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(CategoryOf j, CategoryOf k, Ob a, Ob b) =>
Sieve a b
maximalSieve ((Sieve a b -> Bool) -> [Sieve a b] -> [Sieve a b]
forall (a :: Coverage). (a -> Bool) -> [a] -> [a]
P.filter (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isDense @t) (forall {j :: Coverage} {k :: Coverage} (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 @(Sieve :: j +-> k) @a @b))
plusElements
:: forall t {j} {k} (p :: j +-> k) (a :: k) (b :: j)
. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k, Ob a, Ob b)
=> [Plus t p a b]
plusElements :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k, Ob a,
Ob b) =>
[Plus t p a b]
plusElements = Sieve a b
-> (forall (q :: j +-> k).
Finitary q =>
(q :~> Yo a (OP b)) -> [Plus t p a b])
-> [Plus t p a b]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Sieve a b
leastDenseSieve @t @a @b) \ @q q :~> Yo a (OP b)
incl ->
let pos :: Map NatKey Int
pos = forall {j :: Coverage} {k :: Coverage} (p :: j +-> k).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> NatKey)
-> Map NatKey Int
forall (p :: j +-> k).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> NatKey)
-> Map NatKey Int
natPositionsBy @q \q a b
y -> Yo a (OP b) a b -> NatKey
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(p :: j +-> k).
(FiniteCat j, FiniteCat k, Finitary p, Ob a, Ob b) =>
p a b -> NatKey
natKey (q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl q a b
y)
in [ (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j)
(p :: j +-> k) (t :: Coverage).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
Plus \c ~> a
g b ~> d
h -> c ~> a
g (c ~> a) -> ((Ob c, Ob a) => Maybe (p c d)) -> Maybe (p c d)
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// b ~> d
h (b ~> d) -> ((Ob b, Ob d) => Maybe (p c d)) -> Maybe (p c d)
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// (Int -> p c d) -> Maybe Int -> Maybe (p c d)
forall (a :: Coverage) (b :: Coverage).
(a -> b) -> Maybe a -> Maybe b
forall (f :: Coverage -> Coverage) (a :: Coverage) (b :: Coverage).
Functor f =>
(a -> b) -> f a -> f b
P.fmap (forall {j :: Coverage} {k :: Coverage} (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 -> p c d) -> (Int -> Natural) -> Int -> p c d
forall (b :: Coverage) (c :: Coverage) (a :: Coverage).
(b -> c) -> (a -> b) -> a -> c
P.. ([Natural]
row [Natural] -> Int -> Natural
forall (a :: Coverage). HasCallStack => [a] -> Int -> a
P.!!)) (NatKey -> Map NatKey Int -> Maybe Int
forall (k :: Coverage) (a :: Coverage).
Ord k =>
k -> Map k a -> Maybe a
M.lookup (Yo a (OP b) c d -> NatKey
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(p :: j +-> k).
(FiniteCat j, FiniteCat k, Finitary p, Ob a, Ob b) =>
p a b -> NatKey
natKey ((c ~> a) -> (b ~> d) -> Yo a (OP b) c d
forall {k :: Coverage} {j :: Coverage} (c :: k) (a :: k) (b1 :: j)
(d :: j).
(c ~> a) -> (b1 ~> d) -> Yo a (OP b1) c d
Yo c ~> a
g b ~> d
h)) Map NatKey Int
pos)
| [Natural]
row <- forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[[Natural]]
forall (p :: j +-> k) (q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[[Natural]]
natElements @q @p
]
restrictTo
:: forall {j} {k} q (a :: k) (b :: j) t (p :: j +-> k)
. (q :~> Yo a (OP b))
-> Plus t p a b
-> q :~> p
restrictTo :: forall {j :: Coverage} {k :: Coverage} (q :: k -> j -> Coverage)
(a :: k) (b :: j) (t :: Coverage) (p :: k -> j -> Coverage).
(q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
restrictTo q :~> Yo a (OP b)
incl (Plus forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f) q a b
y = case q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl q a b
y of
Yo a ~> a
g b1 ~> b
h ->
p a b -> Maybe (p a b) -> p a b
forall (a :: Coverage). a -> Maybe a -> a
fromMaybe ([Char] -> p a b
forall a. HasCallStack => [Char] -> a
P.error [Char]
"restrictTo: the sieve is not inside the support -- see HasFiniteCovers's Composition law") ((a ~> a) -> (b ~> b) -> Maybe (p a b)
forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d)
f a ~> a
g b ~> b
b1 ~> b
h)
plusTable
:: forall t {j} {k} (p :: j +-> k) (a :: k) (b :: j)
. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k)
=> Plus t p a b
-> [Natural]
plusTable :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) =>
Plus t p a b -> [Natural]
plusTable x :: Plus t p a b
x@Plus{} = Sieve a b
-> (forall (q :: j +-> k).
Finitary q =>
(q :~> Yo a (OP b)) -> [Natural])
-> [Natural]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Sieve a b
leastDenseSieve @t @a @b) \ @q q :~> Yo a (OP b)
incl -> forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
(p :~> q) -> [Natural]
forall (p :: j +-> k) (q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
(p :~> q) -> [Natural]
natTable @q @p ((q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
forall {j :: Coverage} {k :: Coverage} (q :: k -> j -> Coverage)
(a :: k) (b :: j) (t :: Coverage) (p :: k -> j -> Coverage).
(q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
restrictTo q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl Plus t p a b
x)
samePlus
:: forall t {j} {k} (p :: j +-> k) (a :: k) (b :: j)
. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k)
=> Plus t p a b
-> Plus t p a b
-> P.Bool
samePlus :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) =>
Plus t p a b -> Plus t p a b -> Bool
samePlus x :: Plus t p a b
x@Plus{} Plus t p a b
y = Sieve a b
-> (forall (q :: j +-> k).
Finitary q =>
(q :~> Yo a (OP b)) -> Bool)
-> Bool
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Sieve a b
leastDenseSieve @t @a @b) \ @q q :~> Yo a (OP b)
incl ->
[Bool] -> Bool
forall (t :: Coverage -> Coverage). Foldable t => t Bool -> Bool
P.and
(forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> r) -> [r]
forall (p :: j +-> k) (r :: Coverage).
(Finitary p, FiniteCat j, FiniteCat k) =>
(forall (a :: k) (b :: j). (Ob a, Ob b) => p a b -> r) -> [r]
natDomain @q @P.Bool \ @c @d q a b
z -> let ix :: p a b -> Natural
ix = forall {j :: Coverage} {k :: Coverage} (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 @c @d in p a b -> Natural
ix ((q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
forall {j :: Coverage} {k :: Coverage} (q :: k -> j -> Coverage)
(a :: k) (b :: j) (t :: Coverage) (p :: k -> j -> Coverage).
(q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
restrictTo q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl Plus t p a b
x q a b
z) Natural -> Natural -> Bool
forall (a :: Coverage). Eq a => a -> a -> Bool
P.== p a b -> Natural
ix ((q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
forall {j :: Coverage} {k :: Coverage} (q :: k -> j -> Coverage)
(a :: k) (b :: j) (t :: Coverage) (p :: k -> j -> Coverage).
(q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
restrictTo q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl Plus t p a b
y q a b
z))
instance (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => Finitary (Plus t p :: j +-> k) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size @a @b = [Plus t p a b] -> Natural
forall (i :: Coverage) (a :: Coverage). Num i => [a] -> i
genericLength (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k, Ob a,
Ob b) =>
[Plus t p a b]
plusElements @t @p @a @b)
toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Plus t p a b -> Natural
toIndex @a @b = Sieve a b
-> (forall (q :: j +-> k).
Finitary q =>
(q :~> Yo a (OP b)) -> Plus t p a b -> Natural)
-> Plus t p a b
-> Natural
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j)
(r :: Coverage).
(FiniteCat j, FiniteCat k) =>
Sieve a b
-> (forall (q :: j +-> k). Finitary q => (q :~> Yo a (OP b)) -> r)
-> r
withSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
Sieve a b
leastDenseSieve @t @a @b) \ @q q :~> Yo a (OP b)
incl ->
let ix :: (q :~> p) -> Natural
ix = forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[Char] -> (p :~> q) -> Natural
forall (p :: j +-> k) (q :: j +-> k).
(Finitary p, Finitary q, FiniteCat j, FiniteCat k) =>
[Char] -> (p :~> q) -> Natural
natIndex @q @p [Char]
"toIndex: not natural on the least dense sieve"
in \Plus t p a b
x -> (q :~> p) -> Natural
ix ((q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
forall {j :: Coverage} {k :: Coverage} (q :: k -> j -> Coverage)
(a :: k) (b :: j) (t :: Coverage) (p :: k -> j -> Coverage).
(q :~> Yo a (OP b)) -> Plus t p a b -> q :~> p
restrictTo q a b -> Yo a (OP b) a b
q :~> Yo a (OP b)
incl Plus t p a b
x)
fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> Plus t p a b
fromIndex @a @b = [Plus t p a b] -> Natural -> Plus t p a b
forall (i :: Coverage) (a :: Coverage). Integral i => [a] -> i -> a
genericIndex (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k, Ob a,
Ob b) =>
[Plus t p a b]
plusElements @t @p @a @b)
elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [Plus t p a b]
elements @a @b = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (a :: k) (b :: j).
(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k, Ob a,
Ob b) =>
[Plus t p a b]
plusElements @t @p @a @b
type Sheafify :: forall {j} {k}. Coverage -> j +-> k -> j +-> k
type Sheafify t p = Plus t (Plus t p)
unitPlus :: forall t {j} {k} (p :: j +-> k). (Profunctor p) => p :~> Plus t p
unitPlus :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Plus t p
unitPlus p a b
x = (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j)
(p :: j +-> k) (t :: Coverage).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
Plus (\c ~> a
g b ~> d
h -> p c d -> Maybe (p c d)
forall (a :: Coverage). a -> Maybe a
P.Just ((c ~> a) -> (b ~> d) -> p a b -> p c d
forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> p a b -> p c d
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j) (d :: j).
Profunctor p =>
(c ~> a) -> (b ~> d) -> p a b -> p c d
dimap c ~> a
g b ~> d
h p a b
x)) ((Ob a, Ob b) => Plus t p a b) -> p a b -> Plus t p a b
forall (a :: k) (b :: j) (r :: Coverage).
((Ob a, Ob b) => r) -> p a b -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ p a b
x
unitSheafify :: forall t {j} {k} (p :: j +-> k). (Profunctor p) => p :~> Sheafify t p
unitSheafify :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify p a b
x = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Plus t p
unitPlus @t (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Plus t p
unitPlus @t p a b
x)
extendPlus
:: forall t {j} {k} (p :: j +-> k) q
. (HasFiniteCovers t k, Sheaf t q)
=> (p :~> q) -> Plus t p :~> q
extendPlus :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Plus t p :~> q
extendPlus p :~> q
n = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Profunctor p, Sheaf t q) =>
(forall (c :: k) (d :: j). (Ob c, Ob d) => p c d -> Maybe (q c d))
-> p :~> q
factorLocally @t \(Plus forall (c :: k) (d :: j). (c ~> c) -> (d ~> d) -> Maybe (p c d)
f) -> (p c d -> q c d) -> Maybe (p c d) -> Maybe (q c d)
forall (a :: Coverage) (b :: Coverage).
(a -> b) -> Maybe a -> Maybe b
forall (f :: Coverage -> Coverage) (a :: Coverage) (b :: Coverage).
Functor f =>
(a -> b) -> f a -> f b
P.fmap p c d -> q c d
p :~> q
n ((c ~> c) -> (d ~> d) -> Maybe (p c d)
forall (c :: k) (d :: j). (c ~> c) -> (d ~> d) -> Maybe (p c d)
f c ~> c
forall (a :: k). Ob a => a ~> a
forall {k :: Coverage} (p :: CAT k) (a :: k).
(Promonad p, Ob a) =>
p a a
id d ~> d
forall (a :: j). Ob a => a ~> a
forall {k :: Coverage} (p :: CAT k) (a :: k).
(Promonad p, Ob a) =>
p a a
id)
gluePlus
:: forall t {j} {k} (q :: j +-> k) (a :: k) c (b :: j)
. (Site t k, LocallyFinite k, Ob a, Ob b)
=> Cover t k a c
-> (forall x. Leg t k a c x -> Plus t q x b)
-> Plus t q a b
gluePlus :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(q :: j +-> k) (a :: k) (c :: Coverage) (b :: j).
(Site t k, LocallyFinite k, Ob a, Ob b) =>
Cover t k a c
-> (forall (x :: k). Leg t k a c x -> Plus t q x b) -> Plus t q a b
gluePlus Cover t k a c
c forall (x :: k). Leg t k a c x -> Plus t q x b
m =
let ls :: [SomeLeg t k a c]
ls = Cover t k a c -> [SomeLeg t k a c]
forall (a :: k) (c :: Coverage). Cover t k a c -> [SomeLeg t k a c]
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage).
Site t k =>
Cover t k a c -> [SomeLeg t k a c]
legs Cover t k a c
c
in (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (q c d))
-> Plus t q a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j)
(p :: j +-> k) (t :: Coverage).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d))
-> Plus t p a b
Plus \c ~> a
g b ~> d
h ->
c ~> a
g (c ~> a) -> ((Ob c, Ob a) => Maybe (q c d)) -> Maybe (q c d)
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// [q c d] -> Maybe (q c d)
forall (a :: Coverage). [a] -> Maybe a
listToMaybe ((SomeLeg t k a c -> Maybe (q c d)) -> [SomeLeg t k a c] -> [q c d]
forall (a :: Coverage) (b :: Coverage).
(a -> Maybe b) -> [a] -> [b]
mapMaybe (\(SomeLeg Leg t k a c x
l) -> case Leg t k a c x -> Plus t q x b
forall (x :: k). Leg t k a c x -> Plus t q x b
m Leg t k a c x
l of Plus forall (c :: k) (d :: j). (c ~> x) -> (b ~> d) -> Maybe (q c d)
f -> (c ~> a) -> (x ~> a) -> Maybe (c ~> x)
forall {k :: Coverage} (x :: k) (y :: k) (a :: k).
(LocallyFinite k, Ob x, Ob y, Ob a) =>
(x ~> a) -> (y ~> a) -> Maybe (x ~> y)
factorThrough c ~> a
g (Leg t k a c x -> x ~> a
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k a c x
l) Maybe (c ~> x) -> ((c ~> x) -> Maybe (q c d)) -> Maybe (q c d)
forall (a :: Coverage) (b :: Coverage).
Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: Coverage -> Coverage) (a :: Coverage) (b :: Coverage).
Monad m =>
m a -> (a -> m b) -> m b
P.>>= \c ~> x
u -> (c ~> x) -> (b ~> d) -> Maybe (q c d)
forall (c :: k) (d :: j). (c ~> x) -> (b ~> d) -> Maybe (q c d)
f c ~> x
u b ~> d
h) [SomeLeg t k a c]
ls)
instance (Site t k, LocallyFinite k, CategoryOf j) => Sheaf t (Sheafify t (p :: j +-> k)) where
glue :: forall (a :: k) (c :: Coverage) (b :: j).
(Ob a, Ob b) =>
Cover t k a c
-> (forall (x :: k). Leg t k a c x -> Sheafify t p x b)
-> Sheafify t p a b
glue = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(q :: j +-> k) (a :: k) (c :: Coverage) (b :: j).
(Site t k, LocallyFinite k, Ob a, Ob b) =>
Cover t k a c
-> (forall (x :: k). Leg t k a c x -> Plus t q x b) -> Plus t q a b
gluePlus @t
extendSheafify
:: forall t {j} {k} (p :: j +-> k) q
. (HasFiniteCovers t k, Sheaf t q)
=> (p :~> q) -> Sheafify t p :~> q
extendSheafify :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Sheafify t p :~> q
extendSheafify p :~> q
n = forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Plus t p :~> q
extendPlus @t (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Plus t p :~> q
extendPlus @t p a b -> q a b
p :~> q
n)
type ClosedSieve :: forall {j} {k}. Coverage -> j +-> k
newtype ClosedSieve t (a :: k) (b :: j) = ClosedSieve (Sieve a b)
instance (CategoryOf j, CategoryOf k) => Profunctor (ClosedSieve t :: j +-> k) where
dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> ClosedSieve t a b -> ClosedSieve t c d
dimap c ~> a
l b ~> d
r (ClosedSieve Sieve a b
s) = Sieve c d -> ClosedSieve t c d
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j).
Sieve a b -> ClosedSieve t a b
ClosedSieve ((c ~> a) -> (b ~> d) -> Sieve a b -> Sieve c d
forall (c :: k) (a :: k) (b :: j) (d :: j).
(c ~> a) -> (b ~> d) -> Sieve a b -> Sieve c d
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j) (d :: j).
Profunctor p =>
(c ~> a) -> (b ~> d) -> p a b -> p c d
dimap c ~> a
l b ~> d
r Sieve a b
s)
(Ob a, Ob b) => r
x \\ :: forall (a :: k) (b :: j) (r :: Coverage).
((Ob a, Ob b) => r) -> ClosedSieve t a b -> r
\\ ClosedSieve Sieve a b
s = r
(Ob a, Ob b) => r
x ((Ob a, Ob b) => r) -> Sieve a b -> r
forall (a :: k) (b :: j) (r :: Coverage).
((Ob a, Ob b) => r) -> Sieve a b -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ Sieve a b
s
closedSieves
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b)
=> [ClosedSieve t a b]
closedSieves :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
[ClosedSieve t a b]
closedSieves = [Sieve a b -> ClosedSieve t a b
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j).
Sieve a b -> ClosedSieve t a b
ClosedSieve Sieve a b
s | Sieve a b
s <- forall {j :: Coverage} {k :: Coverage} (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 @(Sieve :: j +-> k) @a @b, forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Bool
isClosed @t Sieve a b
s]
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Finitary (ClosedSieve t :: j +-> k) where
size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural
size @a @b = [ClosedSieve t a b] -> Natural
forall (i :: Coverage) (a :: Coverage). Num i => [a] -> i
genericLength (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
[ClosedSieve t a b]
closedSieves @t @a @b)
toIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
ClosedSieve t a b -> Natural
toIndex @a @b =
let tables :: [[Bool]]
tables = (ClosedSieve t a b -> [Bool]) -> [ClosedSieve t a b] -> [[Bool]]
forall (a :: Coverage) (b :: Coverage). (a -> b) -> [a] -> [b]
P.map (\(ClosedSieve Sieve a b
s) -> Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s) (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
[ClosedSieve t a b]
closedSieves @t @a @b)
in \(ClosedSieve Sieve a b
s) -> [Char] -> [[Bool]] -> [Bool] -> Natural
forall (v :: Coverage). Eq v => [Char] -> [[v]] -> [v] -> Natural
familyIndex [Char]
"toIndex: not a closed sieve" [[Bool]]
tables (Sieve a b -> [Bool]
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(FiniteCat j, FiniteCat k) =>
Sieve a b -> [Bool]
sieveTable Sieve a b
s)
fromIndex :: forall (a :: k) (b :: j).
(Ob a, Ob b) =>
Natural -> ClosedSieve t a b
fromIndex @a @b = [ClosedSieve t a b] -> Natural -> ClosedSieve t a b
forall (i :: Coverage) (a :: Coverage). Integral i => [a] -> i -> a
genericIndex (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
[ClosedSieve t a b]
closedSieves @t @a @b)
elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [ClosedSieve t a b]
elements @a @b = forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) =>
[ClosedSieve t a b]
closedSieves @t @a @b
inClosedSieve :: forall {j} {k} t (a :: k) (b :: j) c d. ClosedSieve t a b -> c ~> a -> b ~> d -> P.Bool
inClosedSieve :: forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j) (c :: k) (d :: j).
ClosedSieve t a b -> (c ~> a) -> (b ~> d) -> Bool
inClosedSieve (ClosedSieve (Sieve forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s)) c ~> a
g b ~> d
h = (c ~> a) -> (b ~> d) -> Bool
forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool
s c ~> a
g b ~> d
h
instance (StableSite t k, CategoryOf j) => Sheaf t (ClosedSieve t :: j +-> k) where
glue :: forall (a :: k) (c :: Coverage) (b :: j).
(Ob a, Ob b) =>
Cover t k a c
-> (forall (x :: k). Leg t k a c x -> ClosedSieve t x b)
-> ClosedSieve t a b
glue Cover t k a c
c forall (x :: k). Leg t k a c x -> ClosedSieve t x b
m =
Sieve a b -> ClosedSieve t a b
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j).
Sieve a b -> ClosedSieve t a b
ClosedSieve
( (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
forall {k :: Coverage} {j :: Coverage} (a :: k) (b :: j).
(Ob a, Ob b) =>
(forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Bool)
-> Sieve a b
Sieve \c ~> a
g b ~> d
h ->
c ~> a
g (c ~> a) -> ((Ob c, Ob a) => Bool) -> Bool
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// case Cover t k a c -> (c ~> a) -> PulledBack t k a c c
forall (b :: k) (a :: k) (c :: Coverage).
Ob b =>
Cover t k a c -> (b ~> a) -> PulledBack t k a c b
forall (t :: Coverage) (k :: Coverage) (b :: k) (a :: k)
(c :: Coverage).
(StableSite t k, Ob b) =>
Cover t k a c -> (b ~> a) -> PulledBack t k a c b
pullbackCover Cover t k a c
c c ~> a
g of
AlreadyFactors (Factors Leg t k a c y
l c ~> y
u) -> ClosedSieve t y b -> (c ~> y) -> (b ~> d) -> Bool
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j) (c :: k) (d :: j).
ClosedSieve t a b -> (c ~> a) -> (b ~> d) -> Bool
inClosedSieve (Leg t k a c y -> ClosedSieve t y b
forall (x :: k). Leg t k a c x -> ClosedSieve t x b
m Leg t k a c y
l) c ~> y
u b ~> d
h
PulledBack Cover t k c c'
c' forall (x :: k). Leg t k c c' x -> Factors t k a c x
factorsThroughLeg ->
(SomeLeg t k c c' -> Bool) -> [SomeLeg t k c c'] -> Bool
forall (t :: Coverage -> Coverage) (a :: Coverage).
Foldable t =>
(a -> Bool) -> t a -> Bool
P.all (\(SomeLeg Leg t k c c' x
l') -> case Leg t k c c' x -> Factors t k a c x
forall (x :: k). Leg t k c c' x -> Factors t k a c x
factorsThroughLeg Leg t k c c' x
l' of Factors Leg t k a c y
l x ~> y
u -> ClosedSieve t y b -> (x ~> y) -> (b ~> d) -> Bool
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j) (c :: k) (d :: j).
ClosedSieve t a b -> (c ~> a) -> (b ~> d) -> Bool
inClosedSieve (Leg t k a c y -> ClosedSieve t y b
forall (x :: k). Leg t k a c x -> ClosedSieve t x b
m Leg t k a c y
l) x ~> y
u b ~> d
h) (Cover t k c c' -> [SomeLeg t k c c']
forall (a :: k) (c :: Coverage). Cover t k a c -> [SomeLeg t k a c]
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage).
Site t k =>
Cover t k a c -> [SomeLeg t k a c]
legs Cover t k c c'
c')
)
closedSieve
:: forall t {j} {k} (a :: k) (b :: j)
. (HasFiniteCovers t k, FiniteCat j, FiniteCat k)
=> Sieve a b
-> ClosedSieve t a b
closedSieve :: forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> ClosedSieve t a b
closedSieve Sieve a b
s = Sieve a b -> ClosedSieve t a b
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j).
Sieve a b -> ClosedSieve t a b
ClosedSieve (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> Sieve a b
closure @t Sieve a b
s)
type SHEAVES :: Coverage -> Kind -> Kind -> Kind
type SHEAVES t j k = SUBCAT ((Finitary :&&: Sheaf t) :: OB (j +-> k))
type SHF :: forall {j} {k}. forall (t :: Coverage) -> (j +-> k) -> SHEAVES t j k
type SHF t (p :: j +-> k) = SUB p :: SHEAVES t j k
instance (Site t k, Enumerable j, Enumerable k) => HasEqualizers (SHEAVES t j k) where
equalize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (r :: Coverage).
(a ~> b)
-> (a ~> b) -> (forall (e :: SHEAVES t j k). (e ~> a) -> r) -> r
equalize (Sub (Prof a1 :~> b1
f)) (Sub (Prof a1 :~> b1
g)) forall (e :: SHEAVES t j k). (e ~> a) -> r
k = (a1 :~> b1)
-> (a1 :~> b1)
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
(Reindex Subobject a1 fs :~> a1) -> r)
-> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k) (r :: Coverage).
(Finitary p, Finitary q, Enumerable j, Enumerable k) =>
(p :~> q)
-> (p :~> q)
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
(Reindex Subobject p fs :~> p) -> r)
-> r
equalizeNat a1 a b -> b1 a b
a1 :~> b1
f a1 a b -> b1 a b
a1 :~> b1
g \Reindex Subobject a1 fs :~> a1
incl -> (SUB (Reindex Subobject a1 fs) ~> a) -> r
forall (e :: SHEAVES t j k). (e ~> a) -> r
k (Prof (Reindex Subobject a1 fs) a1
-> Sub Prof (SUB (Reindex Subobject a1 fs)) (SUB a1)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((Reindex Subobject a1 fs :~> a1)
-> Prof (Reindex Subobject a1 fs) a1
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof Reindex Subobject a1 fs a b -> a1 a b
Reindex Subobject a1 fs :~> a1
incl))
factorEqualizer :: forall (e :: SHEAVES t j k) (x :: SHEAVES t j k)
(e' :: SHEAVES t j k).
(e ~> x) -> (e' ~> x) -> e' ~> e
factorEqualizer (Sub (Prof a1 :~> b1
incl)) (Sub (Prof a1 :~> b1
h)) = Prof a1 a1 -> Sub Prof (SUB a1) (SUB a1)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((a1 :~> a1) -> Prof a1 a1
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof ((a1 :~> b1) -> (a1 :~> b1) -> a1 :~> a1
forall {j :: Coverage} {k :: Coverage} (e :: j +-> k)
(x :: j +-> k) (e' :: j +-> k).
(Finitary e, Finitary x, Profunctor e') =>
(e :~> x) -> (e' :~> x) -> e' :~> e
factorThroughEqualizer a1 a b -> b1 a b
a1 :~> b1
incl a1 a b -> b1 a b
a1 :~> b1
h))
instance (Site t k, Enumerable j, Enumerable k) => HasPullbacks (SHEAVES t j k)
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasInitialObject (SHEAVES t j k) where
type InitialObject @(SHEAVES t j k) = SUB (Sheafify t InitialProfunctor)
initiate :: forall (a :: SHEAVES t j k). Ob a => InitialObject ~> a
initiate @(SUB q) = case forall (k :: Coverage) (a :: k).
(HasInitialObject k, Ob a) =>
InitialObject ~> a
initiate @(j +-> k) @q of Prof InitialProfunctor :~> UN SUB a
n -> Prof (Sheafify t InitialProfunctor) (UN SUB a)
-> Sub Prof (SUB (Sheafify t InitialProfunctor)) (SUB (UN SUB a))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((Sheafify t InitialProfunctor :~> UN SUB a)
-> Prof (Sheafify t InitialProfunctor) (UN SUB a)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Sheafify t p :~> q
extendSheafify @t InitialProfunctor a b -> UN SUB a a b
InitialProfunctor :~> UN SUB a
n))
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasBinaryCoproducts (SHEAVES t j k) where
type (||) @(SHEAVES t j k) a b = SUB (Sheafify t (UN SUB a :+: UN SUB b))
withObCoprod :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (r :: Coverage).
(Ob a, Ob b) =>
(Ob (a || b) => r) -> r
withObCoprod Ob (a || b) => r
r = r
Ob (a || b) => r
r
lft :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k).
(Ob a, Ob b) =>
a ~> (a || b)
lft = Prof (UN SUB a) (Sheafify t (UN SUB a :+: UN SUB b))
-> Sub
Prof (SUB (UN SUB a)) (SUB (Sheafify t (UN SUB a :+: UN SUB b)))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((UN SUB a :~> Sheafify t (UN SUB a :+: UN SUB b))
-> Prof (UN SUB a) (Sheafify t (UN SUB a :+: UN SUB b))
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \UN SUB a a b
x -> forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify @t (UN SUB a a b -> (:+:) (UN SUB a) (UN SUB b) a b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (q :: j +-> k).
p a b -> (:+:) p q a b
InjL UN SUB a a b
x))
rgt :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k).
(Ob a, Ob b) =>
b ~> (a || b)
rgt = Prof (UN SUB b) (Sheafify t (UN SUB a :+: UN SUB b))
-> Sub
Prof (SUB (UN SUB b)) (SUB (Sheafify t (UN SUB a :+: UN SUB b)))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((UN SUB b :~> Sheafify t (UN SUB a :+: UN SUB b))
-> Prof (UN SUB b) (Sheafify t (UN SUB a :+: UN SUB b))
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \UN SUB b a b
y -> forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify @t (UN SUB b a b -> (:+:) (UN SUB a) (UN SUB b) a b
forall {j :: Coverage} {k :: Coverage} (q :: j +-> k) (a :: k)
(b :: j) (p :: j +-> k).
q a b -> (:+:) p q a b
InjR UN SUB b a b
y))
Sub (Prof a1 :~> b1
f) ||| :: forall (x :: SHEAVES t j k) (a :: SHEAVES t j k)
(y :: SHEAVES t j k).
(x ~> a) -> (y ~> a) -> (x || y) ~> a
||| Sub (Prof a1 :~> b1
g) = Prof (Sheafify t (a1 :+: a1)) b1
-> Sub Prof (SUB (Sheafify t (a1 :+: a1))) (SUB b1)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((Sheafify t (a1 :+: a1) :~> b1) -> Prof (Sheafify t (a1 :+: a1)) b1
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (q :: j +-> k).
(HasFiniteCovers t k, Sheaf t q) =>
(p :~> q) -> Sheafify t p :~> q
extendSheafify @t \case InjL a1 a b
x -> a1 a b -> b1 a b
a1 :~> b1
f a1 a b
x; InjR a1 a b
y -> a1 a b -> b1 a b
a1 :~> b1
g a1 a b
y))
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasCoequalizers (SHEAVES t j k) where
coequalize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (r :: Coverage).
(a ~> b)
-> (a ~> b) -> (forall (c :: SHEAVES t j k). (b ~> c) -> r) -> r
coequalize (Sub (Prof @_ @q a1 :~> b1
f)) (Sub (Prof a1 :~> b1
g)) forall (c :: SHEAVES t j k). (b ~> c) -> r
k =
(a1 :~> b1)
-> (a1 :~> b1)
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
(b1 :~> Reindex Quotient b1 fs) -> r)
-> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k) (r :: Coverage).
(Finitary p, Finitary q, Enumerable j, Enumerable k) =>
(p :~> q)
-> (p :~> q)
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
(q :~> Reindex Quotient q fs) -> r)
-> r
coequalizeNat a1 a b -> b1 a b
a1 :~> b1
f a1 a b -> b1 a b
a1 :~> b1
g \ @fs b1 :~> Reindex Quotient b1 fs
proj ->
forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (r :: Coverage).
(Sheaf t p, Finitary p, FiniteCat j, FiniteCat k) =>
(forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r)
-> r
withSheafTables @t @(Sheafify t (Reindex Quotient q fs))
\Sheafify t (Reindex Quotient b1 fs) :~> tab
toTab tab :~> Sheafify t (Reindex Quotient b1 fs)
_ -> (b ~> SUB (Tabulated t lm rm)) -> r
forall (c :: SHEAVES t j k). (b ~> c) -> r
k (Prof b1 (Tabulated t lm rm)
-> Sub Prof (SUB b1) (SUB (Tabulated t lm rm))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((b1 :~> Tabulated t lm rm) -> Prof b1 (Tabulated t lm rm)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \b1 a b
x -> Sheafify t (Reindex Quotient b1 fs) a b -> tab a b
Sheafify t (Reindex Quotient b1 fs) :~> tab
toTab (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify @t (b1 a b -> Reindex Quotient b1 fs a b
b1 :~> Reindex Quotient b1 fs
proj b1 a b
x))))
factorCoequalizer :: forall (c :: SHEAVES t j k) (x :: SHEAVES t j k)
(c' :: SHEAVES t j k).
(x ~> c) -> (x ~> c') -> c ~> c'
factorCoequalizer (Sub (Prof a1 :~> b1
proj)) (Sub (Prof a1 :~> b1
h)) = Prof b1 b1 -> Sub Prof (SUB b1) (SUB b1)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((b1 :~> b1) -> Prof b1 b1
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(c :: j +-> k) (x :: j +-> k) (c' :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Finitary c, Finitary x,
Sheaf t c') =>
(x :~> c) -> (x :~> c') -> c :~> c'
factorThroughLocalEpi @t a1 a b -> b1 a b
a1 :~> b1
proj a1 a b -> b1 a b
a1 :~> b1
h))
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasPushouts (SHEAVES t j k) where
pushout :: forall (o :: SHEAVES t j k) (a :: SHEAVES t j k)
(b :: SHEAVES t j k) (r :: Coverage).
(o ~> a)
-> (o ~> b)
-> (forall (p :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> r)
-> r
pushout (Sub (Prof @_ @a a1 :~> b1
f)) (Sub (Prof @_ @b a1 :~> b1
g)) forall (p :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> r
k =
(a1 :~> (b1 :+: b1))
-> (a1 :~> (b1 :+: b1))
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
((b1 :+: b1) :~> Reindex Quotient (b1 :+: b1) fs) -> r)
-> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k) (r :: Coverage).
(Finitary p, Finitary q, Enumerable j, Enumerable k) =>
(p :~> q)
-> (p :~> q)
-> (forall (fs :: [[[[Nat]]]]).
KnownTable (Objects j) (Objects k) fs =>
(q :~> Reindex Quotient q fs) -> r)
-> r
coequalizeNat (\a1 a b
x -> b1 a b -> (:+:) b1 b1 a b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (q :: j +-> k).
p a b -> (:+:) p q a b
InjL (a1 a b -> b1 a b
a1 :~> b1
f a1 a b
x)) (\a1 a b
x -> b1 a b -> (:+:) b1 b1 a b
forall {j :: Coverage} {k :: Coverage} (q :: j +-> k) (a :: k)
(b :: j) (p :: j +-> k).
q a b -> (:+:) p q a b
InjR (a1 a b -> b1 a b
a1 :~> b1
g a1 a b
x)) \ @fs (b1 :+: b1) :~> Reindex Quotient (b1 :+: b1) fs
proj ->
forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k) (r :: Coverage).
(Sheaf t p, Finitary p, FiniteCat j, FiniteCat k) =>
(forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k).
(tab ~ Tabulated t lm rm, KnownTables j k lm rm, Sheaf t tab) =>
(p :~> tab) -> (tab :~> p) -> r)
-> r
withSheafTables @t @(Sheafify t (Reindex Quotient (a :+: b) fs))
\Sheafify t (Reindex Quotient (b1 :+: b1) fs) :~> tab
toTab tab :~> Sheafify t (Reindex Quotient (b1 :+: b1) fs)
_ ->
(a ~> SUB (Tabulated t lm rm))
-> (b ~> SUB (Tabulated t lm rm)) -> r
forall (p :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> r
k
(Prof b1 (Tabulated t lm rm)
-> Sub Prof (SUB b1) (SUB (Tabulated t lm rm))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((b1 :~> Tabulated t lm rm) -> Prof b1 (Tabulated t lm rm)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \b1 a b
x -> Sheafify t (Reindex Quotient (b1 :+: b1) fs) a b -> tab a b
Sheafify t (Reindex Quotient (b1 :+: b1) fs) :~> tab
toTab (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify @t ((:+:) b1 b1 a b -> Reindex Quotient (b1 :+: b1) fs a b
(b1 :+: b1) :~> Reindex Quotient (b1 :+: b1) fs
proj (b1 a b -> (:+:) b1 b1 a b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (q :: j +-> k).
p a b -> (:+:) p q a b
InjL b1 a b
x)))))
(Prof b1 (Tabulated t lm rm)
-> Sub Prof (SUB b1) (SUB (Tabulated t lm rm))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((b1 :~> Tabulated t lm rm) -> Prof b1 (Tabulated t lm rm)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \b1 a b
y -> Sheafify t (Reindex Quotient (b1 :+: b1) fs) a b -> tab a b
Sheafify t (Reindex Quotient (b1 :+: b1) fs) :~> tab
toTab (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(p :: j +-> k).
Profunctor p =>
p :~> Sheafify t p
unitSheafify @t ((:+:) b1 b1 a b -> Reindex Quotient (b1 :+: b1) fs a b
(b1 :+: b1) :~> Reindex Quotient (b1 :+: b1) fs
proj (b1 a b -> (:+:) b1 b1 a b
forall {j :: Coverage} {k :: Coverage} (q :: j +-> k) (a :: k)
(b :: j) (p :: j +-> k).
q a b -> (:+:) p q a b
InjR b1 a b
y)))))
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
factorPushout (Sub (Prof a1 :~> b1
p1)) (Sub (Prof a1 :~> b1
p2)) (Sub (Prof a1 :~> b1
k1)) (Sub (Prof a1 :~> b1
k2)) =
Prof b1 b1 -> Sub Prof (SUB b1) (SUB b1)
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((b1 :~> b1) -> Prof b1 b1
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof (forall (t :: Coverage) {j :: Coverage} {k :: Coverage}
(c :: j +-> k) (x :: j +-> k) (c' :: j +-> k).
(HasFiniteCovers t k, CategoryOf j, Finitary c, Finitary x,
Sheaf t c') =>
(x :~> c) -> (x :~> c') -> c :~> c'
factorThroughLocalEpi @t (\case InjL a1 a b
x -> a1 a b -> b1 a b
a1 :~> b1
p1 a1 a b
x; InjR a1 a b
y -> a1 a b -> b1 a b
a1 :~> b1
p2 a1 a b
y) (\case InjL a1 a b
x -> a1 a b -> b1 a b
a1 :~> b1
k1 a1 a b
x; InjR a1 a b
y -> a1 a b -> b1 a b
a1 :~> b1
k2 a1 a b
y)))
instance (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasEpiMonoFactorization (SHEAVES t j k)
instance (StableSite t k, Sheaf t q, Profunctor p, CategoryOf j) => Sheaf t (p :~>: q :: j +-> k) where
glue :: forall (a :: k) (c :: Coverage) (b :: j).
(Ob a, Ob b) =>
Cover t k a c
-> (forall (x :: k). Leg t k a c x -> (:~>:) p q x b)
-> (:~>:) p q a b
glue Cover t k a c
c forall (x :: k). Leg t k a c x -> (:~>:) p q x b
m = (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> p c d -> q c d)
-> (:~>:) p q a b
forall {k :: Coverage} {k1 :: Coverage} (a :: k) (b :: k1)
(p :: k -> k1 -> Coverage) (q :: k -> k1 -> Coverage).
(Ob a, Ob b) =>
(forall (c :: k) (d :: k1). (c ~> a) -> (b ~> d) -> p c d -> q c d)
-> (:~>:) p q a b
Exp \c ~> a
g b ~> d
h p c d
x ->
c ~> a
g (c ~> a) -> ((Ob c, Ob a) => q c d) -> q c d
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// b ~> d
h (b ~> d) -> ((Ob b, Ob d) => q c d) -> q c d
forall {k1 :: Coverage} {k2 :: Coverage} (p :: k1 +-> k2) (a :: k2)
(b :: k1) (r :: Coverage).
Profunctor p =>
p a b -> ((Ob a, Ob b) => r) -> r
// case Cover t k a c -> (c ~> a) -> PulledBack t k a c c
forall (b :: k) (a :: k) (c :: Coverage).
Ob b =>
Cover t k a c -> (b ~> a) -> PulledBack t k a c b
forall (t :: Coverage) (k :: Coverage) (b :: k) (a :: k)
(c :: Coverage).
(StableSite t k, Ob b) =>
Cover t k a c -> (b ~> a) -> PulledBack t k a c b
pullbackCover Cover t k a c
c c ~> a
g of
AlreadyFactors (Factors Leg t k a c y
l c ~> y
u) -> case Leg t k a c y -> (:~>:) p q y b
forall (x :: k). Leg t k a c x -> (:~>:) p q x b
m Leg t k a c y
l of Exp forall (c :: k) (d :: j). (c ~> y) -> (b ~> d) -> p c d -> q c d
f -> (c ~> y) -> (b ~> d) -> p c d -> q c d
forall (c :: k) (d :: j). (c ~> y) -> (b ~> d) -> p c d -> q c d
f c ~> y
u b ~> d
h p c d
x
PulledBack Cover t k c c'
c' forall (x :: k). Leg t k c c' x -> Factors t k a c x
factorsThroughLeg -> forall {j :: Coverage} {k :: Coverage} (t :: Coverage)
(p :: j +-> k) (a :: k) (c :: Coverage) (b :: j).
(Sheaf t p, Ob a, Ob b) =>
Cover t k a c -> (forall (x :: k). Leg t k a c x -> p x b) -> p a b
forall (t :: Coverage) (p :: j +-> k) (a :: k) (c :: Coverage)
(b :: j).
(Sheaf t p, Ob a, Ob b) =>
Cover t k a c -> (forall (x :: k). Leg t k a c x -> p x b) -> p a b
glue @t Cover t k c c'
c' \Leg t k c c' x
l' ->
case Leg t k c c' x -> Factors t k a c x
forall (x :: k). Leg t k c c' x -> Factors t k a c x
factorsThroughLeg Leg t k c c' x
l' of
Factors Leg t k a c y
l x ~> y
u -> case Leg t k a c y -> (:~>:) p q y b
forall (x :: k). Leg t k a c x -> (:~>:) p q x b
m Leg t k a c y
l of Exp forall (c :: k) (d :: j). (c ~> y) -> (b ~> d) -> p c d -> q c d
f -> (x ~> y) -> (b ~> d) -> p x d -> q x d
forall (c :: k) (d :: j). (c ~> y) -> (b ~> d) -> p c d -> q c d
f x ~> y
u b ~> d
h ((x ~> c) -> p c d -> p x d
forall (c :: k) (a :: k) (b :: j). (c ~> a) -> p a b -> p c b
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (c :: k)
(a :: k) (b :: j).
Profunctor p =>
(c ~> a) -> p a b -> p c b
lmap (Leg t k c c' x -> x ~> c
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k c c' x
l') p c d
x) ((Ob x, Ob c) => q x d) -> (x ~> c) -> q x d
forall (a :: k) (b :: k) (r :: Coverage).
((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a :: k)
(b :: j) (r :: Coverage).
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ Leg t k c c' x -> x ~> c
forall (a :: k) (c :: Coverage) (x :: k). Leg t k a c x -> x ~> a
forall (t :: Coverage) (k :: Coverage) (a :: k) (c :: Coverage)
(x :: k).
Site t k =>
Leg t k a c x -> x ~> a
legArrow Leg t k c c' x
l'
instance (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasSubobjectClassifier (PROD (SHEAVES t j k)) where
type Omega @(PROD (SHEAVES t j k)) = PR (SUB (ClosedSieve t))
true :: TerminalObject ~> Omega
true = Sub Prof (SUB TerminalProfunctor) (SUB (ClosedSieve t))
-> Prod
(Sub Prof) (PR (SUB TerminalProfunctor)) (PR (SUB (ClosedSieve t)))
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a1 :: k)
(b1 :: j).
p a1 b1 -> Prod p (PR a1) (PR b1)
Prod (Prof TerminalProfunctor (ClosedSieve t)
-> Sub Prof (SUB TerminalProfunctor) (SUB (ClosedSieve t))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub ((TerminalProfunctor :~> ClosedSieve t)
-> Prof TerminalProfunctor (ClosedSieve t)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof \TerminalProfunctor a b
TerminalProfunctor -> Sieve a b -> ClosedSieve t a b
forall {j :: Coverage} {k :: Coverage} (t :: Coverage) (a :: k)
(b :: j).
Sieve a b -> ClosedSieve t a b
ClosedSieve Sieve a b
forall {j :: Coverage} {k :: Coverage} (a :: k) (b :: j).
(CategoryOf j, CategoryOf k, Ob a, Ob b) =>
Sieve a b
maximalSieve))
classifyGraph :: forall (a :: PROD (SHEAVES t j k)) (b :: PROD (SHEAVES t j k)).
(a ~> b) -> (a && b) ~> Omega
classifyGraph (Prod (Sub (Prof a1 :~> b1
n))) = Sub Prof (SUB (a1 :*: b1)) (SUB (ClosedSieve t))
-> Prod
(Sub Prof) (PR (SUB (a1 :*: b1))) (PR (SUB (ClosedSieve t)))
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k) (a1 :: k)
(b1 :: j).
p a1 b1 -> Prod p (PR a1) (PR b1)
Prod (Prof (a1 :*: b1) (ClosedSieve t)
-> Sub Prof (SUB (a1 :*: b1)) (SUB (ClosedSieve t))
forall {k :: Coverage} (ob :: OB k) (a1 :: k) (b1 :: k)
(p :: CAT k).
(ob a1, ob b1) =>
p a1 b1 -> Sub p (SUB a1) (SUB b1)
Sub (((a1 :*: b1) :~> ClosedSieve t) -> Prof (a1 :*: b1) (ClosedSieve t)
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Profunctor q) =>
(p :~> q) -> Prof p q
Prof (forall (t :: Coverage) {j :: Coverage} {k :: Coverage} (a :: k)
(b :: j).
(HasFiniteCovers t k, FiniteCat j, FiniteCat k) =>
Sieve a b -> ClosedSieve t a b
closedSieve @t (Sieve a b -> ClosedSieve t a b)
-> ((:*:) a1 b1 a b -> Sieve a b)
-> (:*:) a1 b1 a b
-> ClosedSieve t a b
forall (b :: Coverage) (c :: Coverage) (a :: Coverage).
(b -> c) -> (a -> b) -> a -> c
forall {k :: Coverage} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. (a1 :~> b1) -> (a1 :*: b1) :~> Sieve
forall {j :: Coverage} {k :: Coverage} (p :: j +-> k)
(q :: j +-> k).
(Profunctor p, Finitary q) =>
(p :~> q) -> (p :*: q) :~> Sieve
graphSieve a1 a b -> b1 a b
a1 :~> b1
n)))
instance (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => ElementaryTopos (PROD (SHEAVES t j k))