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
143
144
145
146
147
148
149
150
151
152
153
154

use super::category::Category;
use super::entity::Entity;
use super::functor::Functor;
use super::relationship::Relationship;

/// Verify the identity law: for every object A and every morphism f from A,
/// compose(identity(A), f) == f and compose(f, identity(target(f))) == f.
pub fn check_identity_law<C: Category>() -> Result<(), String>
where
    C::Morphism: PartialEq,
{
    for obj in C::Object::variants() {
        let id = C::identity(&obj);

        for m in C::morphisms_from(&obj) {
            let left = C::compose(&id, &m);
            if left.as_ref() != Some(&m) {
                return Err(format!(
                    "left identity failed for object {:?}, morphism {:?}: compose(id, m) = {:?}",
                    obj, m, left
                ));
            }
        }

        for m in C::morphisms_to(&obj) {
            let right = C::compose(&m, &id);
            if right.as_ref() != Some(&m) {
                return Err(format!(
                    "right identity failed for object {:?}, morphism {:?}: compose(m, id) = {:?}",
                    obj, m, right
                ));
            }
        }
    }

    Ok(())
}

/// Verify associativity: for all composable triples f, g, h:
/// compose(compose(f, g), h) == compose(f, compose(g, h))
pub fn check_associativity<C: Category>() -> Result<(), String>
where
    C::Morphism: PartialEq,
{
    let morphisms = C::morphisms();

    for f in &morphisms {
        for g in &morphisms {
            if f.target() != g.source() {
                continue;
            }
            for h in &morphisms {
                if g.target() != h.source() {
                    continue;
                }

                let fg = C::compose(f, g);
                let gh = C::compose(g, h);

                let left = fg.as_ref().and_then(|fg| C::compose(fg, h));
                let right = gh.as_ref().and_then(|gh| C::compose(f, gh));

                if left != right {
                    return Err(format!(
                        "associativity failed: ({:?} ∘ {:?}) ∘ {:?} != {:?} ∘ ({:?} ∘ {:?})",
                        f, g, h, f, g, h
                    ));
                }
            }
        }
    }

    Ok(())
}

/// Verify closure: for all composable pairs f: A→B and g: B→C in morphisms(),
/// compose(f, g) must return Some.
pub fn check_closure<C: Category>() -> Result<(), String> {
    let morphisms = C::morphisms();

    for f in &morphisms {
        for g in &morphisms {
            if f.target() != g.source() {
                continue;
            }
            if C::compose(f, g).is_none() {
                return Err(format!(
                    "closure violated: {:?} (→ {:?}) and {:?} ({:?} →) are composable but compose returned None",
                    f,
                    f.target(),
                    g,
                    g.source()
                ));
            }
        }
    }

    Ok(())
}

/// Verify all category laws (identity + associativity + closure).
pub fn check_category_laws<C: Category>() -> Result<(), String>
where
    C::Morphism: PartialEq,
{
    check_closure::<C>()?;
    check_identity_law::<C>()?;
    check_associativity::<C>()?;
    Ok(())
}

/// Verify functor laws: preserves identity and composition.
pub fn check_functor_laws<F: Functor>() -> Result<(), String>
where
    <F::Source as Category>::Morphism: PartialEq,
    <F::Target as Category>::Morphism: PartialEq,
{
    // Identity preservation: F(id_A) == id_{F(A)}
    for obj in <F::Source as Category>::Object::variants() {
        let id_source = F::Source::identity(&obj);
        let mapped_id = F::map_morphism(&id_source);
        let id_target = F::Target::identity(&F::map_object(&obj));

        if mapped_id != id_target {
            return Err(format!(
                "functor identity law failed for object {:?}: F(id) != id_F",
                obj
            ));
        }
    }

    // Composition preservation: F(g∘f) == F(g)∘F(f)
    let morphisms = F::Source::morphisms();
    for f in &morphisms {
        for g in &morphisms {
            if f.target() != g.source() {
                continue;
            }
            if let Some(gf) = F::Source::compose(f, g) {
                let f_mapped_composed = F::map_morphism(&gf);
                let composed_mapped = F::Target::compose(&F::map_morphism(f), &F::map_morphism(g));

                if composed_mapped.as_ref() != Some(&f_mapped_composed) {
                    return Err(format!(
                        "functor composition law failed for {:?}, {:?}",
                        f, g
                    ));
                }
            }
        }
    }

    Ok(())
}