def test_sparse_basis(self):
sparsePP = Basis("pp",2,sparse=True)
sparsePP2 = Basis("pp",2,sparse=True)
sparseBlockPP = Basis("pp",[2,2],sparse=True)
sparsePP_2Q = Basis("pp",4,sparse=True)
sparseGM_2Q = Basis("gm",2,sparse=True) #different sparsity structure than PP 2Q
denseGM = Basis("gm",2,sparse=False)
mxs = sparsePP.get_composite_matrices()
block_mxs = sparseBlockPP.get_composite_matrices()
expeq = sparsePP.expanded_equivalent()
block_expeq = sparseBlockPP.expanded_equivalent()
raw_mxs = bt.basis_matrices("pp",2,sparse=True)
#test equality of bases with other bases and matrices
self.assertEqual(sparsePP, sparsePP2)
self.assertEqual(sparsePP, raw_mxs)
self.assertNotEqual(sparsePP, sparsePP_2Q)
self.assertNotEqual(sparsePP_2Q, sparseGM_2Q)
#sparse transform matrix
trans = sparsePP.transform_matrix(sparsePP2)
self.assertArraysAlmostEqual(trans, np.identity(4,'d'))
trans2 = sparsePP.transform_matrix(denseGM)
#test equality for large bases, which is too expensive so it always returns false
large_sparsePP = Basis("pp",16,sparse=True)
large_sparsePP2 = Basis("pp",16,sparse=True)
self.assertNotEqual(large_sparsePP, large_sparsePP2)
def test_general(self):
Basis('pp', 2)
Basis('std', [2, 1])
Basis([('std', 2), ('gm', 2)])
std = Basis('std', 2)
std4 = Basis('std', 4)
std2x2 = Basis([('std', 2), ('std', 2)])
gm = Basis('gm', 2)
ungm = Basis('gm_unnormalized', 2)
empty = Basis([]) #special "empty" basis
self.assertEqual(empty.name, "*Empty*")
from_basis,to_basis = pygsti.tools.build_basis_pair(np.identity(4,'d'),"std","gm")
from_basis,to_basis = pygsti.tools.build_basis_pair(np.identity(4,'d'),std,"gm")
from_basis,to_basis = pygsti.tools.build_basis_pair(np.identity(4,'d'),"std",gm)
gm_mxs = gm.get_composite_matrices()
unnorm = Basis(matrices=[ gm_mxs[0], 2*gm_mxs[1] ])
std[0]
std.get_sub_basis_matrices(0)
print(gm.get_composite_matrices())
self.assertTrue(gm.is_normalized())
self.assertFalse(ungm.is_normalized())
self.assertFalse(unnorm.is_normalized())
transMx = bt.transform_matrix(std, gm)
composite = Basis([std, gm])
comp = Basis(matrices=[std, gm], name='comp', longname='CustomComposite')
comp.labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
comp = Basis(matrices=[std, gm], name='comp', longname='CustomComposite', labels=[
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'
])
std2x2Matrices = np.array([
[[1, 0],
[0, 0]],
[[0, 1],
[0, 0]],
[[0, 0],
[1, 0]],
[[0, 0],
[0, 1]]
],'complex')
empty = Basis(matrices=[])
alt_standard = Basis(matrices=std2x2Matrices)
print("MXS = \n",alt_standard._matrices)
alt_standard = Basis(matrices=std2x2Matrices,
name='std',
longname='Standard'
)
self.assertEqual(alt_standard, std2x2Matrices)
mx = np.array([
[1, 0, 0, 1],
[0, 1, 2, 0],
[0, 2, 1, 0],
[1, 0, 0, 1]
])
bt.change_basis(mx, 'std', 'gm') # shortname lookup
bt.change_basis(mx, std, gm) # object
bt.change_basis(mx, std, 'gm') # combination
bt.flexible_change_basis(mx, std, gm) #same dimension
I2x2 = np.identity(8,'d')
I4 = bt.flexible_change_basis(I2x2, std2x2, std4)
self.assertArraysAlmostEqual(bt.flexible_change_basis(I4, std4, std2x2), I2x2)
with self.assertRaises(ValueError):
bt.change_basis(mx, std, std4) # basis size mismatch
mxInStdBasis = np.array([[1,0,0,2],
[0,0,0,0],
[0,0,0,0],
[3,0,0,4]],'d')
begin = Basis('std', [1,1])
end = Basis('std', 2)
mxInReducedBasis = bt.resize_std_mx(mxInStdBasis, 'contract', end, begin)
original = bt.resize_std_mx(mxInReducedBasis, 'expand', begin, end)
