Struct DiscreteDblModel

pub struct DiscreteDblModel { /* 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 DiscreteDblModel

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

Creates an empty model of the given theory.

pub fn theory_rc(&self) -> Rc<DiscreteDblTheory>

Gets reference-counting pointer to the theory that this model is of.

pub fn generating_graph( &self, ) -> &impl FinGraph<V = QualifiedName, E = QualifiedName>

Returns the underlying graph of the model.

pub fn is_free(&self) -> bool

Is the model freely generated?

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

Adds a path equation to the model.

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

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.

pub fn push_forward<F>(&mut self, f: &F, new_theory: Rc<DiscreteDblTheory>)

where F: CategoryMap<DomOb = QualifiedName, DomMor = QualifiedPath, CodOb = QualifiedName, CodMor = QualifiedPath>,

Migrate model forward along a map between discrete double theories.

Trait Implementations

impl Category for DiscreteDblModel

type Ob = QualifiedName

Type of objects in category.

type Mor = Path<QualifiedName, QualifiedName>

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.

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

Are the two morphisms in the category equal?

impl Clone for DiscreteDblModel

fn clone(&self) -> DiscreteDblModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DblModel for DiscreteDblModel

type ObType = QualifiedName

Rust type of object types defined in the theory.

type MorType = Path<QualifiedName, QualifiedName>

Rust type of morphism types defined in the theory.

type ObOp = QualifiedName

Type of operations on objects defined in the theory.

type MorOp = Path<QualifiedName, Path<QualifiedName, QualifiedName>>

Type of operations on morphisms defined in the theory.

type Theory = DiscreteDblTheory

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, path: Path<Self::Ob, Self::Mor>, _: &Self::MorOp) -> Self::Mor

Acts on a sequence of morphisms 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 Debug for DiscreteDblModel

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

Formats the value using the given formatter.

impl FgCategory for DiscreteDblModel

type ObGen = QualifiedName

Type of an object generator.

type MorGen = QualifiedName

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 FgDblModel for DiscreteDblModel

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 MutDblModel for DiscreteDblModel

fn add_ob(&mut self, x: Self::ObGen, ob_type: Self::ObType)

Adds an object generator to the model.

fn add_mor( &mut self, f: Self::MorGen, dom: Self::Ob, cod: Self::Ob, mor_type: Self::MorType, )

Adds a morphism generator to the model.

fn make_mor(&mut self, f: Self::MorGen, mor_type: Self::MorType)

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

fn get_dom(&self, f: &Self::MorGen) -> Option<&Self::Ob>

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

fn get_cod(&self, f: &Self::MorGen) -> Option<&Self::Ob>

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

fn set_dom(&mut self, f: Self::MorGen, x: Self::Ob)

Sets the domain of a morphism generator.

fn set_cod(&mut self, f: Self::MorGen, x: Self::Ob)

Sets the codomain of a morphism generator.

impl PartialEq for DiscreteDblModel

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 Validate for DiscreteDblModel

type ValidationError = InvalidDblModel

The type of a validation error.

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

Validates the object.

impl Eq for DiscreteDblModel