miden-ace-codegen 0.31.1

ACE circuit codegen for Plonky3-based Miden AIRs.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::{InputCounts, InputKey, InputLayout};

#[test]
fn masm_layout_aligns_and_maps_aux_inputs() {
    let counts = InputCounts {
        preprocessed_width: 2,
        width: 3,
        aux_width: 2,
        num_aux_boundary: 2,
        num_public: 5,
        num_randomness: 2,
        num_quotient_chunks: 2,
    };
    let layout = InputLayout::new_masm(counts);

    let public_base = layout.index(InputKey::Public(0)).unwrap();
    assert_eq!(public_base % 8, 0);
    let rand_base = layout.index(InputKey::AuxRandBeta).unwrap();
    assert_eq!(rand_base % 2, 0);
    let preprocessed_curr_base =
        layout.index(InputKey::Preprocessed { offset: 0, index: 0 }).unwrap();
    assert_eq!(preprocessed_curr_base % 4, 0);
    let main_curr_base = layout.index(InputKey::Main { offset: 0, index: 0 }).unwrap();
    assert_eq!(main_curr_base % 4, 0);
    let aux_curr_base = layout.index(InputKey::AuxCoord { offset: 0, index: 0, coord: 0 }).unwrap();
    assert_eq!(aux_curr_base % 4, 0);
    let quotient_curr_base = layout
        .index(InputKey::QuotientChunkCoord { offset: 0, chunk: 0, coord: 0 })
        .unwrap();
    assert_eq!(quotient_curr_base % 4, 0);
    let preprocessed_next_base =
        layout.index(InputKey::Preprocessed { offset: 1, index: 0 }).unwrap();
    assert_eq!(preprocessed_next_base % 4, 0);
    let main_next_base = layout.index(InputKey::Main { offset: 1, index: 0 }).unwrap();
    assert_eq!(main_next_base % 4, 0);
    let aux_next_base = layout.index(InputKey::AuxCoord { offset: 1, index: 0, coord: 0 }).unwrap();
    assert_eq!(aux_next_base % 4, 0);
    let quotient_next_base = layout
        .index(InputKey::QuotientChunkCoord { offset: 1, chunk: 0, coord: 0 })
        .unwrap();
    assert_eq!(quotient_next_base % 4, 0);
    let aux_bus_base = layout.index(InputKey::AuxBusBoundary(0)).unwrap();
    assert_eq!(aux_bus_base % 2, 0);
    let stark_base = layout.index(InputKey::Alpha).unwrap();
    assert_eq!(stark_base % 2, 0);
    assert_eq!(layout.index(InputKey::AuxRandBeta), Some(rand_base));
    assert_eq!(layout.index(InputKey::AuxRandAlpha), Some(rand_base + 1));
    assert!(public_base < rand_base);
    assert!(rand_base < preprocessed_curr_base);
    assert!(preprocessed_curr_base < main_curr_base);
    assert!(main_curr_base < aux_curr_base);
    assert!(aux_curr_base < quotient_curr_base);
    assert!(quotient_curr_base < preprocessed_next_base);
    assert!(preprocessed_next_base < main_next_base);
    assert!(main_next_base < aux_next_base);
    assert!(aux_next_base < quotient_next_base);
    assert!(quotient_next_base < aux_bus_base);
    assert!(aux_bus_base < stark_base);
    assert_eq!(
        layout.index(InputKey::Preprocessed { offset: 0, index: 0 }),
        Some(preprocessed_curr_base)
    );
    assert_eq!(
        layout.index(InputKey::Preprocessed { offset: 0, index: 1 }),
        Some(preprocessed_curr_base + 1)
    );
    assert_eq!(
        layout.index(InputKey::Preprocessed { offset: 1, index: 0 }),
        Some(preprocessed_next_base)
    );
    assert_eq!(
        layout.index(InputKey::Preprocessed { offset: 1, index: 1 }),
        Some(preprocessed_next_base + 1)
    );

    // EF values: slots 0-6
    let base = layout.index(InputKey::Alpha).unwrap();
    assert_eq!(layout.index(InputKey::Alpha), Some(base));
    assert_eq!(layout.index(InputKey::ZPowN), Some(base + 1));
    assert_eq!(layout.index(InputKey::ZK), Some(base + 2));
    assert_eq!(layout.index(InputKey::IsFirst), Some(base + 3));
    assert_eq!(layout.index(InputKey::IsLast), Some(base + 4));
    assert_eq!(layout.index(InputKey::IsTransition), Some(base + 5));
    assert_eq!(layout.index(InputKey::Reserved), Some(base + 6));
    // Base-field values: slots 7-9
    assert_eq!(layout.index(InputKey::Weight0), Some(base + 7));
    assert_eq!(layout.index(InputKey::F), Some(base + 8));
    assert_eq!(layout.index(InputKey::S0), Some(base + 9));

    let aux_base = layout.index(InputKey::AuxCoord { offset: 0, index: 0, coord: 0 }).unwrap();
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 0, index: 0, coord: 0 }),
        Some(aux_base)
    );
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 0, index: 0, coord: 1 }),
        Some(aux_base + 1)
    );
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 0, index: 1, coord: 0 }),
        Some(aux_base + 2)
    );
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 0, index: 1, coord: 1 }),
        Some(aux_base + 3)
    );

    let aux_next = layout.index(InputKey::AuxCoord { offset: 1, index: 0, coord: 0 }).unwrap();
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 1, index: 0, coord: 0 }),
        Some(aux_next)
    );
    assert_eq!(
        layout.index(InputKey::AuxCoord { offset: 1, index: 0, coord: 1 }),
        Some(aux_next + 1)
    );

    let quotient_base = layout
        .index(InputKey::QuotientChunkCoord { offset: 0, chunk: 0, coord: 0 })
        .unwrap();
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 0, chunk: 0, coord: 0 }),
        Some(quotient_base)
    );
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 0, chunk: 0, coord: 1 }),
        Some(quotient_base + 1)
    );
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 0, chunk: 1, coord: 0 }),
        Some(quotient_base + 2)
    );
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 0, chunk: 1, coord: 1 }),
        Some(quotient_base + 3)
    );

    let quotient_next = layout
        .index(InputKey::QuotientChunkCoord { offset: 1, chunk: 0, coord: 0 })
        .unwrap();
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 1, chunk: 0, coord: 0 }),
        Some(quotient_next)
    );
    assert_eq!(
        layout.index(InputKey::QuotientChunkCoord { offset: 1, chunk: 0, coord: 1 }),
        Some(quotient_next + 1)
    );
}