1pub use etalon_vibe::{
6 oracle_rmsnorm_f32 as oracle_gpu_rmsnorm_f32, oracle_rope_f32 as oracle_gpu_rope_f32,
7 EtalonGpuComputeProvider,
8};
9
10#[inline]
12pub fn oracle_gpu_affine_f32(x: [f32; 4], scale: f32, bias: f32) -> [f32; 4] {
13 [
14 x[0] * scale + bias,
15 x[1] * scale + bias,
16 x[2] * scale + bias,
17 x[3] * scale + bias,
18 ]
19}
20
21#[inline]
23pub fn oracle_gpu_gemv4_f32(mat: [f32; 16], vec4: [f32; 4]) -> [f32; 4] {
24 etalon_vibe::oracle_gemv4_f32(&mat, &vec4).unwrap_or([0.0; 4])
25}
26
27#[inline]
29pub fn oracle_gpu_topk2_f32(scores: &[f32]) -> [f32; 2] {
30 etalon_vibe::oracle_topk2_f32(scores).unwrap_or([f32::NEG_INFINITY; 2])
31}
32
33use vibescript_abi::{
34 q_hash, q_hash_str, BorrowedSliceView, CallerOutputSlice, CanonicalIri, ContractVersionAxes,
35 DeterminismGuarantee, EffectSet, FuncDescriptor, NQuin48, OntologicalContract, ParamSpec,
36 PrimitiveKind, ProviderDescriptor, ResourceEnvelope, ReversibilityKind, SemVer64, StableFuncId,
37 SubNamespaceDescriptor, TargetProfileMask, VibeNamespaceProvider, VibeTrap,
38};
39
40const INFER_TARGETS: TargetProfileMask = TargetProfileMask(
41 TargetProfileMask::ALL_CPU.0 | TargetProfileMask::GPU_COMPUTE.0,
42);
43
44const RMS_NORM_PARAMS: &[ParamSpec] = &[
49 ParamSpec::slice("x", PrimitiveKind::F64, 4, 4),
50 ParamSpec::slice("weight", PrimitiveKind::F64, 4, 4),
51 ParamSpec::scalar("eps", PrimitiveKind::F64),
52];
53
54const SOFTMAX_PARAMS: &[ParamSpec] = &[ParamSpec::slice("logits", PrimitiveKind::F64, 4, 4)];
55
56const TOKEN_STEP_PARAMS: &[ParamSpec] = &[
57 ParamSpec::slice("logits", PrimitiveKind::F64, 4, 4),
58 ParamSpec::scalar("kv_state_hash", PrimitiveKind::U64),
59 ParamSpec::scalar("step_index", PrimitiveKind::U64),
60];
61
62const RMS_ENV: ResourceEnvelope = ResourceEnvelope::hot_zero_heap(48, 32);
63const SOFTMAX_ENV: ResourceEnvelope = ResourceEnvelope::hot_zero_heap(48, 32);
64const TOKEN_STEP_EFFECTS: EffectSet =
65 EffectSet::HARDWARE_IO.union(EffectSet::GRAPH_MUTATE);
66const TOKEN_STEP_ENV: ResourceEnvelope = ResourceEnvelope {
67 max_ticks: 64,
68 max_scratch_bytes: 0,
69 max_vram_bytes: 128,
70 max_output_bytes: 24,
71 max_spawned_tasks: 0,
72 flags: 0,
73};
74
75const INFER_ACTIVATION_FUNCS: &[FuncDescriptor] = &[
76 FuncDescriptor {
77 name: "rms_norm_f64",
78 canonical_iri: CanonicalIri::new(
79 "https://qualiadb.org/ext/qualia/inference/activations/rms_norm_f64",
80 ),
81 stable_id: StableFuncId::new(0, 0),
82 params: RMS_NORM_PARAMS,
83 output_kind: PrimitiveKind::F64,
84 required_output_elems: 4,
85 effects: EffectSet::PURE_COMPUTE,
86 determinism: DeterminismGuarantee::DeterministicTolerance,
87 reversibility: ReversibilityKind::PureNoState,
88 envelope: RMS_ENV,
89 contract: OntologicalContract {
90 contract_digest: OntologicalContract::canonical_digest(
91 q_hash_str("https://qualiadb.org/ext/qualia/inference/activations/rms_norm_f64"),
92 StableFuncId::new(0, 0),
93 q_hash_str("(f64[4],f64[4],f64)->f64[4]"),
94 EffectSet::PURE_COMPUTE,
95 DeterminismGuarantee::DeterministicTolerance,
96 ReversibilityKind::PureNoState,
97 RMS_ENV,
98 (0, 1),
99 (1, 1),
100 (2, 1),
101 ),
102 schema_hash: q_hash_str("(f64[4],f64[4],f64)->f64[4]"),
103 precondition_quin_span: (0, 1),
104 postcondition_quin_span: (1, 1),
105 invariant_quin_span: (2, 1),
106 },
107 },
108 FuncDescriptor {
109 name: "softmax_f64",
110 canonical_iri: CanonicalIri::new(
111 "https://qualiadb.org/ext/qualia/inference/activations/softmax_f64",
112 ),
113 stable_id: StableFuncId::new(0, 1),
114 params: SOFTMAX_PARAMS,
115 output_kind: PrimitiveKind::F64,
116 required_output_elems: 4,
117 effects: EffectSet::PURE_COMPUTE,
118 determinism: DeterminismGuarantee::DeterministicTolerance,
119 reversibility: ReversibilityKind::PureNoState,
120 envelope: SOFTMAX_ENV,
121 contract: OntologicalContract {
122 contract_digest: OntologicalContract::canonical_digest(
123 q_hash_str("https://qualiadb.org/ext/qualia/inference/activations/softmax_f64"),
124 StableFuncId::new(0, 1),
125 q_hash_str("(f64[4])->f64[4]"),
126 EffectSet::PURE_COMPUTE,
127 DeterminismGuarantee::DeterministicTolerance,
128 ReversibilityKind::PureNoState,
129 SOFTMAX_ENV,
130 (0, 1),
131 (1, 1),
132 (2, 1),
133 ),
134 schema_hash: q_hash_str("(f64[4])->f64[4]"),
135 precondition_quin_span: (0, 1),
136 postcondition_quin_span: (1, 1),
137 invariant_quin_span: (2, 1),
138 },
139 },
140];
141
142const INFER_DECODE_FUNCS: &[FuncDescriptor] = &[FuncDescriptor {
143 name: "governed_token_step",
144 canonical_iri: CanonicalIri::new(
145 "https://qualiadb.org/ext/qualia/inference/decode/governed_token_step",
146 ),
147 stable_id: StableFuncId::new(1, 0),
148 params: TOKEN_STEP_PARAMS,
149 output_kind: PrimitiveKind::U64,
150 required_output_elems: 3,
151 effects: TOKEN_STEP_EFFECTS,
152 determinism: DeterminismGuarantee::DeterministicExact,
153 reversibility: ReversibilityKind::StagedReversible,
154 envelope: TOKEN_STEP_ENV,
155 contract: OntologicalContract {
156 contract_digest: OntologicalContract::canonical_digest(
157 q_hash_str("https://qualiadb.org/ext/qualia/inference/decode/governed_token_step"),
158 StableFuncId::new(1, 0),
159 q_hash_str("(f64[4],u64,u64)->u64[3]"),
160 TOKEN_STEP_EFFECTS,
161 DeterminismGuarantee::DeterministicExact,
162 ReversibilityKind::StagedReversible,
163 TOKEN_STEP_ENV,
164 (0, 1),
165 (1, 1),
166 (2, 1),
167 ),
168 schema_hash: q_hash_str("(f64[4],u64,u64)->u64[3]"),
169 precondition_quin_span: (0, 1),
170 postcondition_quin_span: (1, 1),
171 invariant_quin_span: (2, 1),
172 },
173}];
174
175const INFER_SUB_NAMESPACES: &[SubNamespaceDescriptor] = &[
176 SubNamespaceDescriptor {
177 name: "activations",
178 sub_id: 0,
179 functions: INFER_ACTIVATION_FUNCS,
180 },
181 SubNamespaceDescriptor {
182 name: "decode",
183 sub_id: 1,
184 functions: INFER_DECODE_FUNCS,
185 },
186];
187
188const INFER_DESCRIPTOR: ProviderDescriptor = ProviderDescriptor {
189 canonical_iri: CanonicalIri::new("https://qualiadb.org/ext/qualia/inference"),
190 short_alias: "infer",
191 versions: ContractVersionAxes::v0_3_default(
192 SemVer64::release(0, 3, 0),
193 SemVer64::release(0, 1, 0),
194 ),
195 supported_targets: INFER_TARGETS,
196 sub_namespaces: INFER_SUB_NAMESPACES,
197 max_ontology_quins: 16,
198};
199
200const INFER_ONTOLOGY_QUINS: &[NQuin48] = &[
201 NQuin48::from_parts(
202 q_hash_str("https://qualiadb.org/ext/qualia/inference"),
203 q_hash_str("https://qualiadb.org/schema/vibe#hasPrecondition"),
204 q_hash_str("https://qualiadb.org/schema/vibe#PerTokenSentinelTicketActive"),
205 q_hash_str("https://qualiadb.org/context/public"),
206 1,
207 ),
208 NQuin48::from_parts(
209 q_hash_str("https://qualiadb.org/ext/qualia/inference"),
210 q_hash_str("https://qualiadb.org/schema/vibe#hasPostcondition"),
211 q_hash_str("https://qualiadb.org/schema/vibe#NormalizedDistributionOrRolledBackKv"),
212 q_hash_str("https://qualiadb.org/context/public"),
213 2,
214 ),
215 NQuin48::from_parts(
216 q_hash_str("https://qualiadb.org/ext/qualia/inference"),
217 q_hash_str("https://qualiadb.org/schema/vibe#preservesInvariant"),
218 q_hash_str("https://qualiadb.org/schema/vibe#ZeroUncommittedTokenLeakage"),
219 q_hash_str("https://qualiadb.org/context/public"),
220 3,
221 ),
222];
223
224#[derive(Debug, Clone, Copy, Default)]
226pub struct GovernedInferenceProvider;
227
228impl VibeNamespaceProvider for GovernedInferenceProvider {
229 fn descriptor(&self) -> &'static ProviderDescriptor {
230 &INFER_DESCRIPTOR
231 }
232
233 fn static_ontology_nquins(&self) -> &'static [NQuin48] {
234 INFER_ONTOLOGY_QUINS
235 }
236
237 fn call(
238 &self,
239 stable_id: StableFuncId,
240 inputs: &[BorrowedSliceView<'_>],
241 output: &mut CallerOutputSlice<'_>,
242 ) -> Result<u64, VibeTrap> {
243 match (stable_id.sub_namespace_id, stable_id.func_id) {
244 (0, 0) => {
245 let mut x = [0.0f64; 4];
247 let mut w = [0.0f64; 4];
248 for i in 0..4 {
249 x[i] = inputs[0].read_f64_le(i)?;
250 w[i] = inputs[1].read_f64_le(i)?;
251 if !x[i].is_finite() || !w[i].is_finite() {
252 return Err(VibeTrap::NumericalDomainError);
253 }
254 }
255 let eps = inputs[2].read_f64_le(0)?;
256 if !eps.is_finite() || eps < 0.0 {
257 return Err(VibeTrap::NumericalDomainError);
258 }
259 let normed = oracle_rms_norm_f64(x, w, eps);
260 for &val in &normed {
261 output.push_f64_le(val)?;
262 }
263 Ok(28)
264 }
265 (0, 1) => {
266 let mut logits = [0.0f64; 4];
268 for (i, slot) in logits.iter_mut().enumerate() {
269 let v = inputs[0].read_f64_le(i)?;
270 if !v.is_finite() {
271 return Err(VibeTrap::NumericalDomainError);
272 }
273 *slot = v;
274 }
275 let probs = oracle_softmax_f64(logits);
276 for &p in &probs {
277 output.push_f64_le(p)?;
278 }
279 Ok(24)
280 }
281 (1, 0) => {
282 let mut logits = [0.0f64; 4];
284 for (i, slot) in logits.iter_mut().enumerate() {
285 let v = inputs[0].read_f64_le(i)?;
286 if !v.is_finite() {
287 return Err(VibeTrap::NumericalDomainError);
288 }
289 *slot = v;
290 }
291 let kv_state_hash = inputs[1].read_u64_le(0)?;
292 let step_index = inputs[2].read_u64_le(0)?;
293 let (token_id, next_kv_hash, next_step) =
294 oracle_governed_token_step(logits, kv_state_hash, step_index);
295 output.push_u64_le(token_id)?;
296 output.push_u64_le(next_kv_hash)?;
297 output.push_u64_le(next_step)?;
298 Ok(36)
299 }
300 _ => Err(VibeTrap::FunctionNotFound),
301 }
302 }
303}
304
305#[inline]
307pub fn oracle_rms_norm_f64(x: [f64; 4], weight: [f64; 4], eps: f64) -> [f64; 4] {
308 let mean_sq = 0.25 * (x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3]);
309 let inv_rms = 1.0 / (mean_sq + eps).sqrt();
310 [
311 x[0] * inv_rms * weight[0],
312 x[1] * inv_rms * weight[1],
313 x[2] * inv_rms * weight[2],
314 x[3] * inv_rms * weight[3],
315 ]
316}
317
318#[inline]
320pub fn oracle_softmax_f64(logits: [f64; 4]) -> [f64; 4] {
321 let max_l = logits[0].max(logits[1]).max(logits[2]).max(logits[3]);
322 let e0 = (logits[0] - max_l).exp();
323 let e1 = (logits[1] - max_l).exp();
324 let e2 = (logits[2] - max_l).exp();
325 let e3 = (logits[3] - max_l).exp();
326 let inv_sum = 1.0 / (e0 + e1 + e2 + e3);
327 [e0 * inv_sum, e1 * inv_sum, e2 * inv_sum, e3 * inv_sum]
328}
329
330#[inline]
332pub fn oracle_governed_token_step(
333 logits: [f64; 4],
334 kv_state_hash: u64,
335 step_index: u64,
336) -> (u64, u64, u64) {
337 let mut best_idx = 0usize;
338 let mut best_val = logits[0];
339 let mut i = 1;
340 while i < 4 {
341 if logits[i] > best_val {
342 best_val = logits[i];
343 best_idx = i;
344 }
345 i += 1;
346 }
347 let token_id = best_idx as u64;
348 let mut step_bytes = [0u8; 16];
349 step_bytes[..8].copy_from_slice(&kv_state_hash.to_le_bytes());
350 step_bytes[8..16].copy_from_slice(&token_id.to_le_bytes());
351 let next_kv_hash = q_hash(&step_bytes) ^ step_index.rotate_left(7);
352 (token_id, next_kv_hash, step_index.saturating_add(1))
353}