miden-core 0.3.0

Miden VM core components
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

use super::{
    utils::range as create_range, Felt, Word, CHIPLETS_OFFSET, HASHER_AUX_TRACE_OFFSET, ONE, ZERO,
};
use core::ops::Range;

pub mod bitwise;
pub mod hasher;
pub mod kernel_rom;
pub mod memory;

// CONSTANTS
// ================================================================================================

/// The number of columns in the chiplets which are used as selectors for the hasher chiplet.
pub const NUM_HASHER_SELECTORS: usize = 1;
/// The number of columns in the chiplets which are used as selectors for the bitwise chiplet.
pub const NUM_BITWISE_SELECTORS: usize = 2;
/// The number of columns in the chiplets which are used as selectors for the memory chiplet.
pub const NUM_MEMORY_SELECTORS: usize = 3;
/// The number of columns in the chiplets which are used as selectors for the kernel ROM chiplet.
pub const NUM_KERNEL_ROM_SELECTORS: usize = 4;

/// The first column of the hash chiplet.
pub const HASHER_TRACE_OFFSET: usize = CHIPLETS_OFFSET + NUM_HASHER_SELECTORS;
/// The first column of the bitwise chiplet.
pub const BITWISE_TRACE_OFFSET: usize = CHIPLETS_OFFSET + NUM_BITWISE_SELECTORS;
/// The first column of the memory chiplet.
pub const MEMORY_TRACE_OFFSET: usize = CHIPLETS_OFFSET + NUM_MEMORY_SELECTORS;

// --- GLOBALLY-INDEXED CHIPLET COLUMN ACCESSORS: HASHER ------------------------------------------

/// The column index range in the execution trace containing the selector columns in the hasher.
pub const HASHER_SELECTOR_COL_RANGE: Range<usize> =
    create_range(HASHER_TRACE_OFFSET, hasher::NUM_SELECTORS);
/// The index of the hasher's row column in the execution trace.
pub const HASHER_ROW_COL_IDX: usize = HASHER_TRACE_OFFSET + hasher::ROW_COL_IDX;
/// The range of columns in the execution trace that contain the hasher's state.
pub const HASHER_STATE_COL_RANGE: Range<usize> = Range {
    start: HASHER_TRACE_OFFSET + hasher::STATE_COL_RANGE.start,
    end: HASHER_TRACE_OFFSET + hasher::STATE_COL_RANGE.end,
};
/// The range of columns in the execution trace that contains the capacity portion of the hasher
/// state.
pub const HASHER_CAPACITY_COL_RANGE: Range<usize> = Range {
    start: HASHER_TRACE_OFFSET + hasher::CAPACITY_COL_RANGE.start,
    end: HASHER_TRACE_OFFSET + hasher::CAPACITY_COL_RANGE.end,
};
/// The range of columns in the execution trace that contains the rate portion of the hasher state.
pub const HASHER_RATE_COL_RANGE: Range<usize> = Range {
    start: HASHER_TRACE_OFFSET + hasher::RATE_COL_RANGE.start,
    end: HASHER_TRACE_OFFSET + hasher::RATE_COL_RANGE.end,
};
/// The index of the hasher's node index column in the execution trace.
pub const HASHER_NODE_INDEX_COL_IDX: usize = HASHER_STATE_COL_RANGE.end;

// --- GLOBALLY-INDEXED CHIPLET COLUMN ACCESSORS: BITWISE -----------------------------------------

/// The index within the main trace of the bitwise column containing selector indicating the
/// type of bitwise operation (AND or XOR)
pub const BITWISE_SELECTOR_COL_IDX: usize = BITWISE_TRACE_OFFSET;
/// The index within the main trace of the bitwise column holding the aggregated value of input `a`.
pub const BITWISE_A_COL_IDX: usize = BITWISE_TRACE_OFFSET + bitwise::A_COL_IDX;
/// The index within the main trace of the bitwise column holding the aggregated value of input `b`.
pub const BITWISE_B_COL_IDX: usize = BITWISE_TRACE_OFFSET + bitwise::B_COL_IDX;
/// The index range within the main trace for the bit decomposition of `a` for bitwise operations.
pub const BITWISE_A_COL_RANGE: Range<usize> = Range {
    start: BITWISE_TRACE_OFFSET + bitwise::A_COL_RANGE.start,
    end: BITWISE_TRACE_OFFSET + bitwise::A_COL_RANGE.end,
};
/// The index range within the main trace for the bit decomposition of `b` for bitwise operations.
pub const BITWISE_B_COL_RANGE: Range<usize> = Range {
    start: BITWISE_TRACE_OFFSET + bitwise::B_COL_RANGE.start,
    end: BITWISE_TRACE_OFFSET + bitwise::B_COL_RANGE.end,
};

/// The column index range for the main trace of the bitwise column
pub const BITWISE_TRACE_RANGE: Range<usize> = Range {
    start: BITWISE_TRACE_OFFSET,
    end: BITWISE_TRACE_OFFSET + bitwise::OUTPUT_COL_IDX + 1,
};

/// The index within the main trace of the bitwise column containing the aggregated output value of
/// the previous row.
pub const BITWISE_PREV_OUTPUT_COL_IDX: usize = BITWISE_TRACE_OFFSET + bitwise::PREV_OUTPUT_COL_IDX;
/// The index within the main trace of the bitwise column containing the aggregated output value.
pub const BITWISE_OUTPUT_COL_IDX: usize = BITWISE_TRACE_OFFSET + bitwise::OUTPUT_COL_IDX;

// --- GLOBALLY-INDEXED CHIPLET COLUMN ACCESSORS: MEMORY ------------------------------------------

/// The index within the main trace of the column containing the first memory selector, which
/// indicates the operation (read or write).
pub const MEMORY_SELECTORS_COL_IDX: usize = MEMORY_TRACE_OFFSET;
/// The index within the main trace of the column containing the memory context.
pub const MEMORY_CTX_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::CTX_COL_IDX;
/// The index within the main trace of the column containing the memory address.
pub const MEMORY_ADDR_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::ADDR_COL_IDX;
/// The index within the main trace of the column containing the clock cycle of the memory
/// access.
pub const MEMORY_CLK_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::CLK_COL_IDX;
/// The column index range within the main trace which holds the memory value elements.
pub const MEMORY_V_COL_RANGE: Range<usize> = Range {
    start: MEMORY_TRACE_OFFSET + memory::V_COL_RANGE.start,
    end: MEMORY_TRACE_OFFSET + memory::V_COL_RANGE.end,
};
/// The column index within the main trace for the lower 16-bits of the delta between two
/// consecutive memory context IDs, addresses, or clock cycles.
pub const MEMORY_D0_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::D0_COL_IDX;
/// The column index within the main trace for the upper 16-bits of the delta between two
/// consecutive memory context IDs, addresses, or clock cycles.
pub const MEMORY_D1_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::D1_COL_IDX;
/// The column index within the main trace for the inverse of the delta between two consecutive
/// memory context IDs, addresses, or clock cycles, used to enforce that changes are correctly
/// constrained.
pub const MEMORY_D_INV_COL_IDX: usize = MEMORY_TRACE_OFFSET + memory::D_INV_COL_IDX;