Remove code being deprecated in v0.39

Makefile

@@ -76,8 +76,8 @@ environment:
 			$$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-cirq.git#egg=pennylane-cirq;\
 			$$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-qiskit.git#egg=pennylane-qiskit;\
 			$$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane-qulacs.git#egg=pennylane-qulacs;\
-			$$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Lightning --pre --upgrade;\
 			$$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Catalyst --pre --upgrade;\
+			$$PYTHON_VENV_PATH/bin/python -m pip install --extra-index-url https://test.pypi.org/simple/ PennyLane-Lightning --pre --upgrade;\
 			$$PYTHON_VENV_PATH/bin/python -m pip install --upgrade git+https://github.com/PennyLaneAI/pennylane.git#egg=pennylane;\
 		fi;\
 	fi

conf.py

@@ -110,6 +110,9 @@
 
 # Raise PennyLane deprecation warnings as errors
 warnings.filterwarnings("error", category=PennyLaneDeprecationWarning)
+warnings.filterwarnings(
+    "ignore", message="Device will no longer be accessible", category=PennyLaneDeprecationWarning
+)
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]

demonstrations/tutorial_backprop.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2020-08-11T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-06T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Getting Started"
     ],

demonstrations/tutorial_backprop.py

@@ -55,7 +55,7 @@
 Let's have a go implementing the parameter-shift rule manually in PennyLane.
 """
 import pennylane as qml
-from jax import numpy as np
+from jax import numpy as jnp
 from matplotlib import pyplot as plt
 import jax
 
@@ -69,19 +69,28 @@
 # create a device to execute the circuit on
 dev = qml.device("default.qubit", wires=3)
 
+
+def CNOT_ring(wires):
+    """Apply CNOTs in a ring pattern"""
+    n_wires = len(wires)
+
+    for w in wires:
+        qml.CNOT([w % n_wires, (w + 1) % n_wires])
+
+
 @qml.qnode(dev, diff_method="parameter-shift")
 def circuit(params):
     qml.RX(params[0], wires=0)
     qml.RY(params[1], wires=1)
     qml.RZ(params[2], wires=2)
 
-    qml.broadcast(qml.CNOT, wires=[0, 1, 2], pattern="ring")
+    CNOT_ring(wires=[0, 1, 2])
 
     qml.RX(params[3], wires=0)
     qml.RY(params[4], wires=1)
     qml.RZ(params[5], wires=2)
 
-    qml.broadcast(qml.CNOT, wires=[0, 1, 2], pattern="ring")
+    CNOT_ring(wires=[0, 1, 2])
     return qml.expval(qml.PauliY(0) @ qml.PauliZ(2))
 
 
@@ -109,10 +118,10 @@ def circuit(params):
 
 def parameter_shift_term(qnode, params, i):
     shifted = params.copy()
-    shifted = shifted.at[i].add(np.pi/2)
+    shifted = shifted.at[i].add(jnp.pi/2)
     forward = qnode(shifted)  # forward evaluation
 
-    shifted = shifted.at[i].add(-np.pi)
+    shifted = shifted.at[i].add(-jnp.pi)
     backward = qnode(shifted) # backward evaluation
 
     return 0.5 * (forward - backward)
@@ -125,7 +134,7 @@ def parameter_shift_term(qnode, params, i):
 # to loop over the index ``i``:
 
 def parameter_shift(qnode, params):
-    gradients = np.zeros([len(params)])
+    gradients = jnp.zeros([len(params)])
 
     for i in range(len(params)):
         gradients = gradients.at[i].set(parameter_shift_term(qnode, params, i))
@@ -147,7 +156,7 @@ def parameter_shift(qnode, params):
 # Alternatively, we can directly compute quantum gradients of QNodes using
 # PennyLane's built in :mod:`qml.gradients <pennylane.gradients>` module:
 
-print(np.stack(qml.gradients.param_shift(circuit)(params)))
+print(jnp.stack(qml.gradients.param_shift(circuit)(params)))
 
 ##############################################################################
 # If you count the number of quantum evaluations, you will notice that we had to evaluate the circuit
@@ -372,10 +381,10 @@ def circuit(params):
     t = timeit.repeat("grad_qnode_backprop(params)", globals=globals(), number=num, repeat=reps)
     gradient_backprop.append([num_params, min(t) / num])
 
-gradient_shift = np.array(gradient_shift).T
-gradient_backprop = np.array(gradient_backprop).T
-forward_shift = np.array(forward_shift).T
-forward_backprop = np.array(forward_backprop).T
+gradient_shift = jnp.array(gradient_shift).T
+gradient_backprop = jnp.array(gradient_backprop).T
+forward_shift = jnp.array(forward_shift).T
+forward_backprop = jnp.array(forward_backprop).T
 
 ##############################################################################
 # We now import matplotlib, and plot the results.
@@ -419,8 +428,8 @@ def circuit(params):
 # perform a least squares regression to determine the linear best fit/gradient
 # for the normalized time vs. number of parameters
 x = gradient_shift[0]
-m_shift, c_shift = np.polyfit(*gradient_shift, deg=1)
-m_back, c_back = np.polyfit(*gradient_backprop, deg=1)
+m_shift, c_shift = jnp.polyfit(*gradient_shift, deg=1)
+m_back, c_back = jnp.polyfit(*gradient_backprop, deg=1)
 
 ax.plot(x, m_shift * x + c_shift, '--', label=f"{m_shift:.2f}p{c_shift:+.2f}")
 ax.plot(x, m_back * x + c_back, '--', label=f"{m_back:.2f}p{c_back:+.2f}")

demonstrations/tutorial_kernels_module.metadata.json

@@ -21,7 +21,7 @@
         }
     ],
     "dateOfPublication": "2021-06-24T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-05T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Quantum Machine Learning"
     ],

demonstrations/tutorial_kernels_module.py

@@ -250,7 +250,9 @@ def layer(x, params, wires, i0=0, inc=1):
         i += inc
         qml.RY(params[0, j], wires=[wire])
 
-    qml.broadcast(unitary=qml.CRZ, pattern="ring", wires=wires, parameters=params[1])
+    n_wires = len(wires)
+    for p, w in zip(params[1], wires):
+        qml.CRZ(p, wires=[w % n_wires, (w + 1) % n_wires])
 
 
 ##############################################################################

demonstrations/tutorial_learning_from_experiments.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2022-04-18T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-06T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Quantum Machine Learning"
     ],

demonstrations/tutorial_learning_from_experiments.py

@@ -163,7 +163,7 @@
 
 import pennylane as qml
 from pennylane.templates.layers import RandomLayers
-from pennylane import numpy as np
+import numpy as np
 
 np.random.seed(234087)
 
@@ -346,6 +346,12 @@ def process_data(raw_data):
 dev = qml.device("lightning.qubit", wires=qubits * 2, shots=n_shots)
 
 
+def CNOT_sequence(control_wires, target_wires):
+    """Apply CNOTs in sequence using the provided control and target wires"""
+    for c_wire, t_wire in zip(control_wires, target_wires):
+        qml.CNOT([c_wire, t_wire])
+
+
 @qml.qnode(dev)
 def enhanced_circuit(ts=False):
     "implement the enhanced circuit, using a random unitary"
@@ -361,14 +367,10 @@ def enhanced_circuit(ts=False):
     for q in range(qubits):
         qml.Hadamard(wires=q)
 
-    qml.broadcast(
-        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)
-    )
+    CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits))
     RandomLayers(weights, wires=range(0, qubits), rotations=ops, seed=seed)
     RandomLayers(weights, wires=range(qubits, 2 * qubits), rotations=ops, seed=seed)
-    qml.broadcast(
-        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)
-    )
+    CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits))
 
     for q in range(qubits):
         qml.Hadamard(wires=q)
@@ -479,15 +481,11 @@ def enhanced_circuit(ts=False):
     for q in range(qubits):
         qml.Hadamard(wires=q)
 
-    qml.broadcast(
-        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)
-    )
+    CNOT_sequence(control_wires=range(qubits), target_wires=range(qubits, 2 * qubits))
     RandomLayers(weights, wires=range(0, qubits), rotations=ops, seed=seed)
     RandomLayers(weights, wires=range(qubits, 2 * qubits), rotations=ops, seed=seed)
     noise_layer(np.pi / 4)  # added noise layer
-    qml.broadcast(
-        qml.CNOT, pattern=[[qubits + q, q] for q in range(qubits)], wires=range(qubits * 2)
-    )
+    CNOT_sequence(control_wires=range(qubits, 2 * qubits), target_wires=range(qubits))
 
     for q in range(qubits):
         qml.Hadamard(wires=qubits + q)

demonstrations/tutorial_local_cost_functions.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2020-09-09T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-05T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Optimization"
     ],

demonstrations/tutorial_local_cost_functions.py

@@ -241,14 +241,16 @@ def global_cost_simple(rotations):
     for i in range(wires):
         qml.RX(rotations[0][i], wires=i)
         qml.RY(rotations[1][i], wires=i)
-    qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain")
+    for i in range(wires - 1):
+        qml.CNOT([i, i + 1])
     return qml.probs(wires=range(wires))
 
 def local_cost_simple(rotations):
     for i in range(wires):
         qml.RX(rotations[0][i], wires=i)
         qml.RY(rotations[1][i], wires=i)
-    qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain")
+    for i in range(wires - 1):
+        qml.CNOT([i, i + 1])
     return qml.probs(wires=[0])
 
 global_circuit = qml.QNode(global_cost_simple, dev, interface="autograd")
@@ -371,7 +373,8 @@ def tunable_cost_simple(rotations):
     for i in range(wires):
         qml.RX(rotations[0][i], wires=i)
         qml.RY(rotations[1][i], wires=i)
-    qml.broadcast(qml.CNOT, wires=range(wires), pattern="chain")
+    for i in range(wires - 1):
+        qml.CNOT([i, i + 1])
     return qml.probs(range(locality))
 
 def cost_tunable(rotations):

demonstrations/tutorial_mcm_introduction.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2024-05-10T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-05T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Getting Started",
         "Quantum Computing"

demonstrations/tutorial_mcm_introduction.py

@@ -360,7 +360,7 @@ def bell_pair_with_reset(reset):
 magic_state = np.array([1, np.exp(1j * np.pi / 4)]) / np.sqrt(2)
 
 def t_gadget(wire, aux_wire):
-    qml.QubitStateVector(magic_state, aux_wire)
+    qml.StatePrep(magic_state, aux_wire)
     qml.CNOT([wire, aux_wire])
     mcm = qml.measure(aux_wire, reset=True)  # Resetting disentangles aux qubit
     qml.cond(mcm, qml.S)(wire)  # Apply qml.S(wire) if mcm was 1

demonstrations/tutorial_rl_pulse.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2024-04-09T00:00:00+00:00",
-    "dateOfLastModification": "2024-09-04T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Getting Started",
         "Optimization",

demonstrations/tutorial_rl_pulse.py

@@ -224,7 +224,7 @@
 @partial(jax.vmap, in_axes=(0, None, 0, None))
 @qml.qnode(device=device, interface="jax")
 def evolve_states(state, H, params, t):
-    qml.QubitStateVector(state, wires=wires)
+    qml.StatePrep(state, wires=wires)
     qml.evolve(H)(params, t, atol=1e-5)
     return qml.state()
 
@@ -929,7 +929,7 @@ def get_drive(timespan, freq, wire):
 @qml.qnode(device=device, interface="jax")
 def evolve_states(state, params, t):
     params_sq, params_cr = params
-    qml.QubitStateVector(state, wires=wires)
+    qml.StatePrep(state, wires=wires)
     # Single qubit pulses
     qml.evolve(H_int + H_sq_ini)(params_sq, t, atol=1e-5)
 

demonstrations/tutorial_sc_qubits.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2022-03-22T00:00:00+00:00",
-    "dateOfLastModification": "2024-08-06T00:00:00+00:00",
+    "dateOfLastModification": "2024-09-19T00:00:00+00:00",
     "categories": [
         "Quantum Hardware",
         "Quantum Computing"

demonstrations/tutorial_sc_qubits.py

@@ -404,7 +404,7 @@
 # angle :math:`\phi` actually means a rotation by :math:`\omega_r+\phi`. In PennyLane, the operations read:
 
 import pennylane as qml
-from pennylane import numpy as np
+import numpy as np
 import matplotlib.pyplot as plt
 
 # Call the default.gaussian device with 50 shots
@@ -416,14 +416,14 @@
 # Implement displacement and rotation and measure both X and P observables
 
 
-@qml.qnode(dev, interface="autograd")
+@qml.qnode(dev)
 def measure_P_shots(time, state):
     qml.Displacement(epsilon * time, 0, wires=0)
     qml.Rotation((-1) ** state * chi * time, wires=0)
     return qml.sample(qml.QuadP(0))
 
 
-@qml.qnode(dev, interface="autograd")
+@qml.qnode(dev)
 def measure_X_shots(time, state):
     qml.Displacement(epsilon * time, 0, wires=0)
     qml.Rotation((-1) ** state * chi * time, wires=0)
@@ -499,7 +499,7 @@ def measure_X_shots(time, state):
 dev2 = qml.device("lightning.qubit", wires=1)
 
 # Implement Hamiltonian evolution given phase phi and time t, from a given initial state
-@qml.qnode(dev2, interface="autograd")
+@qml.qnode(dev2)
 def H_evolve(state, phi, time):
 
     if state == 1:
@@ -513,7 +513,7 @@ def H_evolve(state, phi, time):
 
 
 # Implement X rotation exactly
-@qml.qnode(dev2, interface="autograd")
+@qml.qnode(dev2)
 def Sc_X_rot(state, phi):
 
     if state == 1:
@@ -524,7 +524,7 @@ def Sc_X_rot(state, phi):
 
 
 # Implement Y rotation exactly
-@qml.qnode(dev2, interface="autograd")
+@qml.qnode(dev2)
 def Sc_Y_rot(state, phi):
 
     if state == 1:
@@ -617,17 +617,17 @@ def Sc_Y_rot(state, phi):
 Two_qubit_H = qml.Hamiltonian(coeffs, ops)
 
 # Implement Hamiltonian evolution for time t and some initial computational basis state
-@qml.qnode(dev3, interface="autograd")
+@qml.qnode(dev3)
 def Sc_ISWAP(basis_state, time):
-    qml.templates.BasisStatePreparation(basis_state, wires=range(2))
+    qml.BasisState(basis_state, wires=range(2))
     ApproxTimeEvolution(Two_qubit_H, time, 1)
     return qml.state()
 
 
 # Implement ISWAP exactly
-@qml.qnode(dev3, interface="autograd")
+@qml.qnode(dev3)
 def iswap(basis_state):
-    qml.templates.BasisStatePreparation(basis_state, wires=range(2))
+    qml.BasisState(basis_state, wires=range(2))
     qml.ISWAP(wires=[0, 1])
     return qml.state()
 
@@ -732,10 +732,10 @@ def cnot_with_iswap():
 # the evolution under this Hamiltonian for a time :math:`t=\tfrac{\pi}{4\Omega}` with :math:`R_x` and :math:`R_y` rotations
 # and a ``qml.Hadamard`` gate:
 #
-@qml.qnode(dev3, interface="autograd")
+@qml.qnode(dev3)
 def H_evolve(state, phi, time):
     # Prepare initial state
-    qml.templates.BasisStatePreparation(state, wires=range(2))
+    qml.BasisState(state, wires=range(2))
     # Define Hamiltonian
     coeffs = [np.cos(phi), np.sin(phi)]
     ops = [qml.PauliZ(0) @ qml.PauliX(1), qml.PauliZ(0) @ qml.PauliY(1)]