logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-05 07:13:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Working in test

Browse Source
This commit is contained in:
wborgeaud 2022-10-13 14:28:08 +02:00
parent f497fc652c
commit 66a0e77251
2 changed files with 167 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
plonky2/src/plonk/circuit_data.rs
View File

@ -276,7 +276,7 @@ pub struct ProverOnlyCircuitData<
}
/// Circuit data required by the verifier, but not the prover.
#[derive(Debug)]
#[derive(Debug, Eq, PartialEq)]
pub struct VerifierOnlyCircuitData<C: GenericConfig<D>, const D: usize> {
/// A commitment to each constant polynomial and each permutation polynomial.
pub constants_sigmas_cap: MerkleCap<C::F, C::Hasher>,

179
plonky2/src/plonk/recursive_verifier.rs
View File

@ -464,37 +464,190 @@ mod tests {
// type FF = <C as GenericConfig<D>>::FE;
let config = CircuitConfig::standard_recursion_config();
let (proof, vd, cd) = dummy_proof::<F, C, D>(&config, 1 << 13)?;
let (proof, vd, cd) = dummy_proof::<F, C, D>(&config, 1 << 14)?;
let (proof, vd, cd) =
recursive_proof::<F, C, C, D>(proof, vd, cd, &config, None, false, false)?;
let (_proof, _vd, cd) =
recursive_proof::<F, C, C, D>(proof, vd, cd, &config, None, false, false)?;
let (_proof, _vd, mut cd) =
recursive_proof::<F, C, C, D>(proof, vd, cd, &config, Some(14), false, false)?;
cd.num_public_inputs = 69;
// First proof
let config = CircuitConfig::standard_recursion_config();
let mut pw = PartialWitness::new();
let mut builder = CircuitBuilder::<F, D>::new(config);
let verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
builder.register_public_inputs(&verifier_data.circuit_digest.elements);
for i in 0..1 << builder.config.fri_config.cap_height {
builder.register_public_inputs(&verifier_data.constants_sigmas_cap.0[i].elements);
}
let pt = builder.add_virtual_proof_with_pis(&cd);
builder.verify_proof(pt, &verifier_data, &cd);
let dummy_verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
let condition = builder.add_virtual_bool_target();
builder.register_public_input(condition.target);
pw.set_bool_target(condition, false);
let inner_gates = cd.gates.iter().map(|g| g.0.id()).collect::<Vec<_>>();
for gate in &builder.gates {
assert!(inner_gates.contains(&gate.0.id()), "{}", gate.0.id());
}
for _ in builder.num_gates()..(1 << 13) - 100 {
let (dummy_proof, dummy_data) =
crate::plonk::conditional_recursive_verifier::dummy_proof(&cd)?;
let pt0 = builder.add_virtual_proof_with_pis(&cd);
let pt1 = builder.add_virtual_proof_with_pis(&cd);
pw.set_proof_with_pis_target(&pt0, &dummy_proof);
pw.set_proof_with_pis_target(&pt1, &dummy_proof);
pw.set_hash_target(
dummy_verifier_data.circuit_digest,
dummy_data.verifier_only.circuit_digest,
);
pw.set_cap_target(
&dummy_verifier_data.constants_sigmas_cap,
&dummy_data.verifier_only.constants_sigmas_cap,
);
builder.conditionally_verify_proof(
condition,
pt0,
&verifier_data,
pt1,
&dummy_verifier_data,
&cd,
);
while builder.num_gates() < 1 << 13 {
builder.add_gate(NoopGate, vec![]);
}
let data = builder.build::<C>();
dbg!(data.common.degree_bits);
let proof = data.prove(pw)?;
let data = builder.build::<C>();
dbg!(cd.degree_bits);
dbg!(data.common.degree_bits);
assert_eq!(&data.common, &cd);
pw.set_verifier_data_target(&verifier_data, &data.verifier_only);
let proof = data.prove(pw)?;
assert_eq!(
data.verifier_only.circuit_digest.elements[0],
proof.public_inputs[0]
);
data.verify(proof.clone())?;
// Second proof
let config = CircuitConfig::standard_recursion_config();
let mut pw = PartialWitness::new();
let mut builder = CircuitBuilder::<F, D>::new(config);
let verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
builder.register_public_inputs(&verifier_data.circuit_digest.elements);
for i in 0..1 << builder.config.fri_config.cap_height {
builder.register_public_inputs(&verifier_data.constants_sigmas_cap.0[i].elements);
}
let dummy_verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
let condition = builder.add_virtual_bool_target();
builder.register_public_input(condition.target);
pw.set_bool_target(condition, true);
let pt0 = builder.add_virtual_proof_with_pis(&data.common);
let pt1 = builder.add_virtual_proof_with_pis(&data.common);
pw.set_proof_with_pis_target(&pt0, &proof);
pw.set_proof_with_pis_target(&pt1, &proof);
builder.conditionally_verify_proof(
condition,
pt0,
&verifier_data,
pt1,
&dummy_verifier_data,
&data.common,
);
while builder.num_gates() < 1 << 13 {
builder.add_gate(NoopGate, vec![]);
}
let data1 = builder.build::<C>();
assert_eq!(data.common, data1.common);
assert_eq!(data.verifier_only, data1.verifier_only);
dbg!(cd.degree_bits);
dbg!(data1.common.degree_bits);
pw.set_verifier_data_target(&verifier_data, &data.verifier_only);
pw.set_verifier_data_target(&dummy_verifier_data, &data.verifier_only);
let proof = data.prove(pw)?;
assert_eq!(
data.verifier_only.circuit_digest.elements[0],
proof.public_inputs[0]
);
assert_eq!(
data1.verifier_only.circuit_digest.elements[0],
proof.public_inputs[0]
);
data.verify(proof.clone())?;
// Second proof
let config = CircuitConfig::standard_recursion_config();
let mut pw = PartialWitness::new();
let mut builder = CircuitBuilder::<F, D>::new(config);
let verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
builder.register_public_inputs(&verifier_data.circuit_digest.elements);
for i in 0..1 << builder.config.fri_config.cap_height {
builder.register_public_inputs(&verifier_data.constants_sigmas_cap.0[i].elements);
}
let dummy_verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(builder.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(),
};
let condition = builder.add_virtual_bool_target();
builder.register_public_input(condition.target);
pw.set_bool_target(condition, true);
let pt0 = builder.add_virtual_proof_with_pis(&data.common);
let pt1 = builder.add_virtual_proof_with_pis(&data.common);
pw.set_proof_with_pis_target(&pt0, &proof);
pw.set_proof_with_pis_target(&pt1, &proof);
builder.conditionally_verify_proof(
condition,
pt0,
&verifier_data,
pt1,
&dummy_verifier_data,
&data.common,
);
while builder.num_gates() < 1 << 13 {
builder.add_gate(NoopGate, vec![]);
}
let data2 = builder.build::<C>();
assert_eq!(data.common, data2.common);
assert_eq!(data.verifier_only, data2.verifier_only);
dbg!(cd.degree_bits);
dbg!(data1.common.degree_bits);
pw.set_verifier_data_target(&verifier_data, &data.verifier_only);
pw.set_verifier_data_target(&dummy_verifier_data, &data.verifier_only);
let proof = data.prove(pw)?;
assert_eq!(
data.verifier_only.circuit_digest.elements[0],
proof.public_inputs[0]
);
assert_eq!(
data1.verifier_only.circuit_digest.elements[0],
proof.public_inputs[0]
);
data.verify(proof)
}
}