Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[WIP] Sync halo2 lib 0.4.0 #68

Closed
wants to merge 31 commits into from
Closed
Changes from 1 commit
Commits
Show all changes
31 commits
Select commit Hold shift + click to select a range
7bedb67
feat: call synthesize in `MockProver` multiple times to behave same a…
han0110 Jan 19, 2023
4c12249
modify previous commit
Velaciela Oct 8, 2023
323f403
Expose mod `permutation` and re-export `permutation::keygen::Assembly…
han0110 Feb 22, 2023
233dbc6
change: Migrate workspace to pasta_curves-0.5 (#157)
CPerezz Mar 7, 2023
6adc633
fix previous commit
Velaciela Oct 9, 2023
b26a0ae
Extend Circuit trait to take parameters in config (#168)
ed255 Apr 20, 2023
e577808
Allow halo2 constraint names to have non static names (#156)
CeciliaZ030 Apr 20, 2023
b05bc4d
Improve halo2 query calls (#154)
CeciliaZ030 Apr 26, 2023
dd22b61
Implement Clone trait for Hash, Absorbing, and Sponge structs (#171)
enricobottazzi Apr 27, 2023
e56d03f
fix: Fix serialization for VerifyingKey (#178)
CPerezz May 3, 2023
828b21a
Add more getters to expose internal fields
ed255 May 10, 2023
f88dc85
add a constructor (#164)
Ethan-000 May 18, 2023
b2450cd
feat: send sync region (#180)
alexander-camuto Jun 1, 2023
57831cc
fix previous commit
Velaciela Oct 9, 2023
7a80259
Fix `parallelize` workload imbalance (#186)
mratsim Jun 19, 2023
d171a04
Updates halo2_curves dependency to released package (#190)
huitseeker Jul 30, 2023
669a670
fix: explicitly define mds diff type (#196)
alexander-camuto Aug 26, 2023
d19480a
feat: expose `transcript_repr` of `VerifyingKey` and reduce the trait…
han0110 Sep 4, 2023
fe426ae
implement native shuffle argument and api
kilic May 21, 2023
b590427
feat: public cells to allow for implementations of custom `Layouter` …
alexander-camuto Aug 25, 2023
657f98b
Synchronize with upstream (#199)
han0110 Sep 6, 2023
bf08bb4
chore: Update rust-toolchain to 1.66 for testing (#208)
CPerezz Sep 18, 2023
f47c31d
fix: clippy (#203)
thor314 Sep 18, 2023
75be70d
Implement Sum and Product for Expression (#209)
pnyda Sep 27, 2023
6f40fa9
chore: update poseidon dependency
zhenfeizhang Oct 16, 2023
e5acb7d
fix: compiling bug with feautes=parallel_syn
zhenfeizhang Oct 16, 2023
2b92df9
feat(MockProver): replace errors by asserts(privacy-scaling-explorati…
Velaciela Oct 25, 2023
3d44389
boundary offset lost when resolving conflict
Velaciela Oct 25, 2023
5178dc4
disable multiphase prover
zhenfeizhang Dec 19, 2023
b837de6
Sync halo2 lib 0.4.0 merging (#81)
lispc Jan 9, 2024
109522e
Merge branch 'v1.1' into sync-halo2-lib-0.4.0
kunxian-xia Jan 12, 2024
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
feat(MockProver): replace errors by asserts(privacy-scaling-explorati…
Velaciela committed Oct 25, 2023
commit 2b92df993b447887d5ca9e1e12ac60446ed4f4f0
137 changes: 86 additions & 51 deletions halo2_proofs/src/dev.rs
Original file line number Diff line number Diff line change
@@ -414,13 +414,15 @@ impl<F: Field> Mul<F> for Value<F> {
/// }])
/// );
///
/// // If we provide a too-small K, we get an error.
/// assert!(matches!(
/// MockProver::<Fp>::run(2, &circuit, vec![]).unwrap_err(),
/// Error::NotEnoughRowsAvailable {
/// current_k,
/// } if current_k == 2,
/// ));
/// // If we provide a too-small K, we get a panic.
/// use std::panic;
/// let result = panic::catch_unwind(|| {
/// MockProver::<Fp>::run(2, &circuit, vec![]).unwrap_err()
/// });
/// assert_eq!(
/// result.unwrap_err().downcast_ref::<String>().unwrap(),
/// "n=4, minimum_rows=8, k=2"
/// );
/// ```
#[derive(Debug)]
pub struct MockProver<'a, F: Field> {
@@ -537,9 +539,13 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
return Ok(());
}

if !self.usable_rows.contains(&row) {
return Err(Error::not_enough_rows_available(self.k));
}
assert!(
self.usable_rows.contains(&row),
"row={} not in usable_rows={:?}, k={}",
row,
self.usable_rows,
self.k,
);

if !self.rw_rows.contains(&row) {
return Err(Error::InvalidRange(
@@ -694,15 +700,20 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
column: Column<Instance>,
row: usize,
) -> Result<circuit::Value<F>, Error> {
if !self.usable_rows.contains(&row) {
return Err(Error::not_enough_rows_available(self.k));
}
assert!(
self.usable_rows.contains(&row),
"row={}, usable_rows={:?}, k={}",
row,
self.usable_rows,
self.k,
);

self.instance
Ok(self
.instance
.get(column.index())
.and_then(|column| column.get(row))
.map(|v| circuit::Value::known(v.value()))
.ok_or(Error::BoundsFailure)
.expect("bound failure"))
}

fn assign_advice<V, VR, A, AR>(
@@ -723,8 +734,22 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
return Ok(());
}

if !self.usable_rows.contains(&row) {
return Err(Error::not_enough_rows_available(self.k));
if self.in_phase(FirstPhase) {
assert!(
self.usable_rows.contains(&row),
"row={}, usable_rows={:?}, k={}",
row,
self.usable_rows,
self.k,
);
if let Some(region) = self.current_region.as_mut() {
region.update_extent(column.into(), row);
region
.cells
.entry((column.into(), row))
.and_modify(|count| *count += 1)
.or_default();
}
}

if !self.rw_rows.contains(&row) {
@@ -737,15 +762,6 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
));
}

if let Some(region) = self.current_region.as_mut() {
region.update_extent(column.into(), row);
region
.cells
.entry((column.into(), row))
.and_modify(|count| *count += 1)
.or_default();
}

let advice_anno = anno().into();
#[cfg(not(feature = "mock-batch-inv"))]
let val_res = to().into_field().evaluate().assign();
@@ -808,9 +824,13 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
return Ok(());
}

if !self.usable_rows.contains(&row) {
return Err(Error::not_enough_rows_available(self.k));
}
assert!(
self.usable_rows.contains(&row),
"row={}, usable_rows={:?}, k={}",
row,
self.usable_rows,
self.k,
);

if !self.rw_rows.contains(&row) {
return Err(Error::InvalidRange(
@@ -863,9 +883,14 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
return Ok(());
}

if !self.usable_rows.contains(&left_row) || !self.usable_rows.contains(&right_row) {
return Err(Error::not_enough_rows_available(self.k));
}
assert!(
self.usable_rows.contains(&left_row) && self.usable_rows.contains(&right_row),
"left_row={}, right_row={}, usable_rows={:?}, k={}",
left_row,
right_row,
self.usable_rows,
self.k,
);

match self.permutation.as_mut() {
Some(permutation) => permutation.copy(left_column, left_row, right_column, right_row),
@@ -898,9 +923,13 @@ impl<'a, F: Field> Assignment<F> for MockProver<'a, F> {
return Ok(());
}

if !self.usable_rows.contains(&from_row) {
return Err(Error::not_enough_rows_available(self.k));
}
assert!(
self.usable_rows.contains(&from_row),
"row={}, usable_rows={:?}, k={}",
from_row,
self.usable_rows,
self.k,
);

for row in self.usable_rows.clone().skip(from_row) {
self.assign_fixed(|| "", col, row, || to)?;
@@ -947,29 +976,35 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> {
let config = ConcreteCircuit::configure(&mut cs);
let cs = cs;

if n < cs.minimum_rows() {
return Err(Error::not_enough_rows_available(k));
}
assert!(
n >= cs.minimum_rows(),
"n={}, minimum_rows={}, k={}",
n,
cs.minimum_rows(),
k,
);

if instance.len() != cs.num_instance_columns {
return Err(Error::InvalidInstances);
}
assert_eq!(instance.len(), cs.num_instance_columns);

let instance = instance
.into_iter()
.map(|instance| {
if instance.len() > n - (cs.blinding_factors() + 1) {
return Err(Error::InstanceTooLarge);
}
assert!(
instance.len() <= n - (cs.blinding_factors() + 1),
"instance.len={}, n={}, cs.blinding_factors={}",
instance.len(),
n,
cs.blinding_factors()
);

let mut instance_values = vec![InstanceValue::Padding; n];
for (idx, value) in instance.into_iter().enumerate() {
instance_values[idx] = InstanceValue::Assigned(value);
}

Ok(instance_values)
instance_values
})
.collect::<Result<Vec<_>, _>>()?;
.collect::<Vec<_>>();

// Fixed columns contain no blinding factors.
let fixed_vec = Arc::new(vec![vec![CellValue::Unassigned; n]; cs.num_fixed_columns]);
@@ -1008,10 +1043,10 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> {
.collect()
};

#[cfg(feature = "phase-check")]
let current_phase = FirstPhase.to_sealed();
#[cfg(not(feature = "phase-check"))]
let current_phase = crate::plonk::sealed::Phase(cs.max_phase());
// #[cfg(feature = "phase-check")]
// let current_phase = FirstPhase.to_sealed();
// #[cfg(not(feature = "phase-check"))]
// let current_phase = crate::plonk::sealed::Phase(cs.max_phase());

let mut prover = MockProver {
k,
@@ -1031,7 +1066,7 @@ impl<'a, F: FromUniformBytes<64> + Ord> MockProver<'a, F> {
permutation: Some(permutation),
rw_rows: 0..usable_rows,
usable_rows: 0..usable_rows,
current_phase, // FirstPhase.to_sealed(),
current_phase: FirstPhase.to_sealed(),
};

#[cfg(feature = "phase-check")]
7 changes: 2 additions & 5 deletions halo2_proofs/src/plonk/keygen.rs
Original file line number Diff line number Diff line change
@@ -241,7 +241,7 @@ impl<'a, F: Field> Assignment<F> for Assembly<'a, F> {
.fixed
.get_mut(column.index())
.and_then(|v| v.get_mut(row - self.rw_rows.start))
.ok_or(Error::BoundsFailure)? = to().into_field().assign()?;
.expect("bounds failure") = to().into_field().assign()?;

Ok(())
}
@@ -285,10 +285,7 @@ impl<'a, F: Field> Assignment<F> for Assembly<'a, F> {
return Err(Error::not_enough_rows_available(self.k));
}

let col = self
.fixed
.get_mut(column.index())
.ok_or(Error::BoundsFailure)?;
let col = self.fixed.get_mut(column.index()).expect("bounds failure");

let filler = to.assign()?;
for row in self.usable_rows.clone().skip(from_row) {
10 changes: 10 additions & 0 deletions halo2_proofs/src/plonk/permutation/keygen.rs
Original file line number Diff line number Diff line change
@@ -75,6 +75,16 @@ impl Assembly {
if left_row >= self.mapping[left_column].len()
|| right_row >= self.mapping[right_column].len()
{
log::error!(
"BoundsFailure: left_row: {}, right_row: {}",
left_row,
right_row
);
log::error!(
"BoundsFailure: left_max: {}, right_max: {}",
self.mapping[left_column].len(),
self.mapping[right_column].len()
);
return Err(Error::BoundsFailure);
}

6 changes: 4 additions & 2 deletions halo2_proofs/src/plonk/prover.rs
Original file line number Diff line number Diff line change
@@ -261,11 +261,13 @@ where
return Err(Error::not_enough_rows_available(self.k));
}

self.instances
Ok(self
.instances
.get(column.index())
.and_then(|column| column.get(row))
.map(|v| Value::known(*v))
.ok_or(Error::BoundsFailure)
.expect("bound failure"))
}

fn assign_advice<V, VR, A, AR>(
@@ -299,7 +301,7 @@ where
.advice
.get_mut(column.index())
.and_then(|v| v.get_mut(row - self.rw_rows.start))
.ok_or(Error::BoundsFailure)? = to().into_field().assign()?;
.expect("bounds failure") = to().into_field().assign()?;

Ok(())
}