def test_eigen_sorting(self): """Test estate mappings""" X = array([[0, 1], [1, 0]]) Y = array([[0, -1j], [1j, 0]]) Z = array([[1, 0], [0, -1]]) simple_ham = { 'h_str': ['a*X0', 'b*Y0', 'c*Z0'], 'vars': { 'a': 0.1, 'b': 0.1, 'c': 1 }, 'qub': { '0': 2 } } ham_model = HamiltonianModel.from_dict(simple_ham) # check norm for estate in ham_model._estates: self.assertAlmostEqual(norm(estate), 1) # check actually an eigenstate mat = 0.1 * X + 0.1 * Y + 1 * Z for idx, eval in enumerate(ham_model._evals): diff = mat @ ham_model._estates[:, idx] - eval * ham_model._estates[:, idx] self.assertAlmostEqual(norm(diff), 0) # Same test but with strongly off-diagonal hamiltonian, which should raise warning simple_ham = { 'h_str': ['a*X0', 'b*Y0', 'c*Z0'], 'vars': { 'a': 100, 'b': 32.1, 'c': 0.12 }, 'qub': { '0': 2 } } ham_model = HamiltonianModel.from_dict(simple_ham) # check norm for estate in ham_model._estates: self.assertAlmostEqual(norm(estate), 1) # check actually an eigenstate mat = 100 * X + 32.1 * Y + 0.12 * Z for idx, eval in enumerate(ham_model._evals): diff = mat @ ham_model._estates[:, idx] - eval * ham_model._estates[:, idx] self.assertAlmostEqual(norm(diff), 0)
def _system_model_2Q(self, j): """Constructs a model for a 2 qubit system with a U channel controlling coupling and no other Hamiltonian terms. Args: j (float): coupling strength Returns: PulseSystemModel: model for qubit system """ hamiltonian = {} hamiltonian['h_str'] = [ 'a*X0||D0', 'a*X0||D1', '2*np.pi*j*0.25*(Z0*X1)||U0' ] hamiltonian['vars'] = {'a': 0, 'j': j} hamiltonian['qub'] = {'0': 2, '1': 2} ham_model = HamiltonianModel.from_dict(hamiltonian) # set the U0 to have frequency of drive channel 0 u_channel_lo = [[UchannelLO(0, 1.0 + 0.0j)]] subsystem_list = [0, 1] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_1Q(self, omega_0=5., r=0.02): """Constructs a standard model for a 1 qubit system. Args: omega_0 (float): qubit frequency r (float): drive strength Returns: PulseSystemModel: model for qubit system """ hamiltonian = {} hamiltonian['h_str'] = [ '2*np.pi*omega0*0.5*Z0', '2*np.pi*r*0.5*X0||D0' ] hamiltonian['vars'] = {'omega0': omega_0, 'r': r} hamiltonian['qub'] = {'0': 2} ham_model = HamiltonianModel.from_dict(hamiltonian) u_channel_lo = [] subsystem_list = [0] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_3d_oscillator(self, freq, anharm, r): """Model for a duffing oscillator truncated to 3 dimensions. Args: freq (float): frequency of the oscillator anharm (float): anharmonicity of the oscillator r (float): drive strength Returns: PulseSystemModel: model for oscillator system """ hamiltonian = {} hamiltonian['h_str'] = [ 'np.pi*(2*v-alpha)*O0', 'np.pi*alpha*O0*O0', '2*np.pi*r*X0||D0' ] hamiltonian['vars'] = {'v': freq, 'alpha': anharm, 'r': r} hamiltonian['qub'] = {'0': 3} ham_model = HamiltonianModel.from_dict(hamiltonian) u_channel_lo = [] subsystem_list = [0] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_3Q(self, j, subsystem_list=[0, 2]): """Constructs a model for a 3 qubit system, with the goal that the restriction to [0, 2] and to qubits [1, 2] is the same as in _system_model_2Q Args: j (float): coupling strength subsystem_list (list): list of subsystems to include Returns: PulseSystemModel: model for qubit system """ hamiltonian = {} hamiltonian['h_str'] = [ '2*np.pi*j*0.25*(Z0*X2)||U0', '2*np.pi*j*0.25*(Z1*X2)||U1' ] hamiltonian['vars'] = {'j': j} hamiltonian['qub'] = {'0': 2, '1': 2, '2': 2} ham_model = HamiltonianModel.from_dict(hamiltonian, subsystem_list=subsystem_list) # set the U0 to have frequency of drive channel 0 u_channel_lo = [[UchannelLO(0, 1.0 + 0.0j)], [UchannelLO(0, 1.0 + 0.0j)]] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_1Q(self, omega_0, omega_a, qubit_dim=2): """Constructs a simple 1 qubit system model. Args: omega_0 (float): frequency of qubit omega_a (float): strength of drive term qubit_dim (int): dimension of qubit Returns: PulseSystemModel: model for qubit system """ # make Hamiltonian hamiltonian = {} hamiltonian['h_str'] = ['-0.5*omega0*Z0', '0.5*omegaa*X0||D0'] hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a} hamiltonian['qub'] = {'0': qubit_dim} ham_model = HamiltonianModel.from_dict(hamiltonian) u_channel_lo = [] subsystem_list = [0] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _simple_system_model(self, v0=5.0, v1=5.1, j=0.01, r=0.02, alpha0=-0.33, alpha1=-0.33): hamiltonian = {} hamiltonian['h_str'] = [ 'np.pi*(2*v0-alpha0)*O0', 'np.pi*alpha0*O0*O0', '2*np.pi*r*X0||D0', '2*np.pi*r*X0||U1', '2*np.pi*r*X1||U0', 'np.pi*(2*v1-alpha1)*O1', 'np.pi*alpha1*O1*O1', '2*np.pi*r*X1||D1', '2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)' ] hamiltonian['qub'] = {'0': 3, '1': 3} hamiltonian['vars'] = { 'v0': v0, 'v1': v1, 'j': j, 'r': r, 'alpha0': alpha0, 'alpha1': alpha1 } ham_model = HamiltonianModel.from_dict(hamiltonian) subsystem_list = [0, 1] dt = 1. return PulseSystemModel(hamiltonian=ham_model, qubit_freq_est=self._default_qubit_lo_freq, u_channel_lo=self._u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_3Q(self, omega_0, omega_a, omega_i, qubit_dim=2, subsystem_list=None): """Constructs a 3 qubit model. Purpose of this is for testing subsystem restrictions - It is set up so that the system restricted to [0, 2] and [1, 2] is the same (up to channel labelling). Args: omega_0 (float): frequency of qubit omega_a (float): strength of drive term omega_i (float): strength of interaction qubit_dim (int): dimension of qubit Returns: PulseSystemModel: model for qubit system """ # make Hamiltonian hamiltonian = {} # qubit 0 terms hamiltonian['h_str'] = [ '-0.5*omega0*Z0', '0.5*omegaa*X0||D0', '-0.5*omega0*Z1', '0.5*omegaa*X1||D1' ] # interaction terms hamiltonian['h_str'].append('omegai*(Sp0*Sm2+Sm0*Sp2)||U1') hamiltonian['h_str'].append('omegai*(Sp1*Sm2+Sm1*Sp2)||U2') hamiltonian['vars'] = { 'omega0': omega_0, 'omegaa': omega_a, 'omegai': omega_i } hamiltonian['qub'] = {'0': qubit_dim, '1': qubit_dim, '2': qubit_dim} ham_model = HamiltonianModel.from_dict(hamiltonian, subsystem_list) u_channel_lo = [[{ 'q': 0, 'scale': [1.0, 0.0] }], [{ 'q': 0, 'scale': [-1.0, 0.0] }, { 'q': 2, 'scale': [1.0, 0.0] }], [{ 'q': 1, 'scale': [-1.0, 0.0] }, { 'q': 2, 'scale': [1.0, 0.0] }]] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def assert_hamiltonian_parse_exception(self, ham_dict, message): """Test that an attempt to parse a given ham_dict results in an exception with the given message. """ try: ham_model = HamiltonianModel.from_dict(ham_dict) except Exception as exception: self.assertEqual(exception.message, message)
def test_no_variables(self): """Test successful construction of Hamiltonian without variables""" # fully specified hamiltonian without variables ham_dict = {'h_str': ['2*np.pi*O0', '2*np.pi*X0||D0'], 'qub': {'0': 2}} ham_model = HamiltonianModel.from_dict(ham_dict) qubit_lo = ham_model.get_qubit_lo_from_drift() self.assertAlmostEqual(norm(qubit_lo - np.array([1.])), 0)
def two_level_ham(config, subsystem_list, add_y, no_control): # TODO fix 2q version bigy1 = Qobj(tensor(sigmay(), identity(2)).full()) bigy2 = Qobj(tensor(identity(2), sigmay()).full()) bigx1 = Qobj(tensor(sigmax(), identity(2)).full()) bigx2 = Qobj(tensor(identity(2), sigmax()).full()) hamiltonian = {} hamiltonian_backend = config.hamiltonian hamiltonian_dict = HamiltonianModel.from_dict( hamiltonian_backend, subsystem_list=subsystem_list) hamiltonian = {'H_c': {}, 'H_d': 0} for i, control_field in enumerate(hamiltonian_dict._system): matrix = (control_field[0]) prefactor, control = prefactor_parser(control_field[1], hamiltonian_dict._variables) if prefactor == 0: continue if control: # prefactor = prefactor * 2 if 'D' in control: # print("Double check that sigx2 and sigy2 are right") if len(subsystem_list) == 1: hamiltonian['H_c'][control] = sigmax() * prefactor if add_y: if len(subsystem_list) == 1: hamiltonian['H_c'][control + 'y'] = sigmay() * prefactor elif len(subsystem_list) == 2: if control == 'D0': hamiltonian['H_c'][control] = Qobj(bigx1 * prefactor) hamiltonian['H_c'][control + 'y'] = Qobj(bigy1 * prefactor) elif control == 'D1': hamiltonian['H_c'][control] = Qobj(bigx2 * prefactor) hamiltonian['H_c'][control + 'y'] = Qobj(bigy2 * prefactor) else: raise NotImplementedError("Only q0 and q1 rn") else: raise NotImplementedError("Only 1-2q operations supported") else: raise NotImplementedError("need to use y right now") elif no_control: print('not using control channels, skippping...') else: raise NotImplementedError("No use for control channels currently") if len(subsystem_list) == 1: hamiltonian['H_d'] = identity(2) * 0 elif len(subsystem_list) == 2: hamiltonian['H_d'] = identity(4) * 0 return hamiltonian
def test_simulation_without_variables(self): r"""Test behavior of subsystem_list subsystem restriction. Same setup as test_x_gate, but with explicit Hamiltonian construction without variables """ ham_dict = { 'h_str': ['-np.pi*Z0', '0.01*np.pi*X0||D0'], 'qub': { '0': 2 } } ham_model = HamiltonianModel.from_dict(ham_dict) u_channel_lo = [] subsystem_list = [0] dt = 1. system_model = PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt) # set up schedule and qobj total_samples = 50 schedule = self._simple_1Q_schedule(0, total_samples) qobj = assemble([schedule], backend=self.backend_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=[1.], memory_slots=2, shots=256) # set backend backend_options backend_options = {'seed': 9000} # run simulation result = self.backend_sim.run( qobj, system_model=system_model, backend_options=backend_options).result() # test results counts = result.get_counts() exp_counts = {'1': 256} self.assertDictAlmostEqual(counts, exp_counts)
def _system_model_2Q(self, v0=5.0, v1=5.1, j=0.01, r=0.02, alpha0=-0.33, alpha1=-0.33, qub_dim=3): """Constructs a simple 2 transmon PulseSystemModel.""" hamiltonian = {} hamiltonian['h_str'] = [] # Q0 terms hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') hamiltonian['h_str'].append('2*np.pi*r*X0||D0') # Q1 terms hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') hamiltonian['h_str'].append('2*np.pi*r*X1||D1') # Exchange coupling and ControlChannel terms hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') hamiltonian['h_str'].append('2*np.pi*r*X0||U0') hamiltonian['h_str'].append('2*np.pi*r*X1||U1') # set vars and qubit dimensions hamiltonian['vars'] = {'v0': v0, 'v1': v1, 'j': j, 'r': r, 'alpha0': alpha0, 'alpha1': alpha1} hamiltonian['qub'] = {'0' : qub_dim, '1' : qub_dim} ham_model = HamiltonianModel.from_dict(hamiltonian) # set up u channel freqs, u_channel_lo = [[{'q': 1, 'scale': [1.0, 0.0]}], [{'q': 0, 'scale': [1.0, 0.0]}]] subsystem_list = [0, 1] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def _system_model_2Q(self, omega_0, omega_a, omega_i, qubit_dim=2): """Constructs a simple 1 qubit system model. Args: omega_0 (float): frequency of qubit omega_a (float): strength of drive term omega_i (float): strength of interaction qubit_dim (int): dimension of qubit Returns: PulseSystemModel: model for qubit system """ # make Hamiltonian hamiltonian = {} # qubit 0 terms hamiltonian['h_str'] = ['-0.5*omega0*Z0', '0.5*omegaa*X0||D0'] # interaction term hamiltonian['h_str'].append('omegai*(Sp0*Sm1+Sm0*Sp1)||U1') hamiltonian['vars'] = { 'omega0': omega_0, 'omegaa': omega_a, 'omegai': omega_i } hamiltonian['qub'] = {'0': qubit_dim, '1': qubit_dim} ham_model = HamiltonianModel.from_dict(hamiltonian) u_channel_lo = [[{ 'q': 0, 'scale': [1.0, 0.0] }], [{ 'q': 0, 'scale': [-1.0, 0.0] }, { 'q': 1, 'scale': [1.0, 0.0] }]] subsystem_list = [0, 1] dt = 1. return PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt)
def test_2Q_exchange(self): r"""Test a more complicated 2q simulation""" q_freqs = [5., 5.1] r = 0.02 j = 0.02 total_samples = 25 hamiltonian = {} hamiltonian['h_str'] = [ '2*np.pi*v0*0.5*Z0', '2*np.pi*v1*0.5*Z1', '2*np.pi*r*0.5*X0||D0', '2*np.pi*r*0.5*X1||D1', '2*np.pi*j*0.5*I0*I1', '2*np.pi*j*0.5*X0*X1', '2*np.pi*j*0.5*Y0*Y1', '2*np.pi*j*0.5*Z0*Z1' ] hamiltonian['vars'] = { 'v0': q_freqs[0], 'v1': q_freqs[1], 'r': r, 'j': j } hamiltonian['qub'] = {'0': 2, '1': 2} ham_model = HamiltonianModel.from_dict(hamiltonian) # set the U0 to have frequency of drive channel 0 u_channel_lo = [] subsystem_list = [0, 1] dt = 1. system_model = PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt) # try some random schedule schedule = Schedule() drive_pulse = Waveform(np.ones(total_samples)) schedule += Play(drive_pulse, DriveChannel(0)) schedule |= Play(drive_pulse, DriveChannel(1)) << 2 * total_samples schedule |= Acquire(total_samples, AcquireChannel(0), MemorySlot(0)) << 3 * total_samples schedule |= Acquire(total_samples, AcquireChannel(1), MemorySlot(1)) << 3 * total_samples y0 = np.array([1., 0., 0., 0.]) pulse_sim = PulseSimulator(system_model=system_model, initial_state=y0, seed=9000) qobj = assemble([schedule], backend=pulse_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=q_freqs, memory_slots=2, shots=1000) result = pulse_sim.run(qobj).result() pulse_sim_yf = result.get_statevector() # set up and run independent simulation d0_samps = np.concatenate( (np.ones(total_samples), np.zeros(2 * total_samples))) d1_samps = np.concatenate( (np.zeros(2 * total_samples), np.ones(total_samples))) samples = np.array([d0_samps, d1_samps]).transpose() q_freqs = np.array(q_freqs) yf = simulate_2q_exchange_model(y0, q_freqs, r, j, q_freqs, samples, 1.) # Check fidelity of statevectors self.assertGreaterEqual(state_fidelity(pulse_sim_yf, yf), 1 - (10**-5))
def test_subsystem_list_from_dict(self): """Test correct restriction of a Hamiltonian dict to a subset of systems""" # construct 2 duffing oscillator hamiltonian v0 = 5.0 v1 = 5.1 j = 0.01 r = 0.02 alpha0 = -0.33 alpha1 = -0.33 hamiltonian = {} hamiltonian['h_str'] = [ 'np.pi*(2*v0-alpha0)*O0', 'np.pi*alpha0*O0*O0', '2*np.pi*r*X0||D0', '2*np.pi*r*X0||U1', '2*np.pi*r*X1||U0', 'np.pi*(2*v1-alpha1)*O1', 'np.pi*alpha1*O1*O1', '2*np.pi*r*X1||D1', '2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)' ] hamiltonian['qub'] = {'0': 3, '1': 3} hamiltonian['vars'] = { 'v0': v0, 'v1': v1, 'j': j, 'r': r, 'alpha0': alpha0, 'alpha1': alpha1 } # restrict to qubit 0 and verify some properties ham_model0 = HamiltonianModel.from_dict(hamiltonian, subsystem_list=[0]) evals_expected0 = np.array([ 0, np.pi * (2 * v0 - alpha0) + np.pi * alpha0, (2 * np.pi * (2 * v0 - alpha0)) + (4 * np.pi * alpha0) ]) eval_diff = norm(evals_expected0 - ham_model0._evals) self.assertAlmostEqual(eval_diff, 0) channel_labels0 = ham_model0._channels.keys() for key in ['D0', 'U1']: self.assertTrue(key in channel_labels0) self.assertEqual(len(channel_labels0), 2) qubit_lo_freq0 = ham_model0.get_qubit_lo_from_drift() expected_freq0 = np.array([ (np.pi * (2 * v0 - alpha0) + np.pi * alpha0) / (2 * np.pi) ]) self.assertAlmostEqual(norm(qubit_lo_freq0 - expected_freq0), 0) # restrict to qubit 1 and verify some properties ham_model1 = HamiltonianModel.from_dict(hamiltonian, subsystem_list=[1]) evals_expected1 = np.array([ 0, np.pi * (2 * v1 - alpha1) + np.pi * alpha1, (2 * np.pi * (2 * v1 - alpha1)) + (4 * np.pi * alpha1) ]) eval_diff = norm(evals_expected1 - ham_model1._evals) self.assertAlmostEqual(eval_diff, 0) channel_labels1 = ham_model1._channels.keys() for key in ['D1', 'U0']: self.assertTrue(key in channel_labels1) self.assertEqual(len(channel_labels1), 2) qubit_lo_freq1 = ham_model1.get_qubit_lo_from_drift() expected_freq1 = np.array( [0, (np.pi * (2 * v1 - alpha1) + np.pi * alpha1) / (2 * np.pi)]) self.assertAlmostEqual(norm(qubit_lo_freq1 - expected_freq1), 0)
def test_delay_instruction(self): """Test for delay instruction.""" # construct system model specifically for this hamiltonian = {} hamiltonian['h_str'] = ['0.5*r*X0||D0', '0.5*r*Y0||D1'] hamiltonian['vars'] = {'r': np.pi} hamiltonian['qub'] = {'0': 2} ham_model = HamiltonianModel.from_dict(hamiltonian) u_channel_lo = [] subsystem_list = [0] dt = 1. system_model = PulseSystemModel(hamiltonian=ham_model, u_channel_lo=u_channel_lo, subsystem_list=subsystem_list, dt=dt) # construct a schedule that should result in a unitary -Z if delays are correctly handled # i.e. do a pi rotation about x, sandwiched by pi/2 rotations about y in opposite directions # so that the x rotation is transformed into a z rotation. # if delays are not handled correctly this process should fail sched = Schedule() sched += Play(Waveform([0.5]), DriveChannel(1)) sched += Delay(1, DriveChannel(1)) sched += Play(Waveform([-0.5]), DriveChannel(1)) sched += Delay(1, DriveChannel(0)) sched += Play(Waveform([1.]), DriveChannel(0)) sched |= Acquire(1, AcquireChannel(0), MemorySlot(0)) << sched.duration # Result of schedule should be the unitary -1j*Z, so check rotation of an X eigenstate pulse_sim = PulseSimulator(system_model=system_model, initial_state=np.array([1., 1.]) / np.sqrt(2)) qobj = assemble([sched], backend=pulse_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=[0., 0.], memory_slots=2, shots=1) results = pulse_sim.run(qobj).result() statevector = results.get_statevector() expected_vector = np.array([-1j, 1j]) / np.sqrt(2) self.assertGreaterEqual(state_fidelity(statevector, expected_vector), 1 - (10**-5)) # verify validity of simulation when no delays included sched = Schedule() sched += Play(Waveform([0.5]), DriveChannel(1)) sched += Play(Waveform([-0.5]), DriveChannel(1)) sched += Play(Waveform([1.]), DriveChannel(0)) sched |= Acquire(1, AcquireChannel(0), MemorySlot(0)) << sched.duration qobj = assemble([sched], backend=pulse_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=[0., 0.], memory_slots=2, shots=1) results = pulse_sim.run(qobj).result() statevector = results.get_statevector() U = expm(1j * np.pi * self.Y / 4) @ expm(-1j * np.pi * (self.Y / 4 + self.X / 2)) expected_vector = U @ np.array([1., 1.]) / np.sqrt(2) self.assertGreaterEqual(state_fidelity(statevector, expected_vector), 1 - (10**-5))
def convert_qutip_ham(config, subsystem_list, add_y=True, no_control=True, two_level=False, omegad_mult=None): """Convert an IBM backend to a qutip formatted hamiltonian. Args: config (backend.configuration): Backend configuration to get the hamiltonian from subsystem_list (List[int]): List of qubits which the gate will act on (so far only tested on [0] or [0,1]) add_y (bool, optional): Whether or not to perform the RWA and get a sigmay term. Defaults to True. no_control (bool, optional): Whether or not to ignore the control channels. Defaults to True. two_level (bool, optional): Whether to use a two level model or not. Defaults to False. omegad_mult (bool, optional): Whether to multiply the drive terms by a factor (see the writeup). Defaults to None. Raises: NotImplementedError: Only tested with qubits 0 and 1 right now, but could just remove this error NotImplementedError: No 3+ qubit operations examined yet. NotImplementedError: Right now we aren't using the control channels. Returns: [type]: [description] """ if two_level: return two_level_ham(config, subsystem_list, add_y, no_control) a = Qobj([[0, 1, 0], [0, 0, sqrt(2)], [0, 0, 0]]) adag = Qobj([[0, 0, 0], [1, 0, 0], [0, sqrt(2), 0]]) geny = complex(0, 1) * (adag - a) bigy1 = Qobj(tensor(geny, identity(3)).full()) bigy2 = Qobj(tensor(identity(3), geny).full()) hamiltonian_backend = config.hamiltonian if omegad_mult: for i in range(input_backend.configuration().n_qubits): hamiltonian_backend['vars']['omegad' + str(i)] = hamiltonian_backend['vars']['omegad' + str(i)] * omegad_mult hamiltonian_dict = HamiltonianModel.from_dict( hamiltonian_backend, subsystem_list=subsystem_list) hamiltonian = {'H_c': {}, 'iH_c': {}, 'H_d': 0} for i, control_field in enumerate(hamiltonian_dict._system): matrix = (control_field[0]) prefactor, control = prefactor_parser(control_field[1], hamiltonian_dict._variables) if prefactor == 0: continue if control: # prefactor = prefactor * 2 if 'D' in control: hamiltonian['H_c'][control] = Qobj(matrix.full() * prefactor) if add_y: if len(subsystem_list) == 1: hamiltonian['H_c'][control + 'y'] = Qobj(geny * prefactor) elif len(subsystem_list) == 2: print("Double checkthat sigx2 and sigy2 are right") if control == 'D0': hamiltonian['H_c'][control + 'y'] = Qobj(bigy1 * prefactor) elif control == 'D1': hamiltonian['H_c'][control + 'y'] = Qobj(bigy2 * prefactor) else: raise NotImplementedError("Only q0 and q1 rn") else: raise NotImplementedError("Only 1-2q operations supported") elif no_control: print('not using control channels, skippping...') else: raise NotImplementedError("No use for control channels currently") elif hamiltonian['H_d'] == 0: hamiltonian['H_d'] = matrix * prefactor else: hamiltonian['H_d'] += matrix * prefactor if hamiltonian['H_d'] != 0: hamiltonian['H_d'] = Qobj(hamiltonian['H_d'].full()) if hamiltonian['H_d'] == 0: hamiltonian['H_d'] = Qobj(np.zeros((3, 3))) else: print("Drift hamiltonian is 0, (Likely due to missing variables in backend db), do not trust results.") hamiltonian['H_d'] = Qobj(np.zeros((3, 3))) return hamiltonian