def test_raises_on_bad_values(self):
with self.assertRaises(ValueError):
op.StaticStandardOp('BadGate', 'pp', 'statevec')
with self.assertRaises(ValueError):
op.StaticStandardOp('BadGate', 'pp', 'densitymx')
with self.assertRaises(ModuleNotFoundError):
op.StaticStandardOp('Gi', 'pp', 'not_an_evotype')
def test_statevec(self):
std_unitaries = itgs.standard_gatename_unitaries()
for name, U in std_unitaries.items():
if callable(U):
continue # skip unitary functions (create factories)
try:
svop = op.StaticStandardOp(name,
'pp',
'statevec',
state_space=None)
except ModuleNotFoundError: # if 'statevec' isn't built (no cython)
svop = op.StaticStandardOp(name,
'pp',
'statevec_slow',
state_space=None)
self.assertArraysAlmostEqual(svop._rep.to_dense('Hilbert'), U)
def test_chp(self):
std_chp_ops = itgs.standard_gatenames_chp_conversions()
for name, ops in std_chp_ops.items():
if not name.startswith('G'):
continue # currently the 'h', 'p', 'm' gates aren't "standard" yet because they lack unitaries
chpop = op.StaticStandardOp(name, 'pp', 'chp', state_space=None)
op_str = '\n'.join(ops)
if len(op_str):
op_str += '\n'
self.assertEqual(chpop._rep.chp_str(), op_str)
def process_computational_state(rho, target_offset=0):
assert isinstance(rho, _state.ComputationalBasisState), \
"CHP prep must be ComputationalBasisState (may be inside ComposedState/TensorProductState)"
bitflip = _op.StaticStandardOp('Gxpi',
'pp',
evotype='chp',
state_space=None)
for i, zval in enumerate(rho._zvals):
if zval:
file_handle.write(bitflip.chp_str)
def test_densitymx_svterm_cterm(self):
std_unitaries = itgs.standard_gatename_unitaries()
for evotype in ['default']: # 'densitymx', 'svterm', 'cterm'
for name, U in std_unitaries.items():
if callable(U):
continue # skip unitary functions (create factories)
dmop = op.StaticStandardOp(name,
'pp',
evotype,
state_space=None)
self.assertArraysAlmostEqual(
dmop._rep.to_dense('HilbertSchmidt'),
gt.unitary_to_pauligate(U))
class ComposedSpamvecBase(object):
base_prep_vec = sv.ComputationalBasisState([0], 'pp', 'default')
base_noise_op = op.StaticStandardOp('Gxpi2', 'pp',
'default') # X(pi/2) rotation as noise
base_povm = pv.ComputationalBasisPOVM(1, 'default') # Z-basis measurement
expected_out = ld.OutcomeLabelDict([(('0', ), 0.5), (('1', ), 0.5)])
def setUp(self):
self.vec = self.build_vec()
ExplicitOpModel._strict = False
def test_num_params(self):
self.assertEqual(self.vec.num_params, self.n_params)
def test_get_dimension(self):
self.assertEqual(self.vec.dim, 4)
def test_hessian(self):
if self.n_params:
self.assertTrue(self.vec.has_nonzero_hessian())
else:
self.assertFalse(self.vec.has_nonzero_hessian())
def test_forward_simulation(self):
pure_vec = self.vec.state_vec
noise_op = self.vec.error_map
# TODO: Would be nice to check more than densitymx evotype
indep_mdl = ExplicitOpModel(['Q0'], evotype='default')
indep_mdl['rho0'] = pure_vec
indep_mdl['G0'] = noise_op
indep_mdl['Mdefault'] = self.base_povm
indep_mdl.num_params # triggers paramvec rebuild
composed_mdl = ExplicitOpModel(['Q0'], evotype='default')
composed_mdl['rho0'] = self.vec
composed_mdl['Mdefault'] = self.base_povm
composed_mdl.num_params # triggers paramvec rebuild
# Sanity check
indep_circ = Circuit(['rho0', 'G0', 'Mdefault'])
indep_probs = indep_mdl.probabilities(indep_circ)
for k, v in indep_probs.items():
self.assertAlmostEqual(self.expected_out[k], v)
composed_circ = Circuit(['rho0', 'Mdefault'])
composed_probs = composed_mdl.probabilities(composed_circ)
for k, v in composed_probs.items():
self.assertAlmostEqual(self.expected_out[k], v)
class ComposedPovmBase(object):
base_prep = sv.ComputationalBasisState([0], 'pp',
'default') # 0 state prep
base_noise_op = op.StaticStandardOp('Gxpi2', 'pp',
'default') # X(pi/2) rotation as noise
base_povm = pv.ComputationalBasisPOVM(1, 'default') # Z-basis measurement
expected_out = ld.OutcomeLabelDict([(('0', ), 0.5), (('1', ), 0.5)])
def setUp(self):
self.povm = self.build_povm()
ExplicitOpModel._strict = False
def test_num_params(self):
self.assertEqual(self.povm.num_params, self.n_params)
def test_get_dimension(self):
self.assertEqual(self.povm.state_space.dim, 4)
def test_forward_simulation(self):
pure_povm = self.povm.base_povm
noise_op = self.povm.error_map
# TODO: Would be nice to check more than densitymx evotype
indep_mdl = ExplicitOpModel(['Q0'], evotype='default')
indep_mdl['rho0'] = self.base_prep
indep_mdl['G0'] = noise_op.copy()
indep_mdl['Mdefault'] = pure_povm
indep_mdl._clean_paramvec()
composed_mdl = ExplicitOpModel(['Q0'], evotype='default')
composed_mdl['rho0'] = self.base_prep
composed_mdl['Mdefault'] = self.povm
composed_mdl._clean_paramvec()
# Sanity check
indep_circ = Circuit(['rho0', 'G0', 'Mdefault'])
indep_probs = indep_mdl.probabilities(indep_circ)
for k, v in indep_probs.items():
self.assertAlmostEqual(self.expected_out[k], v)
composed_circ = Circuit(['rho0', 'Mdefault'])
composed_probs = composed_mdl.probabilities(composed_circ)
for k, v in composed_probs.items():
self.assertAlmostEqual(self.expected_out[k], v)