Clean up QuantumScript._par_info

doc/releases/changelog-dev.md

@@ -49,6 +49,12 @@ keyword argument when using `GellMann`, which determines which of the 8 Gell-Man
 
 <h3>Improvements</h3>
 
+* Added a new `pennylane.tape.QuantumScript` class that contains all the non-queuing behavior of `QuantumTape`. Now `QuantumTape` inherits from `QuantumScript` as well
+  as `AnnotatedQueue`.
+  This is a developer-facing change, and users should not manipulate `QuantumScript` directly.  Instead, they
+  should continue to rely on `QNode`s.
+  [(#3097)](https://github.com/PennyLaneAI/pennylane/pull/3097)
+
 * `Adjoint` now supports batching if the base operation supports batching.
   [(#3168)](https://github.com/PennyLaneAI/pennylane/pull/3168)
 
@@ -133,6 +139,8 @@ keyword argument when using `GellMann`, which determines which of the 8 Gell-Man
 
 <h3>Breaking changes</h3>
 
+* `QuantumTape._par_info` is now a list of dictionaries, instead of a dictionary whose keys are integers starting from zero.
+
 * `QueuingContext` is renamed `QueuingManager`.
   [(#3061)](https://github.com/PennyLaneAI/pennylane/pull/3061)
 

pennylane/circuit_graph.py

@@ -85,9 +85,8 @@ class CircuitGraph:
         ops (Iterable[.Operator]): quantum operators constituting the circuit, in temporal order
         obs (Iterable[.MeasurementProcess]): terminal measurements, in temporal order
         wires (.Wires): The addressable wire registers of the device that will be executing this graph
-        par_info (dict[int, dict[str, .Operation or int]]): Parameter information. Keys are
-            parameter indices (in the order they appear on the tape), and values are a
-            dictionary containing the corresponding operation and operation parameter index.
+        par_info (list[dict]): Parameter information. For each index, the entry is a dictionary containing an operation
+        and an index into that operation's parameters.
         trainable_params (set[int]): A set containing the indices of parameters that support
             differentiability. The indices provided match the order of appearence in the
             quantum circuit.
@@ -420,7 +419,7 @@ def parametrized_layers(self):
         current = Layer([], [])
         layers = [current]
 
-        for idx, info in self.par_info.items():
+        for idx, info in enumerate(self.par_info):
             if idx in self.trainable_params:
                 op = info["op"]
 

pennylane/gradients/gradient_transform.py

@@ -53,7 +53,7 @@ def gradient_analysis(tape, use_graph=True, grad_fn=None):
     if grad_fn is not None:
         tape._gradient_fn = grad_fn
 
-    for idx, info in tape._par_info.items():
+    for idx, info in enumerate(tape._par_info):
 
         if idx not in tape.trainable_params:
             # non-trainable parameters do not require a grad_method
@@ -101,7 +101,7 @@ def grad_method_validation(method, tape):
 
     diff_methods = {
         idx: info["grad_method"]
-        for idx, info in tape._par_info.items()  # pylint: disable=protected-access
+        for idx, info in enumerate(tape._par_info)  # pylint: disable=protected-access
         if idx in tape.trainable_params
     }
 

pennylane/gradients/parameter_shift_cv.py

@@ -129,7 +129,7 @@ def _gradient_analysis_cv(tape):
 
     tape._gradient_fn = param_shift_cv
 
-    for idx, info in tape._par_info.items():
+    for idx, info in enumerate(tape._par_info):
         info["grad_method"] = _grad_method(tape, idx)
 
 

pennylane/ops/qubit/hamiltonian.py

@@ -540,7 +540,7 @@ def __matmul__(self, H):
             coeffs = qml.math.kron(coeffs1, coeffs2)
             ops_list = itertools.product(ops1, ops2)
             terms = [qml.operation.Tensor(t[0], t[1]) for t in ops_list]
-
+            print(coeffs, terms)
             return qml.Hamiltonian(coeffs, terms, simplify=True)
 
         if isinstance(H, (Tensor, Observable)):

pennylane/optimize/lie_algebra.py

@@ -90,8 +90,8 @@ def algebra_commutator(tape, observables, lie_algebra_basis_names, nqubits):
     for obs in observables:
         for o in obs:
             # create a list of tapes for the plus and minus shifted circuits
-            tapes_plus = [qml.tape.QuantumTape(p + "_p") for p in lie_algebra_basis_names]
-            tapes_min = [qml.tape.QuantumTape(p + "_m") for p in lie_algebra_basis_names]
+            tapes_plus = [qml.tape.QuantumTape(name=f"{p}_p") for p in lie_algebra_basis_names]
+            tapes_min = [qml.tape.QuantumTape(name=f"{p}_m") for p in lie_algebra_basis_names]
 
             # loop through all operations on the input tape
             for op in tape.operations:

pennylane/tape/__init__.py

@@ -18,5 +18,6 @@
 
 from .tape import QuantumTape, get_active_tape, TapeError
 from .operation_recorder import OperationRecorder
+from .qscript import QuantumScript
 from .stop_recording import stop_recording
 from .unwrap import Unwrap, UnwrapTape

pennylane/tape/operation_recorder.py

@@ -14,6 +14,7 @@
 """
 This module contains the :class:`OperationRecorder`.
 """
+# pylint: disable=too-many-arguments
 from pennylane.queuing import QueuingManager
 
 from .tape import QuantumTape
@@ -42,8 +43,12 @@ class OperationRecorder(QuantumTape):
     objects.
     """
 
-    def __init__(self):
-        super().__init__()
+    def __init__(
+        self, ops=None, measurements=None, prep=None, name=None, do_queue=False, _update=True
+    ):
+        super().__init__(
+            ops, measurements, prep=prep, name=name, do_queue=do_queue, _update=_update
+        )
         self.ops = None
         self.obs = None
 
@@ -53,10 +58,6 @@ def _process_queue(self):
         for obj, info in self._queue.items():
             QueuingManager.append(obj, **info)
 
-        # remove the operation recorder from the queuing
-        # context
-        QueuingManager.remove(self)
-
         new_tape = self.expand(depth=5, stop_at=lambda obj: not isinstance(obj, QuantumTape))
         self.ops = new_tape.operations
         self.obs = new_tape.observables