Development branch

demonstrations/ensemble_multi_qpu.py

@@ -64,7 +64,9 @@
 # plotting later on. The first two principal components of the data are used.
 
 np.random.seed(1967)
-x, y = zip(*np.random.permutation(list(zip(x, y))))
+
+data_order = np.random.permutation(np.arange(n_samples))
+x, y = x[data_order], y[data_order]
 
 pca = sklearn.decomposition.PCA(n_components=n_features)
 pca.fit(x)

demonstrations/tutorial_adjoint_diff.py

@@ -20,7 +20,7 @@
 """
 
 ##############################################################################
-# *Author: Christina Lee. Posted: 23 Nov 2021. Last updated: 23 Nov 2021.*
+# *Author: Christina Lee. Posted: 23 Nov 2021. Last updated: 20 Jun 2023.*
 #
 # `Classical automatic differentiation <https://en.wikipedia.org/wiki/Automatic_differentiation#The_chain_rule,_forward_and_reverse_accumulation>`__
 # has two methods of calculation: forward and reverse.
@@ -110,21 +110,26 @@ def circuit(a):
 M = qml.PauliX(wires=1)
 
 ##############################################################################
-# We create our state by using the ``"default.qubit"`` methods ``_create_basis_state``
-# and ``_apply_operation``.
+# We will be using internal functions to manipulate the nuts and bolts of a statevector
+# simulation.
+# 
+# Internally, the statevector simulation uses a 2x2x2x... array to represent the state, whereas
+# the result of a measurement ``qml.state()`` flattens this internal representation. Each dimension
+# in the statevector corresponds to a different qubit.
+# 
+# The internal functions ``create_initial_state`` and ``apply_operation``
+# make additional assumptions about their inputs, and will fail or give incorrect results
+# if those assumptions are not met. To work with these simulation tools, all operations should provide
+# a matrix, and all wires must corresponding to dimensions of the statevector. This means all wires must already
+# be integers starting from ``0``, and not exceed the number of dimensions in the state vector.
 #
-# These are private methods that you shouldn't typically use and are subject to change
-# without a deprecation period,
-# but we use them here to illustrate the algorithm.
-#
-# Internally, the device uses a 2x2x2x... array to represent the state, whereas
-# the measurement ``qml.state()`` and the device attribute ``dev.state``
-# flatten this internal representation.
 
-state = dev._create_basis_state(0)
+from pennylane.devices.qubit import create_initial_state, apply_operation
+
+state = create_initial_state((0, 1))
 
 for op in ops:
-    state = dev._apply_operation(state, op)
+    state = apply_operation(op, state)
 
 print(state)
 
@@ -145,7 +150,7 @@ def circuit(a):
 # Using the ``state`` calculated above, we can create these :math:`|b\rangle` and :math:`|k\rangle`
 # vectors.
 
-bra = dev._apply_operation(state, M)
+bra = apply_operation(M, state)
 ket = state
 
 ##############################################################################
@@ -171,17 +176,17 @@ def circuit(a):
 # and gotten the exact same results.  Here, the subscript :math:`n` is used to indicate that :math:`U_n`
 # was moved to the bra side of the expression.  Let's calculate that instead:
 
-bra_n = dev._create_basis_state(0)
+bra_n = create_initial_state((0, 1))
 
 for op in ops:
-    bra_n = dev._apply_operation(bra_n, op)
-bra_n = dev._apply_operation(bra_n, M)
-bra_n = dev._apply_operation(bra_n, qml.adjoint(ops[-1]))
+    bra_n = apply_operation(op, bra_n)
+bra_n = apply_operation(M, bra_n)
+bra_n = apply_operation(qml.adjoint(ops[-1]), bra_n)
 
-ket_n = dev._create_basis_state(0)
+ket_n = create_initial_state((0, 1))
 
 for op in ops[:-1]: # don't apply last operation
-    ket_n = dev._apply_operation(ket_n, op)
+    ket_n = apply_operation(op, ket_n)
 
 M_expval_n = np.vdot(bra_n, ket_n)
 print(M_expval_n)
@@ -210,13 +215,13 @@ def circuit(a):
 #
 # Let's call this the "version 2" method.
 
-bra_n_v2 = dev._apply_operation(state, M)
+bra_n_v2 = apply_operation(M, state)
 ket_n_v2 = state
 
 adj_op = qml.adjoint(ops[-1])
 
-bra_n_v2 = dev._apply_operation(bra_n_v2, adj_op)
-ket_n_v2 = dev._apply_operation(ket_n_v2, adj_op)
+bra_n_v2 = apply_operation(adj_op, bra_n_v2)
+ket_n_v2 = apply_operation(adj_op, ket_n_v2)
 
 M_expval_n_v2 = np.vdot(bra_n_v2, ket_n_v2)
 print(M_expval_n_v2)
@@ -240,13 +245,13 @@ def circuit(a):
 # For each iteration, we move an operation from the ket side to the bra side.
 # We start near the center at :math:`U_n` and reverse through the operations list until we reach :math:`U_0`.
 
-bra_loop = dev._apply_operation(state, M)
+bra_loop = apply_operation(M, state)
 ket_loop = state
 
 for op in reversed(ops):
     adj_op = qml.adjoint(op)
-    bra_loop = dev._apply_operation(bra_loop, adj_op)
-    ket_loop = dev._apply_operation(ket_loop, adj_op)
+    bra_loop = apply_operation(adj_op, bra_loop)
+    ket_loop = apply_operation(adj_op, ket_loop)
     print(np.vdot(bra_loop, ket_loop))
 
 ##############################################################################
@@ -345,27 +350,26 @@ def circuit(a):
 # We loop over the reversed operations, just as before.  But if the operation has a parameter,
 # we calculate its derivative and append it to a list before moving on. Since the ``operation_derivative``
 # function spits back out a matrix instead of an operation,
-# we have to use ``dev._apply_unitary`` instead to create :math:`|\tilde{k}_i\rangle`.
+# we have to use :class:`~pennylane.QubitUnitary` instead to create :math:`|\tilde{k}_i\rangle`.
 
-bra = dev._apply_operation(state, M)
+bra = apply_operation(M, state)
 ket = state
 
 grads = []
 
 for op in reversed(ops):
     adj_op = qml.adjoint(op)
-    ket = dev._apply_operation(ket, adj_op)
+    ket = apply_operation(adj_op, ket)
 
     # Calculating the derivative
     if op.num_params != 0:
         dU = qml.operation.operation_derivative(op)
-
-        ket_temp = dev._apply_unitary(ket, dU, op.wires)
+        ket_temp = apply_operation(qml.QubitUnitary(dU, op.wires), ket)
 
         dM = 2 * np.real(np.vdot(bra, ket_temp))
         grads.append(dM)
 
-    bra = dev._apply_operation(bra, adj_op)
+    bra = apply_operation(adj_op, bra)
 
 
 # Finally reverse the order of the gradients

demonstrations/tutorial_fermionic_operators.metadata.json

@@ -0,0 +1,56 @@
+{
+    "title": "Fermionic operators",
+    "authors": [
+        {
+            "id": "soran_jahangiri"
+        }
+    ],
+    "dateOfPublication": "2023-06-27T00:00:00",
+    "dateOfLastModification": "2023-06-27T00:00:00",
+    "categories": [
+        "Quantum Chemistry"
+    ],
+    "tags": [],
+    "previewImages": [
+        {
+            "type": "thumbnail",
+            "uri": "/_images/thumbnail_tutorial_fermionic_operators.png"
+        },
+        {
+            "type": "large_thumbnail",
+            "uri": "/_static/large_demo_thumbnails/thumbnail_large_fermionic_operators.png"
+        },
+        {
+            "type": "hero_image",
+            "uri": "/_static/hero_illustrations/fermionic_ops_hero.png"
+        }
+    ],
+    "seoDescription": "Construct Hamiltonians and other observables using fermionic creation and annihilation operators.",
+    "doi": "",
+    "canonicalURL": "/qml/demos/tutorial_fermionic_operators",
+    "references": [
+        {
+            "id": "surjan",
+            "title": "Second Quantized Approach to Quantum Chemistry",
+            "authors": "Peter R. Surjan",
+            "year": "1989",
+            "publisher": "Springer-Verlag",
+            "doi": "",
+            "url": ""
+        }
+    ],
+    "basedOnPapers": [],
+    "referencedByPapers": [],
+    "relatedContent": [
+        {
+            "type": "demonstration",
+            "id": "tutorial_quantum_chemistry",
+            "weight": 1.0
+        },
+        {
+            "type": "demonstration",
+            "id": "tutorial_vqe",
+            "weight": 1.0
+        }
+    ]
+}