qumat 0.0.1__py3-none-any.whl → 0.5.0__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,134 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from braket.aws import AwsQuantumSimulator, AwsDevice
+import boto3
+from braket.aws import AwsDevice, AwsSession
+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':
-        return AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
+    backend_options = backend_config["backend_options"]
+    simulator_type = backend_options.get("simulator_type", "default")
+    region = backend_options.get("region")
+
+    # Create AWS session with region if specified
+    aws_session = None
+    if region:
+        boto_session = boto3.Session(region_name=region)
+        aws_session = AwsSession(boto_session=boto_session)
+
+    if simulator_type == "local":
+        return LocalSimulator()
+    elif simulator_type == "default":
+        return AwsDevice(
+            "arn:aws:braket:::device/quantum-simulator/amazon/sv1",
+            aws_session=aws_session,
+        )
     else:
-        print(f"Simulator type '{simulator_type}' is not supported in Amazon Braket. Using default.")
-        return AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
+        print(
+            f"Simulator type '{simulator_type}' is not supported in Amazon Braket. Using default."
+        )
+        return AwsDevice(
+            "arn:aws:braket:::device/quantum-simulator/amazon/sv1",
+            aws_session=aws_session,
+        )
+
+
+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 create_empty_circuit(num_qubits):
-    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()
+    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}
+        }
+        result = backend.run(circuit, shots=0, inputs=inputs).result()
+    else:
+        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 +166,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,49 @@ 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()
+    parameter_values = backend_config.get("parameter_values", None)
+    if parameter_values:
+        resolver = cirq.ParamResolver(parameter_values)
+        result = simulator.simulate(circuit, param_resolver=resolver)
+    else:
+        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"]