Enum DslIr

pub enum DslIr<C: Config> {
    ImmV(Var<C::N>, C::N),
    ImmF(Felt<C::F>, C::F),
    ImmE(Ext<C::F, C::EF>, C::EF),
    AddV(Var<C::N>, Var<C::N>, Var<C::N>),
    AddVI(Var<C::N>, Var<C::N>, C::N),
    AddF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    AddFI(Felt<C::F>, Felt<C::F>, C::F),
    AddE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AddEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    AddEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    AddEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    AddEFFI(Ext<C::F, C::EF>, Felt<C::F>, C::EF),
    SubV(Var<C::N>, Var<C::N>, Var<C::N>),
    SubVI(Var<C::N>, Var<C::N>, C::N),
    SubVIN(Var<C::N>, C::N, Var<C::N>),
    SubF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    SubFI(Felt<C::F>, Felt<C::F>, C::F),
    SubFIN(Felt<C::F>, C::F, Felt<C::F>),
    SubE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    SubEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    SubEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>),
    SubEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    SubEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    MulV(Var<C::N>, Var<C::N>, Var<C::N>),
    MulVI(Var<C::N>, Var<C::N>, C::N),
    MulF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    MulFI(Felt<C::F>, Felt<C::F>, C::F),
    MulE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    MulEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    MulEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    MulEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    DivF(Felt<C::F>, Felt<C::F>, Felt<C::F>),
    DivFI(Felt<C::F>, Felt<C::F>, C::F),
    DivFIN(Felt<C::F>, C::F, Felt<C::F>),
    DivE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    DivEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF),
    DivEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>),
    DivEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F),
    DivEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>),
    NegV(Var<C::N>, Var<C::N>),
    NegF(Felt<C::F>, Felt<C::F>),
    NegE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    LessThanV(Var<C::N>, Var<C::N>, Var<C::N>),
    LessThanVI(Var<C::N>, Var<C::N>, C::N),
    CastFV(Var<C::N>, Felt<C::F>),
    UnsafeCastVF(Felt<C::F>, Var<C::N>),
    For(RVar<C::N>, RVar<C::N>, C::N, Var<C::N>, TracedVec<DslIr<C>>),
    Loop(TracedVec<DslIr<C>>),
    IfEq(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfNe(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfEqI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    IfNeI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>),
    Break,
    AssertEqV(Var<C::N>, Var<C::N>),
    AssertNeV(Var<C::N>, Var<C::N>),
    AssertEqF(Felt<C::F>, Felt<C::F>),
    AssertNeF(Felt<C::F>, Felt<C::F>),
    AssertEqE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AssertNeE(Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    AssertEqVI(Var<C::N>, C::N),
    AssertNeVI(Var<C::N>, C::N),
    AssertEqFI(Felt<C::F>, C::F),
    AssertNeFI(Felt<C::F>, C::F),
    AssertEqEI(Ext<C::F, C::EF>, C::EF),
    AssertNeEI(Ext<C::F, C::EF>, C::EF),
    Alloc(Ptr<C::N>, RVar<C::N>, usize),
    LoadV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>),
    LoadF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>),
    LoadE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>),
    LoadHeapPtr(Ptr<C::N>),
    StoreV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>),
    StoreF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>),
    StoreE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>),
    StoreHeapPtr(Ptr<C::N>),
    CircuitNum2BitsV(Var<C::N>, usize, Vec<Var<C::N>>),
    CircuitNum2BitsF(Felt<C::F>, Vec<Var<C::N>>),
    Poseidon2PermuteBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>),
    Poseidon2CompressBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>, Array<C, Felt<C::F>>),
    CircuitPoseidon2Permute([Var<C::N>; 3]),
    PrintV(Var<C::N>),
    PrintF(Felt<C::F>),
    PrintE(Ext<C::F, C::EF>),
    Error(),
    HintInputVec(),
    HintBitsU(RVar<C::N>),
    HintBitsV(Var<C::N>, u32),
    HintBitsF(Felt<C::F>, u32),
    StoreHintWord(Ptr<C::N>, MemIndex<C::N>),
    WitnessVar(Var<C::N>, u32),
    WitnessFelt(Felt<C::F>, u32),
    WitnessExt(Ext<C::F, C::EF>, u32),
    Publish(Felt<C::F>, Var<C::N>),
    Halt,
    CircuitCommitVkeyHash(Var<C::N>),
    CircuitCommitCommitedValuesDigest(Var<C::N>),
    CircuitPublish(Var<C::N>, usize),
    CircuitSelectV(Var<C::N>, Var<C::N>, Var<C::N>, Var<C::N>),
    CircuitSelectF(Var<C::N>, Felt<C::F>, Felt<C::F>, Felt<C::F>),
    CircuitSelectE(Var<C::N>, Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>),
    CircuitExt2Felt([Felt<C::F>; 4], Ext<C::F, C::EF>),
    CircuitFelts2Ext([Felt<C::F>; 4], Ext<C::F, C::EF>),
    FriReducedOpening(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Array<C, Felt<C::F>>, Array<C, Ext<C::F, C::EF>>, Ext<C::F, C::EF>),
    LessThan(Var<C::N>, Var<C::N>, Var<C::N>),
    CycleTrackerStart(String),
    CycleTrackerEnd(String),
}

An intermeddiate instruction set for implementing programs.

Programs written in the DSL can compile both to the recursive zkVM and the R1CS or Plonk-ish circuits.

Variants

ImmV(Var<C::N>, C::N)

Assigns an immediate to a variable (var = imm).

ImmF(Felt<C::F>, C::F)

Assigns a field immediate to a field element (felt = field imm).

ImmE(Ext<C::F, C::EF>, C::EF)

Assigns an ext field immediate to an extension field element (ext = ext field imm).

AddV(Var<C::N>, Var<C::N>, Var<C::N>)

Add two variables (var = var + var).

AddVI(Var<C::N>, Var<C::N>, C::N)

Add a variable and an immediate (var = var + imm).

AddF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Add two field elements (felt = felt + felt).

AddFI(Felt<C::F>, Felt<C::F>, C::F)

Add a field element and a field immediate (felt = felt + field imm).

AddE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Add two extension field elements (ext = ext + ext).

AddEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Add an extension field element and an ext field immediate (ext = ext + ext field imm).

AddEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Add an extension field element and a field element (ext = ext + felt).

AddEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Add an extension field element and a field immediate (ext = ext + field imm).

AddEFFI(Ext<C::F, C::EF>, Felt<C::F>, C::EF)

Add a field element and an ext field immediate (ext = felt + ext field imm).

SubV(Var<C::N>, Var<C::N>, Var<C::N>)

Subtracts two variables (var = var - var).

SubVI(Var<C::N>, Var<C::N>, C::N)

Subtracts a variable and an immediate (var = var - imm).

SubVIN(Var<C::N>, C::N, Var<C::N>)

Subtracts an immediate and a variable (var = imm - var).

SubF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Subtracts two field elements (felt = felt - felt).

SubFI(Felt<C::F>, Felt<C::F>, C::F)

Subtracts a field element and a field immediate (felt = felt - field imm).

SubFIN(Felt<C::F>, C::F, Felt<C::F>)

Subtracts a field immediate and a field element (felt = field imm - felt).

SubE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Subtracts two extension field elements (ext = ext - ext).

SubEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Subtrancts an extension field element and an extension field immediate (ext = ext - ext field imm).

SubEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>)

Subtracts an extension field immediate and an extension field element (ext = ext field imm - ext).

SubEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Subtracts an extension field element and a field immediate (ext = ext - field imm).

SubEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Subtracts an extension field element and a field element (ext = ext - felt).

MulV(Var<C::N>, Var<C::N>, Var<C::N>)

Multiplies two variables (var = var * var).

MulVI(Var<C::N>, Var<C::N>, C::N)

Multiplies a variable and an immediate (var = var * imm).

MulF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Multiplies two field elements (felt = felt * felt).

MulFI(Felt<C::F>, Felt<C::F>, C::F)

Multiplies a field element and a field immediate (felt = felt * field imm).

MulE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Multiplies two extension field elements (ext = ext * ext).

MulEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Multiplies an extension field element and an extension field immediate (ext = ext * ext field imm).

MulEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Multiplies an extension field element and a field immediate (ext = ext * field imm).

MulEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Multiplies an extension field element and a field element (ext = ext * felt).

DivF(Felt<C::F>, Felt<C::F>, Felt<C::F>)

Divides two variables (var = var / var).

DivFI(Felt<C::F>, Felt<C::F>, C::F)

Divides a field element and a field immediate (felt = felt / field imm).

DivFIN(Felt<C::F>, C::F, Felt<C::F>)

Divides a field immediate and a field element (felt = field imm / felt).

DivE(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Divides two extension field elements (ext = ext / ext).

DivEI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::EF)

Divides an extension field element and an extension field immediate (ext = ext / ext field imm).

DivEIN(Ext<C::F, C::EF>, C::EF, Ext<C::F, C::EF>)

Divides and extension field immediate and an extension field element (ext = ext field imm / ext).

DivEFI(Ext<C::F, C::EF>, Ext<C::F, C::EF>, C::F)

Divides an extension field element and a field immediate (ext = ext / field imm).

DivEF(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Felt<C::F>)

Divides an extension field element and a field element (ext = ext / felt).

NegV(Var<C::N>, Var<C::N>)

Negates a variable (var = -var).

NegF(Felt<C::F>, Felt<C::F>)

Negates a field element (felt = -felt).

NegE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Negates an extension field element (ext = -ext).

LessThanV(Var<C::N>, Var<C::N>, Var<C::N>)

Compares two variables

LessThanVI(Var<C::N>, Var<C::N>, C::N)

Compares a variable and an immediate

CastFV(Var<C::N>, Felt<C::F>)

Cast a Felt to a Var.

UnsafeCastVF(Felt<C::F>, Var<C::N>)

Cast a Var to a Felt. This is unsafe because of possible overflow. Dynamic mode only.

For(RVar<C::N>, RVar<C::N>, C::N, Var<C::N>, TracedVec<DslIr<C>>)

Executes a for loop with the parameters (start step value, end step value, step size, step variable, body).

Loop(TracedVec<DslIr<C>>)

Executes an indefinite loop.

IfEq(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes an equal conditional branch with the parameters (lhs var, rhs var, then body, else body).

IfNe(Var<C::N>, Var<C::N>, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes a not equal conditional branch with the parameters (lhs var, rhs var, then body, else body).

IfEqI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes an equal conditional branch with the parameters (lhs var, rhs imm, then body, else body).

IfNeI(Var<C::N>, C::N, TracedVec<DslIr<C>>, TracedVec<DslIr<C>>)

Executes a not equal conditional branch with the parameters (lhs var, rhs imm, then body, else body).

Break

Break out of a loop.

AssertEqV(Var<C::N>, Var<C::N>)

Assert that two variables are equal (var == var).

AssertNeV(Var<C::N>, Var<C::N>)

Assert that two variables are not equal (var != var).

AssertEqF(Felt<C::F>, Felt<C::F>)

Assert that two field elements are equal (felt == felt).

AssertNeF(Felt<C::F>, Felt<C::F>)

Assert that two field elements are not equal (felt != felt).

AssertEqE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Assert that two extension field elements are equal (ext == ext).

AssertNeE(Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Assert that two extension field elements are not equal (ext != ext).

AssertEqVI(Var<C::N>, C::N)

Assert that a variable is equal to an immediate (var == imm).

AssertNeVI(Var<C::N>, C::N)

Assert that a variable is not equal to an immediate (var != imm).

AssertEqFI(Felt<C::F>, C::F)

Assert that a field element is equal to a field immediate (felt == field imm).

AssertNeFI(Felt<C::F>, C::F)

Assert that a field element is not equal to a field immediate (felt != field imm).

AssertEqEI(Ext<C::F, C::EF>, C::EF)

Assert that an extension field element is equal to an extension field immediate (ext == ext field imm).

AssertNeEI(Ext<C::F, C::EF>, C::EF)

Assert that an extension field element is not equal to an extension field immediate (ext != ext field imm).

Alloc(Ptr<C::N>, RVar<C::N>, usize)

Allocate (ptr, len, size) a memory slice of length len

LoadV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>)

Load variable (var, ptr, index)

LoadF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>)

Load field element (var, ptr, index)

LoadE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>)

Load extension field

LoadHeapPtr(Ptr<C::N>)

Load heap pointer into a stack variable. ASM only.

StoreV(Var<C::N>, Ptr<C::N>, MemIndex<C::N>)

Store variable at address

StoreF(Felt<C::F>, Ptr<C::N>, MemIndex<C::N>)

Store field element at address

StoreE(Ext<C::F, C::EF>, Ptr<C::N>, MemIndex<C::N>)

Store extension field at address

StoreHeapPtr(Ptr<C::N>)

Store heap pointer. ASM only.

CircuitNum2BitsV(Var<C::N>, usize, Vec<Var<C::N>>)

Decompose a variable into size bits (bits = num2bits(var, size)). Should only be used when target is a gnark circuit.

CircuitNum2BitsF(Felt<C::F>, Vec<Var<C::N>>)

Decompose a field element into bits (bits = num2bits(felt)). Should only be used when target is a gnark circuit.

Poseidon2PermuteBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>)

Permutes an array of baby bear elements using Poseidon2 (output = p2_permute(array)).

Poseidon2CompressBabyBear(Array<C, Felt<C::F>>, Array<C, Felt<C::F>>, Array<C, Felt<C::F>>)

Compresses two baby bear element arrays using Poseidon2 (output = p2_compress(array1, array2)).

CircuitPoseidon2Permute([Var<C::N>; 3])

Permutes an array of Bn254 elements using Poseidon2 (output = p2_permute(array)). Should only be used when target is a gnark circuit.

PrintV(Var<C::N>)

Prints a variable.

PrintF(Felt<C::F>)

Prints a field element.

PrintE(Ext<C::F, C::EF>)

Prints an extension field element.

Error()

Throws an error.

HintInputVec()

Prepare next input vector (preceded by its length) for hinting.

HintBitsU(RVar<C::N>)

Prepare bit decomposition for hinting.

HintBitsV(Var<C::N>, u32)

Prepare bit decomposition for hinting.

HintBitsF(Felt<C::F>, u32)

Prepare bit decomposition for hinting.

StoreHintWord(Ptr<C::N>, MemIndex<C::N>)

WitnessVar(Var<C::N>, u32)

Witness a variable. Should only be used when target is a gnark circuit.

WitnessFelt(Felt<C::F>, u32)

Witness a field element. Should only be used when target is a gnark circuit.

WitnessExt(Ext<C::F, C::EF>, u32)

Witness an extension field element. Should only be used when target is a gnark circuit.

Publish(Felt<C::F>, Var<C::N>)

Label a field element as the ith public input.

Halt

Operation to halt the program. Should be the last instruction in the program.

CircuitCommitVkeyHash(Var<C::N>)

Asserts that the inputted var is equal the circuit’s vkey hash public input. Should only be used when target is a gnark circuit.

CircuitCommitCommitedValuesDigest(Var<C::N>)

Asserts that the inputted var is equal the circuit’s commited values digest public input. Should only be used when target is a gnark circuit.

CircuitPublish(Var<C::N>, usize)

Publish a field element as the ith public value. Should only be used when target is a halo2 circuit.

CircuitSelectV(Var<C::N>, Var<C::N>, Var<C::N>, Var<C::N>)

Select’s a variable based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

CircuitSelectF(Var<C::N>, Felt<C::F>, Felt<C::F>, Felt<C::F>)

Select’s a field element based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

CircuitSelectE(Var<C::N>, Ext<C::F, C::EF>, Ext<C::F, C::EF>, Ext<C::F, C::EF>)

Select’s an extension field element based on a condition. (select(cond, true_val, false_val) => output). Should only be used when target is a gnark circuit.

CircuitExt2Felt([Felt<C::F>; 4], Ext<C::F, C::EF>)

Converts an ext to a slice of felts. Should only be used when target is a gnark circuit.

CircuitFelts2Ext([Felt<C::F>; 4], Ext<C::F, C::EF>)

Converts a slice of felts to an ext. Should only be used when target is a gnark circuit.

FriReducedOpening(Ext<C::F, C::EF>, Ext<C::F, C::EF>, Array<C, Felt<C::F>>, Array<C, Ext<C::F, C::EF>>, Ext<C::F, C::EF>)

FriReducedOpening(alpha, curr_alpha_pow, at_x_array, at_z_array, result)

LessThan(Var<C::N>, Var<C::N>, Var<C::N>)

Executes less than (var = var < var). This operation is NOT constrained.

CycleTrackerStart(String)

Start the cycle tracker used by a block of code annotated by the string input. Calling this with the same string will end the open cycle tracker instance and start a new one with an increasing numeric postfix.

CycleTrackerEnd(String)

End the cycle tracker used by a block of code annotated by the string input.

Trait Implementations

impl<C: Clone + Config> Clone for DslIr<C>

where C::N: Clone, C::F: Clone, C::EF: Clone,

fn clone(&self) -> DslIr<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Config> Debug for DslIr<C>

where C::N: Debug, C::F: Debug, C::EF: Debug,

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

Formats the value using the given formatter.

impl<C: Config> Default for DslIr<C>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, C> Deserialize<'de> for DslIr<C>

where C: Deserialize<'de> + Config, C::N: Deserialize<'de>, C::F: Deserialize<'de>, C::EF: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: Config> Display for DslIr<C>

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

Formats the value using the given formatter.

impl<C> Serialize for DslIr<C>

where C: Serialize + Config, C::N: Serialize, C::F: Serialize, C::EF: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.