qumat 0.0.1__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

qumat/__init__.py

@@ -0,0 +1,20 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .qumat import QuMat
+from . import qdp
+
+__all__ = ["QuMat", "qdp"]

qumat/amazon_braket_backend.py

@@ -14,60 +14,109 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from braket.aws import AwsQuantumSimulator, AwsDevice
+from braket.aws import AwsDevice
+from braket.devices import LocalSimulator
 from braket.circuits import Circuit, FreeParameter
 
+
 def initialize_backend(backend_config):
-    backend_options = backend_config['backend_options']
-    simulator_type = backend_options.get('simulator_type', 'default')
-    if simulator_type == 'default':
+    backend_options = backend_config["backend_options"]
+    simulator_type = backend_options.get("simulator_type", "default")
+    if simulator_type == "local":
+        return LocalSimulator()
+    elif simulator_type == "default":
         return AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
     else:
-        print(f"Simulator type '{simulator_type}' is not supported in Amazon Braket. Using default.")
+        print(
+            f"Simulator type '{simulator_type}' is not supported in Amazon Braket. Using default."
+        )
         return AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
 
-def create_empty_circuit(num_qubits):
-    return Circuit()
+
+def create_empty_circuit(num_qubits: int | None = None):
+    circuit = Circuit()
+    if num_qubits is not None:
+        for i in range(num_qubits):
+            circuit.i(i)
+    return circuit
+
 
 def apply_not_gate(circuit, qubit_index):
     circuit.x(qubit_index)
 
+
 def apply_hadamard_gate(circuit, qubit_index):
     circuit.h(qubit_index)
 
+
 def apply_cnot_gate(circuit, control_qubit_index, target_qubit_index):
     circuit.cnot(control_qubit_index, target_qubit_index)
 
-def apply_toffoli_gate(circuit, control_qubit_index1, control_qubit_index2, target_qubit_index):
+
+def apply_toffoli_gate(
+    circuit, control_qubit_index1, control_qubit_index2, target_qubit_index
+):
     circuit.ccnot(control_qubit_index1, control_qubit_index2, target_qubit_index)
 
+
 def apply_swap_gate(circuit, qubit_index1, qubit_index2):
     circuit.swap(qubit_index1, qubit_index2)
 
+
+def apply_cswap_gate(
+    circuit, control_qubit_index, target_qubit_index1, target_qubit_index2
+):
+    circuit.cswap(control_qubit_index, target_qubit_index1, target_qubit_index2)
+
+
 def apply_pauli_x_gate(circuit, qubit_index):
     circuit.x(qubit_index)
 
+
 def apply_pauli_y_gate(circuit, qubit_index):
     circuit.y(qubit_index)
 
+
 def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
+
+def apply_t_gate(circuit, qubit_index):
+    circuit.t(qubit_index)
+
+
 def execute_circuit(circuit, backend, backend_config):
-    shots = backend_config['backend_options'].get('shots', 1)
-    task = backend.run(circuit, shots=shots)
+    shots = backend_config["backend_options"].get("shots", 1)
+    parameter_values = backend_config.get("parameter_values", {})
+    if parameter_values and circuit.parameters:
+        # Braket accepts parameter names as strings in inputs dict
+        inputs = {
+            param_name: value
+            for param_name, value in parameter_values.items()
+            if param_name in {p.name for p in circuit.parameters}
+        }
+        task = backend.run(circuit, shots=shots, inputs=inputs)
+    else:
+        task = backend.run(circuit, shots=shots)
     result = task.result()
     return result.measurement_counts
 
+
 # placeholder method for use in the testing suite
 def get_final_state_vector(circuit, backend, backend_config):
-    raise NotImplementedError("Final state vector calculation is not currently supported with Amazon Braket.")
+    circuit.state_vector()
+    result = backend.run(circuit, shots=0).result()
+    state_vector = result.values[0]
+
+    return state_vector
+
 
 def draw_circuit(circuit):
     # Unfortunately, Amazon Braket does not have direct support for drawing circuits in the same way
     # as Qiskit and Cirq. You would typically visualize Amazon Braket circuits using external tools.
-    # For simplicity, we'll print the circuit object which gives some textual representation.
-    print(circuit)
+    # For simplicity, we'll return the circuit object's string representation.
+    return str(circuit)
+
 
 def apply_rx_gate(circuit, qubit_index, angle):
     if isinstance(angle, (int, float)):
@@ -92,7 +141,38 @@ def apply_rz_gate(circuit, qubit_index, angle):
         param = FreeParameter(angle)
         circuit.rz(qubit_index, param)
 
+
 def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
-    circuit.rx(qubit_index, theta)
-    circuit.ry(qubit_index, phi)
+    # U(θ, φ, λ) = Rz(φ) · Ry(θ) · Rz(λ)
     circuit.rz(qubit_index, lambd)
+    circuit.ry(qubit_index, theta)
+    circuit.rz(qubit_index, phi)
+
+
+def calculate_prob_zero(results, ancilla_qubit, num_qubits):
+    """
+    Calculate the probability of measuring the ancilla qubit in |0> state.
+
+    Amazon Braket uses big-endian qubit ordering with string format results,
+    where the leftmost bit corresponds to qubit 0.
+
+    Args:
+        results: Measurement results from execute_circuit() (dict with string keys)
+        ancilla_qubit: Index of the ancilla qubit
+        num_qubits: Total number of qubits in the circuit
+
+    Returns:
+        float: Probability of measuring ancilla in |0> state
+    """
+    if isinstance(results, list):
+        results = results[0]
+
+    total_shots = sum(results.values())
+    count_zero = 0
+
+    for state, count in results.items():
+        # Braket: big-endian, leftmost bit is qubit 0
+        if len(state) > ancilla_qubit and state[ancilla_qubit] == "0":
+            count_zero += count
+
+    return count_zero / total_shots if total_shots > 0 else 0.0

qumat/cirq_backend.py

@@ -17,72 +17,120 @@
 import cirq
 import sympy
 
+
 def initialize_backend(backend_config):
-   # Assuming 'simulator_type' specifies the type of simulator in Cirq
-    simulator_type = backend_config.get('backend_options', {}).get('simulator_type', 'default')
-    if simulator_type != 'default':
-        print(f"Simulator type '{simulator_type}' is not supported in Cirq. Ignoring this argument")
+    # Assuming 'simulator_type' specifies the type of simulator in Cirq
+    simulator_type = backend_config.get("backend_options", {}).get(
+        "simulator_type", "default"
+    )
+    if simulator_type != "default":
+        print(
+            f"Simulator type '{simulator_type}' is not supported in Cirq. Ignoring this argument"
+        )
 
     return cirq.Simulator()
 
 
-def create_empty_circuit(num_qubits):
-    return cirq.Circuit()
+def create_empty_circuit(num_qubits: int | None = None):
+    circuit = cirq.Circuit()
+    if num_qubits is not None:
+        qubits = [cirq.LineQubit(i) for i in range(num_qubits)]
+        for qubit in qubits:
+            circuit.append(cirq.I(qubit))
+    return circuit
+
 
 def apply_not_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.X(qubit))
 
+
 def apply_hadamard_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.H(qubit))
 
+
 def apply_cnot_gate(circuit, control_qubit_index, target_qubit_index):
     control_qubit = cirq.LineQubit(control_qubit_index)
     target_qubit = cirq.LineQubit(target_qubit_index)
     circuit.append(cirq.CNOT(control_qubit, target_qubit))
 
-def apply_toffoli_gate(circuit, control_qubit_index1, control_qubit_index2, target_qubit_index):
+
+def apply_toffoli_gate(
+    circuit, control_qubit_index1, control_qubit_index2, target_qubit_index
+):
     control_qubit1 = cirq.LineQubit(control_qubit_index1)
     control_qubit2 = cirq.LineQubit(control_qubit_index2)
     target_qubit = cirq.LineQubit(target_qubit_index)
     circuit.append(cirq.CCX(control_qubit1, control_qubit2, target_qubit))
 
+
 def apply_swap_gate(circuit, qubit_index1, qubit_index2):
     qubit1 = cirq.LineQubit(qubit_index1)
     qubit2 = cirq.LineQubit(qubit_index2)
     circuit.append(cirq.SWAP(qubit1, qubit2))
 
+
+def apply_cswap_gate(
+    circuit, control_qubit_index, target_qubit_index1, target_qubit_index2
+):
+    control_qubit = cirq.LineQubit(control_qubit_index)
+    target_qubit1 = cirq.LineQubit(target_qubit_index1)
+    target_qubit2 = cirq.LineQubit(target_qubit_index2)
+    circuit.append(cirq.CSWAP(control_qubit, target_qubit1, target_qubit2))
+
+
 def apply_pauli_x_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.X(qubit))
 
+
 def apply_pauli_y_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.Y(qubit))
 
+
 def apply_pauli_z_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.Z(qubit))
 
 
+def apply_t_gate(circuit, qubit_index):
+    qubit = cirq.LineQubit(qubit_index)
+    circuit.append(cirq.T(qubit))
+
+
 def execute_circuit(circuit, backend, backend_config):
+    # handle 0-qubit circuits before adding measurements
+    if not circuit.all_qubits():
+        shots = backend_config["backend_options"].get("shots", 1)
+        return [{0: shots}]
+
     # Ensure measurement is added to capture the results
     if not circuit.has_measurements():
-        circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
+        circuit.append(cirq.measure(*circuit.all_qubits(), key="result"))
     simulator = cirq.Simulator()
-    parameter_values = backend_config.get('parameter_values', None)
+    parameter_values = backend_config.get("parameter_values", None)
     if parameter_values:
         # Convert parameter_values to applicable resolvers
         res = [cirq.ParamResolver(parameter_values)]
-        results = simulator.run_sweep(circuit, repetitions=backend_config['backend_options'].get('shots', 1), params=res)
-        return [result.histogram(key='result') for result in results]
+        results = simulator.run_sweep(
+            circuit,
+            repetitions=backend_config["backend_options"].get("shots", 1),
+            params=res,
+        )
+        return [result.histogram(key="result") for result in results]
     else:
-        result = simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
-        return [result.histogram(key='result')]
+        result = simulator.run(
+            circuit, repetitions=backend_config["backend_options"].get("shots", 1)
+        )
+        return [result.histogram(key="result")]
+
 
 def draw_circuit(circuit):
-    print(circuit)
+    # Use Cirq's string representation for circuit visualization
+    return str(circuit)
+
 
 def apply_rx_gate(circuit, qubit_index, angle):
     param = sympy.Symbol(angle) if isinstance(angle, str) else angle
@@ -101,8 +149,44 @@ def apply_rz_gate(circuit, qubit_index, angle):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.rz(param).on(qubit))
 
+
 def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.rz(lambd).on(qubit))
-    circuit.append(cirq.ry(phi).on(qubit))
-    circuit.append(cirq.rx(theta).on(qubit))
+    circuit.append(cirq.ry(theta).on(qubit))
+    circuit.append(cirq.rz(phi).on(qubit))
+
+
+def get_final_state_vector(circuit, backend, backend_config):
+    simulator = cirq.Simulator()
+    result = simulator.simulate(circuit)
+    return result.final_state_vector
+
+
+def calculate_prob_zero(results, ancilla_qubit, num_qubits):
+    """
+    Calculate the probability of measuring the ancilla qubit in |0> state.
+
+    Cirq uses big-endian qubit ordering with integer format results,
+    where qubit i corresponds to bit (num_qubits - 1 - i).
+
+    Args:
+        results: Measurement results from execute_circuit() (list of dicts with integer keys)
+        ancilla_qubit: Index of the ancilla qubit
+        num_qubits: Total number of qubits in the circuit
+
+    Returns:
+        float: Probability of measuring ancilla in |0> state
+    """
+    if isinstance(results, list):
+        results = results[0]
+
+    total_shots = sum(results.values())
+    count_zero = 0
+
+    for state, count in results.items():
+        bit_position = num_qubits - 1 - ancilla_qubit
+        if ((state >> bit_position) & 1) == 0:
+            count_zero += count
+
+    return count_zero / total_shots if total_shots > 0 else 0.0

qumat/qdp.py

@@ -0,0 +1,63 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Quantum Data Plane (QDP) - GPU-accelerated quantum state encoding.
+
+This module provides a unified interface to the QDP engine, enabling
+GPU-accelerated encoding of classical data into quantum states with
+zero-copy PyTorch integration via DLPack.
+
+Example:
+    >>> import qumat.qdp as qdp
+    >>> engine = qdp.QdpEngine(device_id=0)
+    >>> qtensor = engine.encode([1.0, 2.0, 3.0, 4.0], num_qubits=2, encoding_method="amplitude")
+    >>> import torch
+    >>> torch_tensor = torch.from_dlpack(qtensor)
+"""
+
+_INSTALL_MSG = (
+    "QDP requires the qumat-qdp native extension. "
+    "Build and install it with: cd qdp/qdp-python && maturin develop --release"
+)
+
+
+def _make_stub(name: str) -> type:
+    """Create a stub class that raises ImportError on instantiation."""
+
+    def __init__(self, *args, **kwargs):  # type: ignore[no-untyped-def]
+        raise ImportError(_INSTALL_MSG)
+
+    return type(name, (), {"__init__": __init__, "__doc__": f"Stub class - {name}"})
+
+
+try:
+    from _qdp import QdpEngine as QdpEngine
+    from _qdp import QuantumTensor as QuantumTensor
+except ImportError as e:
+    import warnings
+
+    warnings.warn(
+        f"QDP module not available: {e}. "
+        "QDP requires the qumat-qdp native extension which needs to be built with maturin. "
+        "See qdp/qdp-python/README.md for installation instructions.",
+        ImportWarning,
+    )
+
+    QdpEngine = _make_stub("QdpEngine")  # type: ignore[misc]
+    QuantumTensor = _make_stub("QuantumTensor")  # type: ignore[misc]
+
+__all__ = ["QdpEngine", "QuantumTensor"]

qumat/qiskit_backend.py

@@ -15,103 +15,196 @@
 # limitations under the License.
 #
 import qiskit
+from qiskit_aer import AerSimulator
+
 
 def initialize_backend(backend_config):
-    backend_options = backend_config['backend_options']
-    simulator_type = backend_options['simulator_type']
-    shots = backend_options['shots']
-    backend = qiskit.Aer.get_backend(simulator_type)
+    backend_options = backend_config["backend_options"]
+    simulator_type = backend_options["simulator_type"]
+    shots = backend_options.get("shots", 1)
+
+    # Map legacy simulator types to AerSimulator methods
+    simulator_methods = {
+        "aer_simulator": "automatic",
+        "statevector_simulator": "statevector",
+        "qasm_simulator": "automatic",
+        "unitary_simulator": "unitary",
+    }
+
+    if simulator_type in simulator_methods:
+        backend = AerSimulator(method=simulator_methods[simulator_type])
+    else:
+        backend = AerSimulator(method=simulator_type)
+
     backend.shots = shots
     return backend
 
 
-def create_empty_circuit(num_qubits):
-    return qiskit.QuantumCircuit(num_qubits)
+def create_empty_circuit(num_qubits: int | None = None):
+    if num_qubits is not None:
+        return qiskit.QuantumCircuit(num_qubits)
+    else:
+        return qiskit.QuantumCircuit()
+
 
 def apply_not_gate(circuit, qubit_index):
     # Apply a NOT gate (X gate) on the specified qubit
     circuit.x(qubit_index)
 
+
 def apply_hadamard_gate(circuit, qubit_index):
     # Apply a Hadamard gate on the specified qubit
     circuit.h(qubit_index)
 
+
 def apply_cnot_gate(circuit, control_qubit_index, target_qubit_index):
     # Apply a CNOT gate (controlled-X gate) with the specified control and
     # target qubits
     circuit.cx(control_qubit_index, target_qubit_index)
 
-def apply_toffoli_gate(circuit, control_qubit_index1,
-                       control_qubit_index2,
-                       target_qubit_index):
+
+def apply_toffoli_gate(
+    circuit, control_qubit_index1, control_qubit_index2, target_qubit_index
+):
     # Apply a Toffoli gate (controlled-controlled-X gate) with the
     # specified control and target qubits
-    circuit.ccx(control_qubit_index1,
-                     control_qubit_index2,
-                     target_qubit_index)
+    circuit.ccx(control_qubit_index1, control_qubit_index2, target_qubit_index)
+
 
 def apply_swap_gate(circuit, qubit_index1, qubit_index2):
     # Apply a SWAP gate to exchange the states of two qubits
     circuit.swap(qubit_index1, qubit_index2)
 
+
+def apply_cswap_gate(
+    circuit, control_qubit_index, target_qubit_index1, target_qubit_index2
+):
+    # Apply a controlled-SWAP (Fredkin) gate with the specified control and target qubits
+    circuit.cswap(control_qubit_index, target_qubit_index1, target_qubit_index2)
+
+
 def apply_pauli_x_gate(circuit, qubit_index):
     # Apply a Pauli X gate on the specified qubit
     circuit.x(qubit_index)
 
+
 def apply_pauli_y_gate(circuit, qubit_index):
     # Apply a Pauli Y gate on the specified qubit
     circuit.y(qubit_index)
 
+
 def apply_pauli_z_gate(circuit, qubit_index):
     # Apply a Pauli Z gate on the specified qubit
     circuit.z(qubit_index)
 
+
+def apply_t_gate(circuit, qubit_index):
+    # Apply a T gate (π/8 gate) on the specified qubit
+    circuit.t(qubit_index)
+
+
 def execute_circuit(circuit, backend, backend_config):
+    working_circuit = circuit.copy()
+
     # Add measurements if they are not already present
-    if not circuit.cregs:
-        circuit.measure_all()
+    # Check if circuit already has measurement operations
+    has_measurements = any(
+        isinstance(inst.operation, qiskit.circuit.Measure)
+        for inst in working_circuit.data
+    )
+    if not has_measurements:
+        working_circuit.measure_all()
 
     # Ensure the circuit is parameterized properly
-    if circuit.parameters:
+    if working_circuit.parameters:
         # Parse the global parameter configuration
-        parameter_bindings = {param: backend_config['parameter_values'][str(param)] for param in circuit.parameters}
-        transpiled_circuit = qiskit.transpile(circuit, backend)
-        qobj = qiskit.assemble(transpiled_circuit, parameter_binds=[parameter_bindings], shots=backend_config['backend_options']['shots'])
-        job = backend.run(qobj)
+        parameter_bindings = {
+            param: backend_config["parameter_values"][str(param)]
+            for param in working_circuit.parameters
+        }
+        transpiled_circuit = qiskit.transpile(working_circuit, backend)
+        bound_circuit = transpiled_circuit.assign_parameters(parameter_bindings)
+        job = backend.run(
+            bound_circuit, shots=backend_config["backend_options"].get("shots", 1)
+        )
         result = job.result()
         return result.get_counts()
     else:
-        transpiled_circuit = qiskit.transpile(circuit, backend)
-        job = qiskit.execute(transpiled_circuit, backend, shots=backend_config['backend_options']['shots'])
+        transpiled_circuit = qiskit.transpile(working_circuit, backend)
+        job = backend.run(
+            transpiled_circuit, shots=backend_config["backend_options"].get("shots", 1)
+        )
         result = job.result()
         return result.get_counts()
 
+
 # placeholder method for use in the testing suite
 def get_final_state_vector(circuit, backend, backend_config):
-    simulator = qiskit.Aer.get_backend('statevector_simulator')
+    working_circuit = circuit.copy()
+
+    simulator = AerSimulator(method="statevector")
+
+    # Add save_statevector instruction
+    working_circuit.save_statevector()
 
     # Simulate the circuit
-    job = qiskit.execute(circuit, simulator)
+    transpiled_circuit = qiskit.transpile(working_circuit, simulator)
+    job = simulator.run(transpiled_circuit)
     result = job.result()
 
     return result.get_statevector()
 
+
 def draw_circuit(circuit):
     # Use Qiskit's built-in drawing function
-    print(circuit.draw())
+    return circuit.draw()
+
 
 def apply_rx_gate(circuit, qubit_index, angle):
     param = qiskit.circuit.Parameter(angle) if isinstance(angle, str) else angle
     circuit.rx(param, qubit_index)
 
+
 def apply_ry_gate(circuit, qubit_index, angle):
     param = qiskit.circuit.Parameter(angle) if isinstance(angle, str) else angle
     circuit.ry(param, qubit_index)
 
+
 def apply_rz_gate(circuit, qubit_index, angle):
     param = qiskit.circuit.Parameter(angle) if isinstance(angle, str) else angle
     circuit.rz(param, qubit_index)
 
+
 def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
     # Apply the U gate directly with specified parameters
     circuit.u(theta, phi, lambd, qubit_index)
+
+
+def calculate_prob_zero(results, ancilla_qubit, num_qubits):
+    """
+    Calculate the probability of measuring the ancilla qubit in |0> state.
+
+    Qiskit uses little-endian qubit ordering with string format results,
+    where the rightmost bit corresponds to qubit 0.
+
+    Args:
+        results: Measurement results from execute_circuit() (dict with string keys)
+        ancilla_qubit: Index of the ancilla qubit
+        num_qubits: Total number of qubits in the circuit
+
+    Returns:
+        float: Probability of measuring ancilla in |0> state
+    """
+    # Handle different result formats from different backends
+    if isinstance(results, list):
+        results = results[0]
+
+    total_shots = sum(results.values())
+    count_zero = 0
+
+    for state, count in results.items():
+        # Qiskit: little-endian, rightmost bit is qubit 0
+        if len(state) > ancilla_qubit and state[-(ancilla_qubit + 1)] == "0":
+            count_zero += count
+
+    return count_zero / total_shots if total_shots > 0 else 0.0