Struct DiscreteDblModel

pub struct DiscreteDblModel<Id, Cat: FgCategory> { /* private fields */ }

A finitely presented model of a discrete double theory.

Since discrete double theory has only identity operations, such a model is a finite presentation of a category sliced over the object and morphism types comprising the theory. A type theorist would call it a “displayed category”.

Implementations

impl<Id, Cat> DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

pub fn new(theory: Arc<DiscreteDblTheory<Cat>>) -> Self

Creates an empty model of the given theory.

pub fn theory_arc(&self) -> Arc<DiscreteDblTheory<Cat>>

Returns a reference-counting pointer to the theory for this model.

pub fn generating_graph( &self, ) -> &(impl FinGraph<V = Id, E = Id> + use<Id, Cat>)

Returns the underlying graph of the model.

pub fn is_free(&self) -> bool

Is the model freely generated?

pub fn add_equation(&mut self, key: Id, eq: PathEq<Id, Id>)

Adds an equation to the model, making it not free.

pub fn iter_invalid(&self) -> impl Iterator<Item = InvalidDblModel<Id>> + '_

Iterates over failures of model to be well defined.

pub fn infer_missing(&mut self)

Infer missing data in the model, where possible.

Objects used in the domain or codomain of morphisms, but not contained as objects of the model, are added and their types are inferred. It is not always possible to do this consistently, so it is important to validate the model even after calling this method.

Trait Implementations

impl<Id, Cat> Category for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

type Ob = Id

Type of objects in category.

type Mor = Path<Id, Id>

Type of morphisms in category.

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

Does the category contain the value as an object?

fn has_mor(&self, m: &Self::Mor) -> bool

Does the category contain the value as a morphism?

fn dom(&self, m: &Self::Mor) -> Self::Ob

Gets the domain of a morphism in the category.

fn cod(&self, m: &Self::Mor) -> Self::Ob

Gets the codomain of a morphism in the category.

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

Composes a path of morphisms in the category.

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

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

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

Constructs the identity morphism at an object.

impl<Id: Clone, Cat: Clone + FgCategory> Clone for DiscreteDblModel<Id, Cat>

where Cat::Ob: Clone, Cat::Mor: Clone,

fn clone(&self) -> DiscreteDblModel<Id, Cat>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id, Cat> DblModel for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

type ObType = <Cat as Category>::Ob

Rust type of object types defined in the theory.

type MorType = <Cat as Category>::Mor

Rust type of morphism types defined in the theory.

type ObOp = <Cat as Category>::Ob

Type of operations on objects defined in the theory.

type MorOp = Path<<Cat as Category>::Ob, <Cat as Category>::Mor>

Type of operations on morphisms defined in the theory.

type Theory = DiscreteDblTheory<Cat>

The type of double theory that this is a model of.

fn theory(&self) -> &Self::Theory

The double theory that this model is a model of.

fn ob_act(&self, x: Self::Ob, _: &Self::ObOp) -> Self::Ob

Acts on an object with an object operation.

fn mor_act(&self, m: Self::Mor, _: &Self::MorOp) -> Self::Mor

Acts on a morphism with a morphism operation.

fn ob_type(&self, ob: &Self::Ob) -> Self::ObType

Type of an object.

fn mor_type(&self, mor: &Self::Mor) -> Self::MorType

Type of a morphism.

impl<Id: Debug, Cat: Debug + FgCategory> Debug for DiscreteDblModel<Id, Cat>

where Cat::Ob: Debug, Cat::Mor: Debug,

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

Formats the value using the given formatter.

impl<Id, Cat> FgCategory for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

type ObGen = Id

Type of an object generator.

type MorGen = Id

Type of a morphism generator

fn ob_generators(&self) -> impl Iterator<Item = Self::ObGen>

Iterates over object generators.

fn mor_generators(&self) -> impl Iterator<Item = Self::MorGen>

Iterates over morphism generators.

fn mor_generator_dom(&self, f: &Self::MorGen) -> Self::Ob

The domain of a morphism generator

fn mor_generator_cod(&self, f: &Self::MorGen) -> Self::Ob

The codomain of a morphism generator

fn objects(&self) -> impl Iterator<Item = Self::Ob>

Iterates over basic objects.

fn morphisms(&self) -> impl Iterator<Item = Self::Mor>

Iterates over basic morphisms.

impl<Id, Cat> FgDblModel for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

fn ob_generator_type(&self, ob: &Self::ObGen) -> Self::ObType

Type of an object generator.

fn mor_generator_type(&self, mor: &Self::MorGen) -> Self::MorType

Type of a morphism generator.

fn ob_generators_with_type( &self, typ: &Self::ObType, ) -> impl Iterator<Item = Self::ObGen>

Iterates over object generators with the given object type.

fn mor_generators_with_type( &self, typ: &Self::MorType, ) -> impl Iterator<Item = Self::MorGen>

Iterates over morphism generators with the given morphism type.

fn objects_with_type( &self, obtype: &Self::ObType, ) -> impl Iterator<Item = Self::Ob>

Iterators over basic objects with the given object type.

fn morphisms_with_type( &self, mortype: &Self::MorType, ) -> impl Iterator<Item = Self::Mor>

Iterates over basic morphisms with the given morphism type.

impl<Id, Cat> MutDblModel for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

fn add_ob(&mut self, x: Id, typ: Cat::Ob) -> bool

Adds a basic object to the model.

fn add_mor(&mut self, f: Id, dom: Id, cod: Id, typ: Cat::Mor) -> bool

Adds a basic morphism to the model.

fn make_mor(&mut self, f: Id, typ: Cat::Mor) -> bool

Adds a basic morphism to the model without setting its (co)domain.

fn get_dom(&self, f: &Id) -> Option<&Id>

Gets the domain of a basic morphism, if it is set.

fn get_cod(&self, f: &Id) -> Option<&Id>

Gets the codomain of a basic morphism, if it is set.

fn set_dom(&mut self, f: Id, x: Id) -> Option<Id>

Sets the domain of a basic morphism.

fn set_cod(&mut self, f: Id, x: Id) -> Option<Id>

Sets the codomain of a basic morphism.

impl<Id, Cat: FgCategory> PartialEq for DiscreteDblModel<Id, Cat>

where Id: Eq + Hash,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Id, Cat> Validate for DiscreteDblModel<Id, Cat>

where Id: Eq + Clone + Hash, Cat: FgCategory, Cat::Ob: Hash, Cat::Mor: Hash,

type ValidationError = InvalidDblModel<Id>

The type of a validation error.

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

Validates the object.

impl<Id, Cat: FgCategory> Eq for DiscreteDblModel<Id, Cat>

where Id: Eq + Hash,