Struct ShiftedValueIndex 

pub struct ShiftedValueIndex {
    pub value_index: ValueIndex,
    pub shift_seq: [Shift; 2],
}

Similar to ValueIndex, but represents a value that has been shifted.

This is used in the operands to constraints like AndConstraint.

A term carries a sequence of two shifts rather than one. The inner shift, shift_seq[0], applies to the word first; the outer shift, shift_seq[1], applies to its result. Two shifts express maps no single shift can: clearing the low bits and returning the rest to where they started needs both, since no one shift both drops bits and leaves the others in place.

Canonical form

A lone shift goes in the inner slot, so shift_seq[0].is_identity() implies shift_seq[1].is_identity(). That splits every term into three classes:

unshifted         s_1 = s_2 = 0     spelled Shift::IDENTITY twice
singly shifted    s_2 = 0 != s_1    the lone shift sits inner
doubly shifted    s_2 != 0          both slots carry work

A doubly shifted term must not collapse: Shift::compose of the two reports Composition::Pair, never Composition::Single (the two merge into one shift) or Composition::Zero (the two clear every bit, so the term is identically zero). ConstraintSystem::validate enforces both rules.

The [Shift; 2] spelling is not itself canonical as a map: per the composition derivation, 108,571 irreducible spellings denote only 74,341 distinct maps. Nothing in the reduction depends on that normalization for correctness, and buying it back needs a table far larger than the few dozen shifts a real constraint system uses.

Fields

value_index: ValueIndex

The index of this value in the input values vector.

shift_seq: [Shift; 2]

The two shifts applied to the value, inner first.

Implementations

impl ShiftedValueIndex

pub const fn new(value_index: ValueIndex, shift_seq: [Shift; 2]) -> Self

A value shifted by a sequence of two shifts, shift_seq[0] first.

pub const fn single(value_index: ValueIndex, shift: Shift) -> Self

A value shifted by one shift, which the canonical form places in the inner slot.

pub const fn inner(&self) -> Shift

The shift applied first.

pub const fn outer(&self) -> Shift

The shift applied to the inner shift’s result.

pub const fn is_unshifted(&self) -> bool

Whether this term leaves its word untouched.

The canonical form puts a lone shift inner, so an identity inner shift settles it.

pub const fn is_doubly_shifted(&self) -> bool

Whether this term genuinely needs both shift slots.

pub const fn plain(value_index: ValueIndex) -> Self

Create a value index that just uses the specified value, unshifted.

pub const fn sll(value_index: ValueIndex, amount: usize) -> Self

Shift Left Logical by the given number of bits.

Panics

Panics if the shift amount is greater than or equal to 64.

pub const fn srl(value_index: ValueIndex, amount: usize) -> Self

Shift Right Logical by the given number of bits.

Panics

Panics if the shift amount is greater than or equal to 64.

pub const fn sar(value_index: ValueIndex, amount: usize) -> Self

Shift Right Arithmetic by the given number of bits.

This is similar to the Shift Right Logical but instead of shifting in 0 bits it will replicate the sign bit.

Panics

Panics if the shift amount is greater than or equal to 64.

pub const fn rotr(value_index: ValueIndex, amount: usize) -> Self

Rotate Right by the given number of bits.

Rotates bits to the right, with bits shifted off the right end wrapping around to the left.

Panics

Panics if the shift amount is greater than or equal to 64.

pub const fn sll32(value_index: ValueIndex, amount: usize) -> Self

Shift Left Logical on 32-bit halves by the given number of bits.

Performs independent logical left shifts on the upper and lower 32-bit halves. Only uses the lower 5 bits of the shift amount (0-31).

Panics

Panics if the shift amount is greater than or equal to 32.

pub const fn srl32(value_index: ValueIndex, amount: usize) -> Self

Shift Right Logical on 32-bit halves by the given number of bits.

Performs independent logical right shifts on the upper and lower 32-bit halves. Only uses the lower 5 bits of the shift amount (0-31).

Panics

Panics if the shift amount is greater than or equal to 32.

pub const fn sra32(value_index: ValueIndex, amount: usize) -> Self

Shift Right Arithmetic on 32-bit halves by the given number of bits.

Performs independent arithmetic right shifts on the upper and lower 32-bit halves. Sign extends each 32-bit half independently. Only uses the lower 5 bits of the shift amount (0-31).

Panics

Panics if the shift amount is greater than or equal to 32.

pub const fn rotr32(value_index: ValueIndex, amount: usize) -> Self

Rotate Right on 32-bit halves by the given number of bits.

Performs independent rotate right operations on the upper and lower 32-bit halves. Bits shifted off the right end wrap around to the left within each 32-bit half.

Panics

Panics if the shift amount is greater than or equal to 32.

pub fn eval(&self, witness: &ValueVec) -> Word

Evaluates this term against a witness.

A term names one value and a sequence of two shifts to apply to it. It contributes one shifted word to the XOR that forms an operand.

Trait Implementations

impl Clone for ShiftedValueIndex

fn clone(&self) -> ShiftedValueIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShiftedValueIndex

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

Formats the value using the given formatter.

impl DeserializeBytes for ShiftedValueIndex

fn deserialize(read_buf: impl Buf) -> Result<Self, SerializationError>

where Self: Sized,

impl Hash for ShiftedValueIndex

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 Ord for ShiftedValueIndex

fn cmp(&self, other: &ShiftedValueIndex) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ShiftedValueIndex

fn eq(&self, other: &ShiftedValueIndex) -> 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 PartialOrd for ShiftedValueIndex

fn partial_cmp(&self, other: &ShiftedValueIndex) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl SerializeBytes for ShiftedValueIndex

fn serialize(&self, write_buf: impl BufMut) -> Result<(), SerializationError>

impl Copy for ShiftedValueIndex

impl Eq for ShiftedValueIndex

impl StructuralPartialEq for ShiftedValueIndex