High-Level Algorithm Design with Qmod Part I

View on GitHub

Open this notebook in GitHub to run it yourself

Language Concepts

In this workshop we will learn to use high-level quantum programming language concepts to design quantum algorithms. We will use the Qmod language to model the functionality, and the Classiq platform to synthesize it into gate-level descriptions, visualize the circuits, and execute them. We will focus on high-level quantum types and expressions in different evaluation modes. Part I is a walk through Qmod’s structure and constructs, as well as some of its unique high-level concepts. We will look closely at these constructs using small examples. In Part II we will combine some of these concepts in a complete quantum algorithm. There are 5 code exercises in this notebook, split into two sections, A and B. In each exercise follow the instructions - complete the code snippet where indicated by a TODO comment, execute the code, and try to understand the results. Solutions are provided at the end of the notebook. Don’t continue to the next exercise before you completed the previous one and compared your code and results against the solution.

Section A (15 Minutes)

Warmup: A First Qmod Program

Let’s start with a simple example to demonstrate the structure of Qmod code, as well as its synthesis and execution flow. We prepare and sample a Bell state - one of the most fundamental quantum states. Further reading: Quantum Functions

from classiq import *


@qfunc  # This decorator declares a quantum function
def create_bell_state(pair: QArray[QBit, 2]):
    H(pair[0])
    CX(pair[0], pair[1])


@qfunc  # Function 'main' is the entry point of our quantum program
def main(res: Output[QArray[QBit, 2]]):
    allocate(res)
    create_bell_state(res)

Quantum functions in Qmod are defined using a regular Python function, decorated with qfunc, and their parameters must be declared with type hints.

We can now compile with the SDK function synthesize. We get back an executable description called quantum program which we then execute on any simulation or quantum hardware. We then execute it — in our case, a simple sampling (using the default number of shots) of the quantum program will suffice.

qprog = synthesize(main)

show(qprog)  # Visualize the quantum program for analysis

# Execute and print the results
df = sample(qprog)
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJ0bCDIF3EKtCUxjrkJ7Xcing
  

Output:

https://platform.classiq.io/circuit/3IjJ0bCDIF3EKtCUxjrkJ7Xcing?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/9d4f0410-87b1-4d9a-ae93-ae5689fef938

	res	counts	probability	bitstring
0	[0, 0]	1043	0.509277	00
1	[1, 1]	1005	0.490723	11

You should see in approximately 50% of the samples the bit vector 00 and in 50% the bit vector

Synthesis is the process of compiling a high-level description to a gate-level description.The reduction is presented graphically.The executable format can be simulated using various simulation engines, or executed on quantum hardware of choice.

Exercise 1: GHZ State

Based on the Bell state example above, prepare a GHZ state with 3 qubits. The GHZ state creates maximum entanglement between three qubits:

(|000\rangle + |111\rangle)/\sqrt{2}

from classiq import *


@qfunc
def create_ghz_state(qubits: QArray[QBit, 3]):
    # TODO: Apply GHZ logic
    pass


@qfunc
def main(res: Output[QArray[QBit, 3]]):
    allocate(res)
    create_ghz_state(res)


# TODO: Synthesize the model, show, execute and print results
# Hint: Follow the same pattern as the demonstration above

You should see in approximately 50% of the samples the bit vector 000 and in 50% the bit vector

Exercise 2: GHZ with Numeric Variables

Define a main function that calls the create_ghz_state (as implemented in Exercise 1) with a signed quantum number and outputs the results. Synthesize it, analyze the quantum program, execute it and print the results. What do you expect the resulting value of x to be? Further reading: Quantum Types

from classiq import *


@qfunc
def main(x: Output[QNum[3, SIGNED, 0]]):
    allocate(x)
    # TODO: Create GHZ state with QNum (gives 0 and -1)
    # Hint: Is it any different from the previous main implementation?
    pass


qprog = synthesize(main)
show(qprog)  # Visualize the quantum program for analysis

# Execute and print the results
df = sample(qprog)
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJ1qRNVVcVfYLEvrBCvuWEDI5
  

Output:

https://platform.classiq.io/circuit/3IjJ1qRNVVcVfYLEvrBCvuWEDI5?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/af5426eb-df6b-4617-ae3d-bf5c7d98895f

	x	counts	probability	bitstring
0	0	2048	1.0	000

You should see approximately 50% for 0 and 50% for -

In Qmod function arguments are automatically cast between QNum and QArray[QBit] (and also between other quantum types).The value of quantum variables is interpreted based on their type.The state

|111\rangle

represents 7 for an unsigned integer, and -1 as signed integer (in two’s complement encoding).

Section B (30 Minutes)

Exercise 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

Create and execute a quantum program that assigns a quantum arithmetic expression to a numeric variable:

Declare quantum numeric variables a and b as unsigned integers of size of
Apply hadamard_transform on a and b (to put them in uniform superposition of all possible states).
Assign the value of 3*a + b to c.
Synthesize, show, execute and print results.

Inspect the printouts - what numeric attributes were inferred for variable c? Why? Further reading: Numeric Assignment

from classiq import *


@qfunc
def main(a: Output[QNum[2]], b: Output[QNum[2]], c: Output[QNum]):
    allocate(a)
    allocate(b)
    # TODO: Put a and b in equal superposition

    # TODO: Assign the value of 3*a + b to c
    allocate(1, c)  # Placeholder - replace with actual assignment

    # Print out c's inferred size in qubits
    print(f"The size of c is {c.size}")


qprog = synthesize(main)
show(qprog)  # Visualize the quantum program for analysis

# Execute and print the results
df = sample(qprog)
display(df)

Output:


The size of c is 1

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJ39AVhTMXKSH5Yqt2B5q3Ag7
  

Output:

https://platform.classiq.io/circuit/3IjJ39AVhTMXKSH5Yqt2B5q3Ag7?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/9b0474c1-c016-4e64-91c1-e55493e68b3f

	a	b	c	counts	probability	bitstring
0	0	0	0	2048	1.0	00000

The expression result ranges between 0 and1

To represent all values variable c must be an unsigned integer of size 4 qubits or more.

In Qmod the size of numeric variables may be left unspecified. It is then automatically inferred to tightly fit all possible values of the expressions.

Part B: Numeric Type Inference with Fixed-Point Fractions

Repeat Part A, only this time declaring a with 1 fraction digit and b with 2 fraction digits. How did the numeric attributes of c change? What are the corresponding sampled values for c in the result?

from classiq import *


@qfunc
def main(
    a: Output[QNum[2, UNSIGNED, 1]], b: Output[QNum[2, UNSIGNED, 2]], c: Output[QNum]
):
    allocate(a)
    allocate(b)
    # TODO: Put a and b in equal superposition

    # TODO: Assign the value of 3*a + b to c
    # Hint: Is it any different from the previous main implementation?
    allocate(1, c)  # Placeholder - replace with actual assignment

    # Print out the numeric attributes of the inferred type
    print("Numeric attributes of c:")
    print(
        f"size={c.size}, is_signed={c.is_signed}, fraction_digits={c.fraction_digits}"
    )


qprog = synthesize(main)
show(qprog)  # Visualize the quantum program for analysis

# Execute and print the results
df = sample(qprog)
display(df)

Output:

Numeric attributes of c:
  size=1, is_signed=False, fraction_digits=0
  

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJ4RikjLip1iM0c44A5vQPfE8
  

Output:

https://platform.classiq.io/circuit/3IjJ4RikjLip1iM0c44A5vQPfE8?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/9f1f48ea-f85f-4234-9412-4b70ccd7323a

	a	b	c	counts	probability	bitstring
0	0.0	0.0	0	2048	1.0	00000

Variable c should be of size 5, unsigend, and with 2 fraction digits.This is the minimal type that covers the expression’s domain.

In Qmod, numeric variables can represent arbitrary fixed-point values.Arithemetic expression and type inference also accommodate for different decimal point locations.

Exercise 4: Conditional Operations

Define a main function that initializes a quantum variable x (a 3-qubit signed number with 2 binary fraction digits) in an equal superposition of all states, then conditionally flips a single-qubit variable named flag when the value of x is less than

Inspect the execution results - how is flag entangled with x?

	x	counts	probability	bitstring
0	0.25	275	0.134277	0001
1	-0.50	269	0.131348	0110
2	-1.00	261	0.127441	0100
3	0.50	260	0.126953	0010
4	-0.25	256	0.125000	0111
5	-0.75	250	0.122070	0101
6	0.75	242	0.118164	0011
7	0.00	235	0.114746	0000

Exercise 5: Grover Algorithm Using Quantum Struct and Constant Phase

The Grover search algorithm uses two kinds of conditional phase flips - one reflecting about the “good” states, and the other reflecting about the zero state. This is easy to express using fixed

\pi

phase rotation under the required control condition. It is also convenient to encapsulate the problem variables in a quantum struct, so they can be passed around between functional units. Create a quantum program that finds assignments for

a, b

and

c \in \{0, 1, 2, 3\}

that satisfy the equation

3a + b + 2c = 9

Declare the variables as fields of a quantum struct
Define the phase oracle in terms of the problem condition
Define the zero-reflection in the diffuser

	v.dummy	counts	probability	bitstring
0	1	1033	0.504395	1
1	0	1015	0.495605	0

Exercise 6: Phase Arithmetic

Part A

Compute the expression

x * y

in the phase of their respective states. Use a coefficient to distribute all possible states over the

2\pi

phase rotation. To actually view the phases of the states, simulate the program using state-vector simulation. Expand the quantum program visualization down to the gate-level implementation. How is the phase statement synthesized? Inspect the resulting phases of the different states in the printout. Do they match the phase expression over x and y? Further reading: Phase Statement

import numpy as np

from classiq import *


@qfunc
def main(x: Output[QNum[2]], y: Output[QNum[2]]):
    allocate(x)
    allocate(y)
    # TODO: put x and y in uniform superposition

    # TODO: Encode x * y into the phase with a normalization coefficient to 2pi


# Synthesize the model and show
qprog = synthesize(main)
show(qprog)

# Compute the exact state vector (shows the phase encoding, which sampling would hide)

# Execute and print results:
df = calculate_state_vector(qprog, verbose=False)
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJ8RfIfFX3RMkPerXvYjpcOCC
  

Output:

https://platform.classiq.io/circuit/3IjJ8RfIfFX3RMkPerXvYjpcOCC?login=True&version=22
  

	x	y	amplitude	magnitude	phase	probability	bitstring
0	0	0	1.0+0.0j	1.00	0.00π	1.0	0000

The resulting state phases should show

x^2

rotation of the respective computational-state value, modulo 8 (determined by the domain of variable x).The steps are a 1/8 of a full

2\pi

rotation

The phase statement can operate on an arbitrary polynomials over quantum numeric variables, introducing the corresponding Z rotations on the respective states.

Bonus: Fourier Arithmetic

Create a quantum program that computes

y = x^2

by computing

x^2

in the Fourier basis. Then transform the result back to the computational basis. Inspect the execution results to validate the correctness of your algorithm.

import numpy as np

from classiq import *


@qfunc
def main(x: Output[QNum[3]], y: Output[QNum[4]]):
    allocate(x)
    hadamard_transform(x)
    allocate(y)

    # TODO: Use within_apply and function qft() to transform into and out of the Fourier basis


# Synthesize the model and show
qprog = synthesize(main)
# show(qprog)

# Synthesize the model, show, execute and print results
df = sample(qprog)
display(df)

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/ed48f68a-4f91-437d-b0e8-458b382df652

	x	counts	probability	bitstring
0	0	273	0.133301	0000000
1	2	268	0.130859	0000010
2	5	264	0.128906	0000101
3	4	259	0.126465	0000100
4	1	258	0.125977	0000001
5	6	252	0.123047	0000110
6	3	246	0.120117	0000011
7	7	228	0.111328	0000111

The phase statement can be used to implement modular arithmetic in the Fourier basis.

Solutions

Solution 1: GHZ State

from classiq import *


@qfunc
def create_ghz_state(qubits: QArray[QBit, 3]):
    # Apply GHZ logic
    H(qubits[0])
    CX(qubits[0], qubits[1])
    CX(qubits[1], qubits[2])


@qfunc
def main(res: Output[QArray[QBit, 3]]):
    allocate(res)
    create_ghz_state(res)


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.1 Results:")
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJAqQv6NPbNidEyyGxTYmig3D
  

Output:

https://platform.classiq.io/circuit/3IjJAqQv6NPbNidEyyGxTYmig3D?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/5833d308-d468-4cd1-8f7a-a913bf247bed

Output:


Ex.1 Results:

	res	counts	probability	bitstring
0	[0, 0, 0]	1037	0.506348	000
1	[1, 1, 1]	1011	0.493652	111

Solution 2: GHZ with Quantum Numbers

from classiq import *


@qfunc
def main(x: Output[QNum[3, SIGNED, 0]]):
    # Create GHZ state with QNum (gives 0 and -1)
    allocate(x)
    create_ghz_state(x)


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.2 Results:")
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJC5pElprbcmhwoRIlXYnuj6C
  

Output:

https://platform.classiq.io/circuit/3IjJC5pElprbcmhwoRIlXYnuj6C?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/e1207f00-8337-42c9-9288-ad5c8d783b05

Output:


Ex.2 Results:

	x	counts	probability	bitstring
0	0	1039	0.507324	000
1	-1	1009	0.492676	111

Solution 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

from classiq import *


@qfunc
def main(a: Output[QNum[2]], b: Output[QNum[2]], c: Output[QNum]):
    allocate(a)
    allocate(b)
    # Put a and b in equal superposition
    hadamard_transform(a)
    hadamard_transform(b)

    # Assign the value of 3*a + b to c
    c |= 3 * a + b

    # Print out c's inferred size in qubits
    print(f"The size of c is {c.size}")


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.3A Results:")
display(df)

Output:


The size of c is 4

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJDXBmOUxRM8MGUMfOQ6VT59F
  

Output:

https://platform.classiq.io/circuit/3IjJDXBmOUxRM8MGUMfOQ6VT59F?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/5de153ca-c2ea-46e6-81e7-20bdfde28fbc

Output:


Ex.3A Results:

	a	b	c	counts	probability	bitstring
0	1	3	6	146	0.071289	01101101
1	2	0	6	144	0.070312	01100010
2	3	3	12	139	0.067871	11001111
3	2	2	8	136	0.066406	10001010
4	1	1	4	132	0.064453	01000101
5	3	2	11	130	0.063477	10111011
6	1	2	5	129	0.062988	01011001
7	0	0	0	128	0.062500	00000000
8	1	0	3	127	0.062012	00110001
9	2	1	7	126	0.061523	01110110
10	0	2	2	125	0.061035	00101000
11	0	3	3	123	0.060059	00111100
12	0	1	1	119	0.058105	00010100
13	3	0	9	116	0.056641	10010011
14	2	3	9	116	0.056641	10011110
15	3	1	10	112	0.054688	10100111

Part B: Numeric Type Inference with Fixed-Point Fractions

from classiq import *


@qfunc
def main(
    a: Output[QNum[2, UNSIGNED, 1]], b: Output[QNum[2, UNSIGNED, 2]], c: Output[QNum]
):
    # Allocate a and b, then put in superposition
    allocate(a)
    allocate(b)
    hadamard_transform(a)
    hadamard_transform(b)

    # Assign the value of 3*a + b to c
    c |= 3 * a + b

    # Print out the numeric attributes of the inferred type
    print("Numeric attributes of c:")
    print(
        f"size: {c.size}, is_signed: {c.is_signed}, fraction_digits: {c.fraction_digits}"
    )


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.3B Results:")
display(df)

Output:

Numeric attributes of c:
  size: 5, is_signed: False, fraction_digits: 2
  

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJF2w52gTuYXqkTykMng6v1Uo
  

Output:

https://platform.classiq.io/circuit/3IjJF2w52gTuYXqkTykMng6v1Uo?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/52e27ed2-ae2c-4e01-b168-0833d1cdfa63

Output:


Ex.3B Results:

	a	b	c	counts	probability	bitstring
0	0.0	0.75	0.75	149	0.072754	000111100
1	0.5	0.75	2.25	148	0.072266	010011101
2	1.5	0.50	5.00	147	0.071777	101001011
3	1.5	0.25	4.75	143	0.069824	100110111
4	1.0	0.25	3.25	130	0.063477	011010110
5	0.5	0.25	1.75	129	0.062988	001110101
6	1.5	0.00	4.50	129	0.062988	100100011
7	1.5	0.75	5.25	129	0.062988	101011111
8	0.0	0.00	0.00	126	0.061523	000000000
9	0.5	0.50	2.00	126	0.061523	010001001
10	0.0	0.25	0.25	123	0.060059	000010100
11	0.0	0.50	0.50	119	0.058105	000101000
12	0.5	0.00	1.50	116	0.056641	001100001
13	1.0	0.75	3.75	116	0.056641	011111110
14	1.0	0.50	3.50	110	0.053711	011101010
15	1.0	0.00	3.00	108	0.052734	011000010

Solution 4: Conditional Operations

from classiq import *


@qfunc
def main(x: Output[QNum[3, SIGNED, 2]], flag: Output[QBit]):
    allocate(x)
    hadamard_transform(x)

    allocate(flag)
    # Flip the state of flag if x < 0.5
    control(x < 0.5, lambda: X(flag))  # Flip the state of flag if x < 0.5


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.4 Results:")
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJGb4PZiOavcmsTWgj7Rb8Fx6
  

Output:

https://platform.classiq.io/circuit/3IjJGb4PZiOavcmsTWgj7Rb8Fx6?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/521d6a28-8281-41bd-a09e-07cd04df14dc

Output:


Ex.4 Results:

	x	flag	counts	probability	bitstring
0	-0.75	1	270	0.131836	1101
1	-0.50	1	260	0.126953	1110
2	0.50	0	259	0.126465	0010
3	0.75	0	256	0.125000	0011
4	0.00	1	254	0.124023	1000
5	0.25	1	254	0.124023	1001
6	-1.00	1	254	0.124023	1100
7	-0.25	1	241	0.117676	1111

Solution 5: Grover Algorithm Using Quantum Struct and Constant Phase

from classiq import *
from classiq.qmod.symbolic import pi


class MyProblemVars(QStruct):
    # Declare the problem variables as quantum numeric fields
    a: QNum[2]
    b: QNum[2]
    c: QNum[2]


@qfunc
def phase_oracle(v: MyProblemVars):
    # Apply a phase flip if the state of v satisfies the equation (use field access in the form 'v.a' etc.)
    control(3 * v.a + v.b + 2 * v.c == 9, lambda: phase(pi))


@qfunc
def zero_reflection(state: QNum):
    # Apply a phase flip if state is |0>
    control(state == 0, lambda: phase(pi))


@qfunc
def grover_operator(v: MyProblemVars):
    phase_oracle(v)
    hadamard_transform(v)
    zero_reflection(v)
    hadamard_transform(v)


@qfunc
def main(v: Output[MyProblemVars]):
    allocate(v)
    hadamard_transform(v)
    for i in range(2):
        grover_operator(v)


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
show(qprog)

df = sample(qprog)
print("Ex.5 Results:")
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJJ7kroGmyy5srBTSGyT5HvUc
  

Output:

https://platform.classiq.io/circuit/3IjJJ7kroGmyy5srBTSGyT5HvUc?login=True&version=22
  

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/088b4dd1-a6a4-48f0-a3f6-94c120240258

Output:


Ex.5 Results:

	v.a	v.b	v.c	counts	probability	bitstring
0	2	1	1	379	0.185059	010110
1	0	3	3	373	0.182129	111100
2	1	2	2	339	0.165527	101001
3	3	0	0	330	0.161133	000011
4	1	0	3	318	0.155273	110001
5	2	3	0	308	0.150391	001110
6	0	0	2	1	0.000488	100000

Solution 6: Phase Arithmetic

import numpy as np

from classiq import *


@qfunc
def main(x: Output[QNum[2]], y: Output[QNum[2]]):
    allocate(x)
    allocate(y)
    # Put x and y in uniform superposition
    hadamard_transform(x)
    hadamard_transform(y)

    # Encode x * y into the phase with a normalization coefficient to 2pi
    phase(x * y, np.pi / 8)


# Synthesize the model and show
qprog = synthesize(main)
show(qprog)

# Compute the exact state vector (shows the phase encoding, which sampling would hide)

# Execute and print results
df = calculate_state_vector(qprog, verbose=False)
print("Ex.6A Results:")
display(df)

Output:

Quantum program link: https://platform.classiq.io/circuit/3IjJLsugK5rJqx4qlhAk93UA0Fu
  

Output:

https://platform.classiq.io/circuit/3IjJLsugK5rJqx4qlhAk93UA0Fu?login=True&version=22
  

Output:


Ex.6A Results:

	x	y	amplitude	magnitude	phase	probability	bitstring
0	0	0	0.250000-0.000000j	0.25	0.00π	0.0625	0000
1	2	1	0.176777+0.176777j	0.25	0.25π	0.0625	0110
2	1	0	0.250000+0.000000j	0.25	0.00π	0.0625	0001
3	2	0	0.250000-0.000000j	0.25	0.00π	0.0625	0010
4	0	1	0.250000+0.000000j	0.25	0.00π	0.0625	0100
5	0	2	0.250000-0.000000j	0.25	0.00π	0.0625	1000
6	2	3	-0.176777+0.176777j	0.25	0.75π	0.0625	1110
7	1	1	0.230970+0.095671j	0.25	0.13π	0.0625	0101
8	1	2	0.176777+0.176777j	0.25	0.25π	0.0625	1001
9	2	2	0.000000+0.250000j	0.25	0.50π	0.0625	1010
10	0	3	0.250000-0.000000j	0.25	0.00π	0.0625	1100
11	3	1	0.095671+0.230970j	0.25	0.38π	0.0625	0111
12	3	2	-0.176777+0.176777j	0.25	0.75π	0.0625	1011
13	1	3	0.095671+0.230970j	0.25	0.38π	0.0625	1101
14	3	0	0.250000+0.000000j	0.25	0.00π	0.0625	0011
15	3	3	-0.230970-0.095671j	0.25	-0.88π	0.0625	1111

Bonus

import numpy as np

from classiq import *


@qfunc
def main(x: Output[QNum[3]], y: Output[QNum[4]]):
    allocate(x)
    hadamard_transform(x)
    allocate(y)

    # Use within_apply and function qft() to transform into and out of the Fourier basis
    within_apply(
        lambda: qft(y),
        # Evaluates y += x**2  in the Fourier basis
        lambda: phase(y * (x**2), 2 * np.pi / (2**y.size)),
    )


# Synthesize the model, show, execute and print results
qprog = synthesize(main)
# show(qprog)

df = sample(qprog)
print("Ex.6B Results:")
display(df)

Output:


Submitting job to simulator

Output:


Job: https://platform.classiq.io/jobs/abf36155-4a85-4d0d-a79b-ec4cea820578

Output:


Ex.6B Results:

	x	y	counts	probability	bitstring
0	6	4	276	0.134766	0100110
1	7	1	272	0.132812	0001111
2	0	0	267	0.130371	0000000
3	2	4	265	0.129395	0100010
4	3	9	252	0.123047	1001011
5	1	1	242	0.118164	0001001
6	5	9	241	0.117676	1001101
7	4	0	233	0.113770	0000100

Algorithms

Applications

Tutorials

High-Level Algorithm Design with Qmod Part I

View on GitHub

Language Concepts

Section A (15 Minutes)

Warmup: A First Qmod Program

Exercise 1: GHZ State

Exercise 2: GHZ with Numeric Variables

Section B (30 Minutes)

Exercise 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

Part B: Numeric Type Inference with Fixed-Point Fractions

Exercise 4: Conditional Operations

Exercise 5: Grover Algorithm Using Quantum Struct and Constant Phase

Exercise 6: Phase Arithmetic

Part A

Bonus: Fourier Arithmetic

Solutions

Solution 1: GHZ State

Solution 2: GHZ with Quantum Numbers

Solution 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

Part B: Numeric Type Inference with Fixed-Point Fractions

Solution 4: Conditional Operations

Solution 5: Grover Algorithm Using Quantum Struct and Constant Phase

Solution 6: Phase Arithmetic

Bonus

View on GitHub

​Language Concepts

​Section A (15 Minutes)

​Warmup: A First Qmod Program

​Exercise 1: GHZ State

​Exercise 2: GHZ with Numeric Variables

​Section B (30 Minutes)

​Exercise 3: Arithmetic Expressions with Automatic Type Inference

​Part A: Numeric Type Inference

​Part B: Numeric Type Inference with Fixed-Point Fractions

​Exercise 4: Conditional Operations

​Exercise 5: Grover Algorithm Using Quantum Struct and Constant Phase

​Exercise 6: Phase Arithmetic

​Part A

​Bonus: Fourier Arithmetic

​Solutions

​Solution 1: GHZ State

​Solution 2: GHZ with Quantum Numbers

​Solution 3: Arithmetic Expressions with Automatic Type Inference

​Part A: Numeric Type Inference

​Part B: Numeric Type Inference with Fixed-Point Fractions

​Solution 4: Conditional Operations

​Solution 5: Grover Algorithm Using Quantum Struct and Constant Phase

​Solution 6: Phase Arithmetic

​Bonus

Language Concepts

Section A (15 Minutes)

Warmup: A First Qmod Program

Exercise 1: GHZ State

Exercise 2: GHZ with Numeric Variables

Section B (30 Minutes)

Exercise 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

Part B: Numeric Type Inference with Fixed-Point Fractions

Exercise 4: Conditional Operations

Exercise 5: Grover Algorithm Using Quantum Struct and Constant Phase

Exercise 6: Phase Arithmetic

Part A

Bonus: Fourier Arithmetic

Solutions

Solution 1: GHZ State

Solution 2: GHZ with Quantum Numbers

Solution 3: Arithmetic Expressions with Automatic Type Inference

Part A: Numeric Type Inference

Part B: Numeric Type Inference with Fixed-Point Fractions

Solution 4: Conditional Operations

Solution 5: Grover Algorithm Using Quantum Struct and Constant Phase

Solution 6: Phase Arithmetic

Bonus