CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-qutip

Comprehensive Python library for simulating quantum systems dynamics and quantum information processing.

—

Pending
Overview
Eval results
Files

quantum-gates.mddocs/

Quantum Gates and Circuits

Quantum gate operations for quantum computing applications including single-qubit, two-qubit, and multi-qubit gates.

Capabilities

Single-Qubit Gates

Fundamental single-qubit rotations and operations.

def rx(phi: float, N: int = None) -> Qobj:
    """
    Create rotation around X-axis by angle phi.
    
    Parameters:
    - phi: Rotation angle in radians
    - N: Total number of qubits (for multi-qubit systems)
    
    Returns:
    - Qobj: X-rotation gate exp(-i φ σₓ/2)
    """

def ry(phi: float, N: int = None) -> Qobj:
    """
    Create rotation around Y-axis by angle phi.
    
    Parameters:
    - phi: Rotation angle in radians
    - N: Total number of qubits
    
    Returns:
    - Qobj: Y-rotation gate exp(-i φ σᵧ/2)
    """

def rz(phi: float, N: int = None) -> Qobj:
    """
    Create rotation around Z-axis by angle phi.
    
    Parameters:
    - phi: Rotation angle in radians
    - N: Total number of qubits
    
    Returns:
    - Qobj: Z-rotation gate exp(-i φ σᵤ/2)
    """

def phasegate(theta: float, N: int = None) -> Qobj:
    """
    Create phase gate with phase theta.
    
    Parameters:
    - theta: Phase angle in radians
    - N: Total number of qubits
    
    Returns:
    - Qobj: Phase gate diag([1, exp(i θ)])
    """

def qrot(theta: float, phi: float) -> Qobj:
    """
    Create general single-qubit rotation.
    
    Parameters:
    - theta: Polar angle (0 to π)
    - phi: Azimuthal angle (0 to 2π)
    
    Returns:
    - Qobj: General rotation gate
    """

def sqrtnot(N: int = None) -> Qobj:
    """
    Create square root of NOT gate.
    
    Parameters:
    - N: Total number of qubits
    
    Returns:
    - Qobj: √NOT gate
    """

Pauli and Related Gates

Standard Pauli gates and their variants.

def s_gate(N: int = None) -> Qobj:
    """
    Create S gate (phase gate with π/2 phase).
    
    Parameters:
    - N: Total number of qubits
    
    Returns:
    - Qobj: S gate diag([1, i])
    """

def t_gate(N: int = None) -> Qobj:
    """
    Create T gate (π/8 phase gate).
    
    Parameters:
    - N: Total number of qubits
    
    Returns:
    - Qobj: T gate diag([1, exp(i π/4)])
    """

def cs_gate(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled-S gate.
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled S gate
    """

def ct_gate(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled-T gate.
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled T gate
    """

Two-Qubit Gates

Fundamental two-qubit entangling gates.

def cnot(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled-NOT (CNOT) gate.
    
    Parameters:
    - N: Total number of qubits (inferred if None)
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: CNOT gate
    """

def cy_gate(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled-Y gate.
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled Pauli-Y gate
    """

def cz_gate(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled-Z gate.
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled Pauli-Z gate
    """

def cphase(theta: float, N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled phase gate.
    
    Parameters:
    - theta: Phase angle in radians
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled phase gate
    """

def csign(N: int = None, control: int = 0, target: int = 1) -> Qobj:
    """
    Create controlled sign gate (controlled-Z).
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - target: Target qubit index
    
    Returns:
    - Qobj: Controlled sign gate
    """

Swap Gates

Gates for exchanging qubit states.

def swap(N: int = None, targets: list = [0, 1]) -> Qobj:
    """
    Create SWAP gate for exchanging two qubits.
    
    Parameters:
    - N: Total number of qubits
    - targets: List of two qubit indices to swap
    
    Returns:
    - Qobj: SWAP gate
    """

def iswap(N: int = None, targets: list = [0, 1]) -> Qobj:
    """
    Create iSWAP gate (SWAP with phase).
    
    Parameters:
    - N: Total number of qubits
    - targets: List of two qubit indices
    
    Returns:
    - Qobj: iSWAP gate
    """

def sqrtswap(N: int = None, targets: list = [0, 1]) -> Qobj:
    """
    Create square root of SWAP gate.
    
    Parameters:
    - N: Total number of qubits
    - targets: List of two qubit indices
    
    Returns:
    - Qobj: √SWAP gate
    """

def sqrtiswap(N: int = None, targets: list = [0, 1]) -> Qobj:
    """
    Create square root of iSWAP gate.
    
    Parameters:
    - N: Total number of qubits
    - targets: List of two qubit indices
    
    Returns:
    - Qobj: √iSWAP gate
    """

def swapalpha(alpha: float, N: int = None, targets: list = [0, 1]) -> Qobj:
    """
    Create parametric SWAP gate.
    
    Parameters:
    - alpha: Parameter (0 = identity, 1 = SWAP)
    - N: Total number of qubits
    - targets: List of two qubit indices
    
    Returns:
    - Qobj: Parametric SWAP gate
    """

Multi-Qubit Gates

Three-qubit and higher-order quantum gates.

def toffoli(N: int = None, controls: list = [0, 1], target: int = 2) -> Qobj:
    """
    Create Toffoli (CCNOT) gate.
    
    Parameters:
    - N: Total number of qubits
    - controls: List of control qubit indices
    - target: Target qubit index
    
    Returns:
    - Qobj: Toffoli gate (controlled-controlled-NOT)
    """

def fredkin(N: int = None, control: int = 0, targets: list = [1, 2]) -> Qobj:
    """
    Create Fredkin (controlled-SWAP) gate.
    
    Parameters:
    - N: Total number of qubits
    - control: Control qubit index
    - targets: List of two target qubit indices to swap
    
    Returns:
    - Qobj: Fredkin gate
    """

def berkeley(N: int = None, targets: list = [0, 1, 2]) -> Qobj:
    """
    Create Berkeley B gate (three-qubit gate).
    
    Parameters:
    - N: Total number of qubits
    - targets: List of three target qubit indices
    
    Returns:
    - Qobj: Berkeley B gate
    """

Quantum Transforms

Hadamard transform and quantum Fourier transform.

def hadamard_transform(N: int = 1) -> Qobj:
    """
    Create N-qubit Hadamard transform.
    
    Parameters:
    - N: Number of qubits
    
    Returns:
    - Qobj: N-qubit Hadamard gate H⊗N
    """

def qft(N: int, swap: bool = True) -> Qobj:
    """
    Create quantum Fourier transform for N qubits.
    
    Parameters:
    - N: Number of qubits (N = log₂(dimension))
    - swap: Include bit-reversal swaps
    
    Returns:
    - Qobj: Quantum Fourier transform operator
    """

def globalphase(theta: float, N: int) -> Qobj:
    """
    Create global phase gate exp(i θ).
    
    Parameters:
    - theta: Global phase angle
    - N: Number of qubits
    
    Returns:
    - Qobj: Global phase operator
    """

Specialized Gate Sets

Predefined gate sets for specific quantum computing protocols.

def qubit_clifford_group(N: int = 1) -> list:
    """
    Generate N-qubit Clifford group gates.
    
    Parameters:
    - N: Number of qubits
    
    Returns:
    - list: List of Clifford group generators
    """

def molmer_sorensen(theta: float, targets: list = None, N: int = None) -> Qobj:
    """
    Create Mølmer-Sørensen gate for trapped ions.
    
    Parameters:
    - theta: Gate angle parameter
    - targets: Target qubit indices
    - N: Total number of qubits
    
    Returns:
    - Qobj: Mølmer-Sørensen gate
    """

Usage Examples

import qutip as qt
import numpy as np

# Single-qubit rotations
X_gate = qt.rx(np.pi)      # π rotation around X (NOT gate)
Y_gate = qt.ry(np.pi)      # π rotation around Y  
Z_gate = qt.rz(np.pi)      # π rotation around Z
H_gate = qt.ry(np.pi/2) * qt.rz(np.pi)  # Hadamard gate

# Verify NOT gate
psi0 = qt.basis(2, 0)  # |0⟩
psi1 = X_gate * psi0   # Should be |1⟩
print(f"X|0⟩ = {psi1}")

# Phase gates
S = qt.s_gate()        # S = diag([1, i])
T = qt.t_gate()        # T = diag([1, exp(iπ/4)])
phase_pi_4 = qt.phasegate(np.pi/4)  # Custom phase

# Two-qubit gates
CNOT = qt.cnot()       # 2-qubit CNOT gate
CZ = qt.cz_gate()      # Controlled-Z
SWAP = qt.swap()       # SWAP gate

# Create Bell state using CNOT
psi_plus = qt.hadamard_transform(1)  # H ⊗ I
psi_plus = qt.tensor(psi_plus, qt.qeye(2))
initial = qt.tensor(qt.basis(2,0), qt.basis(2,0))  # |00⟩
bell_state = CNOT * psi_plus * initial

# Three-qubit gates
CCX = qt.toffoli()     # Toffoli (CCNOT)
CSWAP = qt.fredkin()   # Fredkin (controlled-SWAP)

# Multi-qubit systems
N_qubits = 3
X_on_qubit_1 = qt.rx(np.pi, N=N_qubits)  # NOT on first qubit of 3-qubit system

# Controlled gates with specified qubits
CNOT_01 = qt.cnot(N=3, control=0, target=1)  # CNOT from qubit 0 to 1
CNOT_12 = qt.cnot(N=3, control=1, target=2)  # CNOT from qubit 1 to 2

# Quantum Fourier Transform
QFT_3 = qt.qft(3)      # 3-qubit QFT
print(f"QFT matrix shape: {QFT_3.shape}")

# Parametric gates
theta = np.pi/4
Rx_theta = qt.rx(theta)           # Parametric X rotation
Ry_theta = qt.ry(theta)           # Parametric Y rotation
CP_theta = qt.cphase(theta)       # Controlled phase with parameter

# Gate sequences and circuits
# Example: Creating GHZ state |000⟩ + |111⟩
initial_state = qt.tensor(qt.basis(2,0), qt.basis(2,0), qt.basis(2,0))  # |000⟩

# Step 1: Hadamard on first qubit
H_first = qt.tensor(qt.hadamard_transform(1), qt.qeye(2), qt.qeye(2))
state1 = H_first * initial_state  # (|000⟩ + |100⟩)/√2

# Step 2: CNOT from qubit 0 to 1
CNOT_01 = qt.cnot(N=3, control=0, target=1)
state2 = CNOT_01 * state1  # (|000⟩ + |110⟩)/√2

# Step 3: CNOT from qubit 1 to 2
CNOT_12 = qt.cnot(N=3, control=1, target=2)
ghz_state = CNOT_12 * state2  # (|000⟩ + |111⟩)/√2

print(f"Created GHZ state fidelity: {abs(qt.ghz_state(3).dag() * ghz_state)**2}")

# Gate decompositions
# Decompose Toffoli into CNOT and single-qubit gates
def toffoli_decomp():
    """Toffoli decomposition using CNOTs and T gates."""
    gates = []
    gates.append(qt.cnot(N=3, control=1, target=2))
    gates.append(qt.tensor(qt.qeye(2), qt.qeye(2), qt.t_gate().dag()))
    gates.append(qt.cnot(N=3, control=0, target=2))
    gates.append(qt.tensor(qt.qeye(2), qt.qeye(2), qt.t_gate()))
    gates.append(qt.cnot(N=3, control=1, target=2))
    gates.append(qt.tensor(qt.qeye(2), qt.qeye(2), qt.t_gate().dag()))
    gates.append(qt.cnot(N=3, control=0, target=2))
    gates.append(qt.tensor(qt.qeye(2), qt.t_gate(), qt.t_gate()))
    gates.append(qt.cnot(N=3, control=0, target=1))
    gates.append(qt.tensor(qt.t_gate(), qt.t_gate().dag(), qt.qeye(2)))
    gates.append(qt.cnot(N=3, control=0, target=1))
    
    # Apply gates in reverse order (right to left multiplication)
    result = qt.qeye([2,2,2])
    for gate in reversed(gates):
        result = gate * result
    return result

# Compare with built-in Toffoli
toffoli_builtin = qt.toffoli(N=3)
toffoli_decomposed = toffoli_decomp()
fidelity = abs((toffoli_builtin.dag() * toffoli_decomposed).tr() / 8)
print(f"Toffoli decomposition fidelity: {fidelity:.6f}")

# Random quantum circuits
def random_circuit(n_qubits, depth):
    """Generate random quantum circuit."""
    gates = [qt.rx, qt.ry, qt.rz]
    circuit = qt.qeye([2]*n_qubits)
    
    for _ in range(depth):
        # Random single-qubit gate
        gate_func = np.random.choice(gates)
        angle = np.random.uniform(0, 2*np.pi)
        qubit = np.random.randint(n_qubits)
        
        # Build gate for specific qubit
        gate_list = [qt.qeye(2) for _ in range(n_qubits)]
        gate_list[qubit] = gate_func(angle)
        single_gate = qt.tensor(*gate_list)
        
        circuit = single_gate * circuit
        
        # Random CNOT
        if np.random.random() > 0.5 and n_qubits > 1:
            control, target = np.random.choice(n_qubits, 2, replace=False)
            cnot_gate = qt.cnot(N=n_qubits, control=control, target=target)
            circuit = cnot_gate * circuit
    
    return circuit

# Generate and test random circuit
random_U = random_circuit(3, 10)
print(f"Random circuit unitarity check: {(random_U * random_U.dag() - qt.qeye([2,2,2])).norm():.2e}")

Types

# All quantum gate functions return Qobj instances with type='oper'
# representing unitary quantum gate operations

Install with Tessl CLI

npx tessl i tessl/pypi-qutip

docs

index.md

operators.md

phase-space.md

process-tomography.md

quantum-gates.md

quantum-information.md

quantum-objects.md

random-objects.md

solvers.md

states.md

superoperators.md

tensor-operations.md

utilities.md

visualization.md

tile.json