Struct Point 

pub struct Point<F> {
    pub x: F,
    pub y: F,
    /* private fields */
}

Affine representation of a point on the circle. x^2 + y^2 == 1

Fields

x: F

y: F

Implementations

impl<F: Field> Point<F>

pub fn new(x: F, y: F) -> Self

pub fn from_projective_line(t: F) -> Self

Circle STARKs, Section 3, Lemma 1: (page 4 of the first revision PDF)

(x, y) = ((1-t^2)/(1+t^2), 2t/(1+t^2))

Panics if t^2 = -1, corresponding to either of the points at infinity (on the projective circle) (1 : ±i : 0)

pub fn to_projective_line(self) -> Option<F>

Circle STARKs, Section 3, Lemma 1: (page 4 of the first revision PDF)

t = y / (x + 1)

Returns None if self.x = -1, corresponding to Inf on the projective line

This is also used as a selector polynomial, with a simple zero at (1,0) and a simple pole at (-1,0), which in the paper is called v_0 Circle STARKs, Section 5.1, Lemma 11 (page 21 of the first revision PDF)

pub fn double(self) -> Self

The “squaring map”, or doubling in additive notation, denoted π(x,y) Circle STARKs, Section 3.1, Equation 1: (page 5 of the first revision PDF)

pub fn repeated_double(self, n: usize) -> Self

Apply the doubling map n times: π^n(x,y)

pub fn v_n(self, log_n: usize) -> F

Evaluate the vanishing polynomial for the standard position coset of size 2^log_n at this point Circle STARKs, Section 3.3, Equation 8 (page 10 of the first revision PDF)

pub fn v_n_prod(self, log_n: usize) -> F

Compute a product of successive v_n’s.

More explicitly this computes (1..log_n).map(|i| self.v_n(i)).product() but uses far fewer self.x.square().double() - F::ONE steps compared to the naive implementation.

pub fn v_tilde_p<EF: ExtensionField<F>>(self, at: Point<EF>) -> EF

Evaluate the selector function which is zero at self and nonzero elsewhere, at at. Called v_0 . T_p⁻¹ or ṽ_p(x,y) in the paper, used for constraint selectors. Panics if p = -self, the pole. Section 5.1, Lemma 11 of Circle Starks (page 21 of first edition PDF)

pub fn s_p_at_p(self, log_n: usize) -> F

The concrete value of the selector s_P = v_n / (v_0 . T_p⁻¹) at P=self, used for normalization. Circle STARKs, Section 5.1, Remark 16 (page 22 of the first revision PDF)

pub fn v_p<EF: ExtensionField<F>>(self, at: Point<EF>) -> (EF, EF)

Evaluate the alternate single-point vanishing function v_p(x), used for DEEP quotient. Returns (a, b), representing the complex number a + bi. Simple zero at p, simple pole at +-infinity. Circle STARKs, Section 3.3, Equation 11 (page 11 of the first edition PDF).

impl<F: ComplexExtendable> Point<F>

pub fn generator(log_n: usize) -> Self

Trait Implementations

impl<F: Field, EF: ExtensionField<F>> Add<Point<F>> for Point<EF>

type Output = Point<EF>

The resulting type after applying the + operator.

fn add(self, rhs: Point<F>) -> Self::Output

Performs the + operation.

impl<F: Field> AddAssign for Point<F>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F: Clone> Clone for Point<F>

fn clone(&self) -> Point<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Copy> Copy for Point<F>

impl<F: Debug> Debug for Point<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Eq> Eq for Point<F>

impl<F: Hash> Hash for Point<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: Field> Mul<usize> for Point<F>

type Output = Point<F>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<F: Field> Neg for Point<F>

Circle STARKs, Section 3.1, Equation 2: (page 5 of the first revision PDF) The inverse map J(x,y) = (x,-y)

type Output = Point<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: PartialEq> PartialEq for Point<F>

fn eq(&self, other: &Point<F>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<F: PartialEq> StructuralPartialEq for Point<F>

impl<F: Field, EF: ExtensionField<F>> Sub<Point<F>> for Point<EF>

type Output = Point<EF>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<F>) -> Self::Output

Performs the - operation.