Struct DiscreteTabTheory

pub struct DiscreteTabTheory<V, E, S = RandomState> { /* private fields */ }

A discrete tabulator theory.

Loosely speaking, a discrete tabulator theory is a discrete double theory extended to allow tabulators. That doesn’t quite make sense as stated because a tabulator comes with two projection arrows and a projection cell, hence cannot exist in a nontrivial discrete double category. A discrete tabulator theory is rather a small double category with tabulators and with no arrows or cells beyond the identities and tabulator projections.

Implementations

impl<V, E, S> DiscreteTabTheory<V, E, S>

where V: Eq + Clone + Hash, E: Eq + Clone + Hash, S: BuildHasher,

pub fn new() -> Self

where S: Default,

Creates an empty discrete tabulator theory.

pub fn tabulator(&self, m: TabMorType<V, E>) -> TabObType<V, E>

Constructs a tabulator of a morphism type.

pub fn unary_projection(&self, proj: TabMorProj<V, E>) -> TabMorOp<V, E>

Constructs a unary projection cell for a tabulator.

pub fn add_ob_type(&mut self, v: V) -> bool

Adds a basic object type to the theory.

pub fn add_mor_type( &mut self, e: E, src: TabObType<V, E>, tgt: TabObType<V, E>, ) -> bool

Adds a basic morphism type to the theory.

pub fn make_mor_type(&mut self, e: E) -> bool

Adds a basic morphim type without initializing its source or target.

Trait Implementations

impl<V: Clone, E: Clone, S: Clone> Clone for DiscreteTabTheory<V, E, S>

fn clone(&self) -> DiscreteTabTheory<V, E, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V, E, S> Default for DiscreteTabTheory<V, E, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<V, E, S> VDblCategory for DiscreteTabTheory<V, E, S>

where V: Eq + Clone + Hash, E: Eq + Clone + Hash, S: BuildHasher,

type Ob = TabObType<V, E>

Type of objects in the VDC.

type Arr = Path<TabObType<V, E>, TabObProj<V, E>>

Type of arrows (tight morphisms) in the VDC.

type Pro = TabMorType<V, E>

Type of proarrows (loose morphisms) in the VDC.

type Cell = TabMorOp<V, E>

Type of cells in the VDC;

fn has_ob(&self, ob: &Self::Ob) -> bool

Does the object belong to the VDC?

fn has_arrow(&self, path: &Self::Arr) -> bool

Does the arrow belong to the VDC?

fn has_proarrow(&self, pro: &Self::Pro) -> bool

Does the proarrow belong to the VDC?

fn has_cell(&self, cell: &Self::Cell) -> bool

Does the cell belong to the VDC?

fn dom(&self, path: &Self::Arr) -> Self::Ob

Gets the domain of an arrow.

fn cod(&self, path: &Self::Arr) -> Self::Ob

Gets the codomain of an arrow.

fn src(&self, m: &Self::Pro) -> Self::Ob

Gets the source of a proarrow.

fn tgt(&self, m: &Self::Pro) -> Self::Ob

Gets the target of a proarrow.

fn cell_dom(&self, cell: &Self::Cell) -> Path<Self::Ob, Self::Pro>

Gets the domain of a cell, a path of proarrows.

fn cell_cod(&self, cell: &Self::Cell) -> Self::Pro

Gets the codomain of a cell, a single proarrow.

fn cell_src(&self, cell: &Self::Cell) -> Self::Arr

Gets the source of a cell, an arrow.

fn cell_tgt(&self, cell: &Self::Cell) -> Self::Arr

Gets the target of a cell, an edge.

fn compose(&self, path: Path<Self::Ob, Self::Arr>) -> Self::Arr

Composes a path of arrows in the VDC.

fn composite2(&self, m: Self::Pro, n: Self::Pro) -> Option<Self::Pro>

Gets the chosen composite for a pair of consecutive proarrows, if there is one.

fn unit(&self, x: Self::Ob) -> Option<Self::Pro>

Gets the chosen unit for an object, if there is one.

fn composite(&self, path: Path<Self::Ob, Self::Pro>) -> Option<Self::Pro>

Gets the chosen composite for a path of proarrows, if there is one.

fn composite_ext(&self, path: Path<Self::Ob, Self::Pro>) -> Option<Self::Cell>

Gets the chosen cell witnessing a composite of proarrows, if there is one.

fn compose_cells( &self, tree: DblTree<Self::Arr, Self::Pro, Self::Cell>, ) -> Self::Cell

Composes a tree of cells in the VDC.

fn arity(&self, cell: &Self::Cell) -> usize

Gets the arity of a cell.

fn compose2(&self, f: Self::Arr, g: Self::Arr) -> Self::Arr

Composes a pair of arrows with compatible (co)domains.

fn id(&self, x: Self::Ob) -> Self::Arr

Constructs the identity arrow at an object.

fn compose_cells2( &self, αs: impl IntoIterator<Item = Self::Cell>, β: Self::Cell, ) -> Self::Cell

Composes a two-layer pasting of cells.

fn id_cell(&self, m: Self::Pro) -> Self::Cell

Constructs the identity cell on a proarrow.

fn has_composite(&self, path: &Path<Self::Ob, Self::Pro>) -> bool

Does the path of proarrows have a chosen composite?

fn has_unit(&self, x: &Self::Ob) -> bool

Does the object have a chosen unit?

fn composite2_ext(&self, m: Self::Pro, n: Self::Pro) -> Option<Self::Cell>

Gets the chosen cell witnessing a composite of two proarrows, if there is one.

fn unit_ext(&self, x: Self::Ob) -> Option<Self::Cell>

Gets the chosen extension cell for an object, if there is one.