qml -> qp in tests + matches (#2751)

**Context:**
In order to reposition PennyLane and Catalyst for general quantum
computing (rather than quantum machine learning) PennyLane will be
imported as `qp` (rather than `qml`). These changes will be made
per-module in Catalyst.

**Description of the Change:**
Update references to PennyLane in `tests`.

**Benefits:**
Improve user perception of the uses of PennyLane + Catalyst.

**Possible Drawbacks:**

**Related GitHub Issues:**

[sc-117236]
[sc-117694]

---------

Co-authored-by: Yushao Chen (Jerry) <chenys13@outlook.com>

Author: kipawaa

frontend/catalyst/__init__.py

@@ -97,12 +97,12 @@
 loop), and will raise a warning informing of the failure.
 
 >>> @qjit(autograph=True)
-... @qml.qnode(dev)
+... @qp.qnode(dev)
 ... def f():
 ...     x = ["0.1", "0.2", "0.3"]
 ...     for i in range(3):
-...         qml.RX(float(x[i]), wires=i)
-...     return qml.expval(qml.PauliZ(0))
+...         qp.RX(float(x[i]), wires=i)
+...     return qp.expval(qp.PauliZ(0))
 Warning: Tracing of an AutoGraph converted for loop failed with an exception:
 ...
 If you intended for the conversion to happen, make sure that the (now dynamic)
@@ -114,12 +114,12 @@
 >>> catalyst.autograph_strict_conversion = False
 >>> catalyst.autograph_ignore_fallbacks = True
 >>> @qjit(autograph=True)
-... @qml.qnode(dev)
+... @qp.qnode(dev)
 ... def f():
 ...     x = ["0.1", "0.2", "0.3"]
 ...     for i in range(3):
-...         qml.RX(float(x[i]), wires=i)
-...     return qml.expval(qml.PauliZ(0))
+...         qp.RX(float(x[i]), wires=i)
+...     return qp.expval(qp.PauliZ(0))
 >>> f()
 array(0.99500417)
 """
@@ -136,14 +136,14 @@
 loop), and will automatically fallback to interpreting the control flow
 logic at compile-time via Python:
 
->>> dev = qml.device("lightning.qubit", wires=1)
+>>> dev = qp.device("lightning.qubit", wires=1)
 >>> @qjit(autograph=True)
-... @qml.qnode(dev)
+... @qp.qnode(dev)
 ... def f():
 ...     params = ["0", "1", "2"]
 ...     for x in params:
-...         qml.RY(int(x) * jnp.pi / 4, wires=0)
-...     return qml.expval(qml.PauliZ(0))
+...         qp.RY(int(x) * jnp.pi / 4, wires=0)
+...     return qp.expval(qp.PauliZ(0))
 >>> f()
 array(-0.70710678)
 
@@ -152,12 +152,12 @@
 
 >>> catalyst.autograph_strict_conversion = True
 >>> @qjit(autograph=True)
-... @qml.qnode(dev)
+... @qp.qnode(dev)
 ... def f():
 ...     params = ["0", "1", "2"]
 ...     for x in params:
-...         qml.RY(int(x) * jnp.pi / 4, wires=0)
-...     return qml.expval(qml.PauliZ(0))
+...         qp.RY(int(x) * jnp.pi / 4, wires=0)
+...     return qp.expval(qp.PauliZ(0))
 AutoGraphError: Could not convert the iteration target ['0', '1', '2'] to array
 while processing the following with AutoGraph:
   File "<ipython-input-44-dbae11e6d745>", line 7, in f

frontend/catalyst/api_extensions/differentiation.py

@@ -908,10 +908,10 @@ def _check_qnode_against_grad_method(f: QNode, method: str, jaxpr: Jaxpr):
     ):
         raise DifferentiableCompileError(
             "The parameter-shift method can only be used for QNodes "
-            "which return either qml.expval or qml.probs."
+            "which return either qp.expval or qp.probs."
         )
 
     if f.diff_method == "adjoint" and any(prim not in [expval_p] for prim in return_ops):
         raise DifferentiableCompileError(
-            "The adjoint method can only be used for QNodes which return qml.expval."
+            "The adjoint method can only be used for QNodes which return qp.expval."
         )

frontend/catalyst/api_extensions/quantum_operators.py

@@ -151,7 +151,7 @@ def circuit():
     """
     EvaluationContext.check_is_tracing("catalyst.measure can only be used from within @qjit.")
     EvaluationContext.check_is_quantum_tracing(
-        "catalyst.measure can only be used from within a qml.qnode."
+        "catalyst.measure can only be used from within a qp.qnode."
     )
     cur_trace = EvaluationContext.get_current_trace()
     wires = list(wires) if isinstance(wires, (list, tuple)) else [wires]
@@ -408,7 +408,7 @@ def __init__(self, target, lazy):
             self.single_op = False
             self.instantiated = False
         else:
-            raise ValueError(f"Expected a callable or a qml.Operator, not {target}")
+            raise ValueError(f"Expected a callable or a qp.Operator, not {target}")
 
     def __call__(self, *args, **kwargs):
         if self.single_op:
@@ -563,7 +563,7 @@ def __init__(self, target, control, control_values, work_wires, work_wire_type="
             self.single_op = False
             self.instantiated = False
         else:
-            raise ValueError(f"Expected a callable or a qml.Operator, not {target}")
+            raise ValueError(f"Expected a callable or a qp.Operator, not {target}")
 
     def __call__(self, *args, **kwargs):
         if self.single_op:

frontend/catalyst/jax_primitives.py

@@ -24,7 +24,7 @@
 
 import jax
 import numpy as np
-import pennylane as qml
+import pennylane as qp
 from jax._src import core, source_info_util, util
 from jax._src.core import pytype_aval_mappings
 from jax._src.interpreters import partial_eval as pe
@@ -426,7 +426,7 @@ def my_circuit(angle: float):
     ), "Decomposition rules with `qreg` do not require `num_params`."
 
     if op_type is not None and not isinstance(op_type, str):
-        if issubclass(op_type, qml.operation.Operation):
+        if issubclass(op_type, qp.operation.Operation):
             op_type = op_type.__name__
         else:
             raise ValueError("op_type must be a string or a pennylane operator.")
@@ -586,12 +586,12 @@ def _quantum_kernel_lowering(ctx, *args, call_jaxpr, qnode, pipelines=None):
     Args:
       ctx: LoweringRuleContext
       *args: List[mlir.Value] corresponding to argument values
-      qnode: qml.Qnode
+      qnode: qp.Qnode
       call_jaxpr: jaxpr representing fn
     Returns:
       List[mlir.Value] corresponding
     """
-    assert isinstance(qnode, qml.QNode), "This function expects qnodes"
+    assert isinstance(qnode, qp.QNode), "This function expects qnodes"
     pipelines = pipelines or ()
 
     func_op = lower_callable(ctx, qnode, call_jaxpr, pipelines)
@@ -1988,7 +1988,7 @@ def custom_measurement_staging_rule(
 
     shape = _merge_dyn_shape(static_shape, dynamic_shape)
     if not dynamic_shape:
-        # Some PL transforms, like @qml.batch_params, do not support dynamic shapes yet
+        # Some PL transforms, like @qp.batch_params, do not support dynamic shapes yet
         # Therefore we still keep static shapes when possible
         # This can be removed, and all avals turned into DShapedArrays, when
         # dynamic program capture in PL is complete

frontend/catalyst/jax_primitives_utils.py

@@ -16,7 +16,7 @@
 import copy
 import functools
 
-import pennylane as qml
+import pennylane as qp
 from jax._src import core, util
 from jax._src.lib.mlir import ir
 from jax.interpreters import mlir
@@ -37,7 +37,7 @@ def _all_expval(call_jaxpr: core.ClosedJaxpr) -> bool:
     return True
 
 
-def _calculate_diff_method(qn: qml.QNode, call_jaxpr: core.ClosedJaxpr):
+def _calculate_diff_method(qn: qp.QNode, call_jaxpr: core.ClosedJaxpr):
     diff_method = str(qn.diff_method)
     if diff_method != "best":
         return diff_method
@@ -78,7 +78,7 @@ def lower_jaxpr(ctx, jaxpr, metadata=None, fn=None):
         FuncOp
     """
 
-    if fn is None or isinstance(fn, qml.QNode):
+    if fn is None or isinstance(fn, qp.QNode):
         equation = get_call_equation(jaxpr)
         call_jaxpr = equation.params["call_jaxpr"]
         pipelines = equation.params.get("pipelines")
@@ -112,7 +112,7 @@ def lower_callable(ctx, callable_, call_jaxpr, pipelines=(), metadata=None):
     """
     if pipelines is None:
         pipelines = tuple()
-    if isinstance(callable_, qml.QNode):
+    if isinstance(callable_, qp.QNode):
         return get_or_create_qnode_funcop(ctx, callable_, call_jaxpr, pipelines, metadata=metadata)
     return get_or_create_funcop(ctx, callable_, call_jaxpr, pipelines, metadata=metadata)
 
@@ -182,7 +182,7 @@ def lower_callable_to_funcop(ctx, callable_, call_jaxpr):
 
     func_op = mlir.lower_jaxpr_to_fun(**kwargs)
 
-    if isinstance(callable_, qml.QNode):
+    if isinstance(callable_, qp.QNode):
         func_op.attributes["quantum.node"] = ir.UnitAttr.get()
 
         diff_method = _calculate_diff_method(callable_, call_jaxpr)
@@ -210,7 +210,7 @@ def get_or_create_qnode_funcop(ctx, callable_, call_jaxpr, pipelines, metadata):
 
     Args:
       ctx: LoweringRuleContext
-      callable_: qml.Qnode
+      callable_: qp.Qnode
       call_jaxpr: jaxpr representing callable_
     Returns:
       FuncOp
@@ -236,12 +236,12 @@ def lower_qnode_to_funcop(ctx, callable_, call_jaxpr, pipelines):
 
     Args:
       ctx: LoweringRuleContext
-      callable_: qml.Qnode
+      callable_: qp.Qnode
       call_jaxpr: jaxpr representing callable_
     Returns:
       FuncOp
     """
-    assert isinstance(callable_, qml.QNode), "This function expects qnodes"
+    assert isinstance(callable_, qp.QNode), "This function expects qnodes"
 
     name = "module_" + callable_.__name__
     # pylint: disable-next=no-member