Skip to main content

stwo_gpu_constraint_framework/
point.rs

1use core::ops::Mul;
2
3use std_shims::{vec, Vec};
4use stwo::core::air::accumulation::PointEvaluationAccumulator;
5use stwo::core::fields::qm31::{SecureField, SECURE_EXTENSION_DEGREE};
6use stwo::core::pcs::TreeVec;
7use stwo::core::{ColumnVec, Fraction};
8
9use super::logup::LogupAtRow;
10use super::{EvalAtRow, INTERACTION_TRACE_IDX};
11
12/// Evaluates expressions at a point out of domain.
13pub struct PointEvaluator<'a> {
14    pub mask: TreeVec<ColumnVec<&'a Vec<SecureField>>>,
15    pub evaluation_accumulator: &'a mut PointEvaluationAccumulator,
16    pub col_index: Vec<usize>,
17    pub denom_inverse: SecureField,
18    pub logup: LogupAtRow<Self>,
19}
20impl<'a> PointEvaluator<'a> {
21    pub fn new(
22        mask: TreeVec<ColumnVec<&'a Vec<SecureField>>>,
23        evaluation_accumulator: &'a mut PointEvaluationAccumulator,
24        denom_inverse: SecureField,
25        log_size: u32,
26        claimed_sum: SecureField,
27    ) -> Self {
28        let col_index = vec![0; mask.len()];
29        Self {
30            mask,
31            evaluation_accumulator,
32            col_index,
33            denom_inverse,
34            logup: LogupAtRow::new(INTERACTION_TRACE_IDX, claimed_sum, log_size),
35        }
36    }
37}
38impl EvalAtRow for PointEvaluator<'_> {
39    type F = SecureField;
40    type EF = SecureField;
41
42    fn next_interaction_mask<const N: usize>(
43        &mut self,
44        interaction: usize,
45        _offsets: [isize; N],
46    ) -> [Self::F; N] {
47        let col_index = self.col_index[interaction];
48        self.col_index[interaction] += 1;
49        let mask = self.mask[interaction][col_index].clone();
50        assert_eq!(mask.len(), N);
51        mask.try_into().unwrap()
52    }
53    fn add_constraint<G>(&mut self, constraint: G)
54    where
55        Self::EF: Mul<G, Output = Self::EF>,
56    {
57        self.evaluation_accumulator
58            .accumulate(self.denom_inverse * constraint);
59    }
60    fn combine_ef(values: [Self::F; SECURE_EXTENSION_DEGREE]) -> Self::EF {
61        SecureField::from_partial_evals(values)
62    }
63
64    super::logup_proxy!();
65}