tessl/pypi-qiskit

An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

—

Pending

Overview

Eval results

Files

Gates and Operations

Name: tessl/pypi-qiskit
Author: tessl

Qiskit provides a comprehensive library of quantum gates and operations, from basic Pauli gates to advanced multi-qubit operations and composite circuits. This library forms the foundation for quantum algorithm construction and circuit building.

Capabilities

Single-Qubit Gates

Fundamental single-qubit operations including Pauli gates, rotations, and Clifford gates.

# Pauli Gates
class XGate(Gate):
    def __init__(self, label=None):
        """Pauli-X gate (bit flip)."""

class YGate(Gate):
    def __init__(self, label=None):
        """Pauli-Y gate."""

class ZGate(Gate):
    def __init__(self, label=None):
        """Pauli-Z gate (phase flip)."""

class IGate(Gate):
    def __init__(self, label=None):
        """Identity gate (no operation)."""

# Clifford Gates
class HGate(Gate):
    def __init__(self, label=None):
        """Hadamard gate (X-Z basis rotation)."""

class SGate(Gate):
    def __init__(self, label=None):
        """S gate (Z^(1/2) = sqrt(Z))."""

class SdgGate(Gate):
    def __init__(self, label=None):
        """S-dagger gate (Z^(-1/2))."""

class TGate(Gate):
    def __init__(self, label=None):
        """T gate (Z^(1/4))."""

class TdgGate(Gate):
    def __init__(self, label=None):
        """T-dagger gate (Z^(-1/4))."""

class SXGate(Gate):
    def __init__(self, label=None):
        """Square-root X gate (X^(1/2))."""

class SXdgGate(Gate):
    def __init__(self, label=None):
        """Inverse square-root X gate (X^(-1/2))."""

# Rotation Gates
class RXGate(Gate):
    def __init__(self, theta, label=None):
        """
        Rotation about X-axis.
        
        Parameters:
        - theta: Rotation angle in radians
        """

class RYGate(Gate):
    def __init__(self, theta, label=None):
        """
        Rotation about Y-axis.
        
        Parameters:
        - theta: Rotation angle in radians
        """

class RZGate(Gate):
    def __init__(self, phi, label=None):
        """
        Rotation about Z-axis.
        
        Parameters:
        - phi: Rotation angle in radians
        """

class PhaseGate(Gate):
    def __init__(self, theta, label=None):
        """
        Phase gate with arbitrary phase.
        
        Parameters:
        - theta: Phase angle in radians
        """

class RGate(Gate):
    def __init__(self, theta, phi, label=None):
        """
        Single-qubit rotation about arbitrary axis.
        
        Parameters:
        - theta: Polar angle
        - phi: Azimuthal angle
        """

# Universal Single-Qubit Gates
class UGate(Gate):
    def __init__(self, theta, phi, lam, label=None):
        """
        Generic single-qubit unitary gate.
        
        Parameters:
        - theta: Polar angle
        - phi: Azimuthal angle
        - lam: Phase angle
        """

class U1Gate(Gate):
    def __init__(self, theta, label=None):
        """
        Single-parameter U gate (phase only).
        
        Parameters:
        - theta: Phase angle
        """

class U2Gate(Gate):
    def __init__(self, phi, lam, label=None):
        """
        Two-parameter U gate.
        
        Parameters:
        - phi: First angle
        - lam: Second angle
        """

class U3Gate(Gate):
    def __init__(self, theta, phi, lam, label=None):
        """
        Three-parameter U gate (most general single-qubit).
        
        Parameters:
        - theta: Polar angle
        - phi: Azimuthal angle  
        - lam: Phase angle
        """

Two-Qubit Gates

Essential two-qubit gates for entanglement and quantum correlations.

# Controlled Gates
class CXGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """
        Controlled-X gate (CNOT).
        
        Parameters:
        - ctrl_state: Control state (default: '1')
        """

class CYGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-Y gate."""

class CZGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-Z gate."""

class CHGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-Hadamard gate."""

class CSGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-S gate."""

class CSdgGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-S-dagger gate."""

class CSXGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Controlled-SX gate."""

class CPhaseGate(Gate):
    def __init__(self, theta, label=None, ctrl_state=None):
        """
        Controlled-phase gate.
        
        Parameters:
        - theta: Phase angle
        """

# Controlled Rotation Gates
class CRXGate(Gate):
    def __init__(self, theta, label=None, ctrl_state=None):
        """
        Controlled rotation about X-axis.
        
        Parameters:
        - theta: Rotation angle
        """

class CRYGate(Gate):
    def __init__(self, theta, label=None, ctrl_state=None):
        """Controlled rotation about Y-axis."""

class CRZGate(Gate):
    def __init__(self, theta, label=None, ctrl_state=None):
        """Controlled rotation about Z-axis."""

# Controlled U Gates
class CUGate(Gate):
    def __init__(self, theta, phi, lam, gamma, label=None, ctrl_state=None):
        """
        Controlled-U gate with global phase.
        
        Parameters:
        - theta, phi, lam: U gate parameters
        - gamma: Global phase
        """

class CU1Gate(Gate):
    def __init__(self, theta, label=None, ctrl_state=None):
        """Controlled-U1 gate."""

class CU3Gate(Gate):
    def __init__(self, theta, phi, lam, label=None, ctrl_state=None):
        """Controlled-U3 gate."""

# Swap Gates
class SwapGate(Gate):
    def __init__(self, label=None):
        """SWAP gate (exchange two qubits)."""

class iSwapGate(Gate):
    def __init__(self, label=None):
        """Imaginary SWAP gate."""

# Specialized Two-Qubit Gates
class DCXGate(Gate):
    def __init__(self, label=None):
        """Double-controlled X gate (equivalent to CNOT-CNOT)."""

class ECRGate(Gate):
    def __init__(self, label=None):
        """Echoed cross-resonance gate."""

# Parameterized Two-Qubit Gates
class RXXGate(Gate):
    def __init__(self, theta, label=None):
        """
        Two-qubit XX rotation.
        
        Parameters:
        - theta: Rotation angle
        """

class RYYGate(Gate):
    def __init__(self, theta, label=None):
        """Two-qubit YY rotation."""

class RZZGate(Gate):
    def __init__(self, theta, label=None):
        """Two-qubit ZZ rotation."""

class RZXGate(Gate):
    def __init__(self, theta, label=None):
        """Two-qubit ZX rotation."""

class XXMinusYYGate(Gate):
    def __init__(self, theta, beta=0, label=None):
        """
        XX-YY interaction gate.
        
        Parameters:
        - theta: Interaction strength
        - beta: Single-qubit rotation angle
        """

class XXPlusYYGate(Gate):
    def __init__(self, theta, beta=0, label=None):
        """XX+YY interaction gate."""

Multi-Qubit Gates

Gates operating on three or more qubits including multi-controlled operations.

# Multi-Controlled Gates
class CCXGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """
        Toffoli gate (doubly-controlled X).
        
        Parameters:
        - ctrl_state: Control state for both controls
        """

class CCZGate(Gate):
    def __init__(self, label=None):
        """Doubly-controlled Z gate."""

class CSwapGate(Gate):
    def __init__(self, label=None):
        """Controlled SWAP gate (Fredkin gate)."""

class C3XGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Triply-controlled X gate."""

class C3SXGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Triply-controlled SX gate."""

class C4XGate(Gate):
    def __init__(self, label=None, ctrl_state=None):
        """Quadruply-controlled X gate."""

class MCXGate(Gate):
    def __init__(self, num_ctrl_qubits, label=None, ctrl_state=None, mode='noancilla'):
        """
        Multi-controlled X gate.
        
        Parameters:
        - num_ctrl_qubits: Number of control qubits
        - ctrl_state: Control state specification
        - mode: Implementation mode ('noancilla', 'recursion', 'v-chain', etc.)
        """

class MCPhaseGate(Gate):
    def __init__(self, lam, num_ctrl_qubits, label=None, ctrl_state=None):
        """
        Multi-controlled phase gate.
        
        Parameters:
        - lam: Phase angle
        - num_ctrl_qubits: Number of control qubits
        """

# Relative Phase Gates
class RCCXGate(Gate):
    def __init__(self, label=None):
        """Relative-phase Toffoli gate (reduced CNOT count)."""

class RC3XGate(Gate):
    def __init__(self, label=None):
        """Relative-phase triply-controlled X gate."""

# Global Phase
class GlobalPhaseGate(Gate):
    def __init__(self, phase, label=None):
        """
        Global phase gate.
        
        Parameters:
        - phase: Global phase angle
        """

Generalized and Composite Gates

Advanced gates for complex quantum operations and algorithm building blocks.

class UnitaryGate(Gate):
    def __init__(self, data, label=None):
        """
        Generic unitary gate from matrix.
        
        Parameters:
        - data: Unitary matrix (numpy array or Operator)
        """

class DiagonalGate(Gate):
    def __init__(self, diag, label=None):
        """
        Diagonal unitary gate.
        
        Parameters:
        - diag: Diagonal elements
        """

class PermutationGate(Gate):
    def __init__(self, pattern, label=None):
        """
        Permutation gate for qubit reordering.
        
        Parameters:
        - pattern: Permutation pattern
        """

class PauliGate(Gate):
    def __init__(self, pauli_string, label=None):
        """
        Multi-qubit Pauli gate.
        
        Parameters:
        - pauli_string: Pauli string (e.g., 'XYZИ')
        """

class LinearFunction(Gate):
    def __init__(self, linear_matrix, validate_input=True):
        """
        Linear function over GF(2).
        
        Parameters:
        - linear_matrix: Binary matrix defining linear function
        - validate_input: Whether to validate matrix
        """

class Isometry(Gate):
    def __init__(self, isometry, num_ancillas_zero, num_ancillas_dirty, 
                 epsilon=1e-10, label=None):
        """
        Isometry from smaller to larger Hilbert space.
        
        Parameters:
        - isometry: Isometry matrix
        - num_ancillas_zero: Number of ancillas initialized to |0⟩
        - num_ancillas_dirty: Number of dirty ancillas
        - epsilon: Tolerance for optimization
        """

# Uniformly Controlled Gates
class UCGate(Gate):
    def __init__(self, gate_list, up_to_diagonal=False, label=None):
        """
        Uniformly controlled gate.
        
        Parameters:
        - gate_list: List of single-qubit gates
        - up_to_diagonal: Whether decomposition is up to diagonal
        """

class UCPauliRotGate(UCGate):
    def __init__(self, angle_list, rot_axis):
        """
        Uniformly controlled Pauli rotations.
        
        Parameters:
        - angle_list: Rotation angles
        - rot_axis: Rotation axis ('X', 'Y', or 'Z')
        """

class UCRXGate(UCPauliRotGate):
    def __init__(self, angle_list):
        """Uniformly controlled RX rotations."""

class UCRYGate(UCPauliRotGate):
    def __init__(self, angle_list):
        """Uniformly controlled RY rotations."""

class UCRZGate(UCPauliRotGate):
    def __init__(self, angle_list):
        """Uniformly controlled RZ rotations."""

Specialized Operations

Non-unitary operations and measurement-related instructions.

class Measure(Instruction):
    def __init__(self):
        """Quantum measurement operation."""

class Reset(Instruction):
    def __init__(self):
        """Reset qubit to |0⟩ state."""

class Barrier(Instruction):
    def __init__(self, num_qubits):
        """
        Synchronization barrier.
        
        Parameters:
        - num_qubits: Number of qubits barrier acts on
        """

class Delay(Instruction):
    def __init__(self, duration, unit='dt'):
        """
        Time delay operation.
        
        Parameters:
        - duration: Delay duration
        - unit: Time unit ('dt', 'ns', 'us', 'ms', 's')
        """

class Store(Instruction):
    def __init__(self, lvalue):
        """
        Store classical value.
        
        Parameters:
        - lvalue: Classical storage location
        """

Gate Utilities and Functions

Helper functions for gate manipulation and circuit construction.

def get_standard_gate_name_mapping():
    """
    Get mapping from standard gate names to gate classes.
    
    Returns:
    Dict[str, Gate]: Mapping from names to gate classes
    """

def add_control(operation, num_ctrl_qubits=1, label=None, ctrl_state=None):
    """
    Add control qubits to existing operation.
    
    Parameters:
    - operation: Gate or instruction to control
    - num_ctrl_qubits: Number of control qubits to add
    - label: Optional label
    - ctrl_state: Control state specification
    
    Returns:
    ControlledGate: Controlled version of operation
    """

def power(operation, power, matrix_power=False):
    """
    Raise gate to a power.
    
    Parameters:
    - operation: Gate to raise to power
    - power: Exponent
    - matrix_power: Whether to use matrix power
    
    Returns:
    Gate: Gate raised to power
    """

def inverse(operation):
    """
    Get inverse of gate.
    
    Parameters:
    - operation: Gate to invert
    
    Returns:
    Gate: Inverse gate
    """

Circuit Library

Qiskit's circuit library provides pre-built quantum circuits and algorithmic building blocks for common quantum computing patterns.

from qiskit.circuit.library import *

# Standard gate library (already covered above)
# Available via: XGate, YGate, ZGate, HGate, etc.

# Arithmetic Circuits
class IntegerComparator:
    def __init__(self, num_state_qubits, value, geq=True):
        """
        Compare integer with a fixed value.
        
        Parameters:
        - num_state_qubits: Number of qubits representing the integer
        - value: Value to compare against
        - geq: True for >=, False for <
        """

class WeightedAdder:
    def __init__(self, num_state_qubits, weights, mod=None):
        """
        Add weighted sum to quantum register.
        
        Parameters:
        - num_state_qubits: Number of state qubits
        - weights: List of weights for addition
        - mod: Modulo for modular arithmetic (optional)
        """

class Multiplier:
    def __init__(self, num_state_qubits, num_result_qubits):
        """
        Quantum multiplier circuit.
        
        Parameters:
        - num_state_qubits: Number of qubits for each input
        - num_result_qubits: Number of qubits for result
        """

# Boolean Logic Circuits  
class AND:
    def __init__(self, num_variable_qubits, flags=None):
        """
        Multi-input AND gate.
        
        Parameters:
        - num_variable_qubits: Number of input qubits
        - flags: List of flags for input inversion
        """

class OR:
    def __init__(self, num_variable_qubits, flags=None):
        """
        Multi-input OR gate.
        
        Parameters:
        - num_variable_qubits: Number of input qubits
        - flags: List of flags for input inversion
        """

class XOR:
    def __init__(self, num_qubits, amount=None):
        """
        Multi-qubit XOR gate.
        
        Parameters:
        - num_qubits: Number of qubits
        - amount: XOR amount (optional)
        """

# Data Encoding Circuits
class BasisEmbedding:
    def __init__(self, feature_dimension, data_preparation=True):
        """
        Encode classical data in computational basis states.
        
        Parameters:
        - feature_dimension: Number of features to encode
        - data_preparation: Whether to add data preparation layer
        """

class AmplitudeEmbedding:
    def __init__(self, num_qubits, normalize=False):
        """
        Encode classical data in quantum amplitudes.
        
        Parameters:
        - num_qubits: Number of qubits  
        - normalize: Whether to normalize input data
        """

class AngleEmbedding:
    def __init__(self, num_features, rotation='Y'):
        """
        Encode features as rotation angles.
        
        Parameters:
        - num_features: Number of features
        - rotation: Rotation gate ('X', 'Y', or 'Z')
        """

# N-Local Circuit Templates
class TwoLocal:
    def __init__(self, num_qubits, rotation_blocks, entanglement_blocks, **kwargs):
        """
        Two-local variational circuit.
        
        Parameters:
        - num_qubits: Number of qubits
        - rotation_blocks: Single-qubit rotation gates
        - entanglement_blocks: Two-qubit entangling gates
        """

class RealAmplitudes:
    def __init__(self, num_qubits, reps=3):
        """
        Real amplitudes ansatz (RY rotations + CX entanglement).
        
        Parameters:
        - num_qubits: Number of qubits
        - reps: Number of repetitions
        """

class EfficientSU2:
    def __init__(self, num_qubits, reps=3):
        """
        Efficient SU(2) ansatz covering full SU(2) space.
        
        Parameters:
        - num_qubits: Number of qubits  
        - reps: Number of repetitions
        """

# Quantum Algorithm Primitives
class QFT:
    def __init__(self, num_qubits, approximation_degree=0, do_swaps=True):
        """
        Quantum Fourier Transform.
        
        Parameters:
        - num_qubits: Number of qubits
        - approximation_degree: Degree of approximation (0 = exact)
        - do_swaps: Whether to include bit-reversal swaps
        """

class GroverOperator:
    def __init__(self, oracle, state_preparation=None, zero_reflection=None):
        """
        Grover operator for amplitude amplification.
        
        Parameters:
        - oracle: Oracle circuit marking target states
        - state_preparation: Initial state preparation
        - zero_reflection: Zero state reflection operator
        """

class PhaseEstimation:
    def __init__(self, num_evaluation_qubits, unitary):
        """
        Quantum Phase Estimation algorithm.
        
        Parameters:
        - num_evaluation_qubits: Number of evaluation qubits
        - unitary: Unitary operator for phase estimation
        """

# Quantum Volume and Benchmark Circuits
class QuantumVolume:
    def __init__(self, num_qubits, depth=None, seed=None):
        """
        Quantum Volume benchmark circuit.
        
        Parameters:
        - num_qubits: Number of qubits (must be square)
        - depth: Circuit depth (equals num_qubits if None)
        - seed: Random seed for reproducibility
        """

class Random:
    def __init__(self, num_qubits, depth, max_operands=2, seed=None):
        """
        Random quantum circuit.
        
        Parameters:
        - num_qubits: Number of qubits
        - depth: Circuit depth
        - max_operands: Maximum operands per gate
        - seed: Random seed
        """

Usage Examples

from qiskit import QuantumCircuit
from qiskit.circuit.library import *
import numpy as np

# Basic single-qubit gates
circuit = QuantumCircuit(3)
circuit.h(0)                    # Hadamard
circuit.x(1)                    # Pauli-X 
circuit.ry(np.pi/4, 2)         # Y-rotation

# Two-qubit gates
circuit.cx(0, 1)               # CNOT
circuit.cz(1, 2)               # Controlled-Z
circuit.swap(0, 2)             # SWAP

# Parameterized gates
theta = np.pi/3
circuit.rxx(theta, 0, 1)       # XX rotation
circuit.ryy(theta/2, 1, 2)     # YY rotation

# Multi-controlled gates
circuit.ccx(0, 1, 2)           # Toffoli
circuit.mcx([0, 1, 2], 3)      # 3-controlled X (needs 4 qubits)

# Advanced gates using gate classes directly
from qiskit.circuit.library import UnitaryGate, DiagonalGate

# Custom unitary from matrix
unitary_matrix = np.array([[1, 0], [0, np.exp(1j * np.pi/4)]])
custom_gate = UnitaryGate(unitary_matrix, label='CustomU')
circuit.append(custom_gate, [0])

# Diagonal gate
diag_elements = [1, -1, 1j, -1j]  # 2-qubit diagonal
diag_gate = DiagonalGate(diag_elements)
circuit.append(diag_gate, [0, 1])

# Pauli string operations
pauli_gate = PauliGate('XYZ')  # X⊗Y⊗Z on 3 qubits
circuit.append(pauli_gate, [0, 1, 2])

# Uniformly controlled rotations
angles = [0, np.pi/4, np.pi/2, 3*np.pi/4]  # 4 angles for 2 control qubits
uc_ry = UCRYGate(angles)
circuit.append(uc_ry, [0, 1, 2])  # Controls: 0,1; Target: 2

# Gate power and control operations
from qiskit.circuit.library import add_control

# Square root of X gate
sqrt_x = SXGate()
circuit.append(sqrt_x, [0])

# Add control to any gate
controlled_ry = add_control(RYGate(np.pi/3), num_ctrl_qubits=2)
circuit.append(controlled_ry, [0, 1, 2])  # 2 controls, 1 target

# Gate composition and inverse
h_gate = HGate()
h_inverse = h_gate.inverse()  # H† = H
circuit.append(h_inverse, [0])

# Measurement and reset
circuit.measure_all()
circuit.reset(0)  # Reset first qubit

print(f"Circuit depth: {circuit.depth()}")
print(f"Gate counts: {circuit.count_ops()}")

Install with Tessl CLI