rust phir classical interp

crates/pecos-phir-json/src/lib.rs

@@ -604,14 +604,26 @@ mod tests {
             "shot counts should match"
         );
 
-        // Compare shared register values between engines
+        // Compare shared register values between engines using binary string representation
+        // (different engines may store values as BitVec vs U32, but the logical values should match)
         let mut compared = 0;
         for (i, (s1, s2)) in shots1.shots.iter().zip(shots2.shots.iter()).enumerate() {
-            for (name, val1) in &s1.data {
-                if let Some(val2) = s2.data.get(name) {
+            for name in s1.data.keys() {
+                if name.starts_with('_') {
+                    continue; // Skip metadata keys like _width_*
+                }
+                if let (Some(str1), Some(str2)) = (
+                    s1.register_to_binary_string(name),
+                    s2.register_to_binary_string(name),
+                ) {
+                    // Compare values by stripping leading zeros (engines may use different widths)
+                    let v1 = str1.trim_start_matches('0');
+                    let v2 = str2.trim_start_matches('0');
+                    let v1 = if v1.is_empty() { "0" } else { v1 };
+                    let v2 = if v2.is_empty() { "0" } else { v2 };
                     assert_eq!(
-                        val1, val2,
-                        "shot {i}: register '{name}' differs between engines"
+                        v1, v2,
+                        "shot {i}: register '{name}' differs between engines (str1={str1}, str2={str2})"
                     );
                     compared += 1;
                 }

crates/pecos-phir-json/src/v0_1.rs

@@ -1,6 +1,8 @@
 pub mod ast;
+pub mod classical_interpreter;
 pub mod engine;
 pub mod foreign_objects;
+pub mod name_resolver;
 pub mod operations;
 pub mod phir_converter;
 pub mod wasm_foreign_object;
@@ -48,22 +50,6 @@ impl PhirImplementation for V0_1 {
             )));
         }
 
-        // Validate that at least one Result command exists
-        let has_result_command = program.ops.iter().any(|op| {
-            if let ast::Operation::ClassicalOp { cop, .. } = op {
-                cop == "Result"
-            } else {
-                false
-            }
-        });
-
-        if !has_result_command {
-            return Err(PecosError::Input(
-                "Invalid PHIR-JSON program structure: Program must contain at least one Result command to specify outputs"
-                    .to_string(),
-            ));
-        }
-
         Ok(program)
     }
 

crates/pecos-phir-json/src/v0_1/ast.rs

@@ -7,6 +7,7 @@ use std::f64::consts::PI;
 pub struct PHIRProgram {
     pub format: String,
     pub version: String,
+    #[serde(default)]
     pub metadata: BTreeMap<String, serde_json::Value>,
     pub ops: Vec<Operation>,
 }
@@ -20,7 +21,9 @@ pub enum Operation {
         data: String,
         data_type: String,
         variable: String,
-        size: usize,
+        /// Size in bits. Optional -- if omitted, inferred from `data_type`.
+        #[serde(default)]
+        size: Option<usize>,
     },
     /// Quantum operation (gates, measurements)
     QuantumOp {
@@ -78,6 +81,11 @@ pub enum Operation {
         #[serde(default)]
         metadata: Option<BTreeMap<String, serde_json::Value>>,
     },
+    /// Data export (`cvar_export`) -- specifies which variables to export
+    DataExport {
+        data: String,
+        variables: Vec<String>,
+    },
     /// Comment
     Comment {
         #[serde(rename = "//")]
@@ -103,8 +111,10 @@ pub enum ArgItem {
     Indexed((String, usize)),
     /// Simple argument (entire register)
     Simple(String),
-    /// Integer literal
+    /// Integer literal (signed, covers most cases)
     Integer(i64),
+    /// Unsigned integer literal (for values > `i64::MAX`, e.g. `u64::MAX`)
+    UInteger(u64),
     /// Expression (for nested expressions)
     Expression(Box<Expression>),
 }
@@ -124,6 +134,20 @@ pub enum Expression {
 // Constants for internal register naming
 pub const MEASUREMENT_PREFIX: &str = "measurement_";
 
+/// Infer variable size from data type when not explicitly provided.
+///
+/// For types like "i32", "u64", extracts the bit width from the name.
+/// For "qubits", returns 0 (size must be explicit).
+#[must_use]
+pub fn infer_size(data_type: &str, explicit_size: Option<usize>) -> usize {
+    if let Some(s) = explicit_size {
+        return s;
+    }
+    // Try to extract bit width from type name (e.g., "i32" -> 32, "u64" -> 64)
+    let digits: String = data_type.chars().filter(char::is_ascii_digit).collect();
+    digits.parse().unwrap_or(0)
+}
+
 /// Custom deserializer to convert angles to radians
 fn deserialize_angles_to_radians<'de, D>(deserializer: D) -> Result<Option<Vec<f64>>, D::Error>
 where

crates/pecos-phir-json/src/v0_1/block_executor.rs

@@ -144,8 +144,12 @@ impl BlockExecutor {
                 size,
             } => {
                 debug!("Processing variable definition: {data_type} {variable}");
-                self.processor
-                    .handle_variable_definition(data, data_type, variable, *size)?;
+                self.processor.handle_variable_definition(
+                    data,
+                    data_type,
+                    variable,
+                    crate::v0_1::ast::infer_size(data_type, *size),
+                )?;
             }
             Operation::QuantumOp {
                 qop, angles, args, ..
@@ -219,6 +223,9 @@ impl BlockExecutor {
                 debug!("Skipping comment: {comment}");
                 // Comments are no-ops
             }
+            Operation::DataExport { .. } => {
+                // Data exports are no-ops during execution
+            }
         }
 
         Ok(())
@@ -831,7 +838,7 @@ mod tests {
                 data: "cvar_define".to_string(),
                 data_type: "i32".to_string(),
                 variable: "x".to_string(),
-                size: 32,
+                size: Some(32),
             },
             Operation::ClassicalOp {
                 cop: "=".to_string(),