def test_localnoise_model_comparisons(self):
pspec = QubitProcessorSpec(2, ['Gi', 'Gxpi2', 'Gypi2'],
geometry='line')
ln_mdl1 = create_crosstalk_free_model(pspec,
depolarization_strengths={
('Gxpi2', 0): 0.1
},
lindblad_error_coeffs={
('Gypi2', 1): {
('H', 1): 0.2,
('S', 2): 0.3
}
})
ln_mmg1 = ln_mdl1.create_modelmember_graph()
# Copy, should be similar and equivalent
# TODO: This failed, not sure why yet
#ln_mdl2 = ln_mdl1.copy()
ln_mdl2 = create_crosstalk_free_model(pspec,
depolarization_strengths={
('Gxpi2', 0): 0.1
},
lindblad_error_coeffs={
('Gypi2', 1): {
('H', 1): 0.2,
('S', 2): 0.3
}
})
ln_mmg2 = ln_mdl2.create_modelmember_graph()
self.assertTrue(ln_mmg2.is_similar(ln_mmg1))
self.assertTrue(ln_mmg2.is_equivalent(ln_mmg1))
# Change parameter, similar but not equivalent
ln_mdl3 = create_crosstalk_free_model(pspec,
depolarization_strengths={
('Gxpi2', 0): 0.3
},
lindblad_error_coeffs={
('Gypi2', 1): {
('H', 1): 0.2,
('S', 2): 0.3
}
})
ln_mmg3 = ln_mdl3.create_modelmember_graph()
self.assertTrue(ln_mmg3.is_similar(ln_mmg1))
self.assertFalse(ln_mmg3.is_equivalent(ln_mmg1))
# Change parameterization, not similar or equivalent
# TODO: This was similar because lindblad similarity doesn't take into which error gens are present
#ln_mdl4 = create_crosstalk_free_model(pspec,
# depolarization_strengths={('Gxpi2', 0): 0.1},
# lindblad_error_coeffs={('Gypi2', 1): {('H', 1): 0.2}})
ln_mdl4 = create_crosstalk_free_model(pspec,
depolarization_strengths={
('Gxpi2', 0): 0.1
})
ln_mmg4 = ln_mdl4.create_modelmember_graph()
self.assertFalse(ln_mmg4.is_similar(ln_mmg1))
self.assertFalse(ln_mmg4.is_equivalent(ln_mmg1))
def test_processorspec(self):
# Tests init a pspec using standard gatenames, and all standards.
n = 3
gate_names = [
'Gh', 'Gp', 'Gxpi', 'Gypi', 'Gzpi', 'Gpdag', 'Gcphase', 'Gi'
]
ps = QubitProcessorSpec(n, gate_names=gate_names, geometry='line')
# Tests init a pspec containing 1 qubit (as special case which could break)
n = 1
gate_names = [
'Gh', 'Gp', 'Gxpi', 'Gypi', 'Gzpi', 'Gpdag', 'Gcphase', 'Gi'
]
ps = QubitProcessorSpec(
n, gate_names=gate_names) # no geometry needed for 1-qubit specs
def setUpClass(cls):
super(RBSampleTester, cls).setUpClass()
glist = ['Gxpi2', 'Gypi2', 'Gcnot'] # 'Gi',
cls.pspec_1 = QubitProcessorSpec(4, glist, qubit_labels=['Q0', 'Q1', 'Q2', 'Q3'], geometry='line')
# # XXX this takes nearly a minute to construct on my machine....
# glist = ['Gxpi', 'Gypi', 'Gzpi', 'Gh', 'Gp', 'Gcphase'] # 'Gi',
# availability = {'Gcphase': [(0, 1), (1, 2)]}
# cls.pspec_2 = QubitProcessorSpec(3, glist, availability=availability, geometry='line')
# XXX is this an OK test fixture? see above.
glist = ['Gxpi2', 'Gypi2', 'Gcphase'] # 'Gi',
availability = {'Gcphase': [(0, 1), (1, 2)]}
cls.pspec_2 = QubitProcessorSpec(3, glist, availability=availability, geometry='line')
glist = ['Gxpi2', 'Gxmpi2', 'Gypi2', 'Gympi2', 'Gcnot'] # 'Gi',
cls.pspec_inv = QubitProcessorSpec(4, glist, qubit_labels=['Q0', 'Q1', 'Q2', 'Q3'], geometry='line')
def setUp(self):
self.gst_design = smq1Q_XYI.get_gst_experiment_design(4,
qubit_labels=[0])
nQubits = 2
self.pspec_2Q = QubitProcessorSpec(
nQubits, ('Gx', 'Gy', 'Gcnot'),
geometry="line",
qubit_labels=['qb{}'.format(i) for i in range(nQubits)])
def test_with_spam(self, pth):
pspec_defaults = QubitProcessorSpec(4, ['Gxpi2', 'Gypi2'], geometry='line')
pspec_names = QubitProcessorSpec(4, ['Gxpi2', 'Gypi2'], geometry='line',
prep_names=("rho1", "rho_1100"), povm_names=("Mz",))
prep_vec = np.zeros(2**4, complex)
prep_vec[4] = 1.0
EA = np.zeros(2**4, complex)
EA[14] = 1.0
EB = np.zeros(2**4, complex)
EB[15] = 1.0
pspec_vecs = QubitProcessorSpec(4, ['Gxpi2', 'Gypi2'], geometry='line',
prep_names=("rhoA", "rhoC"), povm_names=("Ma", "Mc"),
nonstd_preps={'rhoA': "rho0", 'rhoC': prep_vec},
nonstd_povms={'Ma': {'0': "0000", '1': EA},
'Mc': {'OutA': "0000", 'OutB': [EA, EB]}})
pspec_defaults = save_and_load(pspec_defaults, pth)
pspec_names = save_and_load(pspec_names, pth)
pspec_vecs = save_and_load(pspec_vecs, pth)
def test_simulate(self):
# TODO optimize
# Create a pspec, to test the circuit simulator.
n = 4
qubit_labels = ['Q' + str(i) for i in range(n)]
gate_names = ['Gh', 'Gp', 'Gxpi', 'Gpdag', 'Gcnot'] # 'Gi',
ps = QubitProcessorSpec(n, gate_names=gate_names, qubit_labels=qubit_labels, geometry='line')
# Tests the circuit simulator
mdl = mc.create_crosstalk_free_model(ps)
c = circuit.Circuit(layer_labels=[Label('Gh', 'Q0'), Label('Gcnot', ('Q0', 'Q1'))], line_labels=['Q0', 'Q1'])
out = c.simulate(mdl)
self.assertLess(abs(out['00'] - 0.5), 10**-10)
self.assertLess(abs(out['11'] - 0.5), 10**-10)
def test_construct_with_nonstd_gate_unitary_factory(self):
nQubits = 2
def fn(args):
if args is None: args = (0,)
a, = args
sigmaZ = np.array([[1, 0], [0, -1]], 'd')
return scipy.linalg.expm(1j * float(a) * sigmaZ)
ps = QubitProcessorSpec(nQubits, ('Gx', 'Gy', 'Gcnot', 'Ga'), nonstd_gate_unitaries={'Ga': fn})
mdl = mc.create_crosstalk_free_model(ps)
c = Circuit("Gx:1Ga;0.3:1Gx:1@(0,1)")
p = mdl.probabilities(c)
self.assertAlmostEqual(p['00'], 0.08733219254516078)
self.assertAlmostEqual(p['01'], 0.9126678074548386)
c2 = Circuit("Gx:1Ga;0.78539816:1Gx:1@(0,1)") # a clifford: 0.78539816 = pi/4
p2 = mdl.probabilities(c2)
self.assertAlmostEqual(p2['00'], 0.5)
self.assertAlmostEqual(p2['01'], 0.5)
def test_simulate_marginalization(self):
pspec = QubitProcessorSpec(4, ['Gx', 'Gy'], geometry='line')
mdl = mc.create_crosstalk_free_model(pspec)
#Same circuit with different line labels
c = circuit.Circuit("Gx:0Gy:0", line_labels=(0,1,2,3))
cp = circuit.Circuit("Gx:0Gy:0", line_labels=(1,2,0,3))
c01 = circuit.Circuit("Gx:0Gy:0", line_labels=(0,1))
c10 = circuit.Circuit("Gx:0Gy:0", line_labels=(1,0))
c0 = circuit.Circuit("Gx:0Gy:0", line_labels=(0,))
#Make sure mdl.probabilities and circuit.simulate give us the correct answers
pdict = mdl.probabilities(c)
self.assertEqual(len(pdict), 16) # all of 0000 -> 1111
self.assertAlmostEqual(pdict['0000'], 0.5)
self.assertAlmostEqual(pdict['1000'], 0.5)
pdict = mdl.probabilities(cp)
self.assertEqual(len(pdict), 16) # all of 0000 -> 1111
self.assertAlmostEqual(pdict['0000'], 0.5)
self.assertAlmostEqual(pdict['0010'], 0.5)
pdict = mdl.probabilities(c01)
self.assertEqual(len(pdict), 4) # all of 00 -> 11
self.assertAlmostEqual(pdict['00'], 0.5)
self.assertAlmostEqual(pdict['10'], 0.5)
pdict = mdl.probabilities(c10)
self.assertEqual(len(pdict), 4) # all of 00 -> 11
self.assertAlmostEqual(pdict['00'], 0.5)
self.assertAlmostEqual(pdict['01'], 0.5)
pdict = mdl.probabilities(c0)
self.assertEqual(len(pdict), 2) # all of 0 -> 1
self.assertAlmostEqual(pdict['0'], 0.5)
self.assertAlmostEqual(pdict['1'], 0.5)
## SAME results from circuit.simulate, except with smaller dicts (because 0s are dropped)
pdict = c.simulate(mdl)
self.assertEqual(len(pdict), 2)
self.assertAlmostEqual(pdict['0000'], 0.5)
self.assertAlmostEqual(pdict['1000'], 0.5)
pdict = cp.simulate(mdl)
self.assertEqual(len(pdict), 2)
self.assertAlmostEqual(pdict['0000'], 0.5)
self.assertAlmostEqual(pdict['0010'], 0.5)
pdict = c01.simulate(mdl)
self.assertEqual(len(pdict), 2)
self.assertAlmostEqual(pdict['00'], 0.5)
self.assertAlmostEqual(pdict['10'], 0.5)
pdict = c10.simulate(mdl)
self.assertEqual(len(pdict), 2)
self.assertAlmostEqual(pdict['00'], 0.5)
self.assertAlmostEqual(pdict['01'], 0.5)
pdict = c0.simulate(mdl)
self.assertEqual(len(pdict), 2)
self.assertAlmostEqual(pdict['0'], 0.5)
self.assertAlmostEqual(pdict['1'], 0.5)
from pygsti.baseobjs import Label
from pygsti.processors import QubitProcessorSpec
from pygsti.processors import CliffordCompilationRules
from pygsti.circuits import Circuit
from pygsti.tools import symplectic
from ..util import BaseCase, Namespace
## Immutable test fixture data
fixture_1Q = Namespace(
n=1,
# arbitrary symplectic representation of a 1-qubit Clifford
# (generated with `symplectic.random_clifford(1)`)
clifford_sym=np.array([[1, 0], [0, 1]], dtype=np.int8),
clifford_phase=np.array([0, 2]))
fixture_1Q.pspec = QubitProcessorSpec(
num_qubits=1,
gate_names=['Gcnot', 'Gh', 'Gp', 'Gxpi', 'Gypi', 'Gzpi'],
geometry='line')
fixture_1Q.clifford_abs = CliffordCompilationRules.create_standard(
fixture_1Q.pspec,
compile_type="absolute",
what_to_compile=("1Qcliffords", "paulis"),
verbosity=1)
fixture_1Q.clifford_peq = CliffordCompilationRules.create_standard(
fixture_1Q.pspec,
compile_type="paulieq",
what_to_compile=("1Qcliffords", "allcnots"),
verbosity=1)
fixture_2Q = Namespace(
n=2,
qubit_labels=['Q0', 'Q1'],
def save_and_load(obj, pth):
obj.write(pth + ".json")
return QubitProcessorSpec.read(pth + '.json')
def setUp(self):
nQubits = 2
self.pspec_2Q = QubitProcessorSpec(
nQubits, ('Gx', 'Gy', 'Gcnot'),
geometry="line",
qubit_labels=['qb{}'.format(i) for i in range(nQubits)])