halo2-base 0.5.4

Embedded domain specific language (eDSL) for writing circuits with the [`halo2`](https://github.com/axiom-crypto/halo2) API. It simplifies circuit programming to declaring constraints over a single advice and selector column and provides built-in circuit tuning and support for multi-threaded witness generation.
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

use super::*;
use crate::utils::biguint_to_fe;
use crate::utils::testing::base_test;
use crate::QuantumCell::Witness;
use crate::{gates::range::RangeInstructions, QuantumCell};
use num_bigint::BigUint;
use test_case::test_case;

#[test_case(16, 10, Fr::zero(), 0; "range_check() 0 bits")]
#[test_case(16, 10, Fr::from(100), 8; "range_check() pos")]
pub fn test_range_check(k: usize, lookup_bits: usize, a_val: Fr, range_bits: usize) {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        let a = ctx.load_witness(a_val);
        chip.range_check(ctx, a, range_bits);
    })
}

#[test_case(12, 10, Witness(Fr::zero()), Witness(Fr::one()), 64; "check_less_than() pos")]
pub fn test_check_less_than(
    k: usize,
    lookup_bits: usize,
    a: QuantumCell<Fr>,
    b: QuantumCell<Fr>,
    num_bits: usize,
) {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        chip.check_less_than(ctx, a, b, num_bits);
    })
}

#[test_case(10, 8, Fr::zero(), 1; "check_less_than_safe() pos")]
pub fn test_check_less_than_safe(k: usize, lookup_bits: usize, a: Fr, b: u64) {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        let a = ctx.load_witness(a);
        chip.check_less_than_safe(ctx, a, b);
    })
}

#[test_case(10, 8, biguint_to_fe(&BigUint::from(2u64).pow(239)), BigUint::from(2u64).pow(240) - 1usize; "check_big_less_than_safe() pos")]
pub fn test_check_big_less_than_safe(k: usize, lookup_bits: usize, a: Fr, b: BigUint) {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        let a = ctx.load_witness(a);
        chip.check_big_less_than_safe(ctx, a, b)
    })
}

#[test_case(10, 8, [6, 7].map(Fr::from).map(Witness), 3 => Fr::from(1); "is_less_than() pos")]
pub fn test_is_less_than(
    k: usize,
    lookup_bits: usize,
    inputs: [QuantumCell<Fr>; 2],
    bits: usize,
) -> Fr {
    base_test()
        .k(k as u32)
        .lookup_bits(lookup_bits)
        .run(|ctx, chip| *chip.is_less_than(ctx, inputs[0], inputs[1], bits).value())
}

#[test_case(10, 8, Fr::from(2), 3 => Fr::from(1); "is_less_than_safe() pos")]
pub fn test_is_less_than_safe(k: usize, lookup_bits: usize, a: Fr, b: u64) -> Fr {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        let a = ctx.load_witness(a);
        let lt = chip.is_less_than_safe(ctx, a, b);
        *lt.value()
    })
}

#[test_case(10, 8, biguint_to_fe(&BigUint::from(2u64).pow(239)), BigUint::from(2u64).pow(240) - 1usize => Fr::from(1); "is_big_less_than_safe() pos")]
pub fn test_is_big_less_than_safe(k: usize, lookup_bits: usize, a: Fr, b: BigUint) -> Fr {
    base_test().k(k as u32).lookup_bits(lookup_bits).run(|ctx, chip| {
        let a = ctx.load_witness(a);
        *chip.is_big_less_than_safe(ctx, a, b).value()
    })
}

#[test_case(Witness(Fr::from(3)), 2, 2 => (Fr::from(1), Fr::from(1)) ; "div_mod(3, 2)")]
pub fn test_div_mod(a: QuantumCell<Fr>, b: u64, num_bits: usize) -> (Fr, Fr) {
    base_test().run(|ctx, chip| {
        let a = chip.div_mod(ctx, a, b, num_bits);
        (*a.0.value(), *a.1.value())
    })
}

#[test_case(Fr::from(3), 8 => Fr::one() ; "get_last_bit(): 3, 8 bits")]
#[test_case(Fr::from(3), 2 => Fr::one() ; "get_last_bit(): 3, 2 bits")]
#[test_case(Fr::from(0), 2 => Fr::zero() ; "get_last_bit(): 0")]
#[test_case(Fr::from(1), 2 => Fr::one() ; "get_last_bit(): 1")]
#[test_case(Fr::from(2), 2 => Fr::zero() ; "get_last_bit(): 2")]
pub fn test_get_last_bit(a: Fr, bits: usize) -> Fr {
    base_test().run(|ctx, chip| {
        let a = ctx.load_witness(a);
        *chip.get_last_bit(ctx, a, bits).value()
    })
}

#[test_case(Witness(Fr::from(3)), Witness(Fr::from(2)), 3, 3 => (Fr::one(), Fr::one()); "div_mod_var(3 ,2)")]
pub fn test_div_mod_var(
    a: QuantumCell<Fr>,
    b: QuantumCell<Fr>,
    a_num_bits: usize,
    b_num_bits: usize,
) -> (Fr, Fr) {
    base_test().run(|ctx, chip| {
        let a = chip.div_mod_var(ctx, a, b, a_num_bits, b_num_bits);
        (*a.0.value(), *a.1.value())
    })
}