pr4xis 0.6.0

Prove your domain is correct — ontology-driven rule enforcement with category theory, logical composition, and runtime state machines
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::category::Category;
use crate::category::entity::Entity;
use crate::category::relationship::Relationship;

use super::being::Being;

/// Ontological relationship between types of being.
///
/// A directed relationship from one Being type to another.
/// Named relationships encode fundamental DOLCE relations;
/// composed relationships track transitive connections.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct OntologicalRelation {
    pub from: Being,
    pub to: Being,
    pub kind: RelationKind,
}

/// The kind of ontological relationship.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum RelationKind {
    /// Identity morphism.
    Identity,
    /// An endurant participates in a perdurant.
    ParticipatesIn,
    /// A quality inheres in an endurant.
    InheresIn,
    /// A physical endurant constitutes a social object.
    Constitutes,
    /// An event is part of a process.
    PartOf,
    /// A composed relationship (transitive).
    Composed,
}

impl OntologicalRelation {
    fn new(from: Being, to: Being, kind: RelationKind) -> Self {
        Self { from, to, kind }
    }
}

impl Relationship for OntologicalRelation {
    type Object = Being;

    fn source(&self) -> Being {
        self.from
    }

    fn target(&self) -> Being {
        self.to
    }
}

/// The DOLCE upper category: Being types as objects, ontological relations as morphisms.
pub struct DolceCategory;

impl Category for DolceCategory {
    type Object = Being;
    type Morphism = OntologicalRelation;

    fn identity(obj: &Being) -> OntologicalRelation {
        OntologicalRelation::new(*obj, *obj, RelationKind::Identity)
    }

    fn compose(f: &OntologicalRelation, g: &OntologicalRelation) -> Option<OntologicalRelation> {
        if f.to != g.from {
            return None;
        }

        // Identity laws
        if f.kind == RelationKind::Identity {
            return Some(g.clone());
        }
        if g.kind == RelationKind::Identity {
            return Some(f.clone());
        }

        // All other compositions produce a Composed morphism from f.from to g.to
        Some(OntologicalRelation::new(
            f.from,
            g.to,
            RelationKind::Composed,
        ))
    }

    fn morphisms() -> Vec<OntologicalRelation> {
        use Being::*;
        use RelationKind::*;

        let mut m = Vec::new();

        // Identity for each Being
        for b in Being::variants() {
            m.push(OntologicalRelation::new(b, b, Identity));
        }

        // Participation: endurants participate in perdurants
        for endurant in [PhysicalEndurant, SocialObject, MentalObject, AbstractObject] {
            for perdurant in [Event, Process] {
                m.push(OntologicalRelation::new(
                    endurant,
                    perdurant,
                    ParticipatesIn,
                ));
            }
        }

        // Inherence: quality inheres in endurants
        for bearer in [PhysicalEndurant, SocialObject, MentalObject, AbstractObject] {
            m.push(OntologicalRelation::new(Quality, bearer, InheresIn));
        }

        // Constitution: physical constitutes social
        m.push(OntologicalRelation::new(
            PhysicalEndurant,
            SocialObject,
            Constitutes,
        ));

        // Part-of: event part of process
        m.push(OntologicalRelation::new(Event, Process, PartOf));

        // Composed morphisms (transitive closure for closure law)
        // Quality → Endurant → Perdurant (inherence then participation)
        for perdurant in [Event, Process] {
            m.push(OntologicalRelation::new(Quality, perdurant, Composed));
        }
        // Physical → Social → Perdurant (constitution then participation)
        for perdurant in [Event, Process] {
            m.push(OntologicalRelation::new(
                PhysicalEndurant,
                perdurant,
                Composed,
            ));
        }
        // Event → Process (part-of already covers this)
        // Quality → Social (inherence already covers this, but also via physical)
        // Constitution + inherence compositions are already covered by direct morphisms

        m
    }
}