Struct DiscreteDblTheory 

#[repr(transparent)]
pub struct DiscreteDblTheory(pub QualifiedFpCategory);

A discrete double theory.

A discrete double theory is a double theory with no nontrivial operations on either object or morphism types. Viewed as a double category, such a theory is indeed discrete, which can equivalently be defined as:

• a discrete object in the 2-category of double categories
• a double category whose underlying categories are both discrete categories

Tuple Fields

0: QualifiedFpCategory

Trait Implementations

impl DblTheory for DiscreteDblTheory

type Kind = Unital

The kind of the theory: Unital or NonUnital.

type ObType = <DiscreteDblTheory as VDblCategory>::Ob

Rust type of object types in the theory.

type MorType = <DiscreteDblTheory as VDblCategory>::Pro

Rust type of morphism types in the theory.

type ObOp = <DiscreteDblTheory as VDblCategory>::Arr

Rust type of operations on objects in the double theory.

type MorOp = <DiscreteDblTheory as VDblCategory>::Cell

Rust type of operations on morphisms in the double theory.

fn has_ob_type(&self, x: &Self::ObType) -> bool

Does the object type belong to the theory?

fn has_mor_type(&self, m: &Self::MorType) -> bool

Does the morphism type belong to the theory?

fn has_ob_op(&self, f: &Self::ObOp) -> bool

Does the object operation belong to the theory?

fn has_mor_op(&self, α: &Self::MorOp) -> bool

Does the morphism operation belong to the theory?

fn src_type(&self, m: &Self::MorType) -> Self::ObType

Source of a morphism type.

fn tgt_type(&self, m: &Self::MorType) -> Self::ObType

Target of a morphism type.

fn ob_op_dom(&self, f: &Self::ObOp) -> Self::ObType

Domain of an operation on objects.

fn ob_op_cod(&self, f: &Self::ObOp) -> Self::ObType

Codomain of an operation on objects.

fn src_op(&self, α: &Self::MorOp) -> Self::ObOp

Source operation of an operation on morphisms.

fn tgt_op(&self, α: &Self::MorOp) -> Self::ObOp

Target operation of an operation on morphisms.

fn mor_op_dom(&self, α: &Self::MorOp) -> Path<Self::ObType, Self::MorType>

Domain of an operation on morphisms, a path of morphism types.

fn mor_op_cod(&self, α: &Self::MorOp) -> Self::MorType

Codomain of an operation on morphisms, a single morphism type.

fn compose_types( &self, path: Path<Self::ObType, Self::MorType>, ) -> Option<Self::MorType>

Composes a sequence of morphism types, if they have a composite.

fn hom_type( &self, x: Self::ObType, ) -> <Self::Kind as DblTheoryKind>::Wrap<Self::MorType>

Hom morphism type on an object type.

fn hom_op( &self, f: Self::ObOp, ) -> <Self::Kind as DblTheoryKind>::Wrap<Self::MorOp>

Hom morphism operation on an object operation.

fn compose_ob_ops(&self, path: Path<Self::ObType, Self::ObOp>) -> Self::ObOp

Compose a sequence of operations on objects.

fn compose_mor_ops( &self, tree: DblTree<Self::ObOp, Self::MorType, Self::MorOp>, ) -> Self::MorOp

Compose operations on morphisms.

fn id_ob_op(&self, x: Self::ObType) -> Self::ObOp

Identity operation on an object type.

fn id_mor_op(&self, m: Self::MorType) -> Self::MorOp

Identity operation on a morphism type.

impl Debug for DiscreteDblTheory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<FpCategory<QualifiedName, QualifiedName>> for DiscreteDblTheory

fn from(value: QualifiedFpCategory) -> Self

Converts to this type from the input type.

impl RefCast for DiscreteDblTheory

type From = FpCategory<QualifiedName, QualifiedName>

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl VDCWithComposites for DiscreteDblTheory

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

In a discrete double theory, every cell is an extension.

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 through_composite( &self, path: Self::Cell, range: Range<usize>, ) -> Option<Self::Cell>

Factorizes a cell through a composite of proarrows.

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 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_ext(&self, x: Self::Ob) -> Option<Self::Cell>

Gets the chosen extension cell for an object, 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 unit_arrow(&self, f: Self::Arr) -> Option<Self::Cell>

Constructs the unit cell on an arrow, if there is one.

fn through_unit(&self, cell: Self::Cell, index: usize) -> Option<Self::Cell>

Factorizes a cell through the unit proarrow for an object.

impl VDblCategory for DiscreteDblTheory

type Ob = QualifiedName

Type of objects in the VDC.

type Arr = QualifiedName

Type of arrows (tight morphisms) in the VDC.

type Pro = Path<QualifiedName, QualifiedName>

Type of proarrows (loose morphisms) in the VDC.

type Cell = Path<<DiscreteDblTheory as VDblCategory>::Ob, <DiscreteDblTheory as VDblCategory>::Pro>

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, arr: &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, path: &Self::Cell) -> bool

Does the cell belong to the VDC?

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

Gets the domain of an arrow.

fn cod(&self, f: &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, path: &Self::Cell) -> Path<Self::Ob, Self::Pro>

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

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

Gets the codomain of a cell, a single proarrow.

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

Gets the source of a cell, an arrow.

fn cell_tgt(&self, path: &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 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

where Self: Sized,

Composes a two-layer pasting of cells.

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

Constructs the identity cell on a proarrow.

impl Validate for DiscreteDblTheory

type ValidationError = InvalidDblTheory

The type of a validation error.

fn validate(&self) -> Result<(), NonEmpty<Self::ValidationError>>

Validates the object.