rust phir classical interp (#284)

* Add Rust PhirClassicalInterpreter as drop-in replacement for Python version

* Add FFCall bridge, Angle64 name resolver, typed results, cvar_export support

* Fix signed integer binary string formatting to match Python behavior

* Fix multi-assign eval order, optional size, multi-qubit arg format, signed binary strings

* Add unsigned size masking and optional size inference from data type

* Add cinterp='rust' option to HybridEngine, fix dtype name mapping

* Add passthrough iterator for inner interpreter, cache Python class lookups

* Add run_phir_sim for full-Rust execution path (3.6x speedup), auto-detect in HybridEngine

* Remove Result cop requirement, fix bit string widths, filter internal vars from results

* Add WASM and depolarizing noise support to run_phir_sim full Rust path

* Fix cross-engine test to compare values not Data types

* Support Rust and Python noise models in run_phir_sim via build_noise_model

* Add ArgItem::UInteger for u64 max values, fix unsigned ResultValue

* Replace TypedValue storage with BitUInt-based BitValue in Environment

Uses BitUInt from pecos-core for proper arbitrary-width integer storage.
Values are automatically masked to declared bit width. Signed values
interpreted via two's complement on read. Removes manual mask_to_size
workaround.

* Fix BitValue sign interpretation to use type width, disable auto fast path

* Make Rust classical interpreter the default for HybridEngine

* Add pickle support for multiprocessing compatibility

* Add foreign_obj getter for protocol parity

* Fix signed type storage to use type width (matching Python), improve fuzz to 970/971

* Fix expression evaluation to constrain results to operand type width

* Untrack known-issues docs

* Track suspected Python PhirClassicalInterpreter bugs found during Rust reimplementation

* Remove stale Rust known-issues gitignore entry (issues resolved)

* Refine Python suspected bugs: remove fixed/non-bugs, add confidence levels

* Note relationship between suspected Python bugs and PECOS#213

* Fix PECOS dtype overflow (related to #213): truncate instead of reject out-of-range values

* Mark Python dtype overflow bugs as fixed in suspected bugs doc

* Fix ScalarI64 arithmetic overflow panic: use wrapping_add/sub/mul

* Add Rust/Python parity test suite with fuzz testing (60 tests)

* Fix u64 dtype constructor to accept negative values (wrap to unsigned)

* Refactor ExpressionEvaluator to use BitUInt at 64-bit evaluation width

All expression evaluation now happens at MIN_EVAL_WIDTH (64 bits),
matching the hardware model where everything is i64 under the hood.
Variables wider than 64 bits will naturally evaluate at their width.
Removes constrain_to_width hack. Fixes comparison between Boolean
and integer types.

* Use BitUInt arithmetic directly in expression evaluator for arbitrary-width support

* Store all types at type width, mask to size on assignment; fix Qubits zero-width panic

* Fix Python eval_expr to evaluate at Python int width, mask all types to size on assignment

* Add gitignore entry for unstaged QASM-to-PHIR test plan

* Add QASM-to-PHIR-JSON converter, validation tests, and classical edge case tests

* Default to Python classical interpreter, remove disabled full-Rust path

* Fix signed arithmetic, remove dead code, tighten tests

* Guard against negative shift amounts, add i64::MIN / -1 regression test

* Remove TypedValue, qasm-to-phir-test-plan.md, and gitignore entry

Author: ciaranra

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(),