Update stateprep decomposition in tutorial_how_to_quantum_just_in_time_compile_vqe_catalyst demo

demonstrations/tutorial_classically_boosted_vqe.metadata.json

@@ -9,7 +9,7 @@
         }
     ],
     "dateOfPublication": "2022-10-31T00:00:00+00:00",
-    "dateOfLastModification": "2024-12-13T00:00:00+00:00",
+    "dateOfLastModification": "2025-01-23T00:00:00+00:00",
     "categories": [
         "Quantum Chemistry"
     ],

demonstrations/tutorial_classically_boosted_vqe.py

@@ -449,7 +449,7 @@ def hadamard_test(Uq, Ucl, component="real"):
 
     qml.Hadamard(wires=[0])
     qml.ControlledQubitUnitary(
-        Uq.conjugate().T @ Ucl, control_wires=[0], wires=wires[1:]
+        Uq.conjugate().T @ Ucl, wires=wires
     )
     qml.Hadamard(wires=[0])
 

demonstrations/tutorial_how_to_quantum_just_in_time_compile_vqe_catalyst.metadata.json

@@ -10,6 +10,7 @@
     ],
     "dateOfPublication": "2024-04-26T00:00:00+00:00",
     "dateOfLastModification": "2024-11-12T00:00:00+00:00",
+
     "categories": [
         "Quantum Machine Learning",
         "Optimization",

demonstrations/tutorial_how_to_quantum_just_in_time_compile_vqe_catalyst.py

@@ -123,7 +123,7 @@ def cost(params):
 @qml.qjit
 @qml.qnode(dev)
 def cost(params):
-    qml.BasisState.compute_decomposition(hf, wires=range(qubits))
+    qml.BasisState(hf, wires=range(qubits))
     qml.DoubleExcitation(params[0], wires=[0, 1, 2, 3])
     qml.DoubleExcitation(params[1], wires=[0, 1, 4, 5])
     return qml.expval(H)

demonstrations/tutorial_noisy_circuits.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2021-02-22T00:00:00+00:00",
-    "dateOfLastModification": "2024-10-07T00:00:00+00:00",
+    "dateOfLastModification": "2024-12-18T00:00:00+00:00",
     "categories": [
         "Getting Started"
     ],

demonstrations/tutorial_noisy_circuits.py

@@ -144,12 +144,13 @@ def bitflip_circuit(p):
     qml.CNOT(wires=[0, 1])
     qml.BitFlip(p, wires=0)
     qml.BitFlip(p, wires=1)
-    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1)), qml.state()
 
 
 ps = [0.001, 0.01, 0.1, 0.2]
 for p in ps:
-    print(f"QNode output for bit flip probability {p} is {bitflip_circuit(p):.4f}")
+    result = bitflip_circuit(p)
+    print(f"QNode output for bit flip probability {p} is {result[0]:.4f}")
 
 
 ######################################################################
@@ -158,7 +159,7 @@ def bitflip_circuit(p):
 # mitigation and error correction are so important. We can use PennyLane to look under the hood and
 # see the output state of the circuit for the largest noise parameter
 
-print(f"Output state for bit flip probability {p} is \n{np.real(dev.state)}")
+print(f"Output state for bit flip probability {p} is \n{result[1]}")
 
 ######################################################################
 # Besides the bit flip channel, PennyLane supports several other noisy channels that are commonly

demonstrations/tutorial_odegen.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2023-12-12T00:00:00+00:00",
-    "dateOfLastModification": "2024-10-07T00:00:00+00:00",
+    "dateOfLastModification": "2025-01-28T00:00:00+00:00",
     "categories": [
         "Optimization",
         "Quantum Computing",

demonstrations/tutorial_odegen.py

@@ -45,10 +45,10 @@
 that can be executed on hardware.
 
 
-SPS & ODEgen
-------------
+SPS and ODEgen gradient rules
+-----------------------------
 
-Let us start by deriving both the SPS rule and ODEgen.
+Let us start by deriving both the SPS and ODEgen rules.
 
 We are interested in cost functions of the form
 
@@ -163,6 +163,7 @@
 Let us define it in PennyLane and also import some libraries that we are going to need for this demo.
 
 """
+
 import pennylane as qml
 import numpy as np
 import jax.numpy as jnp
@@ -181,21 +182,21 @@
 
 ##############################################################################
 # We are going to consider a system of transmon qubits described by the Hamiltonian
-# 
+#
 # .. math:: H(\theta, t) = - \sum_i \frac{\omega_i}{2} Z_i + \sum_i \Omega_i(t) \sin(\nu_i t + \phi_i(t)) Y_i + \sum_{q, p \in \mathcal{C}} \frac{g_{qp}}{2} (X_i X_p + Y_i Y_p).
-# 
-# The first term describes the single qubits with frequencies :math:`\omega_i.` 
-# The second term describes the driving with drive amplitudes :math:`\Omega_i,` drive frequencies :math:`\nu_i` and phases :math:`\phi_i.` 
-# You can check out our :doc:`recent demo on driving qubits on OQC's Lucy </demos/oqc_pulse>` if 
+#
+# The first term describes the single qubits with frequencies :math:`\omega_i.`
+# The second term describes the driving with drive amplitudes :math:`\Omega_i,` drive frequencies :math:`\nu_i` and phases :math:`\phi_i.`
+# You can check out our :doc:`recent demo on driving qubits on OQC's Lucy </demos/oqc_pulse>` if
 # you want to learn more about the details of controlling transmon qubits.
-# The third term describes the coupling between neighboring qubits. We only have two qubits and a simple topology of 
+# The third term describes the coupling between neighboring qubits. We only have two qubits and a simple topology of
 # :math:`\mathcal{C} = \{(0, 1)\},` hence only one coupling constant :math:`g_{01}.`
-# The coupling is necessary to generate entanglement, which is achieved with cross-resonant driving in fixed-coupling 
+# The coupling is necessary to generate entanglement, which is achieved with cross-resonant driving in fixed-coupling
 # transmon systems, as is the case here.
-# 
-# We will use realistic parameters for the transmons, taken from the `coaxmon design paper <https://arxiv.org/abs/1905.05670>`_ [#Patterson]_ 
+#
+# We will use realistic parameters for the transmons, taken from the `coaxmon design paper <https://arxiv.org/abs/1905.05670>`_ [#Patterson]_
 # (this is the blue-print for the transmon qubits in OQC's Lucy that you can :doc:`access on a pulse level in PennyLane </demos/oqc_pulse>`).
-# In order to prepare the singlet ground state, we will perform a cross-resonance pulse, i.e. driving one qubit at its coupled neighbor's 
+# In order to prepare the singlet ground state, we will perform a cross-resonance pulse, i.e. driving one qubit at its coupled neighbor's
 # frequency for entanglement generation (see [#Patterson]_ or [#Krantz]_) while simultaneously driving the other qubit on resonance.
 # We choose a gate time of :math:`100 \text{ ns}.` We will use a piecewise constant function :func:`~pennylane.pulse.pwc` to parametrize both
 # the amplitude :math:`\Omega_i(t)` and the phase :math:`\phi_i(t)` in time, with ``t_bins = 10`` time bins to allow for enough flexibility in the evolution.
@@ -221,7 +222,7 @@ def wrapped(p, t):
 H_pulse += drive_field(T_CR, qubit_freq[0]) * qml.PauliY(wires[1]) # off-resonance driving of qubit 1
 
 ##############################################################################
-# We can now define the cost function that computes the expectation value of 
+# We can now define the cost function that computes the expectation value of
 # the Heisenberg Hamiltonian after evolving the state with the parametrized pulse Hamiltonian.
 # We then define the two separate qnodes with ODEgen and SPS as their differentiation methods, respectively.
 
@@ -235,7 +236,14 @@ def qnode0(params):
 value_and_grad_jax = jax.jit(jax.value_and_grad(qnode_jax))
 
 num_split_times = 8
-qnode_sps = qml.QNode(qnode0, dev, interface="jax", diff_method=qml.gradients.stoch_pulse_grad, use_broadcasting=True, num_split_times=num_split_times)
+gradient_kwargs = {"use_broadcasting": True, "num_split_times": num_split_times}
+qnode_sps = qml.QNode(
+    qnode0,
+    dev,
+    interface="jax",
+    diff_method=qml.gradients.stoch_pulse_grad,
+    gradient_kwargs=gradient_kwargs,
+)
 value_and_grad_sps = jax.value_and_grad(qnode_sps)
 
 qnode_odegen = qml.QNode(qnode0, dev, interface="jax", diff_method=qml.gradients.pulse_odegen)
@@ -304,12 +312,12 @@ def partial_step(grad_circuit, opt_state, theta):
 
 
 ##############################################################################
-# We see that with analytic gradients (ODEgen), we can reach the ground state energy within 100 epochs, whereas with SPS gradients we cannot find the path 
+# We see that with analytic gradients (ODEgen), we can reach the ground state energy within 100 epochs, whereas with SPS gradients we cannot find the path
 # towards the minimum due to the stochasticity of the gradient estimates. Note that both optimizations start from the same (random) initial point.
 # This picture solidifies when repeating this procedure for multiple runs from different random initializations, as was demonstrated in [#Kottmann]_.
 #
 # We also want to make sure that this is a fair comparison in terms of quantum resources. In the case of ODEgen, we maximally have :math:`\mathcal{R}_\text{ODEgen} = 2 (4^n - 1) = 30` expectation values.
-# For SPS we have :math:`2 N_g N_s = 32` (due to :math:`N_g = 2` and :math:`N_s=8` time samples per gradient that we chose in ``num_split_times`` above). Thus, overall, we require fewer 
+# For SPS we have :math:`2 N_g N_s = 32` (due to :math:`N_g = 2` and :math:`N_s=8` time samples per gradient that we chose in ``num_split_times`` above). Thus, overall, we require fewer
 # quantum resources for ODEgen gradients while achieving better performance.
 #
 # Conclusion
@@ -323,9 +331,8 @@ def partial_step(grad_circuit, opt_state, theta):
 # Running VQE using ODEgen on hardware has recently been demonstrated in [#Kottmann]_ and you can directly find `the code here <https://github.com/XanaduAI/Analytic_Pulse_Gradients/tree/main/VQE_OQC>`_.
 
 
-
 ##############################################################################
-# 
+#
 # References
 # ----------
 #

demonstrations/tutorial_pulse_programming101.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2023-03-08T00:00:00+00:00",
-    "dateOfLastModification": "2024-10-07T00:00:00+00:00",
+    "dateOfLastModification": "2025-02-14T00:00:00+00:00",
     "categories": [
         "Quantum Hardware",
         "Quantum Computing"

demonstrations/tutorial_pulse_programming101.py

@@ -322,15 +322,21 @@ def wrapped(p, t):
 
 ##############################################################################
 # Now we define the ``qnode`` that computes the expectation value of the molecular Hamiltonian.
+# We need to wrap the ``qnode`` in a function so that we can convert the expectation value to a real number.
+# This will enable use to make use of gradient descent methods that require real-valued loss functions.
 
 dev = qml.device("default.qubit", wires=range(n_wires))
 
-@qml.qnode(dev, interface="jax")
 def qnode(theta, t=duration):
-    qml.BasisState(jnp.array(data.tapered_hf_state), wires=H_obj.wires)
-    qml.evolve(H_pulse)(params=(*theta, *theta), t=t)
-    return qml.expval(H_obj)
 
+    @qml.qnode(dev)
+    def _qnode_inner(theta, t=duration):
+        qml.BasisState(jnp.array(data.tapered_hf_state), wires=H_obj.wires)
+        qml.evolve(H_pulse)(params=(*theta, *theta), t=t)
+        return qml.expval(H_obj)
+
+    expectation_value = _qnode_inner(theta, t)  # Execute the qnode
+    return jnp.real(expectation_value)  # Typecast to real number
 
 value_and_grad = jax.jit(jax.value_and_grad(qnode))
 

demonstrations/tutorial_testing_symmetry.metadata.json

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2023-01-24T00:00:00+00:00",
-    "dateOfLastModification": "2024-11-06T00:00:00+00:00",
+    "dateOfLastModification": "2025-01-23T00:00:00+00:00",
     "categories": [
         "Algorithms",
         "Quantum Computing"

demonstrations/tutorial_testing_symmetry.py

@@ -308,14 +308,14 @@ def prep_plus():
 
 # Implement controlled symmetry operations on system
 def CU_sys():
-    qml.ControlledQubitUnitary(c_mat @ c_mat, control_wires=[aux[0]], wires=system)
-    qml.ControlledQubitUnitary(c_mat, control_wires=[aux[1]], wires=system)
+    qml.ControlledQubitUnitary(c_mat @ c_mat, wires=[aux[0]] + list(system))
+    qml.ControlledQubitUnitary(c_mat, wires=[aux[1]] + list(system))
 
 
 # Implement controlled symmetry operations on copy
 def CU_cpy():
-    qml.ControlledQubitUnitary(c_mat @ c_mat, control_wires=[aux[0]], wires=copy)
-    qml.ControlledQubitUnitary(c_mat, control_wires=[aux[1]], wires=copy)
+    qml.ControlledQubitUnitary(c_mat @ c_mat, wires=[aux[0]] + list(copy))
+    qml.ControlledQubitUnitary(c_mat, wires=[aux[1]] + list(copy))
 
 ######################################################################
 # Let’s combine everything and actually run our circuit!