def test_auto_expand(self):
comp = Basis(matrices=[('std', 2,), ('std', 1)])
std = Basis('std', 3)
mxStd = np.identity(5)
test = bt.resize_std_mx(mxStd, 'expand', comp, std)
test2 = bt.resize_std_mx(test, 'contract', std, comp)
self.assertArraysAlmostEqual(test2, mxStd)
def test_composite_basis(self):
comp = Basis([('std', 2,), ('std', 1)])
a = Basis([('std', 2), ('std', 2)])
b = Basis('std', [2,2])
self.assertEqual(len(a), len(b))
self.assertArraysAlmostEqual(np.array(a._matrices), np.array(b._matrices))
def test_expand_contract(self):
# matrix that operates on 2x2 density matrices, but only on the 0-th and 3-rd
# elements which correspond to the diagonals of the 2x2 density matrix.
mxInStdBasis = np.array([[1,0,0,2],
[0,0,0,0],
[0,0,0,0],
[3,0,0,4]],'d')
# Reduce to a matrix operating on a density matrix space with 2 1x1 blocks (hence [1,1])
begin = Basis('std', [1,1])
end = Basis('std', 2)
mxInReducedBasis = bt.resize_std_mx(mxInStdBasis, 'contract', end, begin)
#mxInReducedBasis = bt.change_basis(mxInStdBasis, begin, end)
notReallyContracted = bt.change_basis(mxInStdBasis, 'std', 'std', 4)
correctAnswer = np.array([[ 1.0, 2.0],
[ 3.0, 4.0]])
#self.assertArraysAlmostEqual( mxInReducedBasis, correctAnswer )
self.assertArraysAlmostEqual( notReallyContracted, mxInStdBasis )
expandedMx = bt.resize_std_mx(mxInReducedBasis, 'expand', begin, end)
#expandedMx = bt.change_basis(mxInReducedBasis, end, begin)
expandedMxAgain = bt.change_basis(expandedMx, 'std', 'std', 4)
self.assertArraysAlmostEqual( expandedMx, mxInStdBasis )
self.assertArraysAlmostEqual( expandedMxAgain, mxInStdBasis )
def test_change_between_composites(self):
a = Basis('std', [2, 1])
b = Basis('gm', [2, 1])
mxStd = np.identity(5)
test = bt.change_basis(mxStd, a, b)
self.assertEqual(test.shape, mxStd.shape)
test2 = bt.change_basis(test, b, a)
self.assertArraysAlmostEqual(test2, mxStd)
def test_flexible_change_basis(self):
comp = Basis(matrices=[('gm', 2,), ('gm', 1)])
std = Basis('std', 3)
mx = np.identity(5)
test = bt.flexible_change_basis(mx, comp, std)
self.assertEqual(test.shape[0], sum(comp.dim.blockDims) ** 2)
test2 = bt.flexible_change_basis(test, std, comp)
self.assertArraysAlmostEqual(test2, mx)
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_basis_object(self):
#test a few aspects of a Basis object that other tests miss...
b = Basis("pp",2)
beq = b.expanded_equivalent()
longnm = bt.basis_longname(b)
lbls = bt.basis_element_labels(b)
raw_mxs = bt.basis_matrices("pp",2)
with self.assertRaises(NotImplementedError):
bt.basis_matrices("foobar",2) #invalid basis name
print("Dim = ", repr(b.dim) ) # calls Dim.__repr__
def test_jamiolkowski_ops(self):
gm = Basis('gm', 2)
pp = Basis('pp', 2)
std = Basis('std', 2)
mxGM = np.array(
[[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]],
'complex')
mxStd = bt.change_basis(mxGM, gm, std)
mxPP = bt.change_basis(mxGM, gm, pp)
choiStd = pygsti.jamiolkowski_iso(mxStd, std, std)
choiStd2 = pygsti.jamiolkowski_iso(mxGM, gm, std)
choiStd3 = pygsti.jamiolkowski_iso(mxPP, pp, std)
fastChoiStd = pygsti.fast_jamiolkowski_iso_std(mxStd, std)
fastChoiStd2 = pygsti.fast_jamiolkowski_iso_std(mxGM, gm)
fastChoiStd3 = pygsti.fast_jamiolkowski_iso_std(mxPP, pp)
choiGM = pygsti.jamiolkowski_iso(mxStd, std, gm)
choiGM2 = pygsti.jamiolkowski_iso(mxGM, gm, gm)
choiGM3 = pygsti.jamiolkowski_iso(mxPP, pp, gm)
choiPP = pygsti.jamiolkowski_iso(mxStd, std, pp)
choiPP2 = pygsti.jamiolkowski_iso(mxGM, gm, pp)
choiPP3 = pygsti.jamiolkowski_iso(mxPP, pp, pp)
self.assertArraysAlmostEqual(choiStd, choiStd2)
self.assertArraysAlmostEqual(choiStd, choiStd3)
self.assertArraysAlmostEqual(choiStd, fastChoiStd)
self.assertArraysAlmostEqual(choiStd, fastChoiStd2)
self.assertArraysAlmostEqual(choiStd, fastChoiStd3)
self.assertArraysAlmostEqual(choiGM, choiGM2)
self.assertArraysAlmostEqual(choiGM, choiGM3)
self.assertArraysAlmostEqual(choiPP, choiPP2)
self.assertArraysAlmostEqual(choiPP, choiPP3)
gateStd = pygsti.jamiolkowski_iso_inv(choiStd, std, std)
gateStd2 = pygsti.jamiolkowski_iso_inv(choiGM, gm, std)
gateStd3 = pygsti.jamiolkowski_iso_inv(choiPP, pp, std)
gateGM = pygsti.jamiolkowski_iso_inv(choiStd, std, gm)
gateGM2 = pygsti.jamiolkowski_iso_inv(choiGM, gm, gm)
gateGM3 = pygsti.jamiolkowski_iso_inv(choiPP, pp, gm)
gatePP = pygsti.jamiolkowski_iso_inv(choiStd, std, pp)
gatePP2 = pygsti.jamiolkowski_iso_inv(choiGM, gm, pp)
gatePP3 = pygsti.jamiolkowski_iso_inv(choiPP, pp, pp)
fastGateStd = pygsti.fast_jamiolkowski_iso_std_inv(choiStd, std)
fastGateGM = pygsti.fast_jamiolkowski_iso_std_inv(choiStd, gm)
fastGatePP = pygsti.fast_jamiolkowski_iso_std_inv(choiStd, pp)
self.assertArraysAlmostEqual(gateStd, mxStd)
self.assertArraysAlmostEqual(gateStd2, mxStd)
self.assertArraysAlmostEqual(gateStd3, mxStd)
self.assertArraysAlmostEqual(fastGateStd, mxStd)
self.assertArraysAlmostEqual(gateGM, mxGM)
self.assertArraysAlmostEqual(gateGM2, mxGM)
self.assertArraysAlmostEqual(gateGM3, mxGM)
self.assertArraysAlmostEqual(fastGateGM, mxGM)
self.assertArraysAlmostEqual(gatePP, mxPP)
self.assertArraysAlmostEqual(gatePP2, mxPP)
self.assertArraysAlmostEqual(gatePP3, mxPP)
self.assertArraysAlmostEqual(fastGatePP, mxPP)
'''
with self.assertRaises(NotImplementedError):
pygsti.jamiolkowski_iso(mxStd, "foobar", gm) #invalid gate basis
with self.assertRaises(NotImplementedError):
pygsti.jamiolkowski_iso(mxStd, std, "foobar") #invalid choi basis
with self.assertRaises(NotImplementedError):
pygsti.jamiolkowski_iso_inv(choiStd, "foobar", gm) #invalid choi basis
with self.assertRaises(NotImplementedError):
pygsti.jamiolkowski_iso_inv(choiStd, std, "foobar") #invalid gate basis
'''
sumOfNeg = pygsti.sum_of_negative_choi_evals(std1Q.gs_target)
sumOfNegWt = pygsti.sum_of_negative_choi_evals(std1Q.gs_target, {
'Gx': 1.0,
'Gy': 0.5
})
sumsOfNeg = pygsti.sums_of_negative_choi_evals(std1Q.gs_target)
magsOfNeg = pygsti.mags_of_negative_choi_evals(std1Q.gs_target)
self.assertAlmostEqual(sumOfNeg, 0.0)
self.assertArraysAlmostEqual(sumsOfNeg,
np.zeros(3,
'd')) # 3 gates in std.gs_target
self.assertArraysAlmostEqual(magsOfNeg, np.zeros(
12, 'd')) # 3 gates * 4 evals each = 12
def test_gm_basis(self):
cmb = Basis('gm', sum(self.stateSpaceDims))
self.checkBasis(cmb)
def test_std_basis(self):
cmb = Basis('std', sum(self.stateSpaceDims))
self.checkBasis(cmb)
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)
def test_qt(self):
qt = Basis('qt', 3)
qt = Basis('qt', [3])