converge-prism-analytics 2.0.1

Closed-form analytics and inference for Converge agents: feature extraction, inference packs, and fuzzy inference. Training-pipeline concerns live in converge-crucible-models.
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

use converge_optimization::packs::{
    InvariantDef, InvariantResult, Pack, PackSolveResult, default_gate_evaluation,
};
use converge_pack::gate::GateResult as Result;
use converge_pack::gate::{KernelTraceLink, ProblemSpec, PromotionGate, ProposedPlan};

use crate::fuzzy::{SugenoInferenceEngine, SugenoInferenceInput, SugenoInferenceOutput};

pub struct SugenoInferencePack;

impl Pack for SugenoInferencePack {
    fn name(&self) -> &'static str {
        "sugeno-inference"
    }

    fn version(&self) -> &'static str {
        "1.0.0"
    }

    fn validate_inputs(&self, inputs: &serde_json::Value) -> Result<()> {
        let input: SugenoInferenceInput = serde_json::from_value(inputs.clone())
            .map_err(|e| converge_pack::GateError::invalid_input(format!("Invalid input: {e}")))?;
        input.validate()
    }

    fn invariants(&self) -> &[InvariantDef] {
        static INVARIANTS: std::sync::LazyLock<Vec<InvariantDef>> =
            std::sync::LazyLock::new(|| {
                vec![
                    InvariantDef::critical(
                        "valid-output",
                        "Sugeno output must be finite when at least one rule fires",
                    ),
                    InvariantDef::advisory(
                        "rule-activation",
                        "No sugeno rule fired - output carries no decision signal",
                    ),
                    InvariantDef::critical(
                        "valid-memberships",
                        "All input memberships must be in [0, 1]",
                    ),
                ]
            });
        &INVARIANTS
    }

    fn solve(&self, spec: &ProblemSpec) -> Result<PackSolveResult> {
        let input: SugenoInferenceInput = spec.inputs_as()?;
        input.validate()?;

        let solver = SugenoInferenceEngine;
        let (output, report) = solver.solve(&input, spec)?;

        let trace = KernelTraceLink::audit_only(format!("trace-{}", spec.problem_id));
        let confidence = output.confidence;
        let plan = ProposedPlan::from_payload(
            format!("plan-{}", spec.problem_id),
            self.name(),
            output.summary(),
            &output,
            confidence,
            trace,
        )?;

        Ok(PackSolveResult::new(plan, report))
    }

    fn check_invariants(&self, plan: &ProposedPlan) -> Result<Vec<InvariantResult>> {
        let output: SugenoInferenceOutput = serde_json::from_value(plan.plan.clone())
            .map_err(|e| converge_pack::GateError::invalid_input(e.to_string()))?;

        let mut results = vec![];

        let inputs_valid = output.input_memberships.values().all(|sets| {
            sets.values()
                .all(|value| value.is_finite() && (0.0..=1.0).contains(value))
        });
        if inputs_valid {
            results.push(InvariantResult::pass("valid-memberships"));
        } else {
            results.push(InvariantResult::fail(
                "valid-memberships",
                converge_pack::gate::Violation::new(
                    "valid-memberships",
                    1.0,
                    "An input membership was outside [0, 1]",
                ),
            ));
        }

        match output.output {
            Some(value) if value.is_finite() => {
                results.push(InvariantResult::pass("valid-output"));
            }
            Some(_) => {
                results.push(InvariantResult::fail(
                    "valid-output",
                    converge_pack::gate::Violation::new(
                        "valid-output",
                        1.0,
                        "Sugeno output was non-finite",
                    ),
                ));
            }
            None => {
                results.push(InvariantResult::pass("valid-output"));
            }
        }

        if output.activated_rules.is_empty() {
            results.push(InvariantResult::fail(
                "rule-activation",
                converge_pack::gate::Violation::new(
                    "rule-activation",
                    0.0,
                    "No sugeno rules fired",
                ),
            ));
        } else {
            results.push(InvariantResult::pass("rule-activation"));
        }

        Ok(results)
    }

    fn evaluate_gate(
        &self,
        _plan: &ProposedPlan,
        invariant_results: &[InvariantResult],
    ) -> PromotionGate {
        default_gate_evaluation(invariant_results, self.invariants())
    }
}