Merge branch 'master' into fix_adjops_jacobian

.github/CHANGELOG.md

@@ -13,6 +13,9 @@
 
 ### Breaking changes
 
+* Removed all instances of `qml.QubitStateVector`.
+  [(#985)](https://github.com/PennyLaneAI/pennylane-lightning/pull/985)
+
 * Handling for the legacy operator arithmetic (the `Hamiltonian` and `Tensor` classes in PennyLane) is removed.
   [(#994)](https://github.com/PennyLaneAI/pennylane-lightning/pull/994)
 
@@ -44,7 +47,7 @@
 
 This release contains contributions from (in alphabetical order):
 
-Ali Asadi, Joseph Lee, Luis Alfredo Nuñez Meneses, Shuli Shu, Raul Torres, Haochen Paul Wang
+Ali Asadi, Joseph Lee, Luis Alfredo Nuñez Meneses, Andrija Paurevic, Shuli Shu, Raul Torres, Haochen Paul Wang
 
 ---
 

doc/lightning_gpu/device.rst

@@ -68,7 +68,6 @@ Supported operations and observables
     ~pennylane.PSWAP
     ~pennylane.QFT
     ~pennylane.QubitCarry
-    ~pennylane.QubitStateVector
     ~pennylane.QubitSum
     ~pennylane.QubitUnitary
     ~pennylane.Rot

doc/lightning_kokkos/device.rst

@@ -66,7 +66,6 @@ Supported operations and observables
     ~pennylane.PSWAP
     ~pennylane.QFT
     ~pennylane.QubitCarry
-    ~pennylane.QubitStateVector
     ~pennylane.QubitSum
     ~pennylane.QubitUnitary
     ~pennylane.Rot

doc/lightning_qubit/device.rst

@@ -58,7 +58,6 @@ Supported operations and observables
     ~pennylane.PSWAP
     ~pennylane.QFT
     ~pennylane.QubitCarry
-    ~pennylane.QubitStateVector
     ~pennylane.QubitSum
     ~pennylane.QubitUnitary
     ~pennylane.Rot

doc/lightning_tensor/device.rst

@@ -103,7 +103,6 @@ The "lightning.tensor" supports all gate operations supported by PennyLane.
     ~pennylane.PSWAP
     ~pennylane.QFT
     ~pennylane.QubitCarry
-    ~pennylane.QubitStateVector
     ~pennylane.QubitSum
     ~pennylane.QubitUnitary
     ~pennylane.Rot

mpitests/test_adjoint_jacobian.py

@@ -165,18 +165,17 @@ def tol_for_allclose(c_dtype):
 
     @pytest.mark.parametrize("theta", np.linspace(-2 * np.pi, 2 * np.pi, 7))
     @pytest.mark.parametrize("G", [qml.RX, qml.RY, qml.RZ])
-    @pytest.mark.parametrize("stateprep", [qml.QubitStateVector, qml.StatePrep])
     @pytest.mark.parametrize("batch_obs", [True, False])
     def test_pauli_rotation_gradient(
-        self, stateprep, G, theta, batch_obs, dev
+        self, G, theta, batch_obs, dev
     ):  # pylint: disable=too-many-arguments
         """Tests that the automatic gradients of Pauli rotations are correct."""
         random_state = np.array(
             [0.43593284 - 0.02945156j, 0.40812291 + 0.80158023j], requires_grad=False
         )
 
         qs = QuantumScript(
-            [stateprep(random_state, 0), G(theta, 0)],
+            [qml.StatePrep(random_state, 0), G(theta, 0)],
             [qml.expval(qml.PauliZ(0))],
             trainable_params=[1],
         )
@@ -192,16 +191,15 @@ def test_pauli_rotation_gradient(
         assert np.allclose(calculated_val, numeric_val, atol=tol, rtol=0)
 
     @pytest.mark.parametrize("theta", np.linspace(-2 * np.pi, 2 * np.pi, 7))
-    @pytest.mark.parametrize("stateprep", [qml.QubitStateVector, qml.StatePrep])
     @pytest.mark.parametrize("batch_obs", [True, False])
-    def test_Rot_gradient(self, stateprep, theta, batch_obs, dev):
+    def test_Rot_gradient(self, theta, batch_obs, dev):
         """Tests that the device gradient of an arbitrary Euler-angle-parameterized gate is
         correct."""
         params = np.array([theta, theta**3, np.sqrt(2) * theta])
 
         qs = QuantumScript(
             [
-                stateprep(np.array([1.0, -1.0], requires_grad=False) / np.sqrt(2), wires=0),
+                qml.StatePrep(np.array([1.0, -1.0], requires_grad=False) / np.sqrt(2), wires=0),
                 qml.Rot(*params, wires=[0]),
             ],
             [qml.expval(qml.PauliZ(0))],
@@ -761,7 +759,7 @@ def f(params1, params2):
 
 def circuit_ansatz(params, wires):
     """Circuit ansatz containing all the parametrized gates"""
-    qml.QubitStateVector(unitary_group.rvs(2**8, random_state=0)[0], wires=wires)
+    qml.StatePrep(unitary_group.rvs(2**8, random_state=0)[0], wires=wires)
     qml.RX(params[0], wires=wires[0])
     qml.RY(params[1], wires=wires[1])
     qml.adjoint(qml.RX(params[2], wires=wires[2]))

pennylane_lightning/core/src/simulators/lightning_gpu/algorithms/AdjointJacobianGPU.hpp

@@ -312,8 +312,7 @@ class AdjointJacobian final
             PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                         "The operation is not supported using the adjoint "
                         "differentiation method");
-            if ((ops_name[op_idx] == "QubitStateVector") ||
-                (ops_name[op_idx] == "StatePrep") ||
+            if ((ops_name[op_idx] == "StatePrep") ||
                 (ops_name[op_idx] == "BasisState")) {
                 continue;
             }

pennylane_lightning/core/src/simulators/lightning_gpu/algorithms/AdjointJacobianGPUMPI.hpp

@@ -171,8 +171,7 @@ class AdjointJacobianMPI final
                 PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                             "The operation is not supported using the adjoint "
                             "differentiation method");
-                if ((ops_name[op_idx] == "QubitStateVector") ||
-                    (ops_name[op_idx] == "StatePrep") ||
+                if ((ops_name[op_idx] == "StatePrep") ||
                     (ops_name[op_idx] == "BasisState")) {
                     continue;
                 }
@@ -296,8 +295,7 @@ class AdjointJacobianMPI final
             PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                         "The operation is not supported using the adjoint "
                         "differentiation method");
-            if ((ops_name[op_idx] == "QubitStateVector") ||
-                (ops_name[op_idx] == "StatePrep") ||
+            if ((ops_name[op_idx] == "StatePrep") ||
                 (ops_name[op_idx] == "BasisState")) {
                 continue;
             }

pennylane_lightning/core/src/simulators/lightning_gpu/algorithms/tests/Test_AdjointJacobianGPU.cpp

@@ -91,11 +91,10 @@ TEST_CASE("AdjointJacobianGPU::adjointJacobian Op=RY, Obs=X",
     }
 }
 
-TEST_CASE("AdjointJacobianGPU::adjointJacobian Op=[QubitStateVector, "
+TEST_CASE("AdjointJacobianGPU::adjointJacobian Op=["
           "StatePrep, BasisState], Obs=[Z,Z]",
           "[AdjointJacobianGPU]") {
-    const std::string test_ops =
-        GENERATE("QubitStateVector", "StatePrep", "BasisState");
+    const std::string test_ops = GENERATE("StatePrep", "BasisState");
     using StateVectorT = StateVectorCudaManaged<double>;
     using ComplexT = StateVectorT::ComplexT;
     AdjointJacobian<StateVectorT> adj;
@@ -124,7 +123,7 @@ TEST_CASE("AdjointJacobianGPU::adjointJacobian Op=[QubitStateVector, "
                                         ops,           tp};
 
         // apply_operations should be set as false to cover if statement in
-        // adjointJacobian when ops is "QubitStateVector" "StatePrep" or
+        // adjointJacobian when ops is "StatePrep" or
         // "BasisState". If apply_operations is set as true, errors will be
         // thrown out since ops mentioned above is not supported in
         // apply_operation method of sv.

pennylane_lightning/core/src/simulators/lightning_gpu/algorithms/tests/mpi/Test_AdjointJacobianGPUMPI.cpp

@@ -107,11 +107,10 @@ TEST_CASE("AdjointJacobianGPUMPI::adjointJacobianMPI Op=RX, Obs=[Z,Z]",
     }
 }
 
-TEST_CASE("AdjointJacobianGPUMPI::adjointJacobianMPI Op=[QubitStateVector, "
+TEST_CASE("AdjointJacobianGPUMPI::adjointJacobianMPI Op=["
           "StatePrep, BasisState], Obs=[Z,Z]",
           "[AdjointJacobianGPUMPI]") {
-    const std::string test_ops =
-        GENERATE("QubitStateVector", "StatePrep", "BasisState");
+    const std::string test_ops = GENERATE("StatePrep", "BasisState");
     using StateVectorT = StateVectorCudaMPI<double>;
 
     MPIManager mpi_manager(MPI_COMM_WORLD);

pennylane_lightning/core/src/simulators/lightning_kokkos/algorithms/AdjointJacobianKokkos.hpp

@@ -137,8 +137,7 @@ class AdjointJacobian final
             PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                         "The operation is not supported using the adjoint "
                         "differentiation method");
-            if ((ops_name[op_idx] == "QubitStateVector") ||
-                (ops_name[op_idx] == "StatePrep") ||
+            if ((ops_name[op_idx] == "StatePrep") ||
                 (ops_name[op_idx] == "BasisState")) {
                 continue;
             }

pennylane_lightning/core/src/simulators/lightning_qubit/algorithms/AdjointJacobianLQubit.hpp

@@ -293,8 +293,7 @@ class AdjointJacobian final
             PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                         "The operation is not supported using the adjoint "
                         "differentiation method");
-            if ((ops_name[op_idx] == "QubitStateVector") ||
-                (ops_name[op_idx] == "StatePrep") ||
+            if ((ops_name[op_idx] == "StatePrep") ||
                 (ops_name[op_idx] == "BasisState")) {
                 continue; // Ignore them
             }

pennylane_lightning/core/src/simulators/lightning_qubit/algorithms/VectorJacobianProduct.hpp

@@ -120,8 +120,7 @@ class VectorJacobianProduct final
             PL_ABORT_IF(ops.getOpsParams()[op_idx].size() > 1,
                         "The operation is not supported using the adjoint "
                         "differentiation method");
-            if ((ops_name[op_idx] == "QubitStateVector") ||
-                (ops_name[op_idx] == "StatePrep") ||
+            if ((ops_name[op_idx] == "StatePrep") ||
                 (ops_name[op_idx] == "BasisState")) {
                 continue; // ignore them
             }

pennylane_lightning/lightning_gpu/lightning_gpu.py

@@ -78,7 +78,6 @@
 _operations = frozenset(
     {
         "Identity",
-        "QubitStateVector",
         "QubitUnitary",
         "ControlledQubitUnitary",
         "MultiControlledX",

pennylane_lightning/lightning_gpu/lightning_gpu.toml

@@ -49,7 +49,6 @@ GlobalPhase            = { properties = [ "invertible", "controllable", "differe
 [operators.gates.decomp]
 
 BasisState             = {}
-QubitStateVector       = {}
 StatePrep              = {}
 MultiControlledX       = {}
 

pennylane_lightning/lightning_kokkos/lightning_kokkos.py

@@ -67,7 +67,6 @@
 _operations = frozenset(
     {
         "Identity",
-        "QubitStateVector",
         "QubitUnitary",
         "ControlledQubitUnitary",
         "MultiControlledX",

pennylane_lightning/lightning_kokkos/lightning_kokkos.toml

@@ -50,7 +50,6 @@ T                      = { properties = [ "invertible",                 "differe
 
 BasisState             = {}
 MultiControlledX       = {}
-QubitStateVector       = {}
 StatePrep              = {}
 ControlledQubitUnitary = {}
 

tests/lightning_qubit/test_adjoint_jacobian_class.py

@@ -324,7 +324,7 @@ def test_multiple_rx_gradient_expval_hamiltonian(self, tol, lightning_sv):
 def simple_circuit_ansatz(params, wires):
     """Circuit ansatz containing a large circuit"""
     return [
-        qml.QubitStateVector(unitary_group.rvs(2**4, random_state=0)[0], wires=wires),
+        qml.StatePrep(unitary_group.rvs(2**4, random_state=0)[0], wires=wires),
         qml.RX(params[0], wires=wires[0]),
         qml.RY(params[1], wires=wires[1]),
         qml.RZ(params[2], wires=wires[3]),

tests/lightning_qubit/test_measurements_class.py

@@ -957,11 +957,11 @@ def test_sum(self, phi, theta, lightning_sv, tol):
 @pytest.mark.parametrize(
     "op,par,wires,expected",
     [
-        (qml.QubitStateVector, [0, 1], [1], [1, -1]),
-        (qml.QubitStateVector, [0, 1], [0], [-1, 1]),
-        (qml.QubitStateVector, [1.0 / np.sqrt(2), 1.0 / np.sqrt(2)], [1], [1, 0]),
-        (qml.QubitStateVector, [1j / 2.0, np.sqrt(3) / 2.0], [1], [1, -0.5]),
-        (qml.QubitStateVector, [(2 - 1j) / 3.0, 2j / 3.0], [0], [1 / 9.0, 1]),
+        (qml.StatePrep, [0, 1], [1], [1, -1]),
+        (qml.StatePrep, [0, 1], [0], [-1, 1]),
+        (qml.StatePrep, [1.0 / np.sqrt(2), 1.0 / np.sqrt(2)], [1], [1, 0]),
+        (qml.StatePrep, [1j / 2.0, np.sqrt(3) / 2.0], [1], [1, -0.5]),
+        (qml.StatePrep, [(2 - 1j) / 3.0, 2j / 3.0], [0], [1 / 9.0, 1]),
     ],
 )
 def test_state_vector_2_qubit_subset(tol, op, par, wires, expected, lightning_sv):

tests/lightning_qubit/test_state_vector_class.py

@@ -109,8 +109,6 @@ def test_apply_state_vector_with_lightning_handle(tol):
     [
         (qml.BasisState, [0, 0, 1, 0], [1, 0]),
         (qml.BasisState, [0, 0, 0, 1], [1, 1]),
-        (qml.QubitStateVector, [0, 0, 1, 0], [0, 0, 1, 0]),
-        (qml.QubitStateVector, [0, 0, 0, 1], [0, 0, 0, 1]),
         (qml.StatePrep, [0, 0, 1, 0], [0, 0, 1, 0]),
         (qml.StatePrep, [0, 0, 0, 1], [0, 0, 0, 1]),
         (
@@ -140,7 +138,6 @@ def test_apply_operation_state_preparation(tol, operation, expected_output, par)
     "operation,par",
     [
         (qml.BasisState, [1, 0]),
-        (qml.QubitStateVector, [0, 0, 1, 0]),
         (
             qml.StatePrep,
             [1 / math.sqrt(3), 0, 1 / math.sqrt(3), 1 / math.sqrt(3)],

tests/test_adjoint_jacobian.py

@@ -219,15 +219,14 @@ def test_proj_unsupported(self, dev):
 
     @pytest.mark.parametrize("theta", np.linspace(-2 * np.pi, 2 * np.pi, 7))
     @pytest.mark.parametrize("G", [qml.RX, qml.RY, qml.RZ])
-    @pytest.mark.parametrize("stateprep", [qml.QubitStateVector, qml.StatePrep])
-    def test_pauli_rotation_gradient(self, stateprep, G, theta, dev):
+    def test_pauli_rotation_gradient(self, G, theta, dev):
         """Tests that the automatic gradients of Pauli rotations are correct."""
         random_state = np.array(
             [0.43593284 - 0.02945156j, 0.40812291 + 0.80158023j], requires_grad=False
         )
 
         tape = qml.tape.QuantumScript(
-            [stateprep(random_state, 0), G(theta, 0)], [qml.expval(qml.PauliZ(0))]
+            [qml.StatePrep(random_state, 0), G(theta, 0)], [qml.expval(qml.PauliZ(0))]
         )
 
         tape.trainable_params = {1}
@@ -243,14 +242,13 @@ def test_pauli_rotation_gradient(self, stateprep, G, theta, dev):
         assert np.allclose(calculated_val, numeric_val, atol=tol, rtol=0)
 
     @pytest.mark.parametrize("theta", np.linspace(-2 * np.pi, 2 * np.pi, 7))
-    @pytest.mark.parametrize("stateprep", [qml.QubitStateVector, qml.StatePrep])
-    def test_Rot_gradient(self, stateprep, theta, dev):
+    def test_Rot_gradient(self, theta, dev):
         """Tests that the device gradient of an arbitrary Euler-angle-parameterized gate is
         correct."""
         params = np.array([theta, theta**3, np.sqrt(2) * theta])
 
         with qml.tape.QuantumTape() as tape:
-            stateprep(np.array([1.0, -1.0], requires_grad=False) / np.sqrt(2), wires=0)
+            qml.StatePrep(np.array([1.0, -1.0], requires_grad=False) / np.sqrt(2), wires=0)
             qml.Rot(*params, wires=[0])
             qml.expval(qml.PauliZ(0))
 
@@ -1142,7 +1140,7 @@ def f(params1, params2):
 
 def circuit_ansatz(params, wires):
     """Circuit ansatz containing all the parametrized gates"""
-    qml.QubitStateVector(unitary_group.rvs(2**4, random_state=0)[0], wires=wires)
+    qml.StatePrep(unitary_group.rvs(2**4, random_state=0)[0], wires=wires)
     qml.RX(params[0], wires=wires[0])
     qml.RY(params[1], wires=wires[1])
     qml.adjoint(qml.RX(params[2], wires=wires[2]))