proarrow
Safe HaskellNone
LanguageGHC2024

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

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 dimap g h, not lmap g. A coverage constrains only the contravariant side, but a sieve over j +-> k has two sides, and closure 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 Yo a (OP b), 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. 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 Plus t p. 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.

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: factorLocally of the preimage search. Where factorThroughCoequalizer 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 :+: b. One search over that is also one toIndex 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

Instances details
(Site t k, LocallyFinite k, CategoryOf j) => Sheaf t (Sheafify t p :: k -> j -> Type) Source Github #

Sheafification lands in the sheaves (isSheaf @t @(Sheafify t p) confirms it by enumeration), so a Sheafify can be used wherever a Sheaf is asked for.

gluePlus is lawful only on a separated q, which Plus t p always is, hence the double plus in the head. The also true Sheaf t p => Sheaf t (Plus t p) would overlap this instance with neither more specific.

Instance details

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 -> Sheafify t p x b) -> Sheafify t p a b Source Github #

(HasFiniteCovers t k, Finitary p, FiniteCat j, FiniteCat k) => Finitary (Plus t p :: k -> j -> Type) Source Github #

Numbered by plusElements, as the internal hom is numbered by the natural transformations out of its weight.

Instance details

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 # 
Instance details

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 #

A value's restriction to the least dense sieve, as its natTable: the indices of its values at that sieve's points. See Plus for what that determines.

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 dimap g h x in s. 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

Instances details
(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 g iff every leg of the cover pulled back along g is in the sieve of the family member it factors through. Anything in the glued sieve passes this test, since sieves are closed under precomposition, and anything that passes is in it, since the sieves are closed.

Instance details

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 # 
Instance details

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 dimap (the Lawvere–Tierney axiom that lawvereTierney packages as an arrow on Omega), so a restriction of a closed sieve is closed.

Instance details

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 FINITARY j k on the sheaves for t. 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. Omega is ClosedSieve.

type SHF t (p :: j +-> k) = 'SUB p :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)) Source Github #

A sheaf as an object of SHEAVES, as FIN names an object of FINITARY.

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 p -> q over a cover glues pointwise, because the values glue in q. p needs no condition.

The glued map, at an arrow g into a, pulls the cover back along g (StableSite). Each pulled-back leg factors through an original leg, whose map is asked, and the answers are glued in q. Neither p nor q has to be Finitary. The generic glueBySearch would be exponential in the size of p.

Instance details

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 -> (p :~>: q) x b) -> (p :~>: q) a b Source Github #

(StableSite t k, HasFiniteCovers t k, FiniteCat j, FiniteCat k) => ElementaryTopos (PROD (SHEAVES t j k)) Source Github #

The topos of sheaves. Finite limits and colimits, cartesian closed, a subobject classifier, and image factorization, all defined above and none of them postulated.

The exponential needs StableSite. A full subcategory is closed when it contains its internal homs, and an internal hom is a sheaf by gluing pointwise into the codomain, which needs the cover pulled back along the argument.

Instance details

(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 FINITARY's graph sieve, closed. For an arrow of sheaves that sieve is already closed, since a sheaf is separated. The closedSieve call guards against a Sheaf instance that was asserted instead of decided, which would otherwise fail later in familyIndex as "not a closed sieve".

Instance details

Associated Types

type Omega 
Instance details

Defined in Proarrow.Category.Enriched.Finitary.Sheaf

type Omega = 'PR ('SUB (ClosedSieve t :: k -> j -> Type) :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint)))

Methods

true :: (TerminalObject :: PROD (SHEAVES t j k)) ~> (Omega :: PROD (SHEAVES t j k)) Source Github #

classifyGraph :: forall (a :: PROD (SHEAVES t j k)) (b :: PROD (SHEAVES t j k)). (a ~> b) -> (a && b) ~> (Omega :: PROD (SHEAVES t j k)) Source Github #

(HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasEpiMonoFactorization (SHEAVES t j k) Source Github #

The image of an arrow of sheaves, by the same cokernel-pair construction as in FINITARY: the pushout is a colimit and so sheafified, the equalizer that follows it is not.

Instance details

Methods

factorize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k). (a ~> b) -> (Hom (SHEAVES t j k) :.: Hom (SHEAVES t j k)) a b Source Github #

(HasFiniteCovers t k, FiniteCat j, FiniteCat k) => HasBinaryCoproducts (SHEAVES t j k) Source Github # 
Instance details

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 coequalizeNat's, sheafified. Its projection is epi in the sheaves but need not be onto (the sheafification unit is not), so factorCoequalizer is not FINITARY's. It descends, by factorThroughLocalEpi.

Instance details

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 FINITARY colimit, follow its cocone with unitSheafify, and get the universal property from extendSheafify. This works because sheafification is a left adjoint.

The initial sheaf need not be the initial presheaf. Joins covers the bottom of a lattice by the empty family, so every sheaf has one section there.

Instance details

Associated Types

type InitialObject 
Instance details

Defined in Proarrow.Category.Enriched.Finitary.Sheaf

type InitialObject = 'SUB (Sheafify t (InitialProfunctor :: k -> j -> Type)) :: SUBCAT ((Finitary :: (j +-> k) -> Constraint) :&&: (Sheaf t :: (j +-> k) -> Constraint))

Methods

initiate :: forall (a :: SHEAVES t j k). Ob a => (InitialObject :: SHEAVES t j k) ~> a Source Github #

(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 Sheafify pays for the one under it, since the plus construction re-runs on every toIndex. Taking both steps in FINITARY and sheafifying once at the end gives the same object, since sheafification is a left adjoint and preserves the pushout, and it avoids stacking one plus construction on another.

Instance details

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 FINITARY, by equalizeNat; the result is a sheaf for every coverage, which testEqualizersAreSheaves checks by enumeration.

Instance details

Methods

equalize :: forall (a :: SHEAVES t j k) (b :: SHEAVES t j k) r. (a ~> b) -> (a ~> b) -> (forall (e :: SHEAVES t j k). (e ~> a) -> r) -> r Source Github #

factorEqualizer :: forall (e :: SHEAVES t j k) (x :: SHEAVES t j k) (e' :: SHEAVES t j k). (e ~> x) -> (e' ~> x) -> e' ~> e Source Github #

(Site t k, Enumerable j, Enumerable k) => HasPullbacks (SHEAVES t j k) Source Github # 
Instance details

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 #