def test_simple_hadamard(self): N = 1 H_d = sigmaz() H_c = [sigmax()] qc = QubitCircuit(N) qc.add_gate("SNOT", 0) # test load_circuit, with verbose info num_tslots = 10 evo_time = 10 test = OptPulseProcessor(N, H_d, H_c) tlist, coeffs = test.load_circuit( qc, num_tslots=num_tslots, evo_time=evo_time, verbose=True) # test run_state rho0 = qubit_states(1, [0]) plus = (qubit_states(1, [0]) + qubit_states(1, [1])).unit() result = test.run_state(rho0) assert_allclose(fidelity(result.states[-1], plus), 1, rtol=1.0e-6) # test add/remove ctrl test.add_ctrl(sigmay()) test.remove_ctrl(0) assert_( len(test.ctrls) == 1, msg="Method of remove_ctrl could be wrong.") assert_allclose(test.drift, H_d) assert_( sigmay() in test.ctrls, msg="Method of remove_ctrl could be wrong.")
def TestNoise(self): """ Test for Processor with noise """ # setup and fidelity without noise init_state = qubit_states(2, [0, 0, 0, 0]) tlist = np.array([0., np.pi/2.]) a = destroy(2) proc = Processor(N=2) proc.add_control(sigmax(), targets=1) proc.pulses[0].tlist = tlist proc.pulses[0].coeff = np.array([1]) result = proc.run_state(init_state=init_state) assert_allclose( fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])), 1, rtol=1.e-7) # decoherence noise dec_noise = DecoherenceNoise([0.25*a], targets=1) proc.add_noise(dec_noise) result = proc.run_state(init_state=init_state) assert_allclose( fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])), 0.981852, rtol=1.e-3) # white random noise proc.noise = [] white_noise = RandomNoise(0.2, np.random.normal, loc=0.1, scale=0.1) proc.add_noise(white_noise) result = proc.run_state(init_state=init_state)
def test_multi_qubits(self): """ Test for multi-qubits system. """ N = 3 H_d = tensor([sigmaz()] * 3) H_c = [] # test empty ctrls num_tslots = 30 evo_time = 10 test = OptPulseProcessor(N) test.add_drift(H_d, [0, 1, 2]) test.add_control(tensor([sigmax(), sigmax()]), cyclic_permutation=True) # test periodically adding ctrls sx = sigmax() iden = identity(2) # print(test.ctrls) # print(Qobj(tensor([sx, iden, sx]))) assert_(Qobj(tensor([sx, iden, sx])) in test.ctrls) assert_(Qobj(tensor([iden, sx, sx])) in test.ctrls) assert_(Qobj(tensor([sx, sx, iden])) in test.ctrls) test.add_control(sigmax(), cyclic_permutation=True) test.add_control(sigmay(), cyclic_permutation=True) # test pulse genration for cnot gate, with kwargs qc = [tensor([identity(2), cnot()])] test.load_circuit(qc, num_tslots=num_tslots, evo_time=evo_time, min_fid_err=1.0e-6) rho0 = qubit_states(3, [1, 1, 1]) rho1 = qubit_states(3, [1, 1, 0]) result = test.run_state(rho0, options=Options(store_states=True)) assert_(fidelity(result.states[-1], rho1) > 1 - 1.0e-6)
def test_simple_hadamard(self): """ Test for optimizing a simple hadamard gate """ N = 1 H_d = sigmaz() H_c = sigmax() qc = QubitCircuit(N) qc.add_gate("SNOT", 0) # test load_circuit, with verbose info num_tslots = 10 evo_time = 10 test = OptPulseProcessor(N, drift=H_d) test.add_control(H_c, targets=0) tlist, coeffs = test.load_circuit(qc, num_tslots=num_tslots, evo_time=evo_time, verbose=True) # test run_state rho0 = qubit_states(1, [0]) plus = (qubit_states(1, [0]) + qubit_states(1, [1])).unit() result = test.run_state(rho0) assert_allclose(fidelity(result.states[-1], plus), 1, rtol=1.0e-6) # test add/remove ctrl test.add_control(sigmay()) test.remove_pulse(0) assert_(len(test.pulses) == 1, msg="Method of remove_pulse could be wrong.") assert_allclose(test.drift.drift_hamiltonians[0].qobj, H_d) assert_(sigmay() in test.ctrls, msg="Method of remove_pulse could be wrong.")
def TestChooseSolver(self): # setup and fidelity without noise init_state = qubit_states(2, [0, 0, 0, 0]) tlist = np.array([0., np.pi/2.]) a = destroy(2) proc = Processor(N=2) proc.add_control(sigmax(), targets=1) proc.pulses[0].tlist = tlist proc.pulses[0].coeff = np.array([1]) result = proc.run_state(init_state=init_state, solver="mcsolve") assert_allclose( fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])), 1, rtol=1.e-7)
def testQubitStates(self): """ Tests the qubit_states function. """ psi0_a = basis(2, 0) psi0_b = qubit_states() assert_(psi0_a == psi0_b) psi1_a = basis(2, 1) psi1_b = qubit_states(states=[1]) assert_(psi1_a == psi1_b) psi01_a = tensor(psi0_a, psi1_a) psi01_b = qubit_states(N=2, states=[0, 1]) assert_(psi01_a == psi01_b)
def test_multi_qubits(self): N = 3 H_d = tensor([sigmaz()]*3) H_c = [] # test empty ctrls num_tslots = 30 evo_time = 10 test = OptPulseProcessor(N, H_d, H_c) test.add_ctrl(tensor([sigmax(), sigmax()]), cyclic_permutation=True) # test periodically adding ctrls sx = sigmax() iden = identity(2) assert_(Qobj(tensor([sx, iden, sx])) in test.ctrls) assert_(Qobj(tensor([iden, sx, sx])) in test.ctrls) assert_(Qobj(tensor([sx, sx, iden])) in test.ctrls) test.add_ctrl(sigmax(), cyclic_permutation=True) test.add_ctrl(sigmay(), cyclic_permutation=True) # test pulse genration for cnot gate, with kwargs qc = [tensor([identity(2), cnot()])] test.load_circuit(qc, num_tslots=num_tslots, evo_time=evo_time, min_fid_err=1.0e-6) rho0 = qubit_states(3, [1, 1, 1]) rho1 = qubit_states(3, [1, 1, 0]) result = test.run_state( rho0, options=Options(store_states=True)) print(result.states[-1]) print(rho1) assert_(fidelity(result.states[-1], rho1) > 1-1.0e-6) # test save and read coeffs test.save_coeff("qutip_test_multi_qubits.txt") test2 = OptPulseProcessor(N, H_d, H_c) test2.drift = test.drift test2.ctrls = test.ctrls test2.read_coeff("qutip_test_multi_qubits.txt") os.remove("qutip_test_multi_qubits.txt") assert_(np.max((test.coeffs-test2.coeffs)**2) < 1.0e-13) result = test2.run_state(rho0,) assert_(fidelity(result.states[-1], rho1) > 1-1.0e-6)
def TestNoise(self): """ Test for Processor with noise """ # setup and fidelity without noise rho0 = qubit_states(2, [0, 0, 0, 0]) tlist = np.array([0., np.pi / 2.]) a = destroy(2) proc = Processor(N=2) proc.tlist = tlist proc.coeffs = np.array([1]).reshape((1, 1)) proc.add_ctrl(sigmax(), targets=1) result = proc.run_state(rho0=rho0) assert_allclose(fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])), 1, rtol=1.e-7) # decoherence noise dec_noise = DecoherenceNoise([0.25 * a], targets=1) proc.add_noise(dec_noise) result = proc.run_state(rho0=rho0) assert_allclose(fidelity(result.states[-1], qubit_states(2, [0, 1, 0, 0])), 0.981852, rtol=1.e-3) # white noise with internal/external operators proc.noise = [] white_noise = RandomNoise(loc=0.1, scale=0.1) proc.add_noise(white_noise) result = proc.run_state(rho0=rho0) proc.noise = [] white_noise = RandomNoise(loc=0.1, scale=0.1, ops=sigmax(), targets=1) proc.add_noise(white_noise) result = proc.run_state(rho0=rho0)
def hst_measurement(state: Qobj, qcircuit, sample_size=1): """Hilbert-Schmidt test""" N = len(state.dims[0]) qc = QubitCircuit(N * 2) qc.add_circuit(qcircuit) if state.isket: statein = tensor(state, qubit_states(N)) elif state.isbra: statein = tensor(state, qubit_states(N).dag()) elif state.isoper: statein = tensor(state, ket2dm(qubit_states(N))) state_preps = statein.transform( gate_sequence_product(bell_prep(N, True).propagators())) state_out = state_preps.transform(gate_sequence_product(qc.propagators())) state_postps = state_out.transform( gate_sequence_product(bell_prep(N).propagators())) prob = com_measure(state_postps) hst = np.random.choice(4**N, sample_size, p=prob) mresult = [ state_index_number(state_postps.dims[0], result) for result in hst ] return mresult # raw output
from numpy import pi from qutip import tensor from qutip.operators import sigmax, identity from qutip.qip.circuit import QubitCircuit from qutip.qip.gates import hadamard_transform, cnot, snot, swap, \ gate_sequence_product from qutip.qip.qubits import qubit_states from qutip.states import basis, fock print(basis(N=4, n=0)) print("\n") print(fock(N=4, n=0)) print("\n") print(qubit_states(N=2, states=[0, 0])) print("\n") x = sigmax() print(x) print("\n") ket_zero = qubit_states(N=1, states=[0]) print(ket_zero) print("\n") print(x * ket_zero) print("\n") print(tensor([identity(N=2), hadamard_transform(N=1)]))
from qutip.tensor import tensor # %% [markdown] # Three samples that reduce the dimension of a quantum state are given # %% Generate random input N = 4 # number of qubits n = 2 # number of reduced qubits # Random inputs (qubit state) Input = rand_ket(2**N, dims=[[2] * N, [1] * N]) # Input2 = rand_ket(2**N,dims=[[2]*N,[1]*N]) # Input = 0.99*Input*Input.dag() + 0.01*Input2*Input2.dag() # To add some inpurity # Reference State r_state = qubit_states(n) # 0 state # %% Reduce the dimension of a quantum state by bring one of the subsystem to 0 state print("quantum dimensionality reduction") vc1 = vcirc(N) for L in np.arange(1, 5): # number of ansatz vc1.add_ansatz(np.zeros(N * 3)) # add one layer t0 = time() x0 = np.zeros(N * 3 * L) # init parameters res = circ_maximize(x0, Input, vc1, fid_ref, r_state, [2, 3],
import pytest import numpy as np from variational_circuit.measure import * from variational_circuit.vcirc import * from qutip.states import bell_state from qutip.qip.qubits import qubit_states from qutip.metrics import fidelity zero_state = qubit_states(2) zero_qubit = qubit_states(1) bell = bell_state() vc = vcirc(2) def test_add_ansatz(): vc.add_ansatz([0, 0, 0, 0, 0, 0]) vc.add_ansatz([0, 0, 0, 0, 0, 0]) assert vc.structures == [('regular', None, {}), ('regular', None, {})] assert (vc.ansatzes[0].para == np.array([0, 0, 0, 0, 0, 0])).all() assert (vc.ansatzes[1].para == np.array([0, 0, 0, 0, 0, 0])).all() def test_update_circuit(): vc.update_ansatzes([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) assert (vc.ansatzes[0].para == np.array([1, 1, 1, 1, 1, 1])).all() assert (vc.ansatzes[1].para == np.array([1, 1, 1, 1, 1, 1])).all()