open import Cat.Prelude

open import Data.Power using ()

open import Order.Instances.Pointwise.Diagrams
open import Order.Instances.Pointwise
open import Order.Semilattice.Meet
open import Order.Directed
open import Order.Filter
open import Order.Base
module Order.Filter.Instances.Eventuality where

Eventuality filters🔗

A net in a type consists of a function from a upwards directed set

record Net {od ℓd ℓx} (D : Poset od ℓd) (X : Type ℓx) : Type (od ⊔ ℓd ⊔ ℓx) where
  no-eta-equality
  field
    net : ⌞ D ⌟  X
    dom-directed : is-upwards-directed D
  open is-upwards-directed dom-directed renaming
    ( inhab to dom-inhab
    ; upper-bound to dom-upper-bound
    )
    public
module _ {od ℓd ℓx} {D : Poset od ℓd} {X : Type ℓx} where
  private
    module D = Poset D
  open Filter
  open is-filter-base

  instance
    Funlike-Net : Funlike (Net D X) ⌞ D ⌟ λ _  X
    Funlike-Net .Funlike._·_ = Net.net

Nets are a generalization of sequences that tend to be better behaved both constructively and topologically. Every net presents a filter known as its eventuality filter.

The eventuality filter of a net is the filter defined as:

In more intuitive terms, is in the eventuality filter of if it eventually always lies within the image of

  Eventuality : Net D X  Filter (Subsets X)
  Eventuality f .F .hom A = elΩ (Σ[ i ∈ ⌞ D ⌟ ] (∀ (j : ⌞ D ⌟)  i D.≤ j  f · j ∈ A))
  Eventuality f .F .pres-≤ A⊆B = rec! λ i □A  inc (i , λ j i≤j  A⊆B (f · j) (□A j i≤j))

The posets of subsets is a meet semilattice, so it suffices to show that is a meet semilattice homomorphism.

First, note that if and only if is inhabited, as the image of always lies within and is inhabited by definition.

Next, suppose that By definition, this means that there exists some and such that for all and resp.

Additionally, is directed, so there merely exists some upper bound Finally, for every as and

  Eventuality f .has-is-filter =
    is-meet-slat-hom→is-filter Subsets-is-meet-slat
    $ record
      { top-≤ = λ _ 
        case f.dom-inhab of λ where
          i  inc (i , λ _ _  tt)
      ; ∩-≤ = elim! λ A B i □A j □B 
        case f.dom-upper-bound i j of λ where
          k i≤k j≤k 
            inc (k , λ l k≤l  □A l (D.≤-trans i≤k k≤l) , □B l (D.≤-trans j≤k k≤l))
      }
    where
      module f = Net f
      open is-meet-slat-hom

Filter bases of the eventuality filter🔗

A tail of a net at some is set of all that lie in the image of some with 1.

  Tail : (f : Net D X)  ⌞ D ⌟  ℙ X
  Tail f i x = elΩ (Σ[ j ∈ D ] (i D.≤ j) × f · j ≡ x)

The tails of form a filter base for the eventuality filter.

  Tails-is-filter-base : {f : Net D X}  is-filter-base (Eventuality f) (Tail f)
  Tails-is-filter-base .base∈F i =
    pure (i ,  j i≤j  pure (j , i≤j , refl)))
  Tails-is-filter-base .up-closed A =
    elim! λ i i≤j→f[j]∈A 
      pure (i , λ x  rec!  j i≤j fj=x  subst (_∈ A) fj=x (i≤j→f[j]∈A j i≤j)))

  1. More abstractly, the tails of a net are the left kan extensions of the hom functor along the monotone map ↩︎