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

Algorithm Synthesis

Name: tessl/pypi-qiskit
Author: tessl

Qiskit's synthesis module provides advanced algorithms for decomposing and constructing quantum circuits, including Clifford synthesis, permutation synthesis, and quantum algorithm primitives.

Capabilities

Clifford Synthesis

def synth_clifford_full(clifford, method='AG'):
    """Synthesize Clifford operator into elementary gates."""

def synth_clifford_ag(clifford):
    """Aaronson-Gottesman Clifford synthesis."""

def synth_clifford_bm(clifford):
    """Bravyi-Maslov Clifford synthesis."""

def synth_clifford_greedy(clifford):
    """Greedy Clifford synthesis."""

def synth_clifford_layers(clifford, cx_synth_func=None, cz_synth_func=None):
    """Layer-by-layer Clifford synthesis."""

CNOT and Linear Synthesis

def synth_cnot_count_full_pmh(state):
    """CNOT synthesis using PMH algorithm."""

def synth_cnot_depth_line_kms(state):
    """Linear topology CNOT synthesis."""

def synth_linear_depth_5_from_matrix(matrix):
    """Synthesize linear function with depth 5."""

Permutation Synthesis

def synth_permutation_depth_lnn_kms(pattern):
    """KMS permutation synthesis for linear topology."""

def synth_permutation_basic(pattern):
    """Basic permutation synthesis."""

def synth_permutation_acg(pattern):
    """ACG permutation synthesis algorithm."""

Pauli Evolution Synthesis

class LieTrotter:
    def __init__(self, reps=1):
        """Lie-Trotter decomposition for Hamiltonian evolution."""

class SuzukiTrotter:
    def __init__(self, order, reps=1):
        """Suzuki-Trotter decomposition methods."""

class MatrixExponential:
    def __init__(self):
        """Direct matrix exponential method."""

class QDrift:
    def __init__(self, reps=1):
        """QDrift Hamiltonian evolution algorithm."""

Stabilizer Synthesis

Synthesis algorithms for stabilizer circuits and states.

def synth_stabilizer_layers(stab_state, cz_synth_func=None, 
                           cx_synth_func=None, validate=True):
    """
    Synthesize stabilizer state using layered approach.
    
    Parameters:
    - stab_state: Stabilizer state to synthesize
    - cz_synth_func: Function for CZ synthesis
    - cx_synth_func: Function for CX synthesis  
    - validate: Whether to validate stabilizer state
    """

def synth_stabilizer_depth_lnn(stab_state):
    """
    Depth-optimal stabilizer synthesis for linear topology.
    
    Parameters:
    - stab_state: Stabilizer state to synthesize
    """

def synth_circuit_from_stabilizers(stabilizers, allow_redundant=True):
    """
    Synthesize circuit from stabilizer generators.
    
    Parameters:
    - stabilizers: List of stabilizer generators
    - allow_redundant: Whether to allow redundant stabilizers
    """

Multi-Controlled Gate Synthesis

Synthesis of multi-controlled quantum gates using various decomposition strategies.

def synth_mcx_n_dirty_i15(num_ctrl_qubits, num_dirty_qubits):
    """
    Multi-controlled X gate using dirty ancillas.
    
    Parameters:
    - num_ctrl_qubits: Number of control qubits
    - num_dirty_qubits: Number of dirty ancilla qubits
    """

def synth_mcx_n_clean_m15(num_ctrl_qubits, num_clean_qubits):
    """
    Multi-controlled X gate using clean ancillas.
    
    Parameters:
    - num_ctrl_qubits: Number of control qubits
    - num_clean_qubits: Number of clean ancilla qubits
    """

def synth_mcx_gray_code(num_ctrl_qubits):
    """
    Multi-controlled X gate using Gray code sequence.
    
    Parameters:
    - num_ctrl_qubits: Number of control qubits
    """

def synth_mcx_noaux_v24(num_ctrl_qubits):
    """
    Multi-controlled X gate without ancilla qubits.
    
    Parameters:
    - num_ctrl_qubits: Number of control qubits
    """

Unitary Synthesis

Advanced synthesis algorithms for arbitrary unitary matrices.

def qs_decomposition(unitary, opt_a1=True, opt_a2=True, decomp_gate=None):
    """
    Quantum Shannon decomposition of unitary matrices.
    
    Parameters:
    - unitary: Unitary matrix to decompose
    - opt_a1: Optimize A1 gate
    - opt_a2: Optimize A2 gate  
    - decomp_gate: Decomposition gate type
    """

class OneQubitEulerDecomposer:
    def __init__(self, basis='ZYZ', use_dag=False):
        """
        Single-qubit unitary decomposer.
        
        Parameters:
        - basis: Euler rotation basis ('ZYZ', 'ZXZ', 'XYX', 'ZYX')
        - use_dag: Whether to use DAG representation
        """

class TwoQubitBasisDecomposer:
    def __init__(self, gate, basis_fidelity=1.0, euler_basis=None):
        """
        Two-qubit gate decomposer.
        
        Parameters:
        - gate: Target two-qubit gate
        - basis_fidelity: Fidelity of basis gate
        - euler_basis: Single-qubit Euler basis
        """

class XXDecomposer:
    def __init__(self, embodiments=None):
        """
        Decomposer for XX(theta) gates.
        
        Parameters:
        - embodiments: Available gate embodiments
        """

Discrete Basis Synthesis

Solovay-Kitaev algorithm for discrete gate set approximation.

class SolovayKitaevDecomposition:
    def __init__(self, basic_approximations=None, depth=10):
        """
        Solovay-Kitaev algorithm implementation.
        
        Parameters:
        - basic_approximations: Pre-computed gate approximations
        - depth: Recursion depth for approximation
        """

def generate_basic_approximations(gate_set, depth=10, filename=None):
    """
    Generate basic approximations for Solovay-Kitaev.
    
    Parameters:
    - gate_set: Set of discrete gates
    - depth: Maximum sequence depth
    - filename: File to save approximations
    """

Usage Examples

from qiskit.synthesis import *
from qiskit.quantum_info import Clifford, random_clifford

# Clifford synthesis
clifford = random_clifford(3)
circuit = synth_clifford_full(clifford)

# Permutation synthesis
pattern = [2, 1, 0]  # Reverse 3 qubits
perm_circuit = synth_permutation_basic(pattern)

# Pauli evolution
from qiskit.quantum_info import SparsePauliOp
hamiltonian = SparsePauliOp.from_list([('ZZ', 1.0), ('XX', 0.5)])
evolution = LieTrotter(reps=4)

Install with Tessl CLI