以下是基于您提供的内容整理的完整示例demo，首先展示内容中的示例，然后提供完整实现：

内容中的示例代码

1. 定义电路示例

use bellman::{
    Circuit,
    ConstraintSystem,
    SynthesisError,
};
use pairing::{Engine, Field};

struct MyCircuit<E: Engine> {
    a: Option<E::Fr>,
    b: Option<E::Fr>,
}

impl<E: Engine> Circuit<E> for MyCircuit<E> {
    fn synthesize<CS: ConstraintSystem<E>>(
        self,
        cs: &mut CS
    ) -> Result<(), SynthesisError> {
        let a_var = cs.alloc(|| "a", || {
            self.a.ok_or(SynthesisError::AssignmentMissing)
        })?;
        
        let b_var = cs.alloc(|| "b", || {
            self.b.ok_or(SynthesisError::AssignmentMissing)
        })?;
        
        let ab_var = cs.alloc(|| "a*b", || {
            let mut a = self.a.ok_or(SynthesisError::AssignmentMissing)?;
            let b = self.b.ok_or(SynthesisError::AssignmentMissing)?;
            a.mul_assign(&b);
            Ok(a)
        })?;
        
        cs.enforce(
            || "a*b = ab",
            |lc| lc + a_var,
            |lc| lc + b_var,
            |lc| lc + ab_var
        );
        
        Ok(())
    }
}

2. 生成和验证证明示例

use bellman::groth16::{
    generate_random_parameters,
    create_random_proof,
    prepare_verifying_key,
    verify_proof,
};
use pairing::bls12_381::{Bls12, Fr};
use rand::thread_rng;

fn main() {
    let rng = &mut thread_rng();
    let circuit = MyCircuit::<Bls12> {
        a: Some(Fr::from_str("3").unwrap()),
        b: Some(Fr::from_str("5").unwrap()),
    };
    
    let params = generate_random_parameters::<Bls12, _, _>(
        circuit.clone(), 
        rng
    ).unwrap();
    
    let pvk = prepare_verifying_key(&params.vk);
    let proof = create_random_proof(circuit, &params, rng).unwrap();
    
    let result = verify_proof(&pvk, &proof, &[]).unwrap();
    assert!(result);
    println!("Proof verified successfully!");
}

完整示例demo

use bellman::{
    Circuit,
    ConstraintSystem,
    SynthesisError,
    groth16::{
        generate_random_parameters,
        create_random_proof,
        prepare_verifying_key,
        verify_proof,
    }
};
use pairing::{
    Engine,
    bls12_381::{Bls12, Fr},
    Field
};
use rand::thread_rng;
use std::str::FromStr;

// 定义电路结构
struct MultiplicationCircuit<E: Engine> {
    // 输入值a
    a: Option<E::Fr>,
    // 输入值b
    b: Option<E::Fr>,
}

// 为电路实现Circuit trait
impl<E: Engine> Circuit<E> for MultiplicationCircuit<E> {
    fn synthesize<CS: ConstraintSystem<E>>(
        self,
        cs: &mut CS
    ) -> Result<(), SynthesisError> {
        // 分配输入a
        let a_var = cs.alloc(|| "a", || {
            self.a.ok_or(SynthesisError::AssignmentMissing)
        })?;
        
        // 分配输入b
        let b_var = cs.alloc(|| "b", || {
            self.b.ok_or(SynthesisError::AssignmentMissing)
        })?;
        
        // 计算a*b并分配结果
        let ab_var = cs.alloc(|| "a*b", || {
            let mut a = self.a.ok_or(SynthesisError::AssignmentMissing)?;
            let b = self.b.ok_or(SynthesisError::AssignmentMissing)?;
            a.mul_assign(&b);
            Ok(a)
        })?;
        
        // 添加约束：a * b = ab
        cs.enforce(
            || "a*b = ab constraint",
            |lc| lc + a_var,
            |lc| lc + b_var,
            |lc| lc + ab_var
        );
        
        Ok(())
    }
}

fn main() {
    // 初始化随机数生成器
    let rng = &mut thread_rng();
    
    // 创建电路实例
    let circuit = MultiplicationCircuit::<Bls12> {
        a: Some(Fr::from_str("3").unwrap()),
        b: Some(Fr::from_str("5").unwrap()),
    };
    
    // 1. 生成CRS (公共参考字符串)
    println!("Generating parameters...");
    let params = generate_random_parameters::<Bls12, _, _>(circuit.clone(), rng)
        .expect("Failed to generate parameters");
    
    // 2. 准备验证密钥
    let pvk = prepare_verifying_key(&params.vk);
    
    // 3. 创建证明
    println!("Creating proof...");
    let proof = create_random_proof(circuit, &params, rng)
        .expect("Failed to create proof");
    
    // 4. 验证证明
    println!("Verifying proof...");
    let result = verify_proof(&pvk, &proof, &[])
        .expect("Failed to verify proof");
    
    assert!(result, "Proof verification failed");
    println!("Proof verified successfully!");
    
    // 5. 测试错误案例
    println!("Testing with invalid inputs...");
    let invalid_circuit = MultiplicationCircuit::<Bls12> {
        a: Some(Fr::from_str("4").unwrap()),  // 错误的a值
        b: Some(Fr::from_str("5").unwrap()),
    };
    
    let invalid_proof = create_random_proof(invalid_circuit, &params, rng)
        .expect("Failed to create invalid proof");
    
    let invalid_result = verify_proof(&pvk, &invalid_proof, &[])
        .expect("Failed to verify invalid proof");
    
    assert!(!invalid_result, "Invalid proof should not verify");
    println!("Invalid proof correctly rejected");
}

这个完整示例演示了：

1. 定义一个简单的乘法电路
2. 生成zk-SNARK参数
3. 创建和验证证明
4. 包含错误案例测试

使用步骤：

1. 将代码保存为main.rs
2. 在Cargo.toml中添加bellman和pairing依赖
3. 运行程序将输出证明生成和验证过程

注意：实际使用时需要根据具体需求设计更复杂的电路和约束条件。