> ## Documentation Index
> Fetch the complete documentation index at: https://dynex.mintlify.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Circuit Examples

> Bell state, Grover, Shor, QFT, and quantum transformer circuits on Dynex

# Circuit Examples

## Bell State (Entanglement)

Creates a maximally entangled 2-qubit Bell state.

```python theme={null}
import pennylane as qml
from dynex import DynexConfig, ComputeBackend, DynexCircuit

def bell_circuit(params):
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.state()

config = DynexConfig(compute_backend=ComputeBackend.QPU, qpu_model='apollo_rc1')
circuit = DynexCircuit(config=config)
result = circuit.execute(
    bell_circuit, params=[], wires=2, method='probs',
    num_reads=50, integration_steps=200, shots=1
)
print("Probabilities:", result)
# Expected: ~0.5 for |00⟩ and |11⟩
```

## Simple 2-Qubit Circuit

RX → RY → CNOT → Hadamard sequence:

```python theme={null}
import pennylane as qml
import numpy as np

def simple_circuit(params):
    qml.RX(np.pi, wires=0)     # Flip qubit 0
    qml.RY(np.pi, wires=1)     # Flip qubit 1
    qml.CNOT(wires=[0, 1])     # Entangle
    qml.Hadamard(wires=0)      # Superposition
    return qml.state()

result = circuit.execute(simple_circuit, params=[], wires=2, method='measure')
```

Notebooks: [PennyLane](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_pennylane.ipynb) · [OpenQASM](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_openqasm.ipynb) · [Qiskit](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_qiskit.ipynb)

## Medium Circuit (3 Qubits)

Demonstrates Hadamard, CNOT, RX, CRZ, T, Toffoli, SWAP sequence:

```python theme={null}
def medium_circuit(params):
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RX(0.3, wires=1)
    qml.CRZ(0.1, wires=[0, 1])
    qml.T(wires=1)
    qml.Toffoli(wires=[0, 1, 2])
    qml.SWAP(wires=[1, 2])
    return qml.state()
```

[Notebook](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_medium.ipynb)

## 13-Qubit Full Adder

Implements quantum addition via QFT-based phase encoding:

```python theme={null}
import pennylane as qml
import numpy as np

def kfourier(value, wires):
    for i, wire in enumerate(wires):
        qml.PhaseShift(value * np.pi / (2**i), wires=wire)

def adder_circuit(params):
    a, b = int(params[0]), int(params[1])
    n_bits = 13

    # Encode 'a' via basis embedding
    qml.BasisEmbedding(a, wires=range(n_bits))

    # QFT
    qml.QFT(wires=range(n_bits))

    # Add 'b' in Fourier domain
    kfourier(b, range(n_bits))

    # Inverse QFT
    qml.adjoint(qml.QFT)(wires=range(n_bits))

    return qml.state()

result = circuit.execute(
    adder_circuit, params=[42, 13], wires=13, method='measure',
    num_reads=50, integration_steps=200, shots=1
)
```

[Notebook](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_nbit_adder.ipynb)

## Grover's Algorithm (Integer Factorization)

Uses quantum amplitude amplification to find prime factors:

```python theme={null}
def grover_factorization(params, n=15):
    import pennylane as qml
    import numpy as np

    wires_p = [0, 1, 2]
    wires_q = [3, 4, 5]
    wires_solution = list(range(6, 6 + 2*len(wires_p)))

    # Superposition over factor candidates
    for wire in wires_p + wires_q:
        qml.Hadamard(wires=wire)

    # Multiply p * q into solution register (QFT-based)
    # ... multiplication circuit ...

    # Grover amplitude amplification
    # ... FlipSign + Grover operator ...

    return qml.probs(wires=wires_p + wires_q)

result = circuit.execute(
    grover_factorization, params=[], wires=12, method='probs',
    num_reads=50, integration_steps=500, shots=1
)
```

[Full notebook](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_grover.ipynb)

## Shor's Algorithm

Period-finding circuit for integer factorization of N:

```python theme={null}
# Full implementation in notebook
# Factorizes N=35 with base a=12
```

The circuit uses:

1. Hadamard gates for superposition over estimate qubits
2. Controlled modular exponentiation unitaries
3. Inverse QFT to extract period information
4. Post-processing to derive prime factors

[Full notebook](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_shor.ipynb)

## Quantum Self-Attention Transformer

Quantum analogue of the transformer attention mechanism for NLP:

The circuit:

1. Tokenizes sentences into word embeddings (Word2Vec, 8-dim)
2. Encodes embeddings via `BasisEmbedding`
3. Applies 3 rotation layers (RX, RY, RZ) with entanglement (CRZ, CNOT)
4. Applies QFT + Grover operator for amplitude amplification
5. Measures Z-basis expectation values → softmax → attention weights
6. Generates new sentence by combining weights with word embeddings

```python theme={null}
# See full implementation
# https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_quantum_transformer.ipynb
```

[Full notebook](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_quantum_transformer.ipynb)

## All circuit notebooks

| Circuit                                                                                                                                        | Qubits | Description                              |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ---------------------------------------- |
| [Simple PennyLane](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_pennylane.ipynb)              | 2      | RX, RY, CNOT, H                          |
| [Simple OpenQASM](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_openqasm.ipynb)                | 2      | Same in QASM format                      |
| [Simple Qiskit](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_qiskit.ipynb)                    | 2      | Same in Qiskit                           |
| [Medium](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_medium.ipynb)                           | 3      | H, CNOT, T, Toffoli, SWAP                |
| [Complex 1](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_complex_1.ipynb)                     | 4      | Full entanglement + controlled rotations |
| [Complex 2](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_complex_2.ipynb)                     | 12     | Large-scale entanglement                 |
| [Full Adder](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_nbit_adder.ipynb)                   | 13     | QFT-based addition                       |
| [Grover](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_grover.ipynb)                           | 12     | Integer factorization                    |
| [Shor](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_shor.ipynb)                               | 8      | Period finding, N=35                     |
| [Quantum Transformer](https://github.com/Dynex-Development/awesome-dynex/blob/main/quantum_circuits/circuit_example_quantum_transformer.ipynb) | 8      | NLP self-attention                       |