air-script 0.4.0

AirScript language compiler
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

use winter_air::{BatchingMethod, EvaluationFrame, FieldExtension, ProofOptions, TraceInfo};
use winter_math::fields::f64::BaseElement as Felt;
use winterfell::{AuxTraceWithMetadata, Trace, TraceTable, matrix::ColMatrix};

/// We need to encapsulate the trace table in a struct to manually implement the `aux_trace_width` method of the `Table` trait.
/// Otherwise, using only a TraceTable<Felt> will return an `aux_trace_width` of 0 even if we provide a non-empty aux trace in `Trace::validate`,
/// and it fails the tests.
pub struct MyTraceTable {
    pub trace: TraceTable<Felt>,
    pub aux_width: usize,
}

impl MyTraceTable {
    pub fn new(trace: TraceTable<Felt>, aux_width: usize) -> Self {
        Self { trace, aux_width }
    }
}

impl Trace for MyTraceTable {
    type BaseField = Felt;

    fn info(&self) -> &TraceInfo {
        self.trace.info()
    }

    fn main_segment(&self) -> &ColMatrix<Felt> {
        self.trace.main_segment()
    }

    fn read_main_frame(&self, row_idx: usize, frame: &mut EvaluationFrame<Felt>) {
        self.trace.read_main_frame(row_idx, frame);
    }

    fn aux_trace_width(&self) -> usize {
        self.aux_width
    }
}

pub trait AirTester {
    type PubInputs;

    fn build_main_trace(&self, length: usize) -> MyTraceTable;
    fn public_inputs(&self) -> Self::PubInputs;
    fn build_aux_trace(&self, _length: usize) -> Option<AuxTraceWithMetadata<Felt>> {
        None
    }
    fn build_trace_info(&self, length: usize) -> TraceInfo {
        match &self.build_aux_trace(length) {
            None => TraceInfo::new(self.build_main_trace(length).trace.width(), length),
            Some(aux_trace) => TraceInfo::new_multi_segment(
                self.build_main_trace(length).trace.width(),
                aux_trace.aux_trace.num_cols(),
                aux_trace.aux_rand_elements.rand_elements().len(),
                length,
                vec![],
            ),
        }
    }
    fn build_proof_options(&self) -> ProofOptions {
        ProofOptions::new(
            32, // number of queries
            8,  // blowup factor
            0,  // grinding factor
            FieldExtension::None,
            8,                      // FRI folding factor
            31,                     // FRI max remainder polynomial degree
            BatchingMethod::Linear, // method of batching used in computing constraint composition polynomial
            BatchingMethod::Linear, // method of batching used in computing DEEP polynomial
        )
    }
}