zec
/
halo2
mirror of https://github.com/zcash/halo2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove redundant Error suffix from Error cases

This commit is contained in:
Jack Grigg 2021-05-26 23:55:40 +01:00
parent 209e398cae
commit 7da5605f51
14 changed files with 77 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -11,7 +11,10 @@ and this project adheres to Rust's notion of
- `Error` no longer implements `PartialEq`. Tests can check for specific error - `Error` no longer implements `PartialEq`. Tests can check for specific error
cases with `assert!(matches!(..))`. cases with `assert!(matches!(..))`.
- `Error::IncompatibleParams` is now `Error::InvalidInstances`. - `Error::IncompatibleParams` is now `Error::InvalidInstances`.
- `Error::TranscriptError` stores the underlying `io::Error`. - `Error::OpeningError` is now `Error::Opening`.
- `Error::SynthesisError` is now `Error::Synthesis`.
- `Error::TranscriptError` is now `Error::Transcript`, and stores the
underlying `io::Error`.
### Removed ### Removed
- `halo2::arithmetic::BatchInvert` (use `ff::BatchInvert` instead). - `halo2::arithmetic::BatchInvert` (use `ff::BatchInvert` instead).

24
benches/plonk.rs
View File

@ -90,20 +90,20 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?;
@ -132,20 +132,20 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?;
@ -226,17 +226,17 @@ fn bench_with_k(name: &str, k: u32, c: &mut Criterion) {
let (a0, _, c0) = cs.raw_multiply(&mut layouter, || { let (a0, _, c0) = cs.raw_multiply(&mut layouter, || {
a_squared = self.a.map(|a| a.square()); a_squared = self.a.map(|a| a.square());
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
let (a1, b1, _) = cs.raw_add(&mut layouter, || { let (a1, b1, _) = cs.raw_add(&mut layouter, || {
let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2)); let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2));
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
fin.ok_or(Error::SynthesisError)?, fin.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
cs.copy(&mut layouter, a0, a1)?; cs.copy(&mut layouter, a0, a1)?;

32
examples/circuit-layout.rs
View File

@ -72,32 +72,32 @@ impl<FF: FieldExt> StandardCs<FF> for StandardPlonk<FF> {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
region.assign_advice( region.assign_advice(
|| "lhs^4", || "lhs^4",
self.config.d, self.config.d,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.0.square().square()), || Ok(value.ok_or(Error::Synthesis)?.0.square().square()),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
region.assign_advice( region.assign_advice(
|| "rhs^4", || "rhs^4",
self.config.e, self.config.e,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1.square().square()), || Ok(value.ok_or(Error::Synthesis)?.1.square().square()),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?;
@ -117,32 +117,32 @@ impl<FF: FieldExt> StandardCs<FF> for StandardPlonk<FF> {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
region.assign_advice( region.assign_advice(
|| "lhs^4", || "lhs^4",
self.config.d, self.config.d,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.0.square().square()), || Ok(value.ok_or(Error::Synthesis)?.0.square().square()),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
region.assign_advice( region.assign_advice(
|| "rhs^4", || "rhs^4",
self.config.e, self.config.e,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1.square().square()), || Ok(value.ok_or(Error::Synthesis)?.1.square().square()),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?;
@ -259,17 +259,17 @@ impl<F: FieldExt> Circuit<F> for MyCircuit<F> {
let (a0, _, c0) = cs.raw_multiply(&mut region, || { let (a0, _, c0) = cs.raw_multiply(&mut region, || {
a_squared = self.a.map(|a| a.square()); a_squared = self.a.map(|a| a.square());
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
let (a1, b1, _) = cs.raw_add(&mut region, || { let (a1, b1, _) = cs.raw_add(&mut region, || {
let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2)); let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2));
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
fin.ok_or(Error::SynthesisError)?, fin.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
cs.copy(&mut region, a0, a1)?; cs.copy(&mut region, a0, a1)?;

8
examples/simple-example.rs
View File

@ -172,7 +172,7 @@ impl<F: FieldExt> NumericInstructions<F> for FieldChip<F> {
|| "private input", || "private input",
config.advice[0], config.advice[0],
0, 0,
|| value.ok_or(Error::SynthesisError), || value.ok_or(Error::Synthesis),
)?; )?;
num = Some(Number { cell, value }); num = Some(Number { cell, value });
Ok(()) Ok(())
@ -233,13 +233,13 @@ impl<F: FieldExt> NumericInstructions<F> for FieldChip<F> {
|| "lhs", || "lhs",
config.advice[0], config.advice[0],
0, 0,
|| a.value.ok_or(Error::SynthesisError), || a.value.ok_or(Error::Synthesis),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
config.advice[1], config.advice[1],
0, 0,
|| b.value.ok_or(Error::SynthesisError), || b.value.ok_or(Error::Synthesis),
)?; )?;
region.constrain_equal(a.cell, lhs)?; region.constrain_equal(a.cell, lhs)?;
region.constrain_equal(b.cell, rhs)?; region.constrain_equal(b.cell, rhs)?;
@ -250,7 +250,7 @@ impl<F: FieldExt> NumericInstructions<F> for FieldChip<F> {
|| "lhs * rhs", || "lhs * rhs",
config.advice[0], config.advice[0],
1, 1,
|| value.ok_or(Error::SynthesisError), || value.ok_or(Error::Synthesis),
)?; )?;
// Finally, we return a variable representing the output, // Finally, we return a variable representing the output,

14
examples/two-chip.rs
View File

@ -222,13 +222,13 @@ impl<F: FieldExt> AddInstructions<F> for AddChip<F> {
|| "lhs", || "lhs",
config.advice[0], config.advice[0],
0, 0,
|| a.value.ok_or(Error::SynthesisError), || a.value.ok_or(Error::Synthesis),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
config.advice[1], config.advice[1],
0, 0,
|| b.value.ok_or(Error::SynthesisError), || b.value.ok_or(Error::Synthesis),
)?; )?;
region.constrain_equal(a.cell, lhs)?; region.constrain_equal(a.cell, lhs)?;
region.constrain_equal(b.cell, rhs)?; region.constrain_equal(b.cell, rhs)?;
@ -239,7 +239,7 @@ impl<F: FieldExt> AddInstructions<F> for AddChip<F> {
|| "lhs * rhs", || "lhs * rhs",
config.advice[0], config.advice[0],
1, 1,
|| value.ok_or(Error::SynthesisError), || value.ok_or(Error::Synthesis),
)?; )?;
// Finally, we return a variable representing the output, // Finally, we return a variable representing the output,
@ -362,13 +362,13 @@ impl<F: FieldExt> MulInstructions<F> for MulChip<F> {
|| "lhs", || "lhs",
config.advice[0], config.advice[0],
0, 0,
|| a.value.ok_or(Error::SynthesisError), || a.value.ok_or(Error::Synthesis),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
config.advice[1], config.advice[1],
0, 0,
|| b.value.ok_or(Error::SynthesisError), || b.value.ok_or(Error::Synthesis),
)?; )?;
region.constrain_equal(a.cell, lhs)?; region.constrain_equal(a.cell, lhs)?;
region.constrain_equal(b.cell, rhs)?; region.constrain_equal(b.cell, rhs)?;
@ -379,7 +379,7 @@ impl<F: FieldExt> MulInstructions<F> for MulChip<F> {
|| "lhs * rhs", || "lhs * rhs",
config.advice[0], config.advice[0],
1, 1,
|| value.ok_or(Error::SynthesisError), || value.ok_or(Error::Synthesis),
)?; )?;
// Finally, we return a variable representing the output, // Finally, we return a variable representing the output,
@ -457,7 +457,7 @@ impl<F: FieldExt> FieldInstructions<F> for FieldChip<F> {
|| "private input", || "private input",
config.advice[0], config.advice[0],
0, 0,
|| value.ok_or(Error::SynthesisError), || value.ok_or(Error::Synthesis),
)?; )?;
num = Some(Number { cell, value }); num = Some(Number { cell, value });
Ok(()) Ok(())

8
src/circuit/floor_planner/single_pass.rs
View File

@ -180,7 +180,7 @@ impl<'a, F: Field, CS: Assignment<F> + 'a> Layouter<F> for SingleChipLayouter<'a
_ => None, _ => None,
}) { }) {
Some(Some(len)) => len, Some(Some(len)) => len,
_ => return Err(Error::SynthesisError), // TODO better error _ => return Err(Error::Synthesis), // TODO better error
} }
}; };
@ -320,7 +320,7 @@ impl<'r, 'a, F: Field, CS: Assignment<F> + 'a> RegionLayouter<F>
let value = self.layouter.cs.query_instance(instance, row)?; let value = self.layouter.cs.query_instance(instance, row)?;
let cell = self.assign_advice(annotation, advice, offset, &mut || { let cell = self.assign_advice(annotation, advice, offset, &mut || {
value.ok_or(Error::SynthesisError).map(|v| v.into()) value.ok_or(Error::Synthesis).map(|v| v.into())
})?; })?;
self.layouter.cs.copy( self.layouter.cs.copy(
@ -417,7 +417,7 @@ impl<'r, 'a, F: Field, CS: Assignment<F> + 'a> TableLayouter<F>
to: &'v mut (dyn FnMut() -> Result<Assigned<F>, Error> + 'v), to: &'v mut (dyn FnMut() -> Result<Assigned<F>, Error> + 'v),
) -> Result<(), Error> { ) -> Result<(), Error> {
if self.used_columns.contains(&column) { if self.used_columns.contains(&column) {
return Err(Error::SynthesisError); // TODO better error return Err(Error::Synthesis); // TODO better error
} }
let entry = self.default_and_assigned.entry(column).or_default(); let entry = self.default_and_assigned.entry(column).or_default();
@ -439,7 +439,7 @@ impl<'r, 'a, F: Field, CS: Assignment<F> + 'a> TableLayouter<F>
(true, 0) => entry.0 = Some(value), (true, 0) => entry.0 = Some(value),
// Since there is already an existing default value for this table column, // Since there is already an existing default value for this table column,
// the caller should not be attempting to assign another value at offset 0. // the caller should not be attempting to assign another value at offset 0.
(false, 0) => return Err(Error::SynthesisError), // TODO better error (false, 0) => return Err(Error::Synthesis), // TODO better error
_ => (), _ => (),
} }
if entry.1.len() <= offset { if entry.1.len() <= offset {

4
src/circuit/floor_planner/v1.rs
View File

@ -321,7 +321,7 @@ impl<'p, 'a, F: Field, CS: Assignment<F> + 'a> AssignmentPass<'p, 'a, F, CS> {
_ => None, _ => None,
}) { }) {
Some(Some(len)) => len, Some(Some(len)) => len,
_ => return Err(Error::SynthesisError), // TODO better error _ => return Err(Error::Synthesis), // TODO better error
} }
}; };
@ -436,7 +436,7 @@ impl<'r, 'a, F: Field, CS: Assignment<F> + 'a> RegionLayouter<F> for V1Region<'r
let value = self.plan.cs.query_instance(instance, row)?; let value = self.plan.cs.query_instance(instance, row)?;
let cell = self.assign_advice(annotation, advice, offset, &mut || { let cell = self.assign_advice(annotation, advice, offset, &mut || {
value.ok_or(Error::SynthesisError).map(|v| v.into()) value.ok_or(Error::Synthesis).map(|v| v.into())
})?; })?;
self.plan.cs.copy( self.plan.cs.copy(

6
src/dev.rs
View File

@ -292,15 +292,15 @@ impl<F: Group + Field> Mul<F> for Value<F> {
/// layouter.assign_region(|| "Example region", |mut region| { /// layouter.assign_region(|| "Example region", |mut region| {
/// config.s.enable(&mut region, 0)?; /// config.s.enable(&mut region, 0)?;
/// region.assign_advice(|| "a", config.a, 0, || { /// region.assign_advice(|| "a", config.a, 0, || {
/// self.a.map(|v| F::from(v)).ok_or(Error::SynthesisError) /// self.a.map(|v| F::from(v)).ok_or(Error::Synthesis)
/// })?; /// })?;
/// region.assign_advice(|| "b", config.b, 0, || { /// region.assign_advice(|| "b", config.b, 0, || {
/// self.b.map(|v| F::from(v)).ok_or(Error::SynthesisError) /// self.b.map(|v| F::from(v)).ok_or(Error::Synthesis)
/// })?; /// })?;
/// region.assign_advice(|| "c", config.c, 0, || { /// region.assign_advice(|| "c", config.c, 0, || {
/// self.a /// self.a
/// .and_then(|a| self.b.map(|b| F::from(a * b))) /// .and_then(|a| self.b.map(|b| F::from(a * b)))
/// .ok_or(Error::SynthesisError) /// .ok_or(Error::Synthesis)
/// })?; /// })?;
/// Ok(()) /// Ok(())
/// }) /// })

8
src/plonk/error.rs
View File

@ -6,7 +6,7 @@ use std::io;
pub enum Error { pub enum Error {
/// This is an error that can occur during synthesis of the circuit, for /// This is an error that can occur during synthesis of the circuit, for
/// example, when the witness is not present. /// example, when the witness is not present.
SynthesisError, Synthesis,
/// The provided instances do not match the circuit parameters. /// The provided instances do not match the circuit parameters.
InvalidInstances, InvalidInstances,
/// The constraint system is not satisfied. /// The constraint system is not satisfied.
@ -14,9 +14,9 @@ pub enum Error {
/// Out of bounds index passed to a backend /// Out of bounds index passed to a backend
BoundsFailure, BoundsFailure,
/// Opening error /// Opening error
OpeningError, Opening,
/// Transcript error /// Transcript error
TranscriptError(io::Error), Transcript(io::Error),
/// Instance provided has more rows than supported by circuit /// Instance provided has more rows than supported by circuit
NotEnoughRowsAvailable, NotEnoughRowsAvailable,
/// Instance provided exceeds number of available rows /// Instance provided exceeds number of available rows
@ -29,6 +29,6 @@ pub enum Error {
impl From<io::Error> for Error { impl From<io::Error> for Error {
fn from(error: io::Error) -> Self { fn from(error: io::Error) -> Self {
// The only place we can get io::Error from is the transcript. // The only place we can get io::Error from is the transcript.
Error::TranscriptError(error) Error::Transcript(error)
} }
} }

2
src/plonk/keygen.rs
View File

@ -160,7 +160,7 @@ impl<F: Field> Assignment<F> for Assembly<F> {
.ok_or(Error::BoundsFailure)?; .ok_or(Error::BoundsFailure)?;
for row in self.usable_rows.clone().skip(from_row) { for row in self.usable_rows.clone().skip(from_row) {
col[row] = to.ok_or(Error::SynthesisError)?; col[row] = to.ok_or(Error::Synthesis)?;
} }
Ok(()) Ok(())

4
src/plonk/permutation/keygen.rs
View File

@ -51,12 +51,12 @@ impl Assembly {
.columns .columns
.iter() .iter()
.position(|c| c == &left_column) .position(|c| c == &left_column)
.ok_or(Error::SynthesisError)?; .ok_or(Error::Synthesis)?;
let right_column = self let right_column = self
.columns .columns
.iter() .iter()
.position(|c| c == &right_column) .position(|c| c == &right_column)
.ok_or(Error::SynthesisError)?; .ok_or(Error::Synthesis)?;
// Check bounds // Check bounds
if left_row >= self.mapping[left_column].len() if left_row >= self.mapping[left_column].len()

2
src/plonk/prover.rs
View File

@ -599,5 +599,5 @@ pub fn create_proof<
// We query the h(X) polynomial at x // We query the h(X) polynomial at x
.chain(vanishing.open(x)); .chain(vanishing.open(x));
multiopen::create_proof(params, transcript, instances).map_err(|_| Error::OpeningError) multiopen::create_proof(params, transcript, instances).map_err(|_| Error::Opening)
} }

2
src/plonk/verifier.rs
View File

@ -285,5 +285,5 @@ pub fn verify_proof<'params, C: CurveAffine, E: EncodedChallenge<C>, T: Transcri
// We are now convinced the circuit is satisfied so long as the // We are now convinced the circuit is satisfied so long as the
// polynomial commitments open to the correct values. // polynomial commitments open to the correct values.
multiopen::verify_proof(params, transcript, queries, msm).map_err(|_| Error::OpeningError) multiopen::verify_proof(params, transcript, queries, msm).map_err(|_| Error::Opening)
} }

32
tests/plonk_api.rs
View File

@ -105,32 +105,32 @@ fn plonk_api() {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
region.assign_advice( region.assign_advice(
|| "lhs^4", || "lhs^4",
self.config.d, self.config.d,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.0.square().square()), || Ok(value.ok_or(Error::Synthesis)?.0.square().square()),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
region.assign_advice( region.assign_advice(
|| "rhs^4", || "rhs^4",
self.config.e, self.config.e,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1.square().square()), || Ok(value.ok_or(Error::Synthesis)?.1.square().square()),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::zero()))?;
@ -159,32 +159,32 @@ fn plonk_api() {
0, 0,
|| { || {
value = Some(f()?); value = Some(f()?);
Ok(value.ok_or(Error::SynthesisError)?.0) Ok(value.ok_or(Error::Synthesis)?.0)
}, },
)?; )?;
region.assign_advice( region.assign_advice(
|| "lhs^4", || "lhs^4",
self.config.d, self.config.d,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.0.square().square()), || Ok(value.ok_or(Error::Synthesis)?.0.square().square()),
)?; )?;
let rhs = region.assign_advice( let rhs = region.assign_advice(
|| "rhs", || "rhs",
self.config.b, self.config.b,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1), || Ok(value.ok_or(Error::Synthesis)?.1),
)?; )?;
region.assign_advice( region.assign_advice(
|| "rhs^4", || "rhs^4",
self.config.e, self.config.e,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.1.square().square()), || Ok(value.ok_or(Error::Synthesis)?.1.square().square()),
)?; )?;
let out = region.assign_advice( let out = region.assign_advice(
|| "out", || "out",
self.config.c, self.config.c,
0, 0,
|| Ok(value.ok_or(Error::SynthesisError)?.2), || Ok(value.ok_or(Error::Synthesis)?.2),
)?; )?;
region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?; region.assign_fixed(|| "a", self.config.sa, 0, || Ok(FF::one()))?;
@ -356,17 +356,17 @@ fn plonk_api() {
let (a0, _, c0) = cs.raw_multiply(&mut layouter, || { let (a0, _, c0) = cs.raw_multiply(&mut layouter, || {
a_squared = self.a.map(|a| a.square()); a_squared = self.a.map(|a| a.square());
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
let (a1, b1, _) = cs.raw_add(&mut layouter, || { let (a1, b1, _) = cs.raw_add(&mut layouter, || {
let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2)); let fin = a_squared.and_then(|a2| self.a.map(|a| a + a2));
Ok(( Ok((
self.a.ok_or(Error::SynthesisError)?, self.a.ok_or(Error::Synthesis)?,
a_squared.ok_or(Error::SynthesisError)?, a_squared.ok_or(Error::Synthesis)?,
fin.ok_or(Error::SynthesisError)?, fin.ok_or(Error::Synthesis)?,
)) ))
})?; })?;
cs.copy(&mut layouter, a0, a1)?; cs.copy(&mut layouter, a0, a1)?;