| Safe Haskell | None |
|---|---|
| Language | GHC2024 |
Proarrow.Category.Enriched.Finitary.Sheaf
Description
Sheaves on a finite site, decided by enumeration.
A site is a category where each object a has some covers: families of arrows into a. A
profunctor is a sheaf when an element at a is the same thing as a matching family on a
cover: one element at the source of each leg, agreeing wherever two legs overlap. With finitely
many objects and elements both sides can be listed, and sheafAt compares the two lists. They
must agree as multisets. Equal lengths are not enough: a presheaf can have as many elements as
matching families and still not be a sheaf.
A cover of a generates a Sieve, the arrows into a that factor through a leg, and the
matching families are the natural transformations out of it (withSieve).
The coverage also gives a closure on sieves (closure, lawvereTierney), truth values
(ClosedSieve) and a sheafification (Sheafify) with its unit and universal property. All of
them are computed, so they too can be enumerated and compared, and together they make SHEAVES
an elementary topos.
Synopsis
- 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
- isMaximal :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> Bool
- contains :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> Sieve a b -> Bool
- isCovering :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool
- coveringCover :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, CategoryOf j) => Sieve a b -> Maybe (SomeCover 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
- isClosed :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool
- lawvereTierney :: forall t j k. (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => (Omega :: PROD (FINITARY j k)) ~> (Omega :: PROD (FINITARY j k))
- isSheaf :: forall t {j} {k} (p :: j +-> k). (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => Bool
- 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 -> Bool
- withSieve :: forall {j} {k} (a :: k) (b :: j) r. (FiniteCat j, FiniteCat k) => Sieve a b -> (forall (q :: j +-> k). Finitary q => (q :~> Yo a ('OP b)) -> r) -> r
- withTabulatedSheaf :: forall t {j} {k} (p :: j +-> k) r. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => (forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k). (tab ~ (Tabulated t lm rm :: k -> j -> Type), KnownTables j k lm rm, Sheaf t tab) => (p :~> tab) -> (tab :~> p) -> r) -> r -> r
- withSheafTables :: forall t {j} {k} (p :: j +-> k) r. (Sheaf t p, Finitary p, FiniteCat j, FiniteCat k) => (forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k). (tab ~ (Tabulated t lm rm :: k -> j -> Type), KnownTables j k lm rm, Sheaf t tab) => (p :~> tab) -> (tab :~> p) -> r) -> r
- factorLocally :: forall t {j} {k} p q. (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
- factorThroughLocalEpi :: forall t {j} {k} (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'
- data Plus t (p :: j +-> k) (a :: k) (b :: j) where
- support :: forall {k1} {k} t (p :: k1 +-> k) (a :: k) (b :: k1). Plus t p a b -> Sieve a b
- isDense :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool
- leastDenseSieve :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) => Sieve 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]
- restrictTo :: forall {j} {k} (q :: k -> j -> Type) (a :: k) (b :: j) t (p :: j +-> k). (q :~> Yo a ('OP b)) -> Plus t p a b -> q :~> p
- 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]
- 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 -> Bool
- type Sheafify t (p :: j +-> k) = Plus t (Plus t p)
- unitPlus :: forall t {j} {k} (p :: j +-> k). Profunctor p => p :~> Plus t p
- unitSheafify :: forall t {j} {k} (p :: j +-> k). Profunctor p => p :~> Sheafify t p
- extendPlus :: forall t {j} {k} (p :: j +-> k) (q :: j +-> k). (HasFiniteCovers t k, Sheaf t q) => (p :~> q) -> Plus t p :~> q
- 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 :: k). Leg t k a c x -> Plus t q x b) -> Plus t q a b
- extendSheafify :: forall t {j} {k} (p :: j +-> k) (q :: j +-> k). (HasFiniteCovers t k, Sheaf t q) => (p :~> q) -> Sheafify t p :~> q
- newtype ClosedSieve t (a :: k) (b :: j) = ClosedSieve (Sieve a b)
- closedSieves :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) => [ClosedSieve t a b]
- inClosedSieve :: forall {j} {k} t (a :: k) (b :: j) (c :: k) (d :: j). ClosedSieve t a b -> (c ~> a) -> (b ~> d) -> Bool
- closedSieve :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> ClosedSieve t a b
- type SHEAVES t j k = SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))
- type SHF t (p :: j +-> k) = 'SUB p :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))
Sieves and their closure
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 Source Github #
The sieve a cover generates at (a, b): the arrows into a that factor through a leg,
paired with every arrow out of b.
isMaximal :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> Bool Source Github #
Whether a sieve is the maximal one, containing every arrow of the category.
contains :: forall {j} {k} (a :: k) (b :: j). (FiniteCat j, FiniteCat k) => Sieve a b -> Sieve a b -> Bool Source Github #
Whether every point of the second sieve is a point of the first.
isCovering :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool Source Github #
Whether a sieve is covering: either it is the maximal sieve, or it contains the sieve that some
cover of its object generates. A sieve is closed under composition, so that amounts to
containing the cover's legs (coveringCover).
This takes the coverage at face value. It agrees with the Grothendieck topology the coverage
generates only when the covers are stable and compose. When they do not, closure stops being
idempotent, which testLawvereTierney detects.
coveringCover :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, CategoryOf j) => Sieve a b -> Maybe (SomeCover t k a) Source Github #
The first listed cover all of whose legs lie in the sieve, if there is one. Both isCovering
and extendPlus use this search. It needs no tabulation, since whether a sieve contains the
legs at the identity decides whether it contains everything they generate.
This relies on the closure that Proarrow.Profunctor.Instance.Sieve does not enforce. On a hand-built predicate that is not a sieve it can say yes where comparing the whole generated sieve says no.
closure :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Sieve a b Source Github #
The Lawvere–Tierney closure of a sieve: the pairs (g, h) along which it pulls back to a
covering one. A sieve is covering iff its closure is the maximal sieve.
This uses , not dimap g h. A coverage constrains only the contravariant side, but
a sieve over lmap gj has two sides, and +-> kclosure has to be natural in both.
isClosed :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool Source Github #
Whether a sieve is closed for the topology, i.e. equal to its own closure. These are the
truth values of the sheaf topos, as the sieves are of the presheaf one (see ClosedSieve).
lawvereTierney :: forall t j k. (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => (Omega :: PROD (FINITARY j k)) ~> (Omega :: PROD (FINITARY j k)) Source Github #
The coverage as a Lawvere–Tierney topology on the topos of finitary profunctors: closure, as
an arrow on the subobject classifier.
Deciding the sheaf condition
isSheaf :: forall t {j} {k} (p :: j +-> k). (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => Bool Source Github #
Whether a finitary profunctor is a sheaf for the coverage: at every pair of objects and every cover, restriction is a bijection from the elements at the covered object to the matching families on the sieve the cover generates.
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 -> Bool Source Github #
The sheaf condition at one cover: the restrictions of the elements at the covered object are the matching families on the sieve it generates, as multisets.
withSieve :: forall {j} {k} (a :: k) (b :: j) r. (FiniteCat j, FiniteCat k) => Sieve a b -> (forall (q :: j +-> k). Finitary q => (q :~> Yo a ('OP b)) -> r) -> r Source Github #
A sieve as a subobject of the representable , handed on with its inclusion.
A natural transformation out of it picks an element for every arrow in the sieve, compatibly
with precomposition, which is what a matching family on the sieve is. Yo a (OP b)sheafAt and Plus both
define matching families this way.
The error branch is unreachable for any coverage, since generatedSieve and leastDenseSieve
always give real sieves. Reaching it would take a Finitary instance on the hom-profunctor
whose elements omits an arrow, which testFinitary rules out.
Presenting a sheaf by its tables
withTabulatedSheaf :: forall t {j} {k} (p :: j +-> k) r. (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => (forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k). (tab ~ (Tabulated t lm rm :: k -> j -> Type), KnownTables j k lm rm, Sheaf t tab) => (p :~> tab) -> (tab :~> p) -> r) -> r -> r Source Github #
Present a finitary profunctor by its tables, as
withTabulated does, tagged with the coverage so that
it has a Sheaf instance. That instance is decided here by isSheaf; the failure continuation
is taken when p is no sheaf for t.
This makes a sheaf with no Sheaf instance of its own (a representable, a sheafification) an
object of SHEAVES. Deciding on the tables is also cheaper than on p: a Sheafify answers
each toIndex by re-running the plus construction.
withSheafTables :: forall t {j} {k} (p :: j +-> k) r. (Sheaf t p, Finitary p, FiniteCat j, FiniteCat k) => (forall {lm :: [[[[Nat]]]]} {rm :: [[[[Nat]]]]} (tab :: j +-> k). (tab ~ (Tabulated t lm rm :: k -> j -> Type), KnownTables j k lm rm, Sheaf t tab) => (p :~> tab) -> (tab :~> p) -> r) -> r Source Github #
withTabulatedSheaf for a profunctor that already is a Sheaf, so there is nothing to decide.
The colimits below present their apex, a Sheafify, with this, because an unpresented
Sheafify re-runs the whole plus construction each time the continuation asks for elements.
Descent
factorLocally :: forall t {j} {k} p q. (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 Source Github #
Extend a partial natural transformation into a sheaf to a total one. Where f is undefined
at an element y, it must be defined on the restrictions of y along the legs of some listed
cover, and those values are glued in q. Only this one level of descent is tried.
extendPlus is this at . The colimits below need it because an epimorphism of
sheaves is only locally onto: an element may have no preimage while its restrictions along a
cover all do.Plus t p
glue is lawful here when f commutes with restriction where it is defined. For the callers
below that means the arrow being factored is constant on the fibres it factors through.
factorThroughLocalEpi :: forall t {j} {k} (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' Source Github #
Factor through a map that is onto only locally: of the preimage search.
Where factorLocallyfactorThroughCoequalizer asks the map to be
onto, this asks only what being epi in the sheaves gives.
A pushout needs this for its pair of injections, which are jointly locally onto but not
separately. That case is this at the coproduct, since two arrows into an object are one arrow
out of a . One search over that is also one :+: btoIndex of the element instead of two.
Sheafification
data Plus t (p :: j +-> k) (a :: k) (b :: j) where Source Github #
One step of the plus construction for the topology t. A Plus value is a matching family on
some dense sieve, given as a partial function: it is defined at (g, h) iff that pair is in the
sieve (support), so the sieve cannot disagree with the family. Two values are the same
element when they agree on a dense sieve. Intuitively an element at a is an element of p
given locally: pieces on a cover of a that agree on overlaps.
On a finite site whose covers compose (HasFiniteCovers's Composition law) there is a least
dense sieve, leastDenseSieve, and each element has one family on it. A value is identified by
its restriction there (plusTable), which is what Finitary numbers and Proarrow.Testing
compares, so no quotient is needed. leastDenseSieve fails loudly where the law does not hold.
The constructor does not check that the support is a dense sieve or that the family is
matching. plusElements builds only lawful values; one built by hand is its builder's
responsibility.
Constructors
| Plus :: forall {k} {j} (a :: k) (b :: j) (p :: j +-> k) t. (Ob a, Ob b) => (forall (c :: k) (d :: j). (c ~> a) -> (b ~> d) -> Maybe (p c d)) -> Plus t p a b |
Instances
| (Site t k, LocallyFinite k, CategoryOf j) => Sheaf t (Sheafify t p :: k -> j -> Type) Source Github # | Sheafification lands in the sheaves (
|
| (HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => Finitary (Plus t p :: k -> j -> Type) Source Github # | Numbered by |
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Plus t p a b -> Natural Source Github # fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> Plus t p a b Source Github # elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [Plus t p a b] Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (Plus t p :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Plus t p a b -> Plus t p c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> Plus t p a b -> Plus t p c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> Plus t p a b -> Plus t p a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Plus t p a b -> r Source Github # | |
support :: forall {k1} {k} t (p :: k1 +-> k) (a :: k) (b :: k1). Plus t p a b -> Sieve a b Source Github #
The sieve a value is defined on.
isDense :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> Bool Source Github #
Whether a sieve is dense for the topology: its closure is the maximal sieve. On a lawful
coverage this agrees with isCovering (testDenseIsCovering checks
that). But density is the stable notion, and Plus needs stability, since dimap pulls a
support back along arrows.
leastDenseSieve :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) => Sieve a b Source Github #
The meet of all the dense sieves at a pair of objects. When the covers compose, closure
preserves meets, so this is the least dense sieve. Restriction to it picks one matching family
out of each element of Plus. On a coverage whose covers pull back but do not compose the meet
need not be dense, and then this errors, naming the law that failed, instead of letting Plus
compute on it. The smallest example is a poset w ≤ x ≤ a, w ≤ y ≤ a with a covered by x
and by y separately and each of those by w.
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] Source Github #
The elements of Plus at a pair of objects: the matching families on the least dense sieve, in
the order natElements lists them.
restrictTo :: forall {j} {k} (q :: k -> j -> Type) (a :: k) (b :: j) t (p :: j +-> k). (q :~> Yo a ('OP b)) -> Plus t p a b -> q :~> p Source Github #
A value restricted to a sieve reified as a subobject: the natural transformation out of it that the value's family is.
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] Source Github #
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 -> Bool Source Github #
Whether two values stand for the same element: their restrictions to the least dense sieve
agree. This builds one sieve for the pair, where two plusTables would each build their own.
Proarrow.Testing's equality on Plus uses it, since it compares far more often than it shows.
type Sheafify t (p :: j +-> k) = Plus t (Plus t p) Source Github #
Sheafification: the plus construction twice. One Plus makes a profunctor separated (two
elements with the same restrictions to a dense sieve are equal), and the second makes it a
sheaf. The first alone need not: the constant presheaf with two values on the discrete two-point
space has one section over the empty set after one plus, but still two over the whole space
where a sheaf needs four. On a site whose covers have no overlaps, such as
Atomic on the walking arrow, one plus is already a sheaf and the
second changes nothing.
unitPlus :: forall t {j} {k} (p :: j +-> k). Profunctor p => p :~> Plus t p Source Github #
The unit of the plus construction: an element as the family of its own restrictions, on the maximal sieve.
unitSheafify :: forall t {j} {k} (p :: j +-> k). Profunctor p => p :~> Sheafify t p Source Github #
unitPlus twice: the unit of sheafification.
extendPlus :: forall t {j} {k} (p :: j +-> k) (q :: j +-> k). (HasFiniteCovers t k, Sheaf t q) => (p :~> q) -> Plus t p :~> q Source Github #
The universal property, one plus at a time: a map into a sheaf extends along unitPlus. A
dense support is either everything, and then the family is read off at the identity, or it
contains the legs of some listed cover (density at the identity says so, and coveringCover
finds it), and then the family restricted to those legs glues. Since q is a sheaf, it does not
matter which cover is found. q need not be Finitary; only gluing is asked of it.
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 :: k). Leg t k a c x -> Plus t q x b) -> Plus t q a b Source Github #
Gluing for the plus construction: a matching family over a cover, assembled into one value.
At (g, h) it takes the first leg l with g = l . u (factorThrough) whose family is
defined at (u, h). The support of the result is generated by the legs' supports, so it is dense
by HasFiniteCovers's Composition law. For a matching family the choice
of leg and factorisation does not matter, and glue promises nothing on others.
extendSheafify :: forall t {j} {k} (p :: j +-> k) (q :: j +-> k). (HasFiniteCovers t k, Sheaf t q) => (p :~> q) -> Sheafify t p :~> q Source Github #
extendPlus twice: a map into a sheaf extends along unitSheafify.
The truth values of the topos
newtype ClosedSieve t (a :: k) (b :: j) Source Github #
A sieve equal to its own closure. These are the truth values of the sheaves for t, as all
sieves are of the presheaves. A subsheaf s of p sends an element x to the sieve of pairs
(g, h) with in dimap g h xs. That sieve is closed: if the restrictions of x along a
cover are in s, gluing puts x in s.
It is a newtype because the object has to be nameable, and the equalizer of lawvereTierney
and the identity on Omega (equalizeNat) binds its table existentially.
It is the classifier only when the coverage is a Grothendieck topology (HasFiniteCovers's
Composition law, checked by testLawvereTierney_). Otherwise it quietly
computes something else, while leastDenseSieve fails loudly.
The constructor checks nothing. elements produces only closed sieves, and closedSieve
closes any sieve.
Constructors
| ClosedSieve (Sieve a b) |
Instances
| (StableSite t k, CategoryOf j) => Sheaf t (ClosedSieve t :: k -> j -> Type) Source Github # | The classifier is a sheaf, with gluing built directly: the glued sieve contains |
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods glue :: forall (a :: k) c (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 Source Github # | |
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Finitary (ClosedSieve t :: k -> j -> Type) Source Github # | |
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods size :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => ClosedSieve t a b -> Natural Source Github # fromIndex :: forall (a :: k) (b :: j). (Ob a, Ob b) => Natural -> ClosedSieve t a b Source Github # elements :: forall (a :: k) (b :: j). (Ob a, Ob b) => [ClosedSieve t a b] Source Github # | |
| (CategoryOf j, CategoryOf k) => Profunctor (ClosedSieve t :: k -> j -> Type) Source Github # | Closure commutes with |
Defined in Proarrow.Category.Enriched.Finitary.Sheaf Methods dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> ClosedSieve t a b -> ClosedSieve t c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: j). (c ~> a) -> ClosedSieve t a b -> ClosedSieve t c b Source Github # rmap :: forall (b :: j) (d :: j) (a :: k). (b ~> d) -> ClosedSieve t a b -> ClosedSieve t a d Source Github # (\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> ClosedSieve t a b -> r Source Github # | |
closedSieves :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k, Ob a, Ob b) => [ClosedSieve t a b] Source Github #
The closed sieves at a pair of objects, in the order Sieve lists them.
inClosedSieve :: forall {j} {k} t (a :: k) (b :: j) (c :: k) (d :: j). ClosedSieve t a b -> (c ~> a) -> (b ~> d) -> Bool Source Github #
Whether an arrow pair is in a closed sieve.
closedSieve :: forall t {j} {k} (a :: k) (b :: j). (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => Sieve a b -> ClosedSieve t a b Source Github #
Any sieve as a closed one: lawvereTierney corestricted to its fixed points, which is the
reflection of the presheaf classifier onto the sheaf one.
The category of sheaves
type SHEAVES t j k = SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)) Source Github #
The full subcategory of on the sheaves for FINITARY j kt. Finite limits and the
exponential are FINITARY's, and are sheaves by the closure instances (TerminalProfunctor,
:*:, Reindex, :~>:). Colimits are FINITARY's
followed by Sheafify, since a quotient of sheaves need not be a sheaf, and their universal
property uses factorLocally, since an epi of sheaves is onto only locally.
is OmegaClosedSieve.
type SHF t (p :: j +-> k) = 'SUB p :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)) Source Github #
Orphan instances
| (StableSite t k, Sheaf t q, Profunctor p, CategoryOf j) => Sheaf t (p :~>: q :: k -> j -> Type) Source Github # | The presheaf internal hom into a sheaf is already a sheaf: a matching family of maps The glued map, at an arrow | ||||
| (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => ElementaryTopos (PROD (SHEAVES t j k)) Source Github # | The topos of sheaves. Finite limits and colimits, cartesian closed, a subobject classifier, and image factorization, all defined above and none of them postulated. The exponential needs | ||||
| (StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasSubobjectClassifier (PROD (SHEAVES t j k)) Source Github # | The classifier is the closed sieves, and an arrow is classified by | ||||
Associated Types
| |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasEpiMonoFactorization (SHEAVES t j k) Source Github # | The image of an arrow of sheaves, by the same cokernel-pair construction as in | ||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasBinaryCoproducts (SHEAVES t j k) Source Github # | |||||
Methods withObCoprod :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github # lft :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k). (Ob a, Ob b) => a ~> (a || b) Source Github # rgt :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k). (Ob a, Ob b) => b ~> (a || b) Source Github # (|||) :: forall (x :: SHEAVES t j k) (a :: SHEAVES t j k) (y :: SHEAVES t j k). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github # (+++) :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (x :: SHEAVES t j k) (y :: SHEAVES t j k). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github # | |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasCoequalizers (SHEAVES t j k) Source Github # | The quotient a coequalizer takes is | ||||
Methods coequalize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (a ~> b) -> (a ~> b) -> (forall (c :: SHEAVES t j k). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (c :: SHEAVES t j k) (x :: SHEAVES t j k) (c' :: SHEAVES t j k). (x ~> c) -> (x ~> c') -> c ~> c' Source Github # | |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasInitialObject (SHEAVES t j k) Source Github # | Colimits are the presheaf colimits, sheafified: take the The initial sheaf need not be the initial presheaf. | ||||
Associated Types
| |||||
| (HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasPushouts (SHEAVES t j k) Source Github # | Not the default coproduct-then-coequalizer, which would sheafify the coproduct and then
sheafify the quotient of that. Each | ||||
Methods pushout :: forall (o :: SHEAVES t j k) (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (o ~> a) -> (o ~> b) -> (forall (p :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> r) -> r Source Github # factorPushout :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (p :: SHEAVES t j k) (q :: SHEAVES t j k). (a ~> p) -> (b ~> p) -> (a ~> q) -> (b ~> q) -> p ~> q Source Github # | |||||
| (Site t k, Enumerable j, Enumerable k) => HasEqualizers (SHEAVES t j k) Source Github # | Equalizers as in | ||||
| (Site t k, Enumerable j, Enumerable k) => HasPullbacks (SHEAVES t j k) Source Github # | |||||
Methods pullback :: forall (o :: SHEAVES t j k) (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (a ~> o) -> (b ~> o) -> (forall (p :: SHEAVES t j k). (p ~> a) -> (p ~> b) -> r) -> r Source Github # factorPullback :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) (p :: SHEAVES t j k) (q :: SHEAVES t j k). (p ~> a) -> (p ~> b) -> (q ~> a) -> (q ~> b) -> q ~> p Source Github # | |||||