qualia_core_db/inference/inference_agent/governed/
program.rs1use super::PolicyError;
2use crate::modalities::logic::WebizenOpcode;
3use serde::{Deserialize, Serialize};
4
5#[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}