Merge branch 'main' into feature/res-analysis-specs

Author: jzaia18

.git-blame-ignore-revs

@@ -6,3 +6,44 @@ c73e73b19c8d38e63b41ca4c8039d9f430c55da1
 
 # Use `ruff` and `pyupgrade` to support `3.11`+ Python language features (https://github.com/PennyLaneAI/pennylane/pull/7860)
 a565cd69ad025796923f0354d084f9ca7267ab18
+
+# Migration from qml alias to new qp alias
+#   https://github.com/PennyLaneAI/pennylane/pull/9310
+#   https://github.com/PennyLaneAI/pennylane/pull/9317
+#   https://github.com/PennyLaneAI/pennylane/pull/9320
+#   https://github.com/PennyLaneAI/pennylane/pull/9315
+#   https://github.com/PennyLaneAI/pennylane/pull/9312
+#   https://github.com/PennyLaneAI/pennylane/pull/9314
+#   https://github.com/PennyLaneAI/pennylane/pull/9319
+#   https://github.com/PennyLaneAI/pennylane/pull/9313
+#   https://github.com/PennyLaneAI/pennylane/pull/9326
+#   https://github.com/PennyLaneAI/pennylane/pull/9331
+#   https://github.com/PennyLaneAI/pennylane/pull/9329
+#   https://github.com/PennyLaneAI/pennylane/pull/9280
+#   https://github.com/PennyLaneAI/pennylane/pull/9327
+#   https://github.com/PennyLaneAI/pennylane/pull/9330
+#   https://github.com/PennyLaneAI/pennylane/pull/9325
+#   https://github.com/PennyLaneAI/pennylane/pull/9358
+#   https://github.com/PennyLaneAI/pennylane/pull/9281
+#   https://github.com/PennyLaneAI/pennylane/pull/9360
+#   https://github.com/PennyLaneAI/pennylane/pull/9376
+#   https://github.com/PennyLaneAI/pennylane/pull/9375
+6a08713922d3aa69c18fd49f92190c4663676543
+82b1345f7cb6909b7f8dcdd74a3662697f9c7879
+9c7b57f5918d7996b327c37a5b4242057afdff19
+54df7dacc50bed50bee94012a9ec8332a944c93d
+9c04988b492f96101f948505ad5dcfdf23a28aea
+311e8bf4e463ababe49d2bade2aedd4f080eba0a
+cd92dea6a332d9e58ebe258e2da468e689fb6755
+fe95348de223be724865ec292ed14dd950780167
+46e4cdc78387e769b977a8e1f51dfa01ef58501f
+ae4295c5ee82790be3d67c471aebe162d571b1d0
+a5132e20f658b9bffd64d75499a2ae2e79d0717e
+07f3fad6bfa8543d9650c8e1cb2b265de5f8cfdf
+d3f4d19a9393537d7a484b22e16155ac19a4dcaf
+975767a42ff2f46a3bd36825425e67c3cebd310d
+b97b5729a1e36e9d9a1bd6e58cbbb1af9e2a2024
+99c8984c697fb112f1c09b0a21d82e7eb0dc6df8
+4c57e8c3bd56b381dddd93c6af1e36499b0c98bd
+894eabf146b314ea94a92cb7e398b9f23e7e1470
+1dc01257f80bb08b9d5f8e3168afc47e6ce66ab1

doc/development/adding_operators.rst

@@ -27,8 +27,8 @@ serves as the main abstraction of such objects, and all operators (such as gates
 inherit from it.
 
 >>> from jax import numpy as jnp
->>> op = qml.Rot(jnp.array(0.1), jnp.array(0.2), jnp.array(0.3), wires=["a"])
->>> isinstance(op, qml.operation.Operator)
+>>> op = qp.Rot(jnp.array(0.1), jnp.array(0.2), jnp.array(0.3), wires=["a"])
+>>> isinstance(op, qp.operation.Operator)
 True
 
 The basic components of operators are the following:
@@ -64,20 +64,20 @@ The basic components of operators are the following:
 
    * Representation as a **product of operators** (:meth:`.Operator.decomposition`):
 
-     >>> op = qml.Rot(0.1, 0.2, 0.3, wires=["a"])
+     >>> op = qp.Rot(0.1, 0.2, 0.3, wires=["a"])
      >>> op.decomposition()
      [RZ(0.1, wires=['a']), RY(0.2, wires=['a']), RZ(0.3, wires=['a'])]
 
    * Representation as a **linear combination of operators** (:meth:`.Operator.terms`):
 
-     >>> op = qml.Hamiltonian([1., 2.], [qml.PauliX(0), qml.PauliZ(0)])
+     >>> op = qp.Hamiltonian([1., 2.], [qp.PauliX(0), qp.PauliZ(0)])
      >>> op.terms()
      ((1.0, 2.0), [PauliX(wires=[0]), PauliZ(wires=[0])])
 
    * Representation via the **eigenvalue decomposition** specified by eigenvalues (for the diagonal matrix, :meth:`.Operator.eigvals`)
      and diagonalizing gates (for the unitaries :meth:`.Operator.diagonalizing_gates`):
 
-     >>> op = qml.PauliX(0)
+     >>> op = qp.PauliX(0)
      >>> op.diagonalizing_gates()
      [H(0)]
      >>> op.eigvals()
@@ -86,7 +86,7 @@ The basic components of operators are the following:
    * Representation as a **matrix** (:meth:`.Operator.matrix`), as specified by a global wire order that tells us where the
      wires are found on a register:
 
-     >>> op = qml.PauliRot(0.2, "X", wires=["b"])
+     >>> op = qp.PauliRot(0.2, "X", wires=["b"])
      >>> op.matrix(wire_order=["a", "b"])
      [[9.95e-01-2.26e-18j 2.72e-17-9.98e-02j, 0+0j, 0+0j]
       [2.72e-17-9.98e-02j 9.95e-01-2.26e-18j, 0+0j, 0+0j]
@@ -100,7 +100,7 @@ The basic components of operators are the following:
      >>> col = np.array([1, 0])
      >>> data = np.array([1, -1])
      >>> mat = coo_matrix((data, (row, col)), shape=(4, 4))
-     >>> op = qml.SparseHamiltonian(mat, wires=["a"])
+     >>> op = qp.SparseHamiltonian(mat, wires=["a"])
      >>> op.sparse_matrix(wire_order=["a"])
      (0, 1)   1
      (1, 0) - 1
@@ -111,7 +111,7 @@ specific subclasses.
 
 * Operators inheriting from :class:`~.Operator` support addition and scalar multiplication:
 
-  >>> op = qml.PauliX(0) + 0.1 * qml.PauliZ(0)
+  >>> op = qp.PauliX(0) + 0.1 * qp.PauliZ(0)
   >>> op.name
   Hamiltonian
   >>> op
@@ -120,7 +120,7 @@ specific subclasses.
 
 * Operators may define a hermitian conjugate:
 
-  >>> qml.RX(1., wires=0).adjoint()
+  >>> qp.RX(1., wires=0).adjoint()
   RX(-1.0, wires=[0])
 
 Creating custom operators
@@ -137,7 +137,7 @@ knows a native implementation for ``FlipAndRotate``). It also defines an adjoint
     import pennylane as qp
 
 
-    class FlipAndRotate(qml.operation.Operation):
+    class FlipAndRotate(qp.operation.Operation):
 
         # This attribute tells PennyLane what differentiation method to use. Here
         # we request parameter-shift (or "analytic") differentiation.
@@ -152,7 +152,7 @@ knows a native implementation for ``FlipAndRotate``). It also defines an adjoint
 
             # note: we use the framework-agnostic math library since
             # trainable inputs could be tensors of different types
-            shape = qml.math.shape(angle)
+            shape = qp.math.shape(angle)
             if len(shape) > 1:
                 raise ValueError(f"Expected a scalar angle; got angle of shape {shape}.")
 
@@ -166,7 +166,7 @@ knows a native implementation for ``FlipAndRotate``). It also defines an adjoint
 
             # we extract all wires that the operator acts on,
             # relying on the Wire class arithmetic
-            all_wires = qml.wires.Wires(wire_rot) + qml.wires.Wires(wire_flip)
+            all_wires = qp.wires.Wires(wire_rot) + qp.wires.Wires(wire_flip)
 
             # The parent class expects all trainable parameters to be fed as positional
             # arguments, and all wires acted on fed as a keyword argument.
@@ -186,8 +186,8 @@ knows a native implementation for ``FlipAndRotate``). It also defines an adjoint
             # The general signature of this function is (*parameters, wires, **hyperparameters).
             op_list = []
             if do_flip:
-                op_list.append(qml.PauliX(wires=wires[1]))
-            op_list.append(qml.RX(angle, wires=wires[0]))
+                op_list.append(qp.PauliX(wires=wires[1]))
+            op_list.append(qp.RX(angle, wires=wires[0]))
             return op_list
 
         def adjoint(self):
@@ -219,7 +219,7 @@ FlipAndRotate(-0.1, wires=['q3', 'q1'])
 Once the class has been created, you can run a suite of validation checks using :func:`.ops.functions.assert_valid`.
 This function will warn you of some common errors in custom operators.
 
->>> qml.ops.functions.assert_valid(op)
+>>> qp.ops.functions.assert_valid(op)
 
 If the above operator omitted the ``_unflatten`` custom definition, it would raise:
 
@@ -253,12 +253,12 @@ The new gate can be used with PennyLane devices.
 
     from pennylane import numpy as np
 
-    dev = qml.device("default.qubit", wires=["q1", "q2", "q3"])
+    dev = qp.device("default.qubit", wires=["q1", "q2", "q3"])
 
-    @qml.qnode(dev)
+    @qp.qnode(dev)
     def circuit(angle):
         FlipAndRotate(angle, wire_rot="q1", wire_flip="q1")
-        return qml.expval(qml.PauliZ("q1"))
+        return qp.expval(qp.PauliZ("q1"))
 
 >>> a = np.array(3.14)
 >>> circuit(a)
@@ -267,7 +267,7 @@ The new gate can be used with PennyLane devices.
 If all gates used in the decomposition have gradient recipes defined,
 we can even compute gradients of circuits that use the new gate without any extra effort.
 
->>> qml.grad(circuit)(a)
+>>> qp.grad(circuit)(a)
 -0.0015926529164868282
 
 .. note::
@@ -278,8 +278,8 @@ we can even compute gradients of circuits that use the new gate without any extr
 
         def FlipAndRotate(angle, wire_rot, wire_flip=None, do_flip=False):
             if do_flip:
-                qml.PauliX(wires=wire_flip)
-            qml.RX(angle, wires=wire_rot)
+                qp.PauliX(wires=wire_flip)
+            qp.RX(angle, wires=wire_rot)
 
     and call it in the quantum function *as if it was a gate*.
     However, classes allow much more functionality, such as defining the adjoint gate above,
@@ -308,7 +308,7 @@ For example, we can create a new attribute, ``pauli_ops``, like so:
 
 We can check either a string or an Operation for inclusion in this set:
 
->>> qml.PauliX(0) in pauli_ops
+>>> qp.PauliX(0) in pauli_ops
 True
 >>> "Hadamard" in pauli_ops
 False