quantic-rust 0.1.0__cp313-cp313-macosx_10_12_x86_64.whl

quantic_rust/__init__.py

@@ -0,0 +1,218 @@
+"""
+Quantic-Rust: High-Performance Quantum Computing Library
+
+A Rust-powered quantum circuit synthesis, optimization, and error correction library.
+
+Algorithms are based on papers:
+- "A graph-state based synthesis framework for Clifford isometries" 
+  by T. Goubault de Brugière, S. Martiel, and C. Vuillot
+- "Faster and shorter synthesis of Hamiltonian simulation circuits" 
+  by T. Goubault de Brugère, and S. Martiel
+"""
+
+from typing import List, Tuple, Union, Any
+
+import networkx as nx
+
+from .quantic_rust import (
+    Metric,
+    graph_state_synthesis as rust_gs,
+    stabilizer_state_synthesis as rust_ss,
+    pauli_network_synthesis as rust_pauli_network,
+    codiagonalization as rust_codiag,
+    codiagonalization_sswise as rust_sswise,
+    isometry_synthesis as rust_isometry,
+    extract_rotations as rust_extract_rotations,
+    zhang_rotation_optimization,
+)
+from .utils import convert_circuit
+
+__version__ = "0.1.0"
+__all__ = [
+    "Metric",
+    "pauli_network_synthesis",
+    "graph_state_synthesis",
+    "stabilizer_state_synthesis",
+    "codiagonalization",
+    "clifford_isometry_synthesis",
+    "clifford_synthesis",
+    "extract_rotations",
+]
+
+_Circuit = List[Tuple[str, List[int]]]
+
+
+def pauli_network_synthesis(
+    paulis: list[str],
+    metric: Metric,
+    preserve_order: bool = True,
+    nshuffles: int = 0,
+    skip_sort: bool = False,
+    fix_clifford: bool = False,
+    check: bool = False,
+) -> _Circuit:
+    """
+    Synthesize a circuit implementing a Pauli network for a given set of Pauli operators.
+
+    Args:
+        paulis (list): List of Pauli operators (as strings).
+        metric (:class:`.Metric`): The metric to minimize.
+        preserve_order (optional, bool): Whether to preserve the order of the Pauli operators.
+          Default is True.
+        nshuffles (optional, int): Number of qbit ordering shuffles to perform. Default is 0.
+        skip_sort (optional, bool): Whether to skip sorting Pauli operators by hamming weight.
+          If set to True, the algorithm might fail to converge (use with caution). Default is False.
+        fix_clifford (optional, bool): Whether to fix the final Clifford operator. Default is False.
+        check (optional, bool): Whether to check the validity of the circuit. Default is False.
+
+    Returns:
+        list: The synthesized circuit.
+    """
+    if paulis:
+        return rust_pauli_network(
+            paulis, metric, preserve_order, check, nshuffles, skip_sort, fix_clifford
+        )
+    return []
+
+
+def graph_state_synthesis(
+    graph: nx.Graph, metric: Metric, syndrome_iter: int = 1
+) -> _Circuit:
+    """
+    Synthesize a circuit preparing a given graph state specified by a networkx graph.
+
+    Args:
+        graph (:class:`network.Graph`): A graph (networkx object).
+        metric (:class:`.Metric`): The metric to minimize.
+        syndrome_iter (optional, int): The number of syndrome decoding iteration used
+          in the ISD solver (for `Metric.COUNT` only). Default is 1.
+    Returns:
+        list: The synthesized circuit.
+    """
+    syndrome_iter = syndrome_iter or 1
+    adj = nx.to_numpy_array(graph) > 0.5
+    return rust_gs(adj.tolist(), metric, syndrome_iter)
+
+
+def stabilizer_state_synthesis(
+    stabilizers: list[str], metric: Metric, syndrome_iter: int = 1
+) -> _Circuit:
+    """
+    Synthesize a circuit preparing a given graph state specified by a networkx graph.
+
+    Args:
+        stabilizers (list): A list of strings representing the stabilizers.
+        metric (:class:`.Metric`): The metric to minimize.
+        syndrome_iter (optional, int): The number of syndrome decoding iteration used
+          in the ISD solver (for `Metric.COUNT` only). Default is 1.
+    Returns:
+        list: The synthesized circuit.
+    """
+    return rust_ss(stabilizers, metric, syndrome_iter)
+
+
+def codiagonalization(
+    paulis: list[str], metric: Metric, syndrome_iter: int = 1
+) -> _Circuit:
+    """
+    Synthesize a circuit preparing a codiagonalization Clifford circuit for a given set of
+    pairwise commuting Pauli operators.
+
+    Args:
+        paulis (list): List of the Pauli operators to co-diagonalize (as strings).
+        metric (:class:`.Metric`): The metric to minimize.
+        syndrome_iter (optional, int): The number of syndrome decoding iteration used
+          in the ISD solver (for `Metric.COUNT` only). Default is 1.
+
+    Returns:
+        list: The synthesized circuit.
+    """
+    syndrome_iter = syndrome_iter or 1
+    return rust_codiag(paulis, metric, syndrome_iter)
+
+
+def codiagonalization_sswise(paulis: list[str]) -> _Circuit:
+    """
+    Synthesize a circuit preparing a codiagonalization Clifford circuit for a given set of
+    pairwise commuting Pauli operators.
+
+    This is the heuristic of the paper "A Generic Compilation Strategy for the Unitary
+    Coupled Cluster Ansatz".
+    It is here for comparison purposes with the `codiagonalization` method .
+
+    Args:
+        paulis (list): List of the Pauli operators to co-diagonalize (as strings).
+
+    Returns:
+        list: The synthesized circuit.
+    """
+    return rust_sswise(paulis, 2)
+
+
+def clifford_isometry_synthesis(
+    logicals: list[str], stabilisers: list[str], metric: Metric, syndrome_iter: int = 1
+) -> _Circuit:
+    """
+    Synthesize a Clifford circuit implementing a target Clifford isometry specified by
+    its logical operators and its stabilizers.
+    The tableau is specified by a list of operators (as strings). The first (resp. second) half
+    of the list corresponding to the images of `Zi` (resp. `Xi`) operators.
+
+    Args:
+        logicals (list): The logical operators.
+        stabilisers (list): The stabilizers.
+        metric (:class:`.Metric`): The metric to minimize.
+        syndrome_iter (optional, int): The number of syndrome decoding iteration used in the
+          ISD solver in the metric=`Metric.COUNT` case only. Default is 1.
+
+    Returns:
+        list: The synthesized circuit.
+    """
+    syndrome_iter = syndrome_iter or 1
+    return rust_isometry(logicals, stabilisers, metric, syndrome_iter)
+
+
+def clifford_synthesis(
+    logicals: list[str], metric: Metric, syndrome_iter: int = 1
+) -> _Circuit:
+    """
+    Synthesize a Clifford circuit implementing a target Clifford operator specified by its
+    tableau.
+    The tableau is specified by a list of operators (as strings). The first (resp. second) half
+    of the list corresponding to the images of `Zi` (resp. `Xi`) operators.
+
+    Args:
+        logicals (list): The tableau.
+        metric (:class:`.Metric`): The metric to minimize.
+        syndrome_iter (optional, int): The number of syndrome decoding iteration used in
+          the ISD solver in the metric=`Metric.COUNT` case only. Default is 1.
+
+    Returns:
+        list: The synthesized circuit.
+    """
+    syndrome_iter = syndrome_iter or 1
+    return rust_isometry(logicals, [], metric, syndrome_iter)
+
+
+def extract_rotations(
+    circuit: List[
+        Union[Tuple[str, List[int]], Tuple[str, List[int], Any]]
+    ],
+    optimize: bool = True,
+):
+    """
+    Converts a circuit into a sequence of Pauli rotations and a final Clifford operator.
+    The circuit is specified as a sequence of tuples:
+    - ("CX", [q0, q1]) for a CNOT gate
+    - ("H", [q0]) for a Hadamard gate
+    - ("S", [q0]) for a S gate
+    - ("RZ", [q0], angle) for a RZ gate with angle in radian
+
+    This gate set is exactly universal for QC.
+    """
+    circuit_no_angles, angles = convert_circuit(circuit)
+    nqubits = max(max(g[1]) for g in circuit) + 1
+    rotations, final_clifford_tableau = rust_extract_rotations(
+        circuit_no_angles, [str(a) for a in angles], nqubits, optimize
+    )
+    return rotations, final_clifford_tableau

quantic_rust/utils.py

@@ -0,0 +1,72 @@
+"""
+Utility functions for quantic_rust's circuits
+"""
+
+from typing import List, Tuple
+
+import numpy as np
+
+_Circuit = List[Tuple[str, List[int]]]
+
+
+def entangling_depth(circ: _Circuit) -> int:
+    """
+    Computes the entangling depth of a circuit.
+    Only checks the number of qubits of the gate to decide if it is entangling or not.
+
+    Arguments:
+        circ: A circuit.
+
+    Returns:
+        int: the entangling depth
+    """
+    depths = {}
+    for _, qbits in circ:
+        if len(qbits) > 1:
+            gate_depth = max(depths.get(qbits[0], 0), depths.get(qbits[1], 0)) + 1
+            for qbit in qbits:
+                depths[qbit] = gate_depth
+    return max(depths.values()) if depths else 0
+
+
+def entangling_count(circ: _Circuit) -> int:
+    """
+    Count the number of entangling gates in a circuit.
+    Only checks the number of qubits of the gate to decide if it is entangling or not.
+
+    Arguments:
+        circ: A circuit.
+
+    Returns:
+        int: the entangling count
+    """
+    return sum(len(qbits) == 2 for _, qbits in circ)
+
+
+def convert_circuit(circuit: list) -> (list, list):
+    """
+    Converts a circuit into a CNOT + H + S + RZ(theta) circuit with theta non Clifford (i.e. != kpi/2)
+    """
+    new_circuit = []
+    angles = []
+    for gate in circuit:
+        if gate[0] in ["CX", "CZ", "H", "S", "Sd", "X", "Z", "SqrtX", "SqrtXd"]:
+            new_circuit.append(gate)
+            continue
+        assert gate[0] == "RZ"
+        if isinstance(gate[2], str):
+            new_circuit.append(gate[:2])
+            angles.append(gate[2])
+            continue
+        if np.isclose(0.0, gate[2] % (np.pi / 2)) or np.isclose(
+            np.pi / 2, gate[2] % (np.pi / 2)
+        ):
+            mult, offset = np.divmod(gate[2], np.pi / 2)
+            if np.isclose(offset, np.pi / 2):
+                mult += 1
+            for _ in mult:
+                new_circuit.append(("S", gate[1]))
+            continue
+        new_circuit.append(gate[:2])
+        angles.append(gate[2])
+    return new_circuit, angles