nova-snark 0.69.0

High-speed recursive arguments from folding schemes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Gadgets for enforcing multiple equalities in a single constraint.

use ff::PrimeField;

use crate::frontend::{ConstraintSystem, LinearCombination, SynthesisError, Variable};

/// A gadget for efficiently enforcing multiple equalities in a single constraint system.
#[derive(Debug)]
pub struct MultiEq<Scalar: PrimeField, CS: ConstraintSystem<Scalar>> {
  cs: CS,
  ops: usize,
  bits_used: usize,
  lhs: LinearCombination<Scalar>,
  rhs: LinearCombination<Scalar>,
}

impl<Scalar: PrimeField, CS: ConstraintSystem<Scalar>> MultiEq<Scalar, CS> {
  /// Creates a new `MultiEq` gadget with the given constraint system.
  pub fn new(cs: CS) -> Self {
    MultiEq {
      cs,
      ops: 0,
      bits_used: 0,
      lhs: LinearCombination::zero(),
      rhs: LinearCombination::zero(),
    }
  }

  fn accumulate(&mut self) {
    let ops = self.ops;
    let lhs = self.lhs.clone();
    let rhs = self.rhs.clone();
    self.cs.enforce(
      || format!("multieq {ops}"),
      |_| lhs,
      |lc| lc + CS::one(),
      |_| rhs,
    );
    self.lhs = LinearCombination::zero();
    self.rhs = LinearCombination::zero();
    self.bits_used = 0;
    self.ops += 1;
  }

  /// Enforces that the given left-hand side and right-hand side linear combinations
  /// are equal for the specified number of bits.
  pub fn enforce_equal(
    &mut self,
    num_bits: usize,
    lhs: &LinearCombination<Scalar>,
    rhs: &LinearCombination<Scalar>,
  ) {
    // Check if we will exceed the capacity
    if (Scalar::CAPACITY as usize) <= (self.bits_used + num_bits) {
      self.accumulate();
    }

    assert!((Scalar::CAPACITY as usize) > (self.bits_used + num_bits));

    let coeff = Scalar::from(2u64).pow_vartime([self.bits_used as u64]);
    self.lhs = self.lhs.clone() + (coeff, lhs);
    self.rhs = self.rhs.clone() + (coeff, rhs);
    self.bits_used += num_bits;
  }
}

impl<Scalar: PrimeField, CS: ConstraintSystem<Scalar>> Drop for MultiEq<Scalar, CS> {
  fn drop(&mut self) {
    if self.bits_used > 0 {
      self.accumulate();
    }
  }
}

impl<Scalar: PrimeField, CS: ConstraintSystem<Scalar>> ConstraintSystem<Scalar>
  for MultiEq<Scalar, CS>
{
  type Root = Self;

  fn one() -> Variable {
    CS::one()
  }

  fn alloc<F, A, AR>(&mut self, annotation: A, f: F) -> Result<Variable, SynthesisError>
  where
    F: FnOnce() -> Result<Scalar, SynthesisError>,
    A: FnOnce() -> AR,
    AR: Into<String>,
  {
    self.cs.alloc(annotation, f)
  }

  fn alloc_input<F, A, AR>(&mut self, annotation: A, f: F) -> Result<Variable, SynthesisError>
  where
    F: FnOnce() -> Result<Scalar, SynthesisError>,
    A: FnOnce() -> AR,
    AR: Into<String>,
  {
    self.cs.alloc_input(annotation, f)
  }

  fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC)
  where
    A: FnOnce() -> AR,
    AR: Into<String>,
    LA: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>,
    LB: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>,
    LC: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>,
  {
    self.cs.enforce(annotation, a, b, c)
  }

  fn push_namespace<NR, N>(&mut self, name_fn: N)
  where
    NR: Into<String>,
    N: FnOnce() -> NR,
  {
    self.cs.get_root().push_namespace(name_fn)
  }

  fn pop_namespace(&mut self) {
    self.cs.get_root().pop_namespace()
  }

  fn get_root(&mut self) -> &mut Self::Root {
    self
  }
}