Skip to main content

qualia_core_db/inference/inference_agent/governed/
program.rs

1use super::PolicyError;
2use crate::modalities::logic::WebizenOpcode;
3use serde::{Deserialize, Serialize};
4
5/// Versioned pure-constraint subset of the real Webizen ISA. Unsupported names
6/// fail deserialization. Lifecycle/emit instructions are not silently ignored;
7/// real temporal policy belongs to the graph guard, not the legacy pseudo-LTL.
8#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
9#[serde(tag = "op", deny_unknown_fields)]
10pub enum ConstraintInstruction {
11    MatchSubject { value: u64 },
12    MatchPredicate { value: u64 },
13    MatchObject { value: u64 },
14    MetadataMask { mask: u32 },
15    Bind { vector: u8, register: u8 },
16    MatchRegister { vector: u8, register: u8 },
17    HaltIfFalse,
18    LessThan { vector: u8, value: f32 },
19    GreaterThan { vector: u8, value: f32 },
20    LessOrEqual { vector: u8, value: f32 },
21    GreaterOrEqual { vector: u8, value: f32 },
22    Confidence { minimum: f32 },
23}
24impl ConstraintInstruction {
25    pub(crate) fn lower(self) -> Result<WebizenOpcode, PolicyError> {
26        use ConstraintInstruction::*;
27        let vector = |v| {
28            if v <= 3 {
29                Ok(v)
30            } else {
31                Err(PolicyError::InvalidProgram)
32            }
33        };
34        let register = |r| {
35            if r < 16 {
36                Ok(r as usize)
37            } else {
38                Err(PolicyError::InvalidProgram)
39            }
40        };
41        let finite = |v: f32| {
42            if v.is_finite() {
43                Ok(v)
44            } else {
45                Err(PolicyError::InvalidProgram)
46            }
47        };
48        Ok(match self {
49            MatchSubject { value } => WebizenOpcode::MatchSubject(value),
50            MatchPredicate { value } => WebizenOpcode::MatchPredicate(value),
51            MatchObject { value } => WebizenOpcode::MatchObject(value),
52            MetadataMask { mask } => WebizenOpcode::EvalMetadataMask(mask),
53            Bind {
54                vector: v,
55                register: r,
56            } => WebizenOpcode::BindRegister {
57                vector_id: vector(v)?,
58                register_index: register(r)?,
59            },
60            MatchRegister {
61                vector: v,
62                register: r,
63            } => WebizenOpcode::MatchRegister {
64                vector_id: vector(v)?,
65                register_index: register(r)?,
66            },
67            HaltIfFalse => WebizenOpcode::HaltIfFalse,
68            LessThan { vector: v, value } => WebizenOpcode::LessThan {
69                vector_id: vector(v)?,
70                value: finite(value)?,
71            },
72            GreaterThan { vector: v, value } => WebizenOpcode::GreaterThan {
73                vector_id: vector(v)?,
74                value: finite(value)?,
75            },
76            LessOrEqual { vector: v, value } => WebizenOpcode::LessOrEqual {
77                vector_id: vector(v)?,
78                value: finite(value)?,
79            },
80            GreaterOrEqual { vector: v, value } => WebizenOpcode::GreaterOrEqual {
81                vector_id: vector(v)?,
82                value: finite(value)?,
83            },
84            Confidence { minimum } => {
85                if !(0.0..=1.0).contains(&minimum) {
86                    return Err(PolicyError::InvalidProgram);
87                }
88                WebizenOpcode::YieldConfidence(minimum)
89            }
90        })
91    }
92    pub(crate) fn canonical(self) -> [u8; 12] {
93        use ConstraintInstruction::*;
94        let (tag, a, b, value) = match self {
95            MatchSubject { value } => (0, 0, 0, value),
96            MatchPredicate { value } => (1, 0, 0, value),
97            MatchObject { value } => (2, 0, 0, value),
98            MetadataMask { mask } => (3, 0, 0, mask as u64),
99            Bind { vector, register } => (4, vector, register, 0),
100            MatchRegister { vector, register } => (5, vector, register, 0),
101            HaltIfFalse => (6, 0, 0, 0),
102            LessThan { vector, value } => (7, vector, 0, value.to_bits() as u64),
103            GreaterThan { vector, value } => (8, vector, 0, value.to_bits() as u64),
104            LessOrEqual { vector, value } => (9, vector, 0, value.to_bits() as u64),
105            GreaterOrEqual { vector, value } => (10, vector, 0, value.to_bits() as u64),
106            Confidence { minimum } => (11, 0, 0, minimum.to_bits() as u64),
107        };
108        let mut bytes = [0; 12];
109        bytes[..3].copy_from_slice(&[tag, a, b]);
110        bytes[4..].copy_from_slice(&value.to_le_bytes());
111        bytes
112    }
113}