Struct TensorAlgebra

pub struct TensorAlgebra<F, FE>
where
    F: Field,
    FE: ExtensionField<F>,
{
    pub elems: Vec<FE>,
    /* private fields */
}

An element of the tensor algebra defined as the tensor product of FE and FE as fields.

A tensor algebra element is a length $D$ vector of FE field elements, where $D$ is the degree of FE as an extension of F. The algebra has a “vertical subring” and a “horizontal subring”, which are both isomorphic to FE as a field.

See DP24 Section 2 for further details.

Fields

elems: Vec<FE>

Implementations

impl<F, FE> TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

pub fn new(elems: Vec<FE>) -> Self

Constructs an element from a vector of vertical subring elements.

Preconditions

• elems must have length FE::DEGREE, otherwise this will pad or truncate.

pub const fn kappa() -> usize

Returns $\kappa$, the base-2 logarithm of the extension degree.

pub fn byte_size() -> usize

Returns the byte size of an element.

pub fn one() -> Self

Returns the multiplicative identity element, one.

pub fn vertical_elems(&self) -> &[FE]

Returns a slice of the vertical subfield elements composing the tensor algebra element.

pub fn tensor(vertical: FE, horizontal: FE) -> Self

Tensor product of a vertical subring element and a horizontal subring element.

pub fn from_vertical(x: FE) -> Self

Constructs a TensorAlgebra in the vertical subring.

pub fn try_extract_vertical(&self) -> Option<FE>

If the algebra element lives in the vertical subring, this returns it as a field element.

pub fn scale_vertical(self, scalar: FE) -> Self

Multiply by an element from the vertical subring.

impl<F, FE> TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F> + PackedExtension<F>, FE::Scalar: ExtensionField<F>,

pub fn scale_horizontal(self, scalar: FE) -> Self

Multiply by an element from the vertical subring.

Internally, this performs a transpose, vertical scaling, then transpose sequence. If multiple horizontal scaling operations are required and performance is a concern, it may be better for the caller to do the transposes directly and amortize their cost.

pub fn transpose(self) -> Self

Transposes the algebra element.

A transpose flips the vertical and horizontal subring elements.

Trait Implementations

impl<F, FE> Add<&TensorAlgebra<F, FE>> for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

type Output = TensorAlgebra<F, FE>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self

Performs the + operation.

impl<F, FE> AddAssign<&TensorAlgebra<F, FE>> for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<F, FE> Clone for TensorAlgebra<F, FE>

where F: Field + Clone, FE: ExtensionField<F> + Clone,

fn clone(&self) -> TensorAlgebra<F, FE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, FE> Debug for TensorAlgebra<F, FE>

where F: Field + Debug, FE: ExtensionField<F> + Debug,

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

Formats the value using the given formatter.

impl<F, FE> Default for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

fn default() -> Self

Returns the “default value” for a type.

impl<F, FE> PartialEq for TensorAlgebra<F, FE>

where F: Field + PartialEq, FE: ExtensionField<F> + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F, FE> Sub<&TensorAlgebra<F, FE>> for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

type Output = TensorAlgebra<F, FE>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self

Performs the - operation.

impl<F, FE> SubAssign<&TensorAlgebra<F, FE>> for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<'a, F, FE> Sum<&'a TensorAlgebra<F, FE>> for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F, FE> Eq for TensorAlgebra<F, FE>

where F: Field + Eq, FE: ExtensionField<F> + Eq,

impl<F, FE> StructuralPartialEq for TensorAlgebra<F, FE>

where F: Field, FE: ExtensionField<F>,