def test_enr_destory_double(): "Excitation-number-restricted state space: two excitations" a1, a2 = enr_destroy([4, 4], 2) assert_(a1.shape == [6, 6]) a1, a2, a3 = enr_destroy([4, 4, 4], 2) assert_(a1.shape == [10, 10]) a1, a2, a3, a4 = enr_destroy([4, 4, 4, 4], 2) assert_(a1.shape == [15, 15])
def test_enr_destory_double(): "Excitation-number-restricted state space: two excitations" a1, a2 = enr_destroy([4, 4], 2) assert_(a1.shape == (6, 6)) a1, a2, a3 = enr_destroy([4, 4, 4], 2) assert_(a1.shape == (10, 10)) a1, a2, a3, a4 = enr_destroy([4, 4, 4, 4], 2) assert_(a1.shape == (15, 15))
def test_enr_destory_single(): "Excitation-number-restricted state space: single excitations" a1, a2 = enr_destroy([4, 4], 1) assert_(a1.shape == [3, 3]) a1, a2, a3 = enr_destroy([4, 4, 4], 1) assert_(a1.shape == [4, 4]) a1, a2, a3, a4 = enr_destroy([4, 4, 4, 4], 1) assert_(a1.shape == [5, 5])
def test_enr_destory_single(): "Excitation-number-restricted state space: single excitations" a1, a2 = enr_destroy([4, 4], 1) assert_(a1.shape == (3, 3)) a1, a2, a3 = enr_destroy([4, 4, 4], 1) assert_(a1.shape == (4, 4)) a1, a2, a3, a4 = enr_destroy([4, 4, 4, 4], 1) assert_(a1.shape == (5, 5))
def test_enr_destory_full(): "Excitation-number-restricted state-space: full state space" a1, a2 = enr_destroy([4, 4], 4**2) b1, b2 = tensor(destroy(4), identity(4)), tensor(identity(4), destroy(4)) assert_(a1 == b1) assert_(a2 == b2)
def test_space_size_reduction(self, dimensions, n_excitations): test_operators = qutip.enr_destroy(dimensions, n_excitations) expected_size = _n_enr_states(dimensions, n_excitations) expected_shape = (expected_size, expected_size) for test in test_operators: assert test.shape == expected_shape assert test.dims == [dimensions, dimensions]
def test_no_restrictions(self, dimensions): """ Test that the restricted-excitation operators are equal to the standard operators when there aren't any restrictions. """ test_operators = qutip.enr_destroy(dimensions, sum(dimensions)) a = [qutip.destroy(n) for n in dimensions] iden = [qutip.qeye(n) for n in dimensions] for i, test in enumerate(test_operators): expected = qutip.tensor(iden[:i] + [a[i]] + iden[i + 1:]) assert test == expected assert test.dims == [dimensions, dimensions]
def test_fock_state(dimensions, n_excitations): """ Test Fock state creation agrees with the number operators implied by the existence of the ENR annihiliation operators. """ number = [ a.dag() * a for a in qutip.enr_destroy(dimensions, n_excitations) ] bases = list(qutip.state_number_enumerate(dimensions, n_excitations)) n_samples = min((len(bases), 5)) for basis in random.sample(bases, n_samples): state = qutip.enr_fock(dimensions, n_excitations, basis) for n, x in zip(number, basis): assert abs(n.matrix_element(state.dag(), state)) - x < 1e-10
def test_enr_fock_state(): "Excitation-number-restricted state space: fock states" dims, excitations = [4, 4], 2 a1, a2 = enr_destroy(dims, excitations) psi = enr_fock(dims, excitations, [0, 2]) assert_(abs((a1.dag()*a1).matrix_element(psi.dag(), psi) - 0) < 1e-10) assert_(abs((a2.dag()*a2).matrix_element(psi.dag(), psi) - 2) < 1e-10) psi = enr_fock(dims, excitations, [2, 0]) assert_(abs((a1.dag()*a1).matrix_element(psi.dag(), psi) - 2) < 1e-10) assert_(abs((a2.dag()*a2).matrix_element(psi.dag(), psi) - 0) < 1e-10) psi = enr_fock(dims, excitations, [1, 1]) assert_(abs((a1.dag()*a1).matrix_element(psi.dag(), psi) - 1) < 1e-10) assert_(abs((a2.dag()*a2).matrix_element(psi.dag(), psi) - 1) < 1e-10)