Skip to main content

Documentation Index

Fetch the complete documentation index at: https://prod-mint.classiq.io/llms.txt

Use this file to discover all available pages before exploring further.

View on GitHub

Open this notebook in GitHub to run it yourself
Entanglement is an important aspect to study quantum algorithms. In this tutorial, we show how to create a bell pair state ∣Φ+⟩|\Phi^{+}\rangle of 2 qubits, using the Hadamard and the Controlled-NOT transformation. 
from classiq import *


@qfunc
def my_bell_state(reg: QArray) -> None:
    H(reg[0])
    CX(reg[0], reg[1])


@qfunc
def main(registers: Output[QArray]) -> None:
    allocate(2, registers)
    my_bell_state(registers)


model = create_model(main)


qprog = synthesize(model)

show(qprog)
Output:

Quantum program link: https://platform.classiq.io/circuit/2zJHAuuniJKwF8l4cVdhJpmUxXl

​

​
Mathematical Background

Alice has a qubit which is initially set to ∣0⟩|0\rangle
Bob has a qubit which is initally set to ∣0⟩|0\rangle Alice applies 2x2 Hadamard Matrix (H) to create a superposition of her qubit’s state. It is defined as:
 H⋅(10)=(121212−12)⋅(10)=(1212)=12∣0⟩+12∣1⟩H \cdot \begin{pmatrix} 1 \\ 0 \end{pmatrix} = \begin{pmatrix} \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \end{pmatrix} \cdot \begin{pmatrix} 1 \\ 0 \end{pmatrix} = \begin{pmatrix} \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} = \frac{1}{\sqrt{2}} \left| 0 \right\rangle + \frac{1}{\sqrt{2}} \left| 1 \right\rangle Alice and Bob combine their qubits and generate the composite quantum state as: (1212)⊗(10)=(120120)\begin{pmatrix} \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} \otimes \begin{pmatrix} 1 \\ 0 \end{pmatrix} = \begin{pmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0 \end{pmatrix} Alice now applies the Controlled NOT gate operation, with her qubit being the control qubit and Bob’s qubit as the target qubit. The Controlled NOT qubit when applied only affects the target qubit by inverting its state if the control qubit is ∣1⟩|1\rangle. The 4x4 matrix for Controlled NOT(CNOT) transformation matrix is defined as:
CNOT=(1000010000010010)\text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} The new quantum state is: (1000010000010010)(120120)=(120012)=12∣00⟩+12∣11⟩\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} \begin{pmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}}\\ 0 \end{pmatrix} = \begin{pmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ 0 \\ \frac{1}{\sqrt{2}} \end{pmatrix} = \frac{1}{\sqrt{2}} \left| 00 \right\rangle + \frac{1}{\sqrt{2}} \left| 11 \right\rangle In this situation the qubit’s of Alice and Bob are correlated to each other.
If we measure both the qubits we will either get the state ∣00⟩|00\rangle or the state ∣11⟩|11\rangle with equal probability. It is described as:
  • When Alice observes her state as ∣0⟩|0\rangle then the state of Bob’s qubit collapses to the state ∣0⟩|0\rangle
  • When Alice observes her state as ∣1⟩|1\rangle then the state of Bob’s qubit collapses to the state ∣1⟩|1\rangle
The resultant entangled state is designated as a bell pair state ∣Φ+⟩|\Phi^{+}\rangle ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^{+}\rangle = \frac{1}{\sqrt{2}} \left( |00\rangle + |11\rangle \right)

​

​
GHZ State

The GHZ state, a highly entangeld state entengaling all qubits in a circuit. ∣GHZ⟩=∣0⟩⊗n+∣1⟩⊗n2|GHZ\rangle = \frac{|0\rangle^{\otimes n} + |1\rangle^{\otimes n}}{\sqrt{2}} Create a function that will generate a GHZ state for n qubits. Use the Classiq build in repeat no classical loops. An example circuit is shown below. As you can see to create this circuit, there are two steps:
  1. Apply the H gate to the first qubit.
  2. Perform a CNOT gate between the first qubit and all other qubits, or perform CNOT gates like seen in the image below.

​

​
Practice:

The Classiq library also has a GHZ state preparation built-in (see prepare_ghz_state), but here you will try to implemnt it yourself. 
from classiq import *


@qfunc
def main(reg: Output[QArray]):
    allocate(6, reg)
    # your code here
    pass


qprog_task = synthesize(main)
show(qprog_task)
Output:

Quantum program link: https://platform.classiq.io/circuit/2zJHBIfojHo5Fzga1M4lDAnprRJ

​

​
The full solution for your reference

from classiq import *


@qfunc
def main(reg: Output[QArray]):
    allocate(6, reg)
    H(reg[0])
    repeat(
        count=reg.len - 1,
        iteration=lambda index: CX(ctrl=reg[index], target=reg[index + 1]),
    )


qprog_solution = synthesize(main)
show(qprog_solution)
Output:

Quantum program link: https://platform.classiq.io/circuit/2zJHBdIcIYk5iWQPsDxJZt2ZwAV