From 0b096f9710431918f6a25ded7ac09815d044aca3 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Wed, 9 Oct 2024 12:54:48 -0500
Subject: [PATCH 01/24] Add rotational gates

---
 qumat/amazon_braket_backend.py | 11 ++++++++++-
 qumat/cirq_backend.py          | 15 ++++++++++++++-
 qumat/qiskit_backend.py        | 11 ++++++++++-
 qumat/qumat.py                 | 11 ++++++++++-
 4 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/qumat/amazon_braket_backend.py b/qumat/amazon_braket_backend.py
index bddeae790..02419aa15 100644
--- a/qumat/amazon_braket_backend.py
+++ b/qumat/amazon_braket_backend.py
@@ -67,4 +67,13 @@ 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)
\ No newline at end of file
+    print(circuit)
+
+def apply_rx_gate(circuit, qubit_index, angle):
+    circuit.rx(qubit_index, angle)
+
+def apply_ry_gate(circuit, qubit_index, angle):
+    circuit.ry(qubit_index, angle)
+
+def apply_rz_gate(circuit, qubit_index, angle):
+    circuit.rz(qubit_index, angle)
diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 056b302e6..b61d6a827 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -72,4 +72,17 @@ def execute_circuit(circuit, backend, backend_config):
     return result.histogram(key='result')
 
 def draw_circuit(circuit):
-    print(circuit)
\ No newline at end of file
+    print(circuit)
+
+def apply_rx_gate(circuit, qubit_index, angle):
+    qubit = cirq.LineQubit(qubit_index)
+    circuit.append(cirq.rx(angle).on(qubit))
+
+def apply_ry_gate(circuit, qubit_index, angle):
+    qubit = cirq.LineQubit(qubit_index)
+    circuit.append(cirq.ry(angle).on(qubit))
+
+def apply_rz_gate(circuit, qubit_index, angle):
+    qubit = cirq.LineQubit(qubit_index)
+    circuit.append(cirq.rz(angle).on(qubit))
+
diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index c8324dcf8..cc6c7afd1 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -89,4 +89,13 @@ def get_final_state_vector(circuit, backend, backend_config):
 
 def draw_circuit(circuit):
     # Use Qiskit's built-in drawing function
-    print(circuit.draw())
\ No newline at end of file
+    print(circuit.draw())
+
+def apply_rx_gate(circuit, qubit_index, angle):
+    circuit.rx(angle, qubit_index)
+
+def apply_ry_gate(circuit, qubit_index, angle):
+    circuit.ry(angle, qubit_index)
+
+def apply_rz_gate(circuit, qubit_index, angle):
+    circuit.rz(angle, qubit_index)
diff --git a/qumat/qumat.py b/qumat/qumat.py
index dd5b03eb6..08919d7c6 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -60,4 +60,13 @@ def get_final_state_vector(self):
         return self.backend_module.get_final_state_vector(self.circuit, self.backend, self.backend_config)
 
     def draw(self):
-        return self.backend_module.draw_circuit(self.circuit)
\ No newline at end of file
+        return self.backend_module.draw_circuit(self.circuit)
+
+    def apply_rx_gate(self, qubit_index, angle):
+        self.backend_module.apply_rx_gate(self.circuit, qubit_index, angle)
+
+    def apply_ry_gate(self, qubit_index, angle):
+        self.backend_module.apply_ry_gate(self.circuit, qubit_index, angle)
+
+    def apply_rz_gate(self, qubit_index, angle):
+        self.backend_module.apply_rz_gate(self.circuit, qubit_index, angle)

From a65168acdebec439be113676bc1fb3195f87c934 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Wed, 9 Oct 2024 12:58:39 -0500
Subject: [PATCH 02/24] Add U gate

---
 qumat/amazon_braket_backend.py | 5 +++++
 qumat/cirq_backend.py          | 5 +++++
 qumat/qiskit_backend.py        | 4 ++++
 qumat/qumat.py                 | 3 +++
 4 files changed, 17 insertions(+)

diff --git a/qumat/amazon_braket_backend.py b/qumat/amazon_braket_backend.py
index 02419aa15..9422dda8b 100644
--- a/qumat/amazon_braket_backend.py
+++ b/qumat/amazon_braket_backend.py
@@ -77,3 +77,8 @@ def apply_ry_gate(circuit, qubit_index, angle):
 
 def apply_rz_gate(circuit, qubit_index, angle):
     circuit.rz(qubit_index, angle)
+
+def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
+    circuit.rx(qubit_index, theta)
+    circuit.ry(qubit_index, phi)
+    circuit.rz(qubit_index, lambd)
diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index b61d6a827..e27ab0701 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -86,3 +86,8 @@ def apply_rz_gate(circuit, qubit_index, angle):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.rz(angle).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))
diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index cc6c7afd1..ca3b0ae62 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -99,3 +99,7 @@ def apply_ry_gate(circuit, qubit_index, angle):
 
 def apply_rz_gate(circuit, qubit_index, angle):
     circuit.rz(angle, 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)
diff --git a/qumat/qumat.py b/qumat/qumat.py
index 08919d7c6..97101a4a4 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -70,3 +70,6 @@ def apply_ry_gate(self, qubit_index, angle):
 
     def apply_rz_gate(self, qubit_index, angle):
         self.backend_module.apply_rz_gate(self.circuit, qubit_index, angle)
+
+    def apply_u_gate(self, qubit_index, theta, phi, lambd):
+        self.backend_module.apply_u_gate(self.circuit, qubit_index, theta, phi, lambd)

From c9e2d904d0e1d4a5a4bb170a69d2454a3d382691 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 13:20:58 -0600
Subject: [PATCH 03/24] Closes #468 Closes #469

---
 docs/api.md                         |  42 +++++++-
 examples/Optimization_Example.ipynb | 146 ++++++++++++++++++++++++++++
 pyproject.toml                      |   1 +
 qumat/amazon_braket_backend.py      |  24 ++++-
 qumat/cirq_backend.py               |  13 ++-
 qumat/qiskit_backend.py             |   9 +-
 qumat/qumat.py                      |  19 +++-
 7 files changed, 241 insertions(+), 13 deletions(-)
 create mode 100644 examples/Optimization_Example.ipynb

diff --git a/docs/api.md b/docs/api.md
index 82ae5a918..e97855fcd 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -72,4 +72,44 @@
 - **Purpose**: Visualizes the quantum circuit.
 - **Usage**: Provides a graphical representation of the quantum circuit for better understanding.
 - **Note**: Just a pass through function, will use underlying libraries 
-  method for drawing circuit. 
\ No newline at end of file
+  method for drawing circuit. 
+
+## `apply_rx_gate(self, qubit_index, angle)`  
+- **Purpose**: Applies a rotation around the X-axis to a specified qubit with an optional parameter for optimization.  
+- **Parameters**:  
+    - `qubit_index` (int): Index of the qubit.  
+    - `angle` (str or float): Angle in radians for the rotation. Can be a static value or a parameter name for optimization.  
+- **Usage**: Used to rotate a qubit around the X-axis, often in parameterized quantum circuits for variational algorithms.  
+  
+## `apply_ry_gate(self, qubit_index, angle)`  
+- **Purpose**: Applies a rotation around the Y-axis to a specified qubit with an optional parameter for optimization.  
+- **Parameters**:  
+    - `qubit_index` (int): Index of the qubit.  
+    - `angle` (str or float): Angle in radians for the rotation. Can be a static value or a parameter name for optimization.  
+- **Usage**: Used to rotate a qubit around the Y-axis in parameterized circuits, aiding in the creation of complex quantum states.  
+  
+## `apply_rz_gate(self, qubit_index, angle)`  
+- **Purpose**: Applies a rotation around the Z-axis to a specified qubit with an optional parameter for optimization.  
+- **Parameters**:  
+    - `qubit_index` (int): Index of the qubit.  
+    - `angle` (str or float): Angle in radians for the rotation. Can be a static value or a parameter name for optimization.  
+- **Usage**: Utilized in parameterized quantum circuits to modify the phase of a qubit state during optimization.  
+  
+## `execute_circuit(self, parameter_values=None)`  
+- **Purpose**: Executes the quantum circuit with the ability to bind specific parameter values if provided.  
+- **Parameters**:  
+    - `parameter_values` (dict, optional): A dictionary where keys are parameter names and values are the numerical values to bind.  
+- **Usage**: Enables the execution of parameterized circuits by binding parameter values, facilitating optimization processes.  
+  
+## `bind_parameters(self, parameter_values)`  
+- **Purpose**: Binds numerical values to the parameters of the quantum circuit, allowing for dynamic updates during optimization.  
+- **Parameters**:  
+    - `parameter_values` (dict): A dictionary with parameter names as keys and numerical values to bind.  
+- **Usage**: Essential for optimization loops where parameters are adjusted based on cost function evaluations.  
+  
+## `_handle_parameter(self, param_name)`  
+- **Purpose**: Internal function to manage parameter registration.  
+- **Parameters**:  
+    - `param_name` (str): The name of the parameter to handle.  
+- **Usage**: Automatically invoked when applying parameterized gates to keep track of parameters efficiently.  
+  
diff --git a/examples/Optimization_Example.ipynb b/examples/Optimization_Example.ipynb
new file mode 100644
index 000000000..633281454
--- /dev/null
+++ b/examples/Optimization_Example.ipynb
@@ -0,0 +1,146 @@
+{
+"nbformat": 4,
+ "nbformat_minor": 0,
+ "cells": [
+ {
+   "cell_type": "code",
+   "source": [
+    "!pip install git+https://github.com/apache/mahout.git@main"
+   ],
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "lNDTZhztd2dp",
+    "outputId": "ea3b9e41-43a8-44e7-9daf-e62e71d93143"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quantum Circuit Parameterization and Optimization\n",
+    "\n",
+    "In this notebook, we'll explore how to create parameterized quantum circuits using the QuMat framework. This feature allows us to bind values to parameters at execution time, paving the way for optimization tasks in quantum computing.\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "1. **Parameter Handling**: We will use symbols to represent parameters in quantum gates, allowing these parameters to be updated during optimization.\n",
+    "2. **Circuit Execution with Binding**: We will bind parameter values to a circuit prior to its execution, a critical step in parameter optimization routines.\n",
+    "3. **Simple Optimization Loop**: We'll implement a basic optimization loop that updates parameters based on a cost function.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Setting Up\n",
+    "\n",
+    "We start by setting up the backend configuration and initializing the QuMat framework. This framework interfaces with quantum computing libraries like Qiskit or Cirq to manage the underlying quantum computations.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qumat.qumat import QuMat\n",
+    "\n",
+    "# Configure the backend to use Qiskit with a simulator\n",
+    "backend_config = {\n",
+    "    'backend_name': 'qiskit',\n",
+    "    'backend_options': {'simulator_type': 'qasm_simulator', 'shots': 1024}\n",
+    "}\n",
+    "\n",
+    "# Create an instance of QuMat\n",
+    "qumat_instance = QuMat(backend_config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Creating a Parameterized Quantum Circuit\n",
+    "\n",
+    "We create a simple quantum circuit with one qubit and apply parameterized RX, RY, and RZ gates. The parameters will be defined symbolically, allowing them to be replaced with actual values during execution.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a quantum circuit with 1 qubit\n",
+    "qumat_instance.create_empty_circuit(1)\n",
+    "\n",
+    "# Apply parameterized RX, RY, and RZ gates\n",
+    "qumat_instance.apply_rx_gate(0, 'theta')\n",
+    "qumat_instance.apply_ry_gate(0, 'phi')\n",
+    "qumat_instance.apply_rz_gate(0, 'lambda')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Running the Optimization Loop\n",
+    "\n",
+    "We'll iterate over a simple optimization loop, updating the parameter values for each iteration. This example does not feature a sophisticated cost function, but in practical scenarios, you'd compute and leverage a cost function to guide these updates.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example optimization loop\n",
+    "\n",
+    "# Initial parameter values\n",
+    "current_parameters = {'theta': 0, 'phi': 0, 'lambda': 0}\n",
+    "\n",
+    "# Define a simple placeholder cost function\n",
+    "def your_cost_function():\n",
+    "    # Placeholder: replace with a real function in actual applications\n",
+    "    return 0\n",
+    "\n",
+    "# Run the optimization loop\n",
+    "for iteration in range(10):  # Reduced iteration count for brevity\n",
+    "    cost = your_cost_function()  # Evaluate the cost function\n",
+    "    \n",
+    "    # Update parameter(s) based on some optimization logic\n",
+    "    # This is a placeholder update mechanism\n",
+    "    current_parameters['theta'] += 0.1\n",
+    "    current_parameters['phi'] += 0.1\n",
+    "    current_parameters['lambda'] += 0.1\n",
+    "    \n",
+    "    # Execute the circuit with the updated parameters\n",
+    "    result = qumat_instance.execute_circuit(parameter_values=current_parameters)\n",
+    "    \n",
+    "    print(f\"Iteration {iteration}, Result: {result}, Parameters: {current_parameters}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusion\n",
+    "\n",
+    "This notebook demonstrates how to effectively handle parameters within quantum circuits using the QuMat framework. Although the optimization loop here uses a placeholder mechanism, it highlights how parameterized circuits can be used in iterative optimization processes, often encountered in variational quantum algorithms.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pyproject.toml b/pyproject.toml
index 20f24b2eb..fba0eca67 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -12,6 +12,7 @@ qiskit = "^0.45.1"
 qiskit-aer = "^0.13.2"
 cirq = "^1.3.0"
 amazon-braket-sdk = "^1.10.0"
+sympy = "^1.9"
 
 [tool.poetry.dev-dependencies]
 pytest = "^8.1.1"
diff --git a/qumat/amazon_braket_backend.py b/qumat/amazon_braket_backend.py
index 9422dda8b..b97fcea84 100644
--- a/qumat/amazon_braket_backend.py
+++ b/qumat/amazon_braket_backend.py
@@ -15,7 +15,7 @@
 # limitations under the License.
 #
 from braket.aws import AwsQuantumSimulator, AwsDevice
-from braket.circuits import Circuit
+from braket.circuits import Circuit, FreeParameter
 
 def initialize_backend(backend_config):
     backend_options = backend_config['backend_options']
@@ -69,14 +69,30 @@ def draw_circuit(circuit):
     # For simplicity, we'll print the circuit object which gives some textual representation.
     print(circuit)
 
+
 def apply_rx_gate(circuit, qubit_index, angle):
-    circuit.rx(qubit_index, angle)
+    if isinstance(angle, (int, float)):
+        circuit.rx(qubit_index, angle)
+    else:
+        param = FreeParameter(angle)
+        circuit.rx(qubit_index, param)
+
 
 def apply_ry_gate(circuit, qubit_index, angle):
-    circuit.ry(qubit_index, angle)
+    if isinstance(angle, (int, float)):
+        circuit.ry(qubit_index, angle)
+    else:
+        param = FreeParameter(angle)
+        circuit.ry(qubit_index, param)
+
 
 def apply_rz_gate(circuit, qubit_index, angle):
-    circuit.rz(qubit_index, angle)
+    if isinstance(angle, (int, float)):
+        circuit.rz(qubit_index, angle)
+    else:
+        param = FreeParameter(angle)
+        circuit.rz(qubit_index, param)
+
 
 def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
     circuit.rx(qubit_index, theta)
diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index e27ab0701..ead08b277 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 import cirq
+import sympy
 
 def initialize_backend(backend_config):
    # Assuming 'simulator_type' specifies the type of simulator in Cirq
@@ -74,17 +75,23 @@ def execute_circuit(circuit, backend, backend_config):
 def draw_circuit(circuit):
     print(circuit)
 
+
 def apply_rx_gate(circuit, qubit_index, angle):
+    param = sympy.Symbol(angle) if isinstance(angle, str) else angle
     qubit = cirq.LineQubit(qubit_index)
-    circuit.append(cirq.rx(angle).on(qubit))
+    circuit.append(cirq.rx(param).on(qubit))
+
 
 def apply_ry_gate(circuit, qubit_index, angle):
+    param = sympy.Symbol(angle) if isinstance(angle, str) else angle
     qubit = cirq.LineQubit(qubit_index)
-    circuit.append(cirq.ry(angle).on(qubit))
+    circuit.append(cirq.ry(param).on(qubit))
+
 
 def apply_rz_gate(circuit, qubit_index, angle):
+    param = sympy.Symbol(angle) if isinstance(angle, str) else angle
     qubit = cirq.LineQubit(qubit_index)
-    circuit.append(cirq.rz(angle).on(qubit))
+    circuit.append(cirq.rz(param).on(qubit))
 
 def apply_u_gate(circuit, qubit_index, theta, phi, lambd):
     qubit = cirq.LineQubit(qubit_index)
diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index ca3b0ae62..4668dbb4f 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -92,13 +92,16 @@ def draw_circuit(circuit):
     print(circuit.draw())
 
 def apply_rx_gate(circuit, qubit_index, angle):
-    circuit.rx(angle, qubit_index)
+    param = qiskit.Parameter(angle) if isinstance(angle, str) else angle
+    circuit.rx(param, qubit_index)
 
 def apply_ry_gate(circuit, qubit_index, angle):
-    circuit.ry(angle, qubit_index)
+    param = qiskit.Parameter(angle) if isinstance(angle, str) else angle
+    circuit.ry(param, qubit_index)
 
 def apply_rz_gate(circuit, qubit_index, angle):
-    circuit.rz(angle, qubit_index)
+    param = qiskit.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
diff --git a/qumat/qumat.py b/qumat/qumat.py
index 97101a4a4..f4da5736d 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -20,10 +20,10 @@ class QuMat:
     def __init__(self, backend_config):
         self.backend_config = backend_config
         self.backend_name = backend_config['backend_name']
-        # Dynamically load the backend module based on the user's choice
         self.backend_module = import_module(f".{self.backend_name}_backend", package="qumat")
         self.backend = self.backend_module.initialize_backend(backend_config)
         self.circuit = None
+        self.parameters = {}
 
     def create_empty_circuit(self, num_qubits):
         self.circuit = self.backend_module.create_empty_circuit(num_qubits)
@@ -52,9 +52,17 @@ def apply_pauli_y_gate(self, qubit_index):
     def apply_pauli_z_gate(self, qubit_index):
         self.backend_module.apply_pauli_z_gate(self.circuit, qubit_index)
 
-    def execute_circuit(self):
+    def execute_circuit(self, parameter_values=None):
+        # If parameter_values is provided, bind them to the circuit before execution
+        if parameter_values:
+            self.bind_parameters(parameter_values)
         return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config)
 
+    def bind_parameters(self, parameter_values):
+        for param, value in parameter_values.items():
+            if param in self.parameters:
+                self.parameters[param] = value
+
     # placeholder method for use in the testing suite
     def get_final_state_vector(self):
         return self.backend_module.get_final_state_vector(self.circuit, self.backend, self.backend_config)
@@ -63,13 +71,20 @@ def draw(self):
         return self.backend_module.draw_circuit(self.circuit)
 
     def apply_rx_gate(self, qubit_index, angle):
+        self._handle_parameter(angle)
         self.backend_module.apply_rx_gate(self.circuit, qubit_index, angle)
 
     def apply_ry_gate(self, qubit_index, angle):
+        self._handle_parameter(angle)
         self.backend_module.apply_ry_gate(self.circuit, qubit_index, angle)
 
     def apply_rz_gate(self, qubit_index, angle):
+        self._handle_parameter(angle)
         self.backend_module.apply_rz_gate(self.circuit, qubit_index, angle)
 
+    def _handle_parameter(self, param_name):
+        if isinstance(param_name, str) and param_name not in self.parameters:
+            self.parameters[param_name] = None
+
     def apply_u_gate(self, qubit_index, theta, phi, lambd):
         self.backend_module.apply_u_gate(self.circuit, qubit_index, theta, phi, lambd)

From 7240790c0b32a2f97909e32bc88240d627869fa7 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 13:24:54 -0600
Subject: [PATCH 04/24] typo

---
 qumat/qiskit_backend.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index 4668dbb4f..4240d79b5 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -92,15 +92,15 @@ def draw_circuit(circuit):
     print(circuit.draw())
 
 def apply_rx_gate(circuit, qubit_index, angle):
-    param = qiskit.Parameter(angle) if isinstance(angle, str) else 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.Parameter(angle) if isinstance(angle, str) else 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.Parameter(angle) if isinstance(angle, str) else 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):

From 6569b2fa1bbd61d14ca3b547c6343802eaadefba Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 13:30:48 -0600
Subject: [PATCH 05/24] bind parameters

---
 qumat/qiskit_backend.py | 27 ++++++++++++++++++---------
 qumat/qumat.py          |  2 +-
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index 4240d79b5..967854c20 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -67,15 +67,24 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
 def execute_circuit(circuit, backend, backend_config):
-    # Transpile the circuit
-    circuit.measure_all()
-    transpiled_circuit = qiskit.compiler.transpile(circuit, backend)
-
-    # Execute the transpiled circuit on the backend
-    job = qiskit.execute(transpiled_circuit, backend,
-                         shots=backend_config['backend_options']['shots'])
-    result = job.result()
-    return result.get_counts(transpiled_circuit)
+    # Ensure the circuit is parameterized properly
+    if 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)
+        result = job.result()
+        return result.get_counts()
+    else:
+        # For non-parameterized circuits
+        circuit.measure_all()
+        transpiled_circuit = qiskit.transpile(circuit, backend)
+        job = qiskit.execute(transpiled_circuit, backend, shots=backend_config['backend_options']['shots'])
+        result = job.result()
+        return result.get_counts()
 
 # placeholder method for use in the testing suite
 def get_final_state_vector(circuit, backend, backend_config):
diff --git a/qumat/qumat.py b/qumat/qumat.py
index f4da5736d..db0dc1952 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -53,9 +53,9 @@ def apply_pauli_z_gate(self, qubit_index):
         self.backend_module.apply_pauli_z_gate(self.circuit, qubit_index)
 
     def execute_circuit(self, parameter_values=None):
-        # If parameter_values is provided, bind them to the circuit before execution
         if parameter_values:
             self.bind_parameters(parameter_values)
+        self.backend_config['parameter_values'] = self.parameters  # Pass parameters
         return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config)
 
     def bind_parameters(self, parameter_values):

From bdb3dc8fc80bfa94a18799431ed27c62ae34f4a7 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 13:39:01 -0600
Subject: [PATCH 06/24] bind parameters 2

---
 qumat/qiskit_backend.py | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index 967854c20..dfde87039 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -67,24 +67,25 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
 def execute_circuit(circuit, backend, backend_config):
-    # Ensure the circuit is parameterized properly
-    if 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'])
+    shots = backend_config['backend_options'].get('shots', 1024)
 
+    if circuit.parameters:
+        # Bind parameters if necessary
+        parameter_binds = {
+            param: backend_config.get('parameter_values', {}).get(str(param), 0)
+            for param in circuit.parameters
+        }
+
+        # Assemble and bind parameters to the circuit
+        qobj = qiskit.assemble(qiskit.transpile(circuit, backend), backend=backend, parameter_binds=[parameter_binds], shots=shots)
         job = backend.run(qobj)
-        result = job.result()
-        return result.get_counts()
+
     else:
-        # For non-parameterized circuits
-        circuit.measure_all()
-        transpiled_circuit = qiskit.transpile(circuit, backend)
-        job = qiskit.execute(transpiled_circuit, backend, shots=backend_config['backend_options']['shots'])
-        result = job.result()
-        return result.get_counts()
+        # Execute directly if no parameters exist
+        job = qiskit.execute(circuit, backend, shots=shots)
+
+    result = job.result()
+    return result.get_counts()
 
 # placeholder method for use in the testing suite
 def get_final_state_vector(circuit, backend, backend_config):

From 108adc3ebd68c0ecb6967b99a920c542cae24e43 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 13:49:50 -0600
Subject: [PATCH 07/24] add measurement

---
 qumat/qiskit_backend.py | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index dfde87039..549b5e56e 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -67,25 +67,28 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
 def execute_circuit(circuit, backend, backend_config):
-    shots = backend_config['backend_options'].get('shots', 1024)
+    # Add measurements if they are not already present
+    if not circuit.cregs:
+        circuit.measure_all()
 
+    # Ensure the circuit is parameterized properly
     if circuit.parameters:
-        # Bind parameters if necessary
-        parameter_binds = {
-            param: backend_config.get('parameter_values', {}).get(str(param), 0)
-            for param in circuit.parameters
-        }
-
-        # Assemble and bind parameters to the circuit
-        qobj = qiskit.assemble(qiskit.transpile(circuit, backend), backend=backend, parameter_binds=[parameter_binds], shots=shots)
-        job = backend.run(qobj)
+        # Parse the global parameter configuration
+        parameter_bindings = {param: backend_config['parameter_values'][str(param)] for param in circuit.parameters}
 
-    else:
-        # Execute directly if no parameters exist
-        job = qiskit.execute(circuit, backend, shots=shots)
+        transpiled_circuit = qiskit.transpile(circuit, backend)
+        qobj = qiskit.assemble(transpiled_circuit, parameter_binds=[parameter_bindings], shots=backend_config['backend_options']['shots'])
 
-    result = job.result()
-    return result.get_counts()
+        job = backend.run(qobj)
+        result = job.result()
+        return result.get_counts()
+    else:
+        # For non-parameterized circuits
+        circuit.measure_all()
+        transpiled_circuit = qiskit.transpile(circuit, backend)
+        job = qiskit.execute(transpiled_circuit, backend, shots=backend_config['backend_options']['shots'])
+        result = job.result()
+        return result.get_counts()
 
 # placeholder method for use in the testing suite
 def get_final_state_vector(circuit, backend, backend_config):

From 701eefacbf71ee6567bb83cd02fa8e792fe70432 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 14:08:11 -0600
Subject: [PATCH 08/24] parameter sweep

---
 qumat/cirq_backend.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index ead08b277..96b94aa28 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -65,11 +65,20 @@ def apply_pauli_z_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.Z(qubit))
 
-def execute_circuit(circuit, backend, backend_config):
-    # This is a simplified example. You'll need to adjust this based on how you're handling backend configuration.
-    circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
+def execute_circuit(circuit, backend, backend_config, parameter_values=None):
+    # Append measurement to all qubits at the end of the circuit
+    qubits = circuit.all_qubits()
+    circuit.append(cirq.measure(*qubits, key='result'))
+
+    if parameter_values is None:
+        parameter_values = {}
+
+    # Construct the parameter resolver for Cirq
+    resolver = {sympy.Symbol(k): v for k, v in parameter_values.items()}
+
+    # Execute the circuit via a parameter sweep
     simulator = cirq.Simulator()
-    result = simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
+    result = simulator.run(circuit, param_resolver=resolver, repetitions=backend_config['backend_options'].get('shots', 1))
     return result.histogram(key='result')
 
 def draw_circuit(circuit):

From 177665778a1570a88c5ca36125ffb71127693f60 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 14:34:08 -0600
Subject: [PATCH 09/24] parameter sweep

---
 qumat/cirq_backend.py | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 96b94aa28..3acaabc63 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -66,20 +66,18 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.append(cirq.Z(qubit))
 
 def execute_circuit(circuit, backend, backend_config, parameter_values=None):
-    # Append measurement to all qubits at the end of the circuit
-    qubits = circuit.all_qubits()
-    circuit.append(cirq.measure(*qubits, key='result'))
-
-    if parameter_values is None:
-        parameter_values = {}
-
-    # Construct the parameter resolver for Cirq
-    resolver = {sympy.Symbol(k): v for k, v in parameter_values.items()}
-
-    # Execute the circuit via a parameter sweep
-    simulator = cirq.Simulator()
-    result = simulator.run(circuit, param_resolver=resolver, repetitions=backend_config['backend_options'].get('shots', 1))
-    return result.histogram(key='result')
+    # Ensure measurement is added to capture the results
+    circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
+
+    if parameter_values:
+        # Convert parameter_values to applicable resolvers
+        res = [cirq.ParamResolver(parameter_values)]
+        simulator = cirq.Simulator()
+        results = simulator.run_sweep(circuit=circuit, repetitions=backend_config['backend_options'].get('shots', 1), params=res)
+        return [result.histogram(key='result') for result in results]
+    else:
+        result = cirq.simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
+        return result.histogram(key='result')
 
 def draw_circuit(circuit):
     print(circuit)

From daba46714bf03981460a67cdbc2d2e9d080161d4 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 14:40:29 -0600
Subject: [PATCH 10/24] typo

---
 qumat/cirq_backend.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 3acaabc63..5dd478da4 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -68,15 +68,14 @@ def apply_pauli_z_gate(circuit, qubit_index):
 def execute_circuit(circuit, backend, backend_config, parameter_values=None):
     # Ensure measurement is added to capture the results
     circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
-
+    simulator = cirq.Simulator()
     if parameter_values:
         # Convert parameter_values to applicable resolvers
         res = [cirq.ParamResolver(parameter_values)]
-        simulator = cirq.Simulator()
         results = simulator.run_sweep(circuit=circuit, repetitions=backend_config['backend_options'].get('shots', 1), params=res)
         return [result.histogram(key='result') for result in results]
     else:
-        result = cirq.simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
+        result = simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
         return result.histogram(key='result')
 
 def draw_circuit(circuit):

From 72a09e5dd17888c12ce00915fb9adf4306dfe8e6 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 14:44:23 -0600
Subject: [PATCH 11/24] test

---
 qumat/cirq_backend.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 5dd478da4..597f06ff8 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -65,18 +65,19 @@ def apply_pauli_z_gate(circuit, qubit_index):
     qubit = cirq.LineQubit(qubit_index)
     circuit.append(cirq.Z(qubit))
 
+
 def execute_circuit(circuit, backend, backend_config, parameter_values=None):
     # Ensure measurement is added to capture the results
     circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
     simulator = cirq.Simulator()
-    if parameter_values:
+    # if parameter_values:
         # Convert parameter_values to applicable resolvers
-        res = [cirq.ParamResolver(parameter_values)]
-        results = simulator.run_sweep(circuit=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')
+    res = [cirq.ParamResolver(parameter_values)]
+    results = simulator.run_sweep(circuit=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')
 
 def draw_circuit(circuit):
     print(circuit)

From eb5fae7729b9abee1124983da187d0647edfdaea Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 14:48:19 -0600
Subject: [PATCH 12/24] test

---
 qumat/cirq_backend.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 597f06ff8..ded89fdd1 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -73,7 +73,7 @@ def execute_circuit(circuit, backend, backend_config, parameter_values=None):
     # if parameter_values:
         # Convert parameter_values to applicable resolvers
     res = [cirq.ParamResolver(parameter_values)]
-    results = simulator.run_sweep(circuit=circuit, repetitions=backend_config['backend_options'].get('shots', 1), params=res)
+    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))

From 63b1597233576fe196671cd2ee2658cb8f77195b Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:02:31 -0600
Subject: [PATCH 13/24] fix

---
 qumat/cirq_backend.py | 17 +++++++++--------
 qumat/qumat.py        |  2 +-
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index ded89fdd1..500ec088f 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -66,18 +66,19 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.append(cirq.Z(qubit))
 
 
-def execute_circuit(circuit, backend, backend_config, parameter_values=None):
+def execute_circuit(circuit, backend, backend_config):
     # Ensure measurement is added to capture the results
     circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
     simulator = cirq.Simulator()
-    # if parameter_values:
+    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]
-    # else:
-    #     result = simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
-    #     return result.histogram(key='result')
+        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]
+    else:
+        result = simulator.run(circuit, repetitions=backend_config['backend_options'].get('shots', 1))
+        return result.histogram(key='result')
 
 def draw_circuit(circuit):
     print(circuit)
diff --git a/qumat/qumat.py b/qumat/qumat.py
index db0dc1952..df5d8f172 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -56,7 +56,7 @@ def execute_circuit(self, parameter_values=None):
         if parameter_values:
             self.bind_parameters(parameter_values)
         self.backend_config['parameter_values'] = self.parameters  # Pass parameters
-        return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config)
+        return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config, parameter_values)
 
     def bind_parameters(self, parameter_values):
         for param, value in parameter_values.items():

From a231c3f52a15454ef6bdbcde52efa76818aa9692 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:04:58 -0600
Subject: [PATCH 14/24] typo

---
 qumat/qumat.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qumat/qumat.py b/qumat/qumat.py
index df5d8f172..db0dc1952 100644
--- a/qumat/qumat.py
+++ b/qumat/qumat.py
@@ -56,7 +56,7 @@ def execute_circuit(self, parameter_values=None):
         if parameter_values:
             self.bind_parameters(parameter_values)
         self.backend_config['parameter_values'] = self.parameters  # Pass parameters
-        return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config, parameter_values)
+        return self.backend_module.execute_circuit(self.circuit, self.backend, self.backend_config)
 
     def bind_parameters(self, parameter_values):
         for param, value in parameter_values.items():

From ea3a57bbe5687ef8b1215dca66da3a2899359a73 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:09:28 -0600
Subject: [PATCH 15/24] typo

---
 qumat/qiskit_backend.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index 549b5e56e..b9eeaa14a 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -75,16 +75,12 @@ def execute_circuit(circuit, backend, backend_config):
     if 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)
         result = job.result()
         return result.get_counts()
     else:
-        # For non-parameterized circuits
-        circuit.measure_all()
         transpiled_circuit = qiskit.transpile(circuit, backend)
         job = qiskit.execute(transpiled_circuit, backend, shots=backend_config['backend_options']['shots'])
         result = job.result()

From db89a86fcc088a463ef582b24abbff0354b1cb66 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:13:17 -0600
Subject: [PATCH 16/24] typo

---
 qumat/qiskit_backend.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index b9eeaa14a..90f0af8d2 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -67,9 +67,9 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
 def execute_circuit(circuit, backend, backend_config):
-    # Add measurements if they are not already present
-    if not circuit.cregs:
-        circuit.measure_all()
+    # # Add measurements if they are not already present
+    # if not circuit.cregs:
+    #     circuit.measure_all()
 
     # Ensure the circuit is parameterized properly
     if circuit.parameters:

From e670a7b93fe8a8db147aeb5ae422c80b9cc72313 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:19:24 -0600
Subject: [PATCH 17/24] typo

---
 qumat/cirq_backend.py   | 4 ++--
 qumat/qiskit_backend.py | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 500ec088f..fd8ddceeb 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -68,7 +68,7 @@ def apply_pauli_z_gate(circuit, qubit_index):
 
 def execute_circuit(circuit, backend, backend_config):
     # Ensure measurement is added to capture the results
-    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)
     if parameter_values:
@@ -78,7 +78,7 @@ def execute_circuit(circuit, backend, backend_config):
         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')
+        return [result.histogram(key='result')]
 
 def draw_circuit(circuit):
     print(circuit)
diff --git a/qumat/qiskit_backend.py b/qumat/qiskit_backend.py
index 90f0af8d2..b9eeaa14a 100644
--- a/qumat/qiskit_backend.py
+++ b/qumat/qiskit_backend.py
@@ -67,9 +67,9 @@ def apply_pauli_z_gate(circuit, qubit_index):
     circuit.z(qubit_index)
 
 def execute_circuit(circuit, backend, backend_config):
-    # # Add measurements if they are not already present
-    # if not circuit.cregs:
-    #     circuit.measure_all()
+    # Add measurements if they are not already present
+    if not circuit.cregs:
+        circuit.measure_all()
 
     # Ensure the circuit is parameterized properly
     if circuit.parameters:

From 5ead65ed8d90d73f9178a10974d677f2a6d9cf11 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:23:40 -0600
Subject: [PATCH 18/24] typo

---
 qumat/cirq_backend.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index fd8ddceeb..977227df6 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -68,7 +68,9 @@ def apply_pauli_z_gate(circuit, qubit_index):
 
 def execute_circuit(circuit, backend, backend_config):
     # Ensure measurement is added to capture the results
-    # circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
+    for i, qubit in enumerate(circuit.all_qubits()):
+        circuit.append(cirq.measure(qubit, key=f'result_{i}'))
+
     simulator = cirq.Simulator()
     parameter_values = backend_config.get('parameter_values', None)
     if parameter_values:

From 575bd826d7b1374b9d75d3429110e60913c9b63c Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Tue, 5 Nov 2024 15:25:39 -0600
Subject: [PATCH 19/24] typo

---
 qumat/cirq_backend.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/qumat/cirq_backend.py b/qumat/cirq_backend.py
index 977227df6..45b3abe92 100644
--- a/qumat/cirq_backend.py
+++ b/qumat/cirq_backend.py
@@ -68,9 +68,8 @@ def apply_pauli_z_gate(circuit, qubit_index):
 
 def execute_circuit(circuit, backend, backend_config):
     # Ensure measurement is added to capture the results
-    for i, qubit in enumerate(circuit.all_qubits()):
-        circuit.append(cirq.measure(qubit, key=f'result_{i}'))
-
+    if not circuit.has_measurements():
+        circuit.append(cirq.measure(*circuit.all_qubits(), key='result'))
     simulator = cirq.Simulator()
     parameter_values = backend_config.get('parameter_values', None)
     if parameter_values:

From b1b1f4198a0aff74b0985c671d5b7a0d35165d3c Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Thu, 7 Nov 2024 16:29:12 -0600
Subject: [PATCH 20/24] notebook branch - need a more elegant solution for
 this...

---
 examples/Optimization_Example.ipynb | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/examples/Optimization_Example.ipynb b/examples/Optimization_Example.ipynb
index 633281454..3a1ccd69f 100644
--- a/examples/Optimization_Example.ipynb
+++ b/examples/Optimization_Example.ipynb
@@ -1,11 +1,11 @@
 {
-"nbformat": 4,
- "nbformat_minor": 0,
+ "nbformat": 4,
+ "nbformat_minor": 2,
  "cells": [
- {
+  {
    "cell_type": "code",
    "source": [
-    "!pip install git+https://github.com/apache/mahout.git@main"
+    "!pip install git+https://github.com/apache/mahout.git@468-469"
    ],
    "metadata": {
     "colab": {
@@ -111,16 +111,16 @@
     "# Run the optimization loop\n",
     "for iteration in range(10):  # Reduced iteration count for brevity\n",
     "    cost = your_cost_function()  # Evaluate the cost function\n",
-    "    \n",
+    "\n",
     "    # Update parameter(s) based on some optimization logic\n",
     "    # This is a placeholder update mechanism\n",
     "    current_parameters['theta'] += 0.1\n",
     "    current_parameters['phi'] += 0.1\n",
     "    current_parameters['lambda'] += 0.1\n",
-    "    \n",
+    "\n",
     "    # Execute the circuit with the updated parameters\n",
     "    result = qumat_instance.execute_circuit(parameter_values=current_parameters)\n",
-    "    \n",
+    "\n",
     "    print(f\"Iteration {iteration}, Result: {result}, Parameters: {current_parameters}\")"
    ]
   },
@@ -140,7 +140,5 @@
    "language": "python",
    "name": "python3"
   }
- },
- "nbformat": 4,
- "nbformat_minor": 2
+ }
 }

From 5b10819e9f6a4596f252258b883f26a5b6f2cc22 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Thu, 7 Nov 2024 16:31:44 -0600
Subject: [PATCH 21/24] update coordinate to my fork

---
 examples/Optimization_Example.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/Optimization_Example.ipynb b/examples/Optimization_Example.ipynb
index 3a1ccd69f..d06aca335 100644
--- a/examples/Optimization_Example.ipynb
+++ b/examples/Optimization_Example.ipynb
@@ -5,7 +5,7 @@
   {
    "cell_type": "code",
    "source": [
-    "!pip install git+https://github.com/apache/mahout.git@468-469"
+    "!pip install git+https://github.com/rawkintrevo/mahout.git@468-469"
    ],
    "metadata": {
     "colab": {

From af16248ef04daab3557e15a1a378b968aee0ba17 Mon Sep 17 00:00:00 2001
From: Trevor Grant <trevor.d.grant@gmail.com>
Date: Wed, 13 Nov 2024 16:42:35 -0600
Subject: [PATCH 22/24] Update Optimization_Example.ipynb

---
 examples/Optimization_Example.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/Optimization_Example.ipynb b/examples/Optimization_Example.ipynb
index d06aca335..5b84b8e03 100644
--- a/examples/Optimization_Example.ipynb
+++ b/examples/Optimization_Example.ipynb
@@ -5,7 +5,7 @@
   {
    "cell_type": "code",
    "source": [
-    "!pip install git+https://github.com/rawkintrevo/mahout.git@468-469"
+    "# !pip install git+https://github.com/rawkintrevo/mahout.git@468-469"
    ],
    "metadata": {
     "colab": {

From 308bc371e6615b4bb070e37c8f03299be94b1537 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Thu, 14 Nov 2024 13:24:13 -0600
Subject: [PATCH 23/24] testing hacks

---
 .github/workflows/notebook-testing.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/notebook-testing.yml b/.github/workflows/notebook-testing.yml
index 56c105d32..cc7559618 100644
--- a/.github/workflows/notebook-testing.yml
+++ b/.github/workflows/notebook-testing.yml
@@ -25,6 +25,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip  
           pip install nbconvert nbclient ipykernel
+          pip install -e .
 
       - name: Run Jupyter Notebooks
         run: |

From a10bab45375f3699f1ba0bed975b4883ee196288 Mon Sep 17 00:00:00 2001
From: rawkintrevo <trevor.d.grant@gmail.com>
Date: Thu, 14 Nov 2024 13:40:52 -0600
Subject: [PATCH 24/24] testing hacks

---
 examples/Optimization_Example.ipynb | 2 +-
 examples/Simple_Example.ipynb       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/Optimization_Example.ipynb b/examples/Optimization_Example.ipynb
index 5b84b8e03..32cf3fa44 100644
--- a/examples/Optimization_Example.ipynb
+++ b/examples/Optimization_Example.ipynb
@@ -5,7 +5,7 @@
   {
    "cell_type": "code",
    "source": [
-    "# !pip install git+https://github.com/rawkintrevo/mahout.git@468-469"
+    "# pip install git+https://github.com/apache/mahout.git@main"
    ],
    "metadata": {
     "colab": {
diff --git a/examples/Simple_Example.ipynb b/examples/Simple_Example.ipynb
index 7905ca11d..7e04c82f0 100644
--- a/examples/Simple_Example.ipynb
+++ b/examples/Simple_Example.ipynb
@@ -29,7 +29,7 @@
   {
    "cell_type": "code",
    "source": [
-    "!pip install git+https://github.com/apache/mahout.git@main"
+    "# pip install git+https://github.com/apache/mahout.git@main"
    ],
    "metadata": {
     "colab": {