def test_args(self): """Test that the plugin requires correct arguments""" self.logTestName() with self.assertRaisesRegex( TypeError, "missing 1 required positional argument: 'wires'"): qml.device("default.qubit")
def test_outdated_API(self, n): """Test exception raised if plugin that targets an old API is loaded""" self.logTestName() with self.assertRaisesRegex(qml.DeviceError, 'plugin requires PennyLane versions'): qml.device('default.qubit', wires=0)
def test_initiatlization_via_pennylane(self): for short_name in [ 'qiskit.aer', 'qiskit.legacy', 'qiskit.basicaer', 'qiskit.ibm' ]: try: qml.device(short_name, wires=2, ibmqx_token=IBMQX_TOKEN) except DeviceError: raise Exception( "This test is expected to fail until pennylane-qiskit is installed." )
def test_aer_device(self): if self.args.provider in ['aer', 'all']: import qiskit try: for backend in qiskit.Aer.backends(): qml.device('qiskit.aer', wires=1, backend=backend) except DeviceError: raise Exception( "This test is expected to fail until pennylane-qiskit is installed." )
def test_unsupported_observables(self): """Test error is raised with unsupported observables""" self.logTestName() dev = qml.device('default.gaussian', wires=2) obs = set(dev._expectation_map.keys()) all_obs = { m[0] for m in inspect.getmembers(qml.expval, inspect.isclass) } for g in all_obs - obs: op = getattr(qml.expval, g) if op.num_wires == 0: wires = [0] else: wires = list(range(op.num_wires)) @qml.qnode(dev) def circuit(*x): """Test quantum function""" x = prep_par(x, op) return op(*x, wires=wires) with self.assertRaisesRegex( qml.DeviceError, "Expectation {} not supported on device default.gaussian". format(g)): x = np.random.random([op.num_params]) circuit(*x)
def test_simple_circuits(self): default_qubit = qml.device('default.qubit', wires=4) for dev in self.devices: gates = [ qml.PauliX(wires=0), qml.PauliY(wires=1), qml.PauliZ(wires=2), qml.S(wires=3), qml.T(wires=0), qml.RX(2.3, wires=1), qml.RY(1.3, wires=2), qml.RZ(3.3, wires=3), qml.Hadamard(wires=0), qml.Rot(0.1, 0.2, 0.3, wires=1), qml.CRot(0.1, 0.2, 0.3, wires=[2, 3]), qml.Toffoli(wires=[0, 1, 2]), qml.SWAP(wires=[1, 2]), qml.CSWAP(wires=[1, 2, 3]), qml.U1(1.0, wires=0), qml.U2(1.0, 2.0, wires=2), qml.U3(1.0, 2.0, 3.0, wires=3), qml.CRX(0.1, wires=[1, 2]), qml.CRY(0.2, wires=[2, 3]), qml.CRZ(0.3, wires=[3, 1]), qml.CZ(wires=[2, 3]), qml.QubitUnitary(np.array([[1, 0], [0, 1]]), wires=2), ] layers = 3 np.random.seed(1967) gates_per_layers = [ np.random.permutation(gates).numpy() for _ in range(layers) ] for obs in { qml.PauliX(wires=0), qml.PauliY(wires=0), qml.PauliZ(wires=0), qml.Identity(wires=0), qml.Hadamard(wires=0) }: if obs.name in dev.observables: def circuit(): """4-qubit circuit with layers of randomly selected gates and random connections for multi-qubit gates.""" qml.BasisState(np.array([1, 0, 0, 0]), wires=[0, 1, 2, 3]) for gates in gates_per_layers: for gate in gates: if gate.name in dev.operations: qml.apply(gate) return qml.expval(obs) qnode_default = qml.QNode(circuit, default_qubit) qnode = qml.QNode(circuit, dev) assert np.allclose(qnode(), qnode_default(), atol=1e-3)
def test_execution(self): """Tests the StronglyEntanglingCircuit for various parameters.""" np.random.seed(0) outcomes = [] for num_wires in range(2, 4): for num_layers in range(1, 3): dev = qml.device('default.qubit', wires=num_wires) weights = np.random.randn(num_layers, num_wires, 3) @qml.qnode(dev) def circuit(weights, x=None): qml.BasisState(x, wires=range(num_wires)) qml.template.StronglyEntanglingCircuit( weights, True, wires=range(num_wires)) return qml.expval.PauliZ(0) outcomes.append( circuit(weights, x=np.array(np.random.randint(0, 1, num_wires)))) res = np.array(outcomes) expected = np.array([-0.29242496, 0.22129055, 0.07540091, -0.77626557]) self.assertAllAlmostEqual(res, expected, delta=self.tol)
def test_exceptions(self): """test that exceptions are correctly raised""" dev = qml.device('default.gaussian', wires=1) varphi = [0.42342] @qml.qnode(dev) def circuit(varphi, mesh): qml.template.Interferometer(theta=None, phi=None, varphi=varphi, mesh=mesh, wires=0) return qml.expval.MeanPhoton(0) with self.assertRaisesRegex( QuantumFunctionError, "The mesh parameter influences the " "circuit architecture and can not be passed as a QNode parameter." ): circuit(varphi, 'rectangular') @qml.qnode(dev) def circuit(varphi, bs): qml.template.Interferometer(theta=None, phi=None, varphi=varphi, beamsplitter=bs, wires=0) return qml.expval.MeanPhoton(0) with self.assertRaisesRegex( QuantumFunctionError, "The beamsplitter parameter influences the " "circuit architecture and can not be passed as a QNode parameter." ): circuit(varphi, 'clements')
def test_four_mode_triangular(self): """Test that a 4 mode interferometer using triangular mesh gives the correct gates""" N = 4 wires = range(N) dev = qml.device('default.gaussian', wires=N) theta = [0.321, 0.4523, 0.21321, 0.123, 0.5234, 1.23] phi = [0.234, 0.324, 0.234, 1.453, 1.42341, -0.534] varphi = [0.42342, 0.234, 0.4523] def circuit_tria(varphi): qml.template.Interferometer(theta, phi, varphi, mesh='triangular', wires=wires) return [qml.expval.MeanPhoton(w) for w in wires] qnode = qml.QNode(circuit_tria, dev) self.assertAllAlmostEqual(qnode(varphi), [0] * N, delta=self.tol) queue = qnode.queue self.assertEqual(len(queue), 9) expected_bs_wires = [[2, 3], [1, 2], [0, 1], [2, 3], [1, 2], [2, 3]] for idx, op in enumerate(qnode.queue[:6]): self.assertTrue(isinstance(op, qml.Beamsplitter)) self.assertAllEqual(op.parameters, [theta[idx], phi[idx]]) self.assertAllEqual(op.wires, expected_bs_wires[idx]) for idx, op in enumerate(qnode.queue[6:]): self.assertTrue(isinstance(op, qml.Rotation)) self.assertAllEqual(op.parameters, [varphi[idx]]) self.assertAllEqual(op.wires, [idx])
def test_two_mode_rect_overparameterised(self): """Test that a two mode interferometer using the rectangular mesh correctly gives a beamsplitter+2 rotation gates when requested""" N = 2 wires = range(N) dev = qml.device('default.gaussian', wires=N) theta = [0.321] phi = [0.234] varphi = [0.42342, 0.543] def circuit(varphi): qml.template.Interferometer(theta, phi, varphi, wires=wires) return [qml.expval.MeanPhoton(w) for w in wires] qnode = qml.QNode(circuit, dev) self.assertAllAlmostEqual(qnode(varphi), [0, 0], delta=self.tol) queue = qnode.queue self.assertEqual(len(queue), 3) self.assertTrue(isinstance(qnode.queue[0], qml.Beamsplitter)) self.assertAllEqual(qnode.queue[0].parameters, theta + phi) self.assertTrue(isinstance(qnode.queue[1], qml.Rotation)) self.assertAllEqual(qnode.queue[1].parameters, [varphi[0]]) self.assertTrue(isinstance(qnode.queue[2], qml.Rotation)) self.assertAllEqual(qnode.queue[2].parameters, [varphi[1]])
def test_ibm_device(self): if self.args.provider in ['ibm', 'all']: import qiskit qiskit.IBMQ.enable_account(token=IBMQX_TOKEN) backends = qiskit.IBMQ.backends() qiskit.IBMQ.disable_accounts() try: for backend in backends: qml.device('qiskit.ibm', wires=1, ibmqx_token=IBMQX_TOKEN, backend=backend) except DeviceError: raise Exception( "This test is expected to fail until pennylane-qiskit is installed." )
def test_unsupported_observables(self): """Test error is raised with unsupported observables""" self.logTestName() dev = qml.device("default.qubit", wires=2) obs = set(dev._observable_map.keys()) all_obs = set(qml.ops.__all_obs__) for g in all_obs - obs: op = getattr(qml.ops, g) if op.num_wires == 0: wires = [0] else: wires = list(range(op.num_wires)) @qml.qnode(dev) def circuit(*x): """Test quantum function""" x = prep_par(x, op) return qml.expval(op(*x, wires=wires)) with self.assertRaisesRegex( qml.DeviceError, "Observable {} not supported on device default.qubit". format(g), ): x = np.random.random([op.num_params]) circuit(*x)
def setUp(self): self.default_devices = ['default.qubit', 'default.gaussian'] self.dev = {} for device_name in self.default_devices: self.dev[device_name] = qml.device(device_name, wires=2)
def test_unsupported_gates(self): """Test error is raised with unsupported gates""" self.logTestName() dev = qml.device("default.qubit", wires=2) gates = set(dev._operation_map.keys()) all_gates = set(qml.ops.__all_ops__) for g in all_gates - gates: op = getattr(qml.ops, g) if op.num_wires == 0: wires = [0] else: wires = list(range(op.num_wires)) @qml.qnode(dev) def circuit(*x): """Test quantum function""" x = prep_par(x, op) op(*x, wires=wires) if issubclass(op, qml.operation.CV): return qml.expval(qml.X(0)) return qml.expval(qml.PauliZ(0)) with self.assertRaisesRegex( qml.DeviceError, "Gate {} not supported on device default.qubit".format(g), ): x = np.random.random([op.num_params]) circuit(*x)
def test_first_order_cv(self, tol): """Test variance of a first order CV expectation value""" dev = qml.device('default.gaussian', wires=1) @qml.qnode(dev) def circuit(r, phi): qml.Squeezing(r, 0, wires=0) qml.Rotation(phi, wires=0) return qml.var(qml.X(0)) r = 0.543 phi = -0.654 var = circuit(r, phi) expected = np.exp(2 * r) * np.sin(phi)**2 + np.exp( -2 * r) * np.cos(phi)**2 assert np.allclose(var, expected, atol=tol, rtol=0) # circuit jacobians gradA = circuit.jacobian([r, phi], method='A') gradF = circuit.jacobian([r, phi], method='F') expected = np.array([ 2 * np.exp(2 * r) * np.sin(phi)**2 - 2 * np.exp(-2 * r) * np.cos(phi)**2, 2 * np.sinh(2 * r) * np.sin(2 * phi) ]) assert np.allclose(gradA, expected, atol=tol, rtol=0) assert np.allclose(gradF, expected, atol=tol, rtol=0)
def test_qnode_evaluation_agrees(self): "Tests that simple example is consistent." self.logTestName() dev = qml.device('default.qubit', wires=2) @qml.qnode(dev, interface='autograd') def circuit(phi, theta): qml.RX(phi[0], wires=0) qml.RY(phi[1], wires=1) qml.CNOT(wires=[0, 1]) qml.PhaseShift(theta[0], wires=0) return qml.expval(qml.PauliZ(0)) @qml.qnode(dev, interface='tfe') def circuit_tfe(phi, theta): qml.RX(phi[0], wires=0) qml.RY(phi[1], wires=1) qml.CNOT(wires=[0, 1]) qml.PhaseShift(theta[0], wires=0) return qml.expval(qml.PauliZ(0)) phi = [0.5, 0.1] theta = [0.2] phi_t = tfe.Variable(phi) theta_t = tfe.Variable(theta) autograd_eval = circuit(phi, theta) tfe_eval = circuit_tfe(phi_t, theta_t) self.assertAllAlmostEqual(autograd_eval, tfe_eval.numpy(), delta=self.tol)
def test_keywordarg_not_differentiated(self, tol): """Tests that qnodes do not differentiate w.r.t. keyword arguments.""" a, b = 0.5, 0.54 def circuit1(weights, x=0.3): qml.QubitStateVector(np.array([1, 0, 1, 1]) / np.sqrt(3), wires=[0, 1]) qml.Rot(weights[0], weights[1], x, wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1)) dev = qml.device('default.qubit', wires=2) circuit1 = qml.QNode(circuit1, dev) def circuit2(weights): qml.QubitStateVector(np.array([1, 0, 1, 1]) / np.sqrt(3), wires=[0, 1]) qml.Rot(weights[0], weights[1], 0.3, wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1)) circuit2 = qml.QNode(circuit2, dev) res1 = circuit1.jacobian([np.array([a, b])]) res2 = circuit2.jacobian([np.array([a, b])]) assert np.allclose(res1, res2, atol=tol, rtol=0)
def test_differentiate_second_third_positional(self, tol): """Tests that the second and third positional arguments are differentiated.""" def circuit4(a, b, c): qml.RX(b, wires=0) qml.RX(c, wires=1) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)) dev = qml.device('default.qubit', wires=2) circuit4 = qml.QNode(circuit4, dev) a = 0.7418 b = -5. c = np.pi / 7 circuit_output = circuit4(a, b, c) expected_output = np.array([[np.cos(b), np.cos(c)]]) assert np.allclose(circuit_output, expected_output, atol=tol, rtol=0) # circuit jacobians circuit_jacobian = circuit4.jacobian([a, b, c]) expected_jacobian = np.array([[0., -np.sin(b), 0.], [0., 0., -np.sin(c)]]) assert np.allclose(circuit_jacobian, expected_jacobian, atol=tol, rtol=0)
def test_multiple_expectation_jacobian_positional(self, tol): """Tests that qnodes using positional arguments return correct gradients for multiple expectation values.""" a, b, c = 0.5, 0.54, 0.3 def circuit(x, y, z): qml.QubitStateVector(np.array([1, 0, 1, 1]) / np.sqrt(3), wires=[0, 1]) qml.Rot(x, y, z, wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1)) dev = qml.device('default.qubit', wires=2) circuit = qml.QNode(circuit, dev) # compare our manual Jacobian computation to theoretical result # Note: circuit.jacobian actually returns a full jacobian in this case res = circuit.jacobian(np.array([a, b, c])) assert np.allclose(self.expected_jacobian(a, b, c), res, atol=tol, rtol=0) # compare our manual Jacobian computation to autograd # not sure if this is the intended usage of jacobian jac0 = qml.jacobian(circuit, 0) jac1 = qml.jacobian(circuit, 1) jac2 = qml.jacobian(circuit, 2) res = np.stack([jac0(a, b, c), jac1(a, b, c), jac2(a, b, c)]).T assert np.allclose(self.expected_jacobian(a, b, c), res, atol=tol, rtol=0)
def test_multiple_expectation_jacobian_array(self, tol): """Tests that qnodes using an array argument return correct gradients for multiple expectation values.""" a, b, c = 0.5, 0.54, 0.3 def circuit(weights): qml.QubitStateVector(np.array([1, 0, 1, 1]) / np.sqrt(3), wires=[0, 1]) qml.Rot(weights[0], weights[1], weights[2], wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1)) dev = qml.device('default.qubit', wires=2) circuit = qml.QNode(circuit, dev) res = circuit.jacobian([np.array([a, b, c])]) assert np.allclose(self.expected_jacobian(a, b, c), res, atol=tol, rtol=0) jac = qml.jacobian(circuit, 0) res = jac(np.array([a, b, c])) assert np.allclose(self.expected_jacobian(a, b, c), res, atol=tol, rtol=0)
def test_multidim_array(self, s, tol): """Tests that arguments which are multidimensional arrays are properly evaluated and differentiated in QNodes.""" multidim_array = np.reshape(b, s) def circuit(w): qml.RX(w[np.unravel_index(0, s)], wires=0) # b[0] qml.RX(w[np.unravel_index(1, s)], wires=1) # b[1] qml.RX(w[np.unravel_index(2, s)], wires=2) # ... qml.RX(w[np.unravel_index(3, s)], wires=3) qml.RX(w[np.unravel_index(4, s)], wires=4) qml.RX(w[np.unravel_index(5, s)], wires=5) qml.RX(w[np.unravel_index(6, s)], wires=6) qml.RX(w[np.unravel_index(7, s)], wires=7) return tuple(qml.expval(qml.PauliZ(idx)) for idx in range(len(b))) dev = qml.device('default.qubit', wires=8) circuit = qml.QNode(circuit, dev) # circuit evaluations circuit_output = circuit(multidim_array) expected_output = np.cos(b) assert np.allclose(circuit_output, expected_output, atol=tol, rtol=0) # circuit jacobians circuit_jacobian = circuit.jacobian([multidim_array]) expected_jacobian = -np.diag(np.sin(b)) assert np.allclose(circuit_jacobian, expected_jacobian, atol=tol, rtol=0)
def test_caching(self): """Test that the circuit structure does not change on subsequent evalutions with caching turned on """ dev = qml.device('default.qubit', wires=2) def circuit(x, c=None): qml.RX(x, wires=0) for i in range(c.val): qml.RX(x, wires=i) return qml.expval(qml.PauliZ(0)) circuit = qml.QNode(circuit, dev, cache=True) # first evaluation circuit(0, c=0) # check structure assert len(circuit.queue) == 1 # second evaluation circuit(0, c=1) # check structure assert len(circuit.queue) == 1
def test_obs_queue(self): """Check that peaking at the obs queue works correctly""" self.logTestName() # queue some gates queue = [] queue.append(qml.RX(0.543, wires=[0], do_queue=False)) queue.append(qml.CNOT(wires=[0, 1], do_queue=False)) dev = qml.device('default.qubit', wires=2) # outside of an execution context, error will be raised with self.assertRaisesRegex( ValueError, "Cannot access the observable value queue outside of the execution context!" ): dev.obs_queue # inside of the execute method, it works with self.assertLogs(level='INFO') as l: dev.execute(queue, [qml.expval(qml.PauliX(0, do_queue=False))]) self.assertEqual(len(l.output), 1) self.assertEqual(len(l.records), 1) self.assertIn('INFO:root:[<pennylane.ops.qubit.PauliX object', l.output[0])
def test_differentiate_positional_multidim(self, tol): """Tests that all positional arguments are differentiated when they are multidimensional.""" def circuit(a, b): qml.RX(a[0], wires=0) qml.RX(a[1], wires=1) qml.RX(b[2, 1], wires=2) return qml.expval(qml.PauliZ(0)), qml.expval( qml.PauliZ(1)), qml.expval(qml.PauliZ(2)) dev = qml.device('default.qubit', wires=3) circuit = qml.QNode(circuit, dev) a = np.array([-np.sqrt(2), -0.54]) b = np.array([np.pi / 7] * 6).reshape([3, 2]) circuit_output = circuit(a, b) expected_output = np.cos(np.array([[a[0], a[1], b[-1, 0]]])) assert np.allclose(circuit_output, expected_output, atol=tol, rtol=0) # circuit jacobians circuit_jacobian = circuit.jacobian([a, b]) expected_jacobian = np.array([ [-np.sin(a[0])] + [0.] * 7, # expval 0 [0., -np.sin(a[1])] + [0.] * 6, # expval 1 [0.] * 2 + [0.] * 5 + [-np.sin(b[2, 1])] ]) # expval 2 assert np.allclose(circuit_jacobian, expected_jacobian, atol=tol, rtol=0)
def test_supported_gates(self): """Test that all supported gates work correctly""" self.logTestName() a = 0.312 dev = qml.device('default.gaussian', wires=2) for g, qop in dev._operation_map.items(): log.debug('\tTesting gate %s...', g) self.assertTrue(dev.supported(g)) dev.reset() op = getattr(qml.ops, g) if op.num_wires == 0: wires = list(range(2)) else: wires = list(range(op.num_wires)) @qml.qnode(dev) def circuit(*x): """Reference quantum function""" qml.Displacement(a, 0, wires=[0]) op(*x, wires=wires) return qml.expval.X(0) # compare to reference result def reference(*x): """reference circuit""" if g == 'GaussianState': return x[0][0] if g == 'Displacement': alpha = x[0] * np.exp(1j * x[1]) return (alpha + a).real * np.sqrt(2 * hbar) if 'State' in g: mu, _ = qop(*x, hbar=hbar) return mu[0] S = qop(*x) # calculate the expected output if op.num_wires == 1: S = block_diag(S, np.identity(2))[:, [0, 2, 1, 3]][[0, 2, 1, 3]] return (S @ np.array([a.real, a.imag, 0, 0]) * np.sqrt(2 * hbar))[0] if g == 'GaussianState': p = [ np.array([0.432, 0.123, 0.342, 0.123]), np.diag([0.5234] * 4) ] else: p = [0.432423, -0.12312, 0.324][:op.num_params] self.assertAllEqual(circuit(*p), reference(*p))
def test_load_default_qubit_device(self): """Test that the default plugin loads correctly""" self.logTestName() dev = qml.device("default.qubit", wires=2) self.assertEqual(dev.num_wires, 2) self.assertEqual(dev.shots, 0) self.assertEqual(dev.short_name, "default.qubit")
def test_load_default_gaussian_device(self): """Test that the default plugin loads correctly""" self.logTestName() dev = qml.device('default.gaussian', wires=2, hbar=2) self.assertEqual(dev.num_wires, 2) self.assertEqual(dev.shots, 0) self.assertEqual(dev.hbar, 2) self.assertEqual(dev.short_name, 'default.gaussian')
def test_qnode_cv_gradient_methods(self): """Tests the gradient computation methods on CV circuits.""" # we can only use the 'A' method on parameters which only affect gaussian operations # that are not succeeded by nongaussian operations par = [0.4, -2.3] dev = qml.device('default.qubit', wires=2) def check_methods(qf, d): q = qml.QNode(qf, dev) # NOTE: the default plugin is a discrete (qubit) simulator, it cannot # execute CV gates, but the QNode can be constructed q.construct(par) assert q.grad_method_for_par == d def qf(x, y): qml.Displacement(x, 0, wires=[0]) qml.CubicPhase(0.2, wires=[0]) qml.Squeezing(0.3, y, wires=[1]) qml.Rotation(1.3, wires=[1]) # nongaussian succeeding x but not y # TODO when QNode uses a DAG to describe the circuit, uncomment this line #qml.Kerr(0.4, [0]) return qml.expval(qml.X(0)), qml.expval(qml.X(1)) check_methods(qf, {0: 'F', 1: 'A'}) def qf(x, y): qml.Displacement(x, 0, wires=[0]) qml.CubicPhase(0.2, wires=[0]) # nongaussian succeeding x qml.Squeezing(0.3, x, wires=[1]) # x affects gates on both wires, y unused qml.Rotation(1.3, wires=[1]) return qml.expval(qml.X(0)), qml.expval(qml.X(1)) check_methods(qf, {0: 'F'}) def qf(x, y): qml.Displacement(x, 0, wires=[0]) qml.Displacement(1.2, y, wires=[0]) qml.Beamsplitter(0.2, 1.7, wires=[0, 1]) qml.Rotation(1.9, wires=[0]) qml.Kerr(0.3, wires=[ 1 ]) # nongaussian succeeding both x and y due to the beamsplitter return qml.expval(qml.X(0)), qml.expval(qml.X(1)) check_methods(qf, {0: 'F', 1: 'F'}) def qf(x, y): qml.Kerr(y, wires=[1]) qml.Displacement(x, 0, wires=[0]) qml.Beamsplitter(0.2, 1.7, wires=[0, 1]) return qml.expval(qml.X(0)), qml.expval(qml.X(1)) check_methods(qf, {0: 'A', 1: 'F'})
def test_initiatlization_via_pennylane(self): for short_name in [ 'projectq.simulator', 'projectq.classical', 'projectq.ibm' ]: try: dev = dev = qml.device(short_name, wires=2, user='******', password='******', verbose=True) except DeviceError: raise Exception("This test is expected to fail until pennylane-pq is installed.")
def test_error_analytic_second_order_cv(self): """Test exception raised if attempting to use a second order observable to compute the variance derivative analytically""" dev = qml.device('default.gaussian', wires=1) @qml.qnode(dev) def circuit(a): qml.Displacement(a, 0, wires=0) return qml.var(qml.NumberOperator(0)) with pytest.raises(ValueError, match=r"cannot be used with the parameter\(s\) \{0\}"): circuit.jacobian([1.], method='A')