​

Quantum Types

​

Quantum Scalar Types

• qbit represents the states $|0\rangle$, $|1\rangle$, or a superposition of the two
• qnum represents numbers in some discrete domain - integers or fixed-point reals

​

Syntax

​

Semantics

• Computational-basis encoding of numeric types is big-endian (the most significant bit has the highest index).
• size-int-expr determines the overall number of qubits used to store the number, including sign and fraction where applicable.
• If sign-bool-expr is True (SIGNED), two’s complement is used to represent signed numbers, utilizing the most-significant bit for sign.
• frac-digits-int-expr determines the number of least-significant bits representing binary fraction digits.
• When only size-int-expr is specified and sign-bool-expr and frac-digits-int-expr are left out, the later two are set to UNSIGNED and 0 (integer) respectively.

​

Attributes

• qbit:
  • size: The total number of qubits (always 1).
• qnum:
  • size: The total number of qubits (including the fraction digits and the sign bit).
  • is_signed: Whether the number is signed.
  • fraction_digits: The number of fraction digits.

​

Examples

from classiq import *


@qfunc
def prepare_1101(qba: Output[QArray[QBit]]):
    allocate(4, qba)
    X(qba[0])
    X(qba[2])
    X(qba[3])


@qfunc
def main(x: Output[QNum[4]], y: Output[QNum[4, SIGNED, 1]]):
    prepare_1101(x)
    prepare_1101(y)

qfunc prepare_1101(output qba: qbit[]) {
  allocate(4, qba);
  X(qba[0]);
  X(qba[2]);
  X(qba[3]);
}

qfunc main(output x: qnum<4>, output y: qnum<4, SIGNED, 1>) {
  prepare_1101(x);
  prepare_1101(y);
}

​

Numeric Inference Rules

• When the varialbe is initialized with allocate, the size is determined by the num_qubits argument, while sign and fraction-digits are either explicitly specified or default to False (UNSIGNED) and 0 respectively.
• When the variable is passed to a function as its output argument with declared type qbit[], the size is determined by the actual array size, while sign and fraction-digits default to False (UNSIGNED) and 0 respectively.
• When the variable is passed to a function as its output argument with declared type qnum, the size is determined by the actual size, sign, and fraction-digits of the function’s output.
• When the variable is initialized on the left of an out-of-place assignment =, the domain of the expression determines its representation properties.
• Variables retain their type, including the representation attributes, even after being un-initialized (for example, when occurring on the left side of a bind statement). Subsequent initializations must agree with the specific qnum type.
• On the right side of a bind statement (->) the representation attributes of qnum variables must already be known either through declaration, or by previous initialization (and subsequent un-initialization).

​

Examples

from classiq import *


@qfunc
def main(a: Output[QNum], b: Output[QNum[2, SIGNED, 1]], res: Output[QNum]) -> None:
    allocate(2, a)  # 'a' is a 2 qubit unsigned int in the domain [0, 1, 2, 3]
    hadamard_transform(a)  # 'a' is in a superposition of all values in its domain
    prepare_state([0, 0.5, 0.5, 0], 0, b)  # 'b' is in superposition of 01 and 10
    res |= a + b

qfunc main(output a: qnum, output b: qnum<2, SIGNED, 1>, output res: qnum) {
  allocate(2, a);
  hadamard_transform(a);
  prepare_state([0, 0.5, 0.5, 0], 0, b);
  res = a + b;
}

​

Rounding a qnum in Qmod

​

Examples

from classiq import *


@qfunc
def main(x: Output[QNum[3, False, 1]], y: Output[QNum[4, False, 2]]):
    allocate(
        x
    )  # Allocate x as a quantum number with 3 qubits, no sign and 1 fraction digit
    allocate(
        y
    )  # Allocate y as a quantum number with 4 qubits, no sign and 1 fraction digit
    hadamard_transform(x)  # Create a superposition of all possible numbers of x
    y ^= 1.4 * x  # Evaluate y = 1.4 * x

qfunc main(output x: qnum<3, False, 1>, output y: qnum<4, False, 2>) {
    allocate(x);
    allocate(y);
    hadamard_transform(x);
    y ^= 1.4 * x;
}

    state=[{'x': 1.0, 'y': 1.25}: 268,
            {'x': 1.5, 'y': 2.0}: 262,
            {'x': 2.5, 'y': 3.25}: 261,
            {'x': 0.0, 'y': 0.0}: 260,
            {'x': 2.0, 'y': 2.75}: 255,
            {'x': 3.5, 'y': 0.75}: 253,
            {'x': 0.5, 'y': 0.5}: 251,
            {'x': 3.0, 'y': 0.0}: 238]

​

Quantum arrays

​

Syntax

​

Semantics

• element_type optionally determines the type of the array elements. Arrays are homogenous, that is, all elements are of the same type. When left unspecified, the type defaults to qbit.
• length-expr optionally determines the number of elements in the array. The overall size of the array is its length multiplied by the size of the element type. When the length is unspecified, it is determined upon initialization based on the element size. Similarly, when the size of the element type is not specified, it is inferred upon initialization based on the length. Either the length, or the size of the element type, must be specified in the declaration
• The length cannot change throughout the lifetime of an array.

• Subscript: array-expression [ index-expression ]
• Slice: array-expression [ from-index-expression : to-index-expression ]
• Length: array-expression . len

​

Attributes

• size: The total number of qubits (= length × element size).
• len: The number of array elements.

​

Examples

from classiq import qfunc, Output, QArray, QBit, hadamard_transform, bind


@qfunc
def main(x: Output[QArray[QBit, 3]], res: Output[QBit]) -> None:
    allocate(x)
    hadamard_transform(x)
    res |= (x[0] | ~x[1] | ~x[2]) & (~x[0] | x[1] | ~x[2])

qfunc main(output x: qbit[3], output res: qbit) {
  allocate(x);
  hadamard_transform(x);
  res = (x[0] | ~x[1] | ~x[2]) & (~x[0] | x[1] | ~x[2]);
}

from classiq import qfunc, Output, QArray, QNum, SIGNED, bind


@qfunc
def main(res: Output[QNum]) -> None:
    n0 = QNum("n0", 3)
    n0 |= 6
    n1 = QNum("n1", 3)
    n1 |= 7

    n_arr = QArray("n_arr", QNum[3, SIGNED, 0])
    bind([n0, n1], n_arr)

    res |= n_arr[0] + n_arr[1]

qfunc main(output res: qnum) {
  n0: qnum<3>;
  n0 = 6;
  n1: qnum<3>;
  n1 = 7;
  n_arr: qnum<3, SIGNED, 0>[];
  {n0, n1} -> n_arr;
  res = n_arr[0] + n_arr[1];
}

​

Quantum structs

​

Syntax

​

Semantics

• Only quantum types are allowed as field types in a quantum struct.
• Quantum structs may be arbitrarily nested, that is, a field of a struct may itself be a struct or a struct array. However, recursive struct types are not allowed.
• The overall size of a struct (the number of qubits used to store it) must be known upon declaration. This means that the size of all fields, except at most one, must be fully specified.

​

Attributes

• size: The total number of qubits (= the sum of field sizes).

​

Examples

from classiq import *


class MyQStruct(QStruct):
    a: QBit
    b: QNum[3]


@qfunc
def main(s: Output[MyQStruct]) -> None:
    allocate(s)
    H(s.a)
    s.b ^= 6

qstruct MyQStruct {
  a: qbit;
  b: qnum<3>;
}

qfunc main(output s: MyQStruct) {
allocate(s);
H(s.a);
s.b ^= 6;
}

from classiq import *


class MyProblem(QStruct):
    a: QNum[2, UNSIGNED, 2]
    b: QNum[3, UNSIGNED, 3]


@qperm
def my_problem_constraint(p: Const[MyProblem], res: QBit) -> None:
    res ^= p.a + p.b == 0.625


@qfunc
def main(p: Output[MyProblem]) -> None:
    allocate(p)
    grover_search(2, lambda p: phase_oracle(my_problem_constraint, p), p)

qstruct MyProblem {
  a: qnum<2, UNSIGNED, 2>;
  b: qnum<3, UNSIGNED, 3>;
}

qperm my_problem_constraint(const p: MyProblem, res: qbit) {
  res ^= (p.a + p.b) == 0.625;
}

qfunc main(output p: MyProblem) {
  allocate(p);
  grover_search(2, lambda(p) {
    phase_oracle(my_problem_constraint, p);
  }, p);
}

    state={'p': {'a': 0.0, 'b': 0.625}} shots=350
    state={'p': {'a': 0.25, 'b': 0.375}} shots=344
    state={'p': {'a': 0.5, 'b': 0.125}} shots=306

print(MyProblem.num_qubits)  # 5