remove clones and fix clippy

Author: jotabulacios

crates/provers/gkr/src/circuit.rs

@@ -18,53 +18,45 @@ pub struct Gate {
     pub gate_type: GateType,
 
     /// Two inputs, indexes into the previous layer gates outputs.
-    pub inputs: [usize; 2],
+    pub inputs_idx: [usize; 2],
 }
 
 impl Gate {
-    pub fn new(gate_type: GateType, inputs: [usize; 2]) -> Self {
-        Self { gate_type, inputs }
+    pub fn new(gate_type: GateType, inputs_idx: [usize; 2]) -> Self {
+        Self {
+            gate_type,
+            inputs_idx,
+        }
     }
 }
 
-/// Circuit layer structure
-///
-///  Output:     o          o     <- circuit.layers[0]
-///            /   \      /   \
-///           o     o    o     o  <- circuit.layers[1]
-///                   ...        
-///             o   o   o   o     <- circuit.ayers[layer.len() - 1]
-///            / \ / \ / \ / \
-///  Input:    o o o o o o o o
-
-///
-/// - The top nodes are the circuit outputs (layers[0]).
-/// - The bottom nodes are the circuit inputs, they don't belong to the vector `layers`.
-/// - Each layer contains gates; edges represent wiring between layers.
-/// - The circuit is evaluated from inputs upward, but layers are stored from output to input.
-
 /// A layer of gates in the circuit.
 #[derive(Clone)]
 pub struct CircuitLayer {
-    pub layer: Vec<Gate>,
+    pub gates: Vec<Gate>,
+    pub num_of_vars: usize, // log2 of number of gates in this layer
 }
 
 impl CircuitLayer {
-    pub fn new(layer: Vec<Gate>) -> Self {
-        Self { layer }
+    pub fn new(gates: Vec<Gate>) -> Self {
+        let num_of_vars = if gates.is_empty() {
+            0
+        } else {
+            gates.len().next_power_of_two().trailing_zeros() as usize
+        };
+        Self { gates, num_of_vars }
     }
 
     pub fn len(&self) -> usize {
-        self.layer.len()
+        self.gates.len()
     }
 
     pub fn is_empty(&self) -> bool {
-        self.layer.is_empty()
+        self.gates.is_empty()
     }
 }
 
 /// An evaluation of a `Circuit` on some input.
-
 pub struct CircuitEvaluation<F> {
     /// Evaluations on per-layer basis.
     pub layers: Vec<Vec<F>>,
@@ -81,9 +73,30 @@ impl<F: Copy> CircuitEvaluation<F> {
 pub enum CircuitError {
     InputsNotPowerOfTwo,
     LayerNotPowerOfTwo(usize), // index of the layer that is not a power of two
+    GateInputsError(usize),    // index of the layer with invalid gate inputs
+    EmptyCircuitError,
 }
 
 /// The circuit in layered form.
+///
+/// ## Circuit Structure
+///
+/// Circuits are organized in layers, with each layer containing gates that operate on outputs from the previous layer:
+///
+/// ```text
+/// Output:     o          o     <- circuit.layers[0]
+///           /   \      /   \
+///          o     o    o     o  <- circuit.layers[1]
+///                  ...        
+///            o   o   o   o     <- circuit.layers[layer.len() - 1]
+///           / \ / \ / \ / \
+/// Input:    o o o o o o o o
+/// ```
+///
+/// - The top nodes are the circuit outputs (layers[0]).
+/// - The bottom nodes are the circuit inputs, they don't belong to the vector `layers`.
+/// - Each layer contains gates; edges represent wiring between layers.
+/// - The circuit is evaluated from inputs upward, but layers are stored from output to input.
 #[derive(Clone)]
 pub struct Circuit {
     /// First layer being the output layer, last layer being
@@ -92,63 +105,89 @@ pub struct Circuit {
 
     /// Number of inputs
     num_inputs: usize,
-    layer_num_vars: Vec<usize>, // log2 of number of gates per layer
-    input_num_vars: usize,      // log2 of number of inputs
+    input_num_vars: usize, // log2 of number of inputs
 }
 
 impl Circuit {
     pub fn new(layers: Vec<CircuitLayer>, num_inputs: usize) -> Result<Self, CircuitError> {
+        if layers.is_empty() {
+            return Err(CircuitError::EmptyCircuitError);
+        }
+
         if !num_inputs.is_power_of_two() {
             return Err(CircuitError::InputsNotPowerOfTwo);
         }
+
         let input_num_vars = num_inputs.trailing_zeros() as usize;
-        let mut layer_num_vars = Vec::with_capacity(layers.len());
+
+        // Validate that each layer has power-of-two gates
         for (i, layer) in layers.iter().enumerate() {
             if !layer.len().is_power_of_two() {
                 return Err(CircuitError::LayerNotPowerOfTwo(i));
             }
-            layer_num_vars.push(layer.len().trailing_zeros() as usize);
         }
+
+        // Validate that gate inputs in each layer don't exceed the next layer number of gates
+        for (i, layer_pair) in layers.windows(2).enumerate() {
+            let current_layer = &layer_pair[0];
+            let next_layer = &layer_pair[1];
+            let next_layer_gates = next_layer.len();
+
+            for gate in &current_layer.gates {
+                let [a, b] = gate.inputs_idx;
+                if a >= next_layer_gates || b >= next_layer_gates {
+                    return Err(CircuitError::GateInputsError(i));
+                }
+            }
+        }
+
+        // Validate that the last layer gate inputs don't exceed the number of inputs
+        if let Some(last_layer) = layers.last() {
+            for gate in &last_layer.gates {
+                let [a, b] = gate.inputs_idx;
+                if a >= num_inputs || b >= num_inputs {
+                    return Err(CircuitError::GateInputsError(layers.len() - 1));
+                }
+            }
+        }
+
         Ok(Self {
             layers,
             num_inputs,
-            layer_num_vars,
             input_num_vars,
         })
     }
 
     pub fn num_vars_at(&self, layer: usize) -> Option<usize> {
-        let num_gates = if let Some(layer) = self.layers.get(layer) {
-            layer.len()
+        if let Some(layer) = self.layers.get(layer) {
+            Some(layer.num_of_vars)
         } else if layer == self.layers.len() {
-            self.num_inputs
+            Some(self.input_num_vars)
         } else {
-            return None;
-        };
-
-        Some((num_gates as u64).trailing_zeros() as usize)
+            None
+        }
     }
 
     /// Evaluate a `Circuit` on a given input.
     pub fn evaluate<F>(&self, input: &[FieldElement<F>]) -> CircuitEvaluation<FieldElement<F>>
     where
         F: IsField,
     {
-        let mut layers = vec![];
+        let mut layers = Vec::with_capacity(self.layers.len() + 1);
         let mut current_input = input.to_vec();
 
         layers.push(current_input.clone());
 
         for layer in self.layers.iter().rev() {
             let temp_layer: Vec<_> = layer
-                .layer
+                .gates
                 .iter()
-                .map(|e| match e.gate_type {
+                .map(|gate| match gate.gate_type {
                     GateType::Add => {
-                        current_input[e.inputs[0]].clone() + current_input[e.inputs[1]].clone()
+                        &current_input[gate.inputs_idx[0]] + &current_input[gate.inputs_idx[1]]
                     }
                     GateType::Mul => {
-                        current_input[e.inputs[0]].clone() * current_input[e.inputs[1]].clone()
+                        &current_input[gate.inputs_idx[0]] * &current_input[gate.inputs_idx[1]]
                     }
                 })
                 .collect();
@@ -163,22 +202,22 @@ impl Circuit {
 
     /// The $\text{add}_i(a, b, c)$ polynomial value at layer $i$.
     pub fn add_i(&self, i: usize, a: usize, b: usize, c: usize) -> bool {
-        let gate = &self.layers[i].layer[a];
-        gate.gate_type == GateType::Add && gate.inputs[0] == b && gate.inputs[1] == c
+        let gate = &self.layers[i].gates[a];
+        gate.gate_type == GateType::Add && gate.inputs_idx[0] == b && gate.inputs_idx[1] == c
     }
 
     /// The $\text{mul}_i(a, b, c)$ polynomial value at layer $i$.
     pub fn mul_i(&self, i: usize, a: usize, b: usize, c: usize) -> bool {
-        let gate = &self.layers[i].layer[a];
-        gate.gate_type == GateType::Mul && gate.inputs[0] == b && gate.inputs[1] == c
+        let gate = &self.layers[i].gates[a];
+        gate.gate_type == GateType::Mul && gate.inputs_idx[0] == b && gate.inputs_idx[1] == c
     }
 
     pub fn layers(&self) -> &[CircuitLayer] {
         &self.layers
     }
 
     pub fn num_outputs(&self) -> usize {
-        self.layers[0].layer.len()
+        self.layers[0].gates.len()
     }
 
     pub fn num_inputs(&self) -> usize {
@@ -193,18 +232,18 @@ impl Circuit {
     where
         F::BaseType: Send + Sync + Copy,
     {
-        let num_vars_current = self.layer_num_vars[i];
-        let num_vars_next = if let Some(n) = self.layer_num_vars.get(i + 1) {
-            *n
+        let num_vars_current = self.layers[i].num_of_vars;
+        let num_vars_next = if let Some(layer) = self.layers.get(i + 1) {
+            layer.num_of_vars
         } else {
             self.input_num_vars
         };
         let total_vars = num_vars_current + 2 * num_vars_next;
         let mut add_i_evals = vec![FieldElement::zero(); 1 << total_vars];
-        for (a, gate) in self.layers[i].layer.iter().enumerate() {
+        for (a, gate) in self.layers[i].gates.iter().enumerate() {
             if gate.gate_type == GateType::Add {
-                let b = gate.inputs[0];
-                let c = gate.inputs[1];
+                let b = gate.inputs_idx[0];
+                let c = gate.inputs_idx[1];
                 let idx = (a << (2 * num_vars_next)) | (b << num_vars_next) | c;
                 add_i_evals[idx] = FieldElement::one();
             }
@@ -224,18 +263,18 @@ impl Circuit {
     where
         F::BaseType: Send + Sync + Copy,
     {
-        let num_vars_current = self.layer_num_vars[i];
-        let num_vars_next = if let Some(n) = self.layer_num_vars.get(i + 1) {
-            *n
+        let num_vars_current = self.layers[i].num_of_vars;
+        let num_vars_next = if let Some(layer) = self.layers.get(i + 1) {
+            layer.num_of_vars
         } else {
             self.input_num_vars
         };
         let total_vars = num_vars_current + 2 * num_vars_next;
         let mut mul_i_evals = vec![FieldElement::zero(); 1 << total_vars];
-        for (a, gate) in self.layers[i].layer.iter().enumerate() {
+        for (a, gate) in self.layers[i].gates.iter().enumerate() {
             if gate.gate_type == GateType::Mul {
-                let b = gate.inputs[0];
-                let c = gate.inputs[1];
+                let b = gate.inputs_idx[0];
+                let c = gate.inputs_idx[1];
                 let idx = (a << (2 * num_vars_next)) | (b << num_vars_next) | c;
                 mul_i_evals[idx] = FieldElement::one();
             }

crates/provers/gkr/src/lib.rs

@@ -20,14 +20,14 @@ pub fn circuit_to_bytes(circuit: &Circuit) -> Vec<u8> {
     // For each layer append the number of gates, the type and the input indeces of each gate.
     for layer in circuit.layers() {
         bytes.extend_from_slice(&(layer.len() as u32).to_le_bytes());
-        for gate in &layer.layer {
+        for gate in &layer.gates {
             let gate_type = match gate.gate_type {
                 crate::circuit::GateType::Add => 0u8,
                 crate::circuit::GateType::Mul => 1u8,
             };
             bytes.push(gate_type);
-            bytes.extend_from_slice(&(gate.inputs[0] as u32).to_le_bytes());
-            bytes.extend_from_slice(&(gate.inputs[1] as u32).to_le_bytes());
+            bytes.extend_from_slice(&(gate.inputs_idx[0] as u32).to_le_bytes());
+            bytes.extend_from_slice(&(gate.inputs_idx[1] as u32).to_le_bytes());
         }
     }
     bytes
@@ -47,7 +47,7 @@ where
 {
     b.iter()
         .zip(c.iter())
-        .map(|(b_val, c_val)| b_val.clone() + t.clone() * (c_val.clone() - b_val.clone()))
+        .map(|(b_val, c_val)| b_val + t * (c_val - b_val))
         .collect()
 }
 

crates/provers/gkr/src/prover.rs

@@ -117,16 +117,15 @@ impl Prover {
     {
         let mut domain_points_x = Vec::new();
         let mut evaluation_values_y = Vec::new();
+        let w_next_poly = DenseMultilinearPolynomial::new(w_next_evals);
         for i in 0..3 {
             let eval_point_x = FieldElement::from(i as u64);
-            domain_points_x.push(eval_point_x.clone());
-
             let line_at_eval_point = crate::line(b, c, &eval_point_x);
-            let w_next_poly = DenseMultilinearPolynomial::new(w_next_evals.clone());
             let q_at_eval_point = w_next_poly
                 .evaluate(line_at_eval_point)
                 .map_err(|_| ProverError::MultilinearPolynomialEvaluationError)?;
 
+            domain_points_x.push(eval_point_x);
             evaluation_values_y.push(q_at_eval_point);
         }
         let poly_q = Polynomial::interpolate(&domain_points_x, &evaluation_values_y)
@@ -182,7 +181,7 @@ impl Prover {
             let gkr_poly_terms =
                 Prover::build_gkr_polynomial(circuit, &r_i, w_next_evals, layer_idx)?;
 
-            let sumcheck_proof = gkr_sumcheck_prove(gkr_poly_terms.clone(), &mut transcript)?;
+            let sumcheck_proof = gkr_sumcheck_prove(gkr_poly_terms, &mut transcript)?;
 
             let sumcheck_challenges = &sumcheck_proof.challenges;
 
@@ -205,14 +204,15 @@ impl Prover {
 
             let layer_proof = LayerProof {
                 sumcheck_proof,
-                poly_q: poly_q.clone(),
+                poly_q,
             };
             layer_proofs.push(layer_proof);
         }
 
+        let output_values = evaluation.layers[0].clone();
         let proof = GKRProof {
             input_values: input.to_vec(),
-            output_values: evaluation.layers[0].clone(),
+            output_values,
             layer_proofs,
         };
 

crates/provers/gkr/src/sumcheck.rs

@@ -90,7 +90,7 @@ where
         let r_j = transcript.sample_field_element();
 
         challenges.push(r_j.clone());
-        current_challenge = Some(r_j.clone());
+        current_challenge = Some(r_j);
     }
 
     let sumcheck_proof = GKRSumcheckProof {
@@ -144,7 +144,7 @@ where
 
         let g_j_0 = g_j.evaluate::<F>(&FieldElement::zero());
         let g_j_1 = g_j.evaluate::<F>(&FieldElement::one());
-        let sum_evals = g_j_0.clone() + g_j_1.clone();
+        let sum_evals = &g_j_0 + &g_j_1;
 
         // We need to manually track the expected sum
         let expected_sum = if j == 0 {

crates/provers/gkr/src/verifier.rs

@@ -35,11 +35,11 @@ impl Verifier {
         // Append the circuit data to the transcript.
         transcript.append_bytes(&crate::circuit_to_bytes(circuit));
         // Append public inputs x.
-        for x in proof.input_values.clone() {
+        for x in &proof.input_values {
             transcript.append_bytes(&x.to_bytes_be());
         }
         // Append public outputs y (first layer of evaluation).
-        for y in proof.output_values.clone() {
+        for y in &proof.output_values {
             transcript.append_bytes(&y.to_bytes_be());
         }