Rename to num_public_and_private_variables

algorithms/src/snark/varuna/ahp/ahp.rs

@@ -107,7 +107,7 @@ impl<F: PrimeField, SM: SNARKMode> AHPForR1CS<F, SM> {
 
     /// Get all the strict degree bounds enforced in the AHP.
     pub fn get_degree_bounds(info: &CircuitInfo) -> Result<[usize; 4]> {
-        let num_variables = info.num_variables;
+        let num_variables = info.num_public_and_private_variables;
         let num_non_zero_a = info.num_non_zero_a;
         let num_non_zero_b = info.num_non_zero_b;
         let num_non_zero_c = info.num_non_zero_c;

algorithms/src/snark/varuna/ahp/indexer/circuit.rs

@@ -133,7 +133,7 @@ impl<F: PrimeField, SM: SNARKMode> Circuit<F, SM> {
 
     /// The size of the variable domain in this R1CS instance.
     pub fn variable_domain_size(&self) -> Result<usize> {
-        Ok(crate::fft::EvaluationDomain::<F>::new(self.index_info.num_variables)
+        Ok(crate::fft::EvaluationDomain::<F>::new(self.index_info.num_public_and_private_variables)
             .ok_or(anyhow!("Cannot create EvaluationDomain"))?
             .size())
     }
@@ -197,8 +197,9 @@ impl<F: PrimeField, SM: SNARKMode> CanonicalDeserialize for Circuit<F, SM> {
         let index_info: CircuitInfo = CanonicalDeserialize::deserialize_with_mode(&mut reader, compress, validate)?;
         let constraint_domain_size = EvaluationDomain::<F>::compute_size_of_domain(index_info.num_constraints)
             .ok_or(SerializationError::InvalidData)?;
-        let variable_domain_size = EvaluationDomain::<F>::compute_size_of_domain(index_info.num_variables)
-            .ok_or(SerializationError::InvalidData)?;
+        let variable_domain_size =
+            EvaluationDomain::<F>::compute_size_of_domain(index_info.num_public_and_private_variables)
+                .ok_or(SerializationError::InvalidData)?;
         let non_zero_a_domain_size = EvaluationDomain::<F>::compute_size_of_domain(index_info.num_non_zero_a)
             .ok_or(SerializationError::InvalidData)?;
         let non_zero_b_domain_size = EvaluationDomain::<F>::compute_size_of_domain(index_info.num_non_zero_b)

algorithms/src/snark/varuna/ahp/indexer/circuit_info.rs

@@ -26,7 +26,7 @@ pub struct CircuitInfo {
     pub num_public_inputs: usize,
     /// The number of public and private variables in the constraint system.
     /// Note: This does *NOT* include the number of constants in the constraint system.
-    pub num_variables: usize,
+    pub num_public_and_private_variables: usize,
     /// The number of constraints.
     pub num_constraints: usize,
     /// The number of non-zero entries in the A matrix.
@@ -41,14 +41,14 @@ impl CircuitInfo {
     /// The maximum degree of polynomial required to represent this index in the AHP.
     pub fn max_degree<F: PrimeField, SM: SNARKMode>(&self) -> Result<usize> {
         let max_non_zero = self.num_non_zero_a.max(self.num_non_zero_b).max(self.num_non_zero_c);
-        AHPForR1CS::<F, SM>::max_degree(self.num_constraints, self.num_variables, max_non_zero)
+        AHPForR1CS::<F, SM>::max_degree(self.num_constraints, self.num_public_and_private_variables, max_non_zero)
     }
 }
 
 impl ToBytes for CircuitInfo {
     fn write_le<W: Write>(&self, mut w: W) -> Result<(), io::Error> {
         (self.num_public_inputs as u64).write_le(&mut w)?;
-        (self.num_variables as u64).write_le(&mut w)?;
+        (self.num_public_and_private_variables as u64).write_le(&mut w)?;
         (self.num_constraints as u64).write_le(&mut w)?;
         (self.num_non_zero_a as u64).write_le(&mut w)?;
         (self.num_non_zero_b as u64).write_le(&mut w)?;

algorithms/src/snark/varuna/ahp/indexer/indexer.rs

@@ -168,7 +168,7 @@ impl<F: PrimeField, SM: SNARKMode> AHPForR1CS<F, SM> {
 
         let index_info = CircuitInfo {
             num_public_inputs: num_padded_public_variables,
-            num_variables,
+            num_public_and_private_variables: num_variables,
             num_constraints,
             num_non_zero_a,
             num_non_zero_b,

algorithms/src/snark/varuna/ahp/prover/round_functions/mod.rs

@@ -121,7 +121,8 @@ impl<F: PrimeField, SM: SNARKMode> AHPForR1CS<F, SM> {
                         }
 
                         if circuit.index_info.num_constraints != num_constraints
-                            || circuit.index_info.num_variables != (num_public_variables + num_private_variables)
+                            || circuit.index_info.num_public_and_private_variables
+                                != (num_public_variables + num_private_variables)
                         {
                             return Err(AHPError::InstanceDoesNotMatchIndex);
                         }

algorithms/src/snark/varuna/ahp/prover/state.rs

@@ -122,9 +122,9 @@ impl<'a, F: PrimeField, SM: SNARKMode> State<'a, F, SM> {
                     EvaluationDomain::new(index_info.num_constraints).ok_or(SynthesisError::PolyTooLarge)?;
                 max_num_constraints = max_num_constraints.max(index_info.num_constraints);
 
-                let variable_domain =
-                    EvaluationDomain::new(index_info.num_variables).ok_or(SynthesisError::PolyTooLarge)?;
-                max_num_variables = max_num_variables.max(index_info.num_variables);
+                let variable_domain = EvaluationDomain::new(index_info.num_public_and_private_variables)
+                    .ok_or(SynthesisError::PolyTooLarge)?;
+                max_num_variables = max_num_variables.max(index_info.num_public_and_private_variables);
 
                 let non_zero_domains = AHPForR1CS::<_, SM>::cmp_non_zero_domains(index_info, max_non_zero_domain)?;
                 max_non_zero_domain = non_zero_domains.max_non_zero_domain;

algorithms/src/snark/varuna/ahp/verifier/verifier.rs

@@ -71,7 +71,8 @@ impl<TargetField: PrimeField, SM: SNARKMode> AHPForR1CS<TargetField, SM> {
             end_timer!(constraint_domain_time);
 
             let variable_domain_time = start_timer!(|| format!("Constructing constraint domain for {circuit_id}"));
-            let variable_domain = EvaluationDomain::new(circuit_info.num_variables).ok_or(AHPError::PolyTooLarge)?;
+            let variable_domain =
+                EvaluationDomain::new(circuit_info.num_public_and_private_variables).ok_or(AHPError::PolyTooLarge)?;
             end_timer!(variable_domain_time);
 
             let non_zero_a_time = start_timer!(|| format!("Constructing non-zero-a domain for {circuit_id}"));

algorithms/src/snark/varuna/tests.rs

@@ -740,7 +740,8 @@ mod varuna_test_vectors {
         let non_zero_a_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_non_zero_a).unwrap();
         let non_zero_b_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_non_zero_b).unwrap();
         let non_zero_c_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_non_zero_c).unwrap();
-        let variable_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_variables).unwrap();
+        let variable_domain =
+            EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_public_and_private_variables).unwrap();
         let constraint_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_constraints).unwrap();
         let input_domain = EvaluationDomain::<Fr>::new(index_pk.circuit.index_info.num_public_inputs).unwrap();
 

algorithms/src/snark/varuna/varuna.rs

@@ -659,7 +659,7 @@ where
         let mut circuit_ids = Vec::with_capacity(keys_to_inputs.len());
         for (&vk, &public_inputs_i) in keys_to_inputs.iter() {
             max_num_constraints = max_num_constraints.max(vk.circuit_info.num_constraints);
-            max_num_variables = max_num_variables.max(vk.circuit_info.num_variables);
+            max_num_variables = max_num_variables.max(vk.circuit_info.num_public_and_private_variables);
 
             let non_zero_domains = AHPForR1CS::<_, SM>::cmp_non_zero_domains(&vk.circuit_info, max_non_zero_domain)?;
             max_non_zero_domain = non_zero_domains.max_non_zero_domain;

ledger/store/src/transaction/deployment.rs

@@ -345,7 +345,7 @@ pub trait DeploymentStorage<N: Network>: Clone + Send + Sync {
             // Retrieve the number of public and private variables.
             // Note: This number does *NOT* include the number of constants. This is safe because
             // this program is never deployed, as it is a first-class citizen of the protocol.
-            let num_variables = verifying_key.circuit_info.num_variables as u64;
+            let num_variables = verifying_key.circuit_info.num_public_and_private_variables as u64;
             // Return the verifying key.
             return Ok(Some(VerifyingKey::new(verifying_key.clone(), num_variables)));
         }

synthesizer/process/src/lib.rs

@@ -161,7 +161,7 @@ impl<N: Network> Process<N> {
             // Retrieve the number of public and private variables.
             // Note: This number does *NOT* include the number of constants. This is safe because
             // this program is never deployed, as it is a first-class citizen of the protocol.
-            let num_variables = verifying_key.circuit_info.num_variables as u64;
+            let num_variables = verifying_key.circuit_info.num_public_and_private_variables as u64;
             // Insert the verifying key.
             stack.insert_verifying_key(function_name, VerifyingKey::new(verifying_key.clone(), num_variables))?;
             lap!(timer, "Load verifying key for {function_name}");

synthesizer/process/src/trace/mod.rs

@@ -313,7 +313,7 @@ impl<N: Network> Trace<N> {
             // Retrieve the number of public and private variables.
             // Note: This number does *NOT* include the number of constants. This is safe because
             // this program is never deployed, as it is a first-class citizen of the protocol.
-            let num_variables = verifying_key.circuit_info.num_variables as u64;
+            let num_variables = verifying_key.circuit_info.num_public_and_private_variables as u64;
             // Insert the inclusion verifier inputs.
             verifier_inputs.push((VerifyingKey::<N>::new(verifying_key, num_variables), batch_inclusion_inputs));
         }