Address Feedback

Add a number of changes to address feedback on PR. Adds some try-excepts around stim imports, fixes a few bugs and renames a function.

Author: Corey Ostrove

Diff for: pygsti/baseobjs/errorgenbasis.py

@@ -724,7 +724,7 @@ def elemgen_supports_and_matrices(self):
         """
         return  tuple(zip(self.elemgen_supports, self.elemgen_matrices))
 
-    def label_index(self, label, ok_if_missing=False):
+    def label_index(self, label, ok_if_missing=False, identity_label='I'):
         """
         Return the index of the specified elementary error generator label
         in this basis' `labels` list.
@@ -736,12 +736,13 @@ def label_index(self, label, ok_if_missing=False):
         
         ok_if_missing : bool
            If True, then returns `None` instead of an integer when the given label is not present.
+        
+        identity_label : str, optional (default 'I')
+            An optional string specifying the label used to denote the identity in basis element labels.
         """
-        #CIO: I don't entirely understand the intention behind this method, so rather than trying to make it work
-        #using `LocalElementaryErrorgenLabel` I'll just assert it is a global one for now...
         if isinstance(label, _LocalElementaryErrorgenLabel):
-            raise NotImplementedError('This method is not currently implemented for `LocalElementaryErrorgenLabel` inputs.')
-        
+            label = _GlobalElementaryErrorgenLabel.cast(label, self.sslbls, identity_label=identity_label)
+
         support = label.sslbls
         eetype = label.errorgen_type
         bels = label.basis_element_labels

Diff for: pygsti/errorgenpropagation/errorpropagator.py

@@ -6,8 +6,14 @@
 # in compliance with the License.  You may obtain a copy of the License at
 # http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
 #***************************************************************************************************
-
-import stim
+import warnings
+try:
+    import stim
+except ImportError:
+    msg = "Stim is required for use of the error generator propagation module, " \
+          "and it does not appear to be installed. If you intend to use this module please update" \
+          " your environment."
+    warnings.warn(msg)
 import numpy as _np
 import scipy.linalg as _spl
 from .localstimerrorgen import LocalStimErrorgenLabel as _LSE

Diff for: pygsti/errorgenpropagation/localstimerrorgen.py

@@ -9,7 +9,10 @@
 
 from pygsti.baseobjs.errorgenlabel import ElementaryErrorgenLabel as _ElementaryErrorgenLabel, GlobalElementaryErrorgenLabel as _GEEL,\
 LocalElementaryErrorgenLabel as _LEEL
-import stim
+try:
+    import stim
+except ImportError:
+    pass
 import numpy as _np
 from pygsti.tools import change_basis
 from pygsti.tools.lindbladtools import create_elementary_errorgen

Diff for: pygsti/tools/errgenproptools.py

@@ -10,7 +10,15 @@
 # http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
 #***************************************************************************************************
 
-import stim
+import warnings
+try:
+    import stim
+except ImportError:
+    msg = "Stim is required for use of the error generator propagation tools module, " \
+          "and it does not appear to be installed. If you intend to use this module please update" \
+          " your environment."
+    warnings.warn(msg)
+
 import numpy as _np
 from pygsti.baseobjs.errorgenlabel import GlobalElementaryErrorgenLabel as _GEEL, LocalElementaryErrorgenLabel as _LEEL
 from pygsti.baseobjs import QubitSpace as _QubitSpace

Diff for: pygsti/tools/jamiolkowski.py

@@ -327,7 +327,7 @@ def sums_of_negative_choi_eigenvalues(model):
     """
     ret = []
     for (_, gate) in model.operations.items():
-        J = fast_jamiolkowski_iso_std(gate.to_dense(), model.basis)  # Choi mx basis doesn't matter
+        J = fast_jamiolkowski_iso_std(gate.to_dense(on_space='HilbertSchmidt'), model.basis)  # Choi mx basis doesn't matter
         evals = _np.linalg.eigvals(J)  # could use eigvalsh, but wary of this since eigh can be wrong...
         sumOfNeg = 0.0
         for ev in evals:

Diff for: pygsti/tools/lindbladtools.py

@@ -506,7 +506,7 @@ def create_lindbladian_term_errorgen(typ, Lm, Ln=None, sparse=False):  # noqa N8
     return lind_errgen
 
 
-def random_error_generator_rates(num_qubits, errorgen_types=('H', 'S', 'C', 'A'), max_weights=None,
+def random_CPTP_error_generator_rates(num_qubits, errorgen_types=('H', 'S', 'C', 'A'), max_weights=None,
                                  H_params=(0.,.01), SCA_params=(0.,.01), error_metric=None, error_metric_value=None, 
                                  relative_HS_contribution=None, fixed_errorgen_rates=None, sslbl_overlap=None, 
                                  label_type='global', seed=None, qubit_labels=None):

Diff for: test/unit/objects/test_errorgenbasis.py

@@ -107,10 +107,12 @@ def test_label_index(self):
         labels = self.complete_errorgen_basis_default_1Q.labels
 
         test_eg = GlobalElementaryErrorgenLabel('C', ['X', 'Y'], (0,))
+        test_eg_local = LocalElementaryErrorgenLabel('C', ['XI', 'YI'])
         test_eg_missing = GlobalElementaryErrorgenLabel('C', ['X', 'Y'], (1,))
 
         lbl_idx = self.complete_errorgen_basis_default_1Q.label_index(test_eg)
-
+        lbl_idx_1 = self.complete_errorgen_basis_default_1Q.label_index(test_eg_local)
+        assert lbl_idx == lbl_idx_1
         assert lbl_idx ==  labels.index(test_eg)
 
         with self.assertRaises(KeyError):

Diff for: test/unit/tools/test_lindbladtools.py

@@ -94,7 +94,7 @@ def test_elementary_errorgen_bases(self):
 class RandomErrorgenRatesTester(BaseCase):
 
     def test_default_settings(self):
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, seed=1234, label_type='local')
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, seed=1234, label_type='local')
 
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 240)
@@ -105,31 +105,31 @@ def test_default_settings(self):
 
     def test_sector_restrictions(self):
         #H-only:
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H',), seed=1234)
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H',), seed=1234)
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 15)
         #also make sure this is CPTP, do so by constructing an error generator and confirming it doesn't fail
         #with CPTP parameterization. This should fail if the error generator dictionary is not CPTP.
         errorgen = LindbladErrorgen.from_elementary_errorgens(random_errorgen_rates, parameterization='CPTPLND', truncate=False, state_space=QubitSpace(2))
 
         #S-only
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('S',), seed=1234)
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('S',), seed=1234)
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 15)
         #also make sure this is CPTP, do so by constructing an error generator and confirming it doesn't fail
         #with CPTP parameterization. This should fail if the error generator dictionary is not CPTP.
         errorgen = LindbladErrorgen.from_elementary_errorgens(random_errorgen_rates, parameterization='CPTPLND', truncate=False, state_space=QubitSpace(2))
 
         #H+S
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), seed=1234)
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), seed=1234)
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 30)
         #also make sure this is CPTP, do so by constructing an error generator and confirming it doesn't fail
         #with CPTP parameterization. This should fail if the error generator dictionary is not CPTP.
         errorgen = LindbladErrorgen.from_elementary_errorgens(random_errorgen_rates, parameterization='CPTPLND', truncate=False, state_space=QubitSpace(2))
 
         #H+S+A
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S','A'), seed=1234)
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S','A'), seed=1234)
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 135)
         #also make sure this is CPTP, do so by constructing an error generator and confirming it doesn't fail
@@ -138,7 +138,7 @@ def test_sector_restrictions(self):
 
     def test_error_metric_restrictions(self):
         #test generator_infidelity
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 error_metric= 'generator_infidelity', 
                                                                 error_metric_value=.99, seed=1234)
         #confirm this has the correct generator infidelity.
@@ -152,7 +152,7 @@ def test_error_metric_restrictions(self):
         assert abs(gen_infdl-.99)<1e-5
 
         #test generator_error
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 error_metric= 'total_generator_error', 
                                                                 error_metric_value=.99, seed=1234)
         #confirm this has the correct generator infidelity.
@@ -166,7 +166,7 @@ def test_error_metric_restrictions(self):
         assert abs(gen_error-.99)<1e-5
 
         #test relative_HS_contribution:
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 error_metric= 'generator_infidelity', 
                                                                 error_metric_value=.99, 
                                                                 relative_HS_contribution=(.5, .5), seed=1234)
@@ -181,7 +181,7 @@ def test_error_metric_restrictions(self):
 
         assert abs(gen_infdl_S - gen_infdl_H)<1e-5
 
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 error_metric= 'total_generator_error', 
                                                                 error_metric_value=.99, 
                                                                 relative_HS_contribution=(.5, .5), seed=1234)
@@ -198,41 +198,41 @@ def test_error_metric_restrictions(self):
 
     def test_fixed_errorgen_rates(self):
         fixed_rates_dict = {GlobalElementaryErrorgenLabel('H', ('X',), (0,)): 1}
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 fixed_errorgen_rates=fixed_rates_dict, 
                                                                 seed=1234)
 
         self.assertEqual(random_errorgen_rates[GlobalElementaryErrorgenLabel('H', ('X',), (0,))], 1)
 
     def test_label_type(self):
 
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 label_type='local', seed=1234)
         assert isinstance(next(iter(random_errorgen_rates)), LocalElementaryErrorgenLabel)
 
     def test_sslbl_overlap(self):
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S'), 
                                                                 sslbl_overlap=(0,), 
                                                                 seed=1234)
         for coeff in random_errorgen_rates:
             assert 0 in coeff.sslbls
 
     def test_weight_restrictions(self):
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S','C','A'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S','C','A'), 
                                                                 label_type='local', seed=1234,
                                                                 max_weights={'H':1, 'S':1, 'C':1, 'A':1})
         assert len(random_errorgen_rates) == 24
         #confirm still CPTP
         errorgen = LindbladErrorgen.from_elementary_errorgens(random_errorgen_rates, parameterization='CPTPLND', truncate=False, state_space=QubitSpace(2))
 
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, errorgen_types=('H','S','C','A'), 
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, errorgen_types=('H','S','C','A'), 
                                                                 label_type='local', seed=1234,
                                                                 max_weights={'H':2, 'S':2, 'C':1, 'A':1})
         assert len(random_errorgen_rates) == 42
         errorgen = LindbladErrorgen.from_elementary_errorgens(random_errorgen_rates, parameterization='CPTPLND', truncate=False, state_space=QubitSpace(2))
 
     def test_global_labels(self):
-        random_errorgen_rates = lt.random_error_generator_rates(num_qubits=2, seed=1234, label_type='global')
+        random_errorgen_rates = lt.random_CPTP_error_generator_rates(num_qubits=2, seed=1234, label_type='global')
 
         #make sure that we get the expected number of rates:
         self.assertEqual(len(random_errorgen_rates), 240)