Merge with main

Author: 4l0n50

circuit/src/alloc_entry.rs

@@ -21,6 +21,7 @@ pub enum AllocationType {
     Mul,
     Div,
     NonPrimitiveOp(NonPrimitiveOpType),
+    WitnessHint,
 }
 
 /// Detailed allocation entry for debugging
@@ -92,6 +93,7 @@ fn dump_internal_log(allocation_log: &[AllocationEntry]) {
     let mut muls = Vec::new();
     let mut divs = Vec::new();
     let mut non_primitives = Vec::new();
+    let mut witness_hints = Vec::new();
 
     fn display_label(label: &str) -> String {
         if label.is_empty() {
@@ -110,6 +112,7 @@ fn dump_internal_log(allocation_log: &[AllocationEntry]) {
             AllocationType::Mul => muls.push(entry),
             AllocationType::Div => divs.push(entry),
             AllocationType::NonPrimitiveOp(_) => non_primitives.push(entry),
+            AllocationType::WitnessHint => witness_hints.push(entry),
         }
     }
 
@@ -256,6 +259,18 @@ fn dump_internal_log(allocation_log: &[AllocationEntry]) {
         }
         tracing::debug!("");
     }
+
+    if !witness_hints.is_empty() {
+        tracing::debug!("--- Witness Hints ({}) ---", witness_hints.len());
+        for entry in witness_hints {
+            tracing::debug!(
+                "  expr_{} (WitnessHint){}",
+                entry.expr_id.0,
+                display_label(entry.label)
+            );
+        }
+        tracing::debug!("");
+    }
 }
 
 /// List all unique scopes present in the allocation log.

circuit/src/builder/circuit_builder.rs

@@ -1,7 +1,8 @@
 use alloc::vec::Vec;
+use core::hash::Hash;
 
 use hashbrown::HashMap;
-use p3_field::PrimeCharacteristicRing;
+use p3_field::{Field, PrimeCharacteristicRing};
 
 use super::compiler::{ExpressionLowerer, NonPrimitiveLowerer, Optimizer};
 use super::{BuilderConfig, ExpressionBuilder, PublicInputTracker};
@@ -122,6 +123,18 @@ where
         self.public_tracker.count()
     }
 
+    /// Allocates a witness hint (uninitialized witness slot set during non-primitive execution).
+    #[must_use]
+    pub fn alloc_witness_hint(&mut self, label: &'static str) -> ExprId {
+        self.expr_builder.add_witness_hint(label)
+    }
+
+    /// Allocates multiple witness hints.
+    #[must_use]
+    pub fn alloc_witness_hints(&mut self, count: usize, label: &'static str) -> Vec<ExprId> {
+        self.expr_builder.add_witness_hints(count, label)
+    }
+
     /// Adds a constant to the circuit (deduplicated).
     ///
     /// If this value was previously added, returns the original ExprId.
@@ -299,7 +312,7 @@ where
 
 impl<F> CircuitBuilder<F>
 where
-    F: Clone + PrimeCharacteristicRing + PartialEq + Eq + core::hash::Hash,
+    F: Field + Clone + PrimeCharacteristicRing + PartialEq + Eq + Hash,
 {
     /// Builds the circuit into a Circuit with separate lowering and IR transformation stages.
     /// Returns an error if lowering fails due to an internal inconsistency.
@@ -333,7 +346,7 @@ where
         let primitive_ops = optimizer.optimize(primitive_ops);
 
         // Stage 4: Generate final circuit
-        let mut circuit = Circuit::new(witness_count);
+        let mut circuit = Circuit::new(witness_count, expr_to_widx);
         circuit.primitive_ops = primitive_ops;
         circuit.non_primitive_ops = lowered_non_primitive_ops;
         circuit.public_rows = public_rows;
@@ -478,7 +491,7 @@ mod tests {
         assert!(circuit.enabled_ops.is_empty());
 
         match &circuit.primitive_ops[0] {
-            crate::op::Prim::Const { out, val } => {
+            crate::op::Op::Const { out, val } => {
                 assert_eq!(*out, WitnessId(0));
                 assert_eq!(*val, BabyBear::ZERO);
             }
@@ -501,23 +514,23 @@ mod tests {
         assert_eq!(circuit.primitive_ops.len(), 3);
 
         match &circuit.primitive_ops[0] {
-            crate::op::Prim::Const { out, val } => {
+            crate::op::Op::Const { out, val } => {
                 assert_eq!(*out, WitnessId(0));
                 assert_eq!(*val, BabyBear::ZERO);
             }
             _ => panic!("Expected Const at index 0"),
         }
 
         match &circuit.primitive_ops[1] {
-            crate::op::Prim::Public { out, public_pos } => {
+            crate::op::Op::Public { out, public_pos } => {
                 assert_eq!(*out, WitnessId(1));
                 assert_eq!(*public_pos, 0);
             }
             _ => panic!("Expected Public at index 1"),
         }
 
         match &circuit.primitive_ops[2] {
-            crate::op::Prim::Public { out, public_pos } => {
+            crate::op::Op::Public { out, public_pos } => {
                 assert_eq!(*out, WitnessId(2));
                 assert_eq!(*public_pos, 1);
             }
@@ -543,23 +556,23 @@ mod tests {
         assert_eq!(circuit.primitive_ops.len(), 3);
 
         match &circuit.primitive_ops[0] {
-            crate::op::Prim::Const { out, val } => {
+            crate::op::Op::Const { out, val } => {
                 assert_eq!(*out, WitnessId(0));
                 assert_eq!(*val, BabyBear::ZERO);
             }
             _ => panic!("Expected Const at index 0"),
         }
 
         match &circuit.primitive_ops[1] {
-            crate::op::Prim::Const { out, val } => {
+            crate::op::Op::Const { out, val } => {
                 assert_eq!(*out, WitnessId(1));
                 assert_eq!(*val, BabyBear::from_u64(1));
             }
             _ => panic!("Expected Const at index 1"),
         }
 
         match &circuit.primitive_ops[2] {
-            crate::op::Prim::Const { out, val } => {
+            crate::op::Op::Const { out, val } => {
                 assert_eq!(*out, WitnessId(2));
                 assert_eq!(*val, BabyBear::from_u64(2));
             }
@@ -581,7 +594,7 @@ mod tests {
         assert_eq!(circuit.primitive_ops.len(), 4);
 
         match &circuit.primitive_ops[3] {
-            crate::op::Prim::Add { out, a, b } => {
+            crate::op::Op::Add { out, a, b } => {
                 assert_eq!(*out, WitnessId(3));
                 assert_eq!(*a, WitnessId(1));
                 assert_eq!(*b, WitnessId(2));