Initialize dictionaries with braces

This results in performance improvement. See https://pylint.readthedocs.io/en/latest/user_guide/messages/refactor/use-dict-literal.html and https://gist.github.com/hofrob/ad143aaa84c096f42489c2520a3875f9

Author: apozas

inflation/InflationProblem.py

@@ -188,7 +188,7 @@ def __init__(self,
                     self._classical_sources[ii] = 1
         self._nonclassical_sources = np.logical_not(self._classical_sources).astype(np.uint8)
 
-        self._partial_inverse_dag = dict()
+        self._partial_inverse_dag = {}
         for il in self.intermediate_latents:
             this_ils_parents = set(v for (v, kids) in self.dag.items() if il in kids)
             self._partial_inverse_dag[il] = this_ils_parents
@@ -625,7 +625,7 @@ def names_to_ints(self) -> dict:
     # FUNCTIONS PERTAINING TO KNOWABILITY                                     #
     ###########################################################################
     def _interpret_operator(self, op: np.ndarray) -> dict:
-        interpretation = dict()
+        interpretation = {}
         party_int = op[0] -1
         interpretation["Party as Integer"] = party_int
         interpretation["Party"] = self.names[party_int]

inflation/lp/InflationLP.py

@@ -99,7 +99,7 @@ def __init__(self,
         self.names_to_ints = inflationproblem.names_to_ints
         self._lexrepr_to_names = inflationproblem._lexrepr_to_names
         self._lexrepr_to_copy_index_free_names = inflationproblem._lexrepr_to_copy_index_free_names
-        self.op_from_name = dict()
+        self.op_from_name = {}
         for i, op_names in enumerate(inflationproblem._lexrepr_to_all_names.tolist()):
             for op_name in op_names:
                 self.op_from_name.setdefault(op_name, i)
@@ -187,10 +187,10 @@ def __init__(self,
         # init so as to be able to test the Monomial constructor function
         # without generate_lp.
 
-        self._atomic_monomial_from_hash  = dict()
-        self.monomial_from_atoms        = dict()
-        self.monomial_from_name = dict()
-        self.monomial_from_symbol = dict()
+        self._atomic_monomial_from_hash  = {}
+        self.monomial_from_atoms        = {}
+        self.monomial_from_name = {}
+        self.monomial_from_symbol = {}
         self.One  = self.Monomial(self.identity_operator, idx=1)
         self._generate_lp()
 
@@ -250,7 +250,7 @@ def atomic_monomials(self):
     @cached_property
     def atom_from_name(self):
         """Returns the atomic monomials."""
-        lookup_dict = dict()
+        lookup_dict = {}
         for atom in self.atomic_factors:
             lookup_dict[atom.name] = atom
             lookup_dict[atom.legacy_name] = atom
@@ -270,7 +270,7 @@ def do_conditional_atoms(self):
     @cached_property
     def factorization_conditions(self):
         """Returns the factorization conditions."""
-        conds = dict()
+        conds = {}
         for mon in self.monomials:
             if mon.n_factors > 1:
                 conds[mon] = tuple(self.monomial_from_atoms[(fac,)]
@@ -280,7 +280,7 @@ def factorization_conditions(self):
     @cached_property
     def quadratic_factorization_conditions(self):
         """Returns the quadratic factorization conditions."""
-        conds = dict()
+        conds = {}
         for mon in self.monomials:
             if mon.n_factors > 1:
                 conds[mon] = (self.monomial_from_atoms[mon.factors[:1]],
@@ -322,7 +322,7 @@ def set_distribution(self,
             knowable_values = {atom: atom.compute_marginal(prob_array)
                                for atom in self.knowable_atoms}
         else:
-            knowable_values = dict()
+            knowable_values = {}
 
         self.set_values(knowable_values,
                         use_lpi_constraints=use_lpi_constraints,
@@ -671,7 +671,7 @@ def certificate_as_dict(self,
                  "polynomial constraints, the certificate is not guaranteed " +
                  "to apply to other distributions.")
         if np.allclose(list(dual.values()), 0.):
-            return dict()
+            return {}
         if clean:
             dual = clean_coefficients(dual, chop_tol, round_decimals)
         return {self.monomial_from_name[k]: v for k, v in dual.items()
@@ -1126,7 +1126,7 @@ def _sanitise_dict(self, input_dict: Any) -> Dict:
             if input_dict.free_symbols:
                 input_dict_copy = {k: float(v) for k, v in sp.expand(input_dict).as_coefficients_dict().items()}
             else:
-                input_dict_copy = dict()
+                input_dict_copy = {}
         else:
             input_dict_copy = input_dict
         output_dict = defaultdict(int)
@@ -1244,8 +1244,8 @@ def _generate_lp(self) -> None:
         if self.generate_lp_has_been_called:
             return None
 
-        self._atomic_monomial_from_hash = dict()
-        self.monomial_from_atoms = dict()
+        self._atomic_monomial_from_hash = {}
+        self.monomial_from_atoms = {}
         self.Constant_Term = self.One.__copy__()
         self.Constant_Term.name = self.constant_term_name
         self.monomial_from_name[self.constant_term_name] = self.Constant_Term
@@ -1302,9 +1302,9 @@ def _generate_lp(self) -> None:
         # Associate Monomials to the remaining entries.
         _monomials = []
         _monomial_names = []
-        _compmonomial_from_idx = dict()
-        _compmonomial_to_idx = dict()
-        boolvec2mon = dict()
+        _compmonomial_from_idx = {}
+        _compmonomial_to_idx = {}
+        boolvec2mon = {}
         for idx, mon_as_lexboolvec in tqdm(enumerate(self._monomials_as_lexboolvecs),
                              disable=not self.verbose,
                              desc="Initializing monomials   ",
@@ -1673,7 +1673,7 @@ def _cleanup_after_set_values(self) -> None:
             for mon in nonzero_known_monomials:
                 self.moment_lowerbounds[mon] = 1.
                 del self.known_moments[mon]
-            self.semiknown_moments = dict()
+            self.semiknown_moments = {}
         num_nontrivial_known = len(self.known_moments)
         if self.verbose > 1 and num_nontrivial_known > 1:
             eprint("Number of variables with fixed numeric value:",
@@ -1694,12 +1694,12 @@ def _reset_bounds(self) -> None:
     def _reset_lowerbounds(self) -> None:
         """Reset the list of lower bounds."""
         self._reset_solution()
-        self.moment_lowerbounds = dict()
+        self.moment_lowerbounds = {}
 
     def _reset_upperbounds(self) -> None:
         """Reset the list of upper bounds."""
         self._reset_solution()
-        self.moment_upperbounds = dict()
+        self.moment_upperbounds = {}
 
     def _reset_objective(self) -> None:
         """Reset the objective function."""
@@ -1710,8 +1710,8 @@ def _reset_objective(self) -> None:
     def _reset_values(self) -> None:
         """Reset the known values."""
         self._reset_solution()
-        self.known_moments     = dict()
-        self.semiknown_moments = dict()
+        self.known_moments     = {}
+        self.semiknown_moments = {}
         self.known_moments[self.One] = 1.
         self.extra_equalities = []
         self.extra_inequalities = []
@@ -1996,7 +1996,7 @@ def _set_upperbounds(self, upperbounds: Union[dict, None]) -> None:
         self._reset_upperbounds()
         if upperbounds is None:
             return
-        sanitized_upperbounds = dict()
+        sanitized_upperbounds = {}
         for mon, upperbound in upperbounds.items():
             mon = self._sanitise_monomial(mon)
             if mon not in sanitized_upperbounds.keys():
@@ -2022,7 +2022,7 @@ def _set_lowerbounds(self, lowerbounds: Union[dict, None]) -> None:
         self._reset_lowerbounds()
         if lowerbounds is None:
             return
-        sanitized_lowerbounds = dict()
+        sanitized_lowerbounds = {}
         for mon, lowerbound in lowerbounds.items():
             mon = self._sanitise_monomial(mon)
             if mon not in sanitized_lowerbounds.keys():

inflation/sdp/InflationSDP.py

@@ -204,15 +204,15 @@ def __init__(self,
             self.all_commuting_q_2d = \
                 lambda mon: self.all_commuting_q_1d(self.mon_to_lexrepr(mon))
 
-        self.canon_lexmon_from_hash     = dict()
-        self.canonsym_lexmon_from_hash  = dict()
+        self.canon_lexmon_from_hash     = {}
+        self.canonsym_lexmon_from_hash  = {}
         # These next properties are reset during generate_relaxation, but
         # are needed in init so as to be able to test the Monomial constructor
         # function without generate_relaxation.
-        self.atomic_monomial_from_hash  = dict()
-        self.monomial_from_atoms        = dict()
-        self.monomial_from_name         = dict()
-        self.monomial_from_symbol       = dict()
+        self.atomic_monomial_from_hash  = {}
+        self.monomial_from_atoms        = {}
+        self.monomial_from_name         = {}
+        self.monomial_from_symbol       = {}
         self.Zero = self.Moment_2d(self.zero_operator, idx=0)
         self.One  = self.Moment_2d(self.identity_operator, idx=1)
         self._relaxation_has_been_generated = False
@@ -298,10 +298,10 @@ def generate_relaxation(self,
             Additional arguments that will be passed to
             ``InflationSDP.build_columns``.
         """
-        self.atomic_monomial_from_hash  = dict()
-        self.monomial_from_atoms        = dict()
-        self.monomial_from_name         = dict()
-        self.monomial_from_symbol       = dict()
+        self.atomic_monomial_from_hash  = {}
+        self.monomial_from_atoms        = {}
+        self.monomial_from_name         = {}
+        self.monomial_from_symbol       = {}
         self.Zero = self.Moment_2d(self.zero_operator, idx=0)
         self.One  = self.Moment_2d(self.identity_operator, idx=1)
         self.Constant_Term = self.One.__copy__()
@@ -351,7 +351,7 @@ def generate_relaxation(self,
 
         # Associate Monomials to the remaining entries. The zero monomial is
         # not stored during calculate_momentmatrix
-        self.compmoment_from_idx = dict()
+        self.compmoment_from_idx = {}
         if self.momentmatrix_has_a_zero:
             self.compmoment_from_idx[0] = self.Zero
         for (idx, lexmon) in tqdm(self.symmetrized_corresp.items(),
@@ -409,13 +409,13 @@ def generate_relaxation(self,
                 self.minimal_equalities.append(eq_dict)
 
         self.minimal_inequalities = []
-        self.moment_upperbounds  = dict()
+        self.moment_upperbounds  = {}
         self.moment_lowerbounds  = {m: 0. for m in self.hermitian_moments}
 
         self.set_objective(None)
         self.set_values(None)
 
-        self.maskmatrices = dict()
+        self.maskmatrices = {}
         self._relaxation_has_been_generated = True
 
     def set_extra_equalities(self,
@@ -492,7 +492,7 @@ def set_bounds(self,
         if bounds is None:
             return
         # Sanitize list of bounds
-        sanitized_bounds = dict()
+        sanitized_bounds = {}
         for mon, bound in bounds.items():
             mon = self._sanitise_moment(mon)
             if mon not in sanitized_bounds.keys():
@@ -525,7 +525,7 @@ def atomic_monomials(self):
     @cached_property
     def atom_from_name(self):
         """Returns the atomic monomials."""
-        lookup_dict = dict()
+        lookup_dict = {}
         for atom in self.atomic_factors:
             lookup_dict[atom.name] = atom
             lookup_dict[atom.legacy_name] = atom
@@ -583,7 +583,7 @@ def set_distribution(self,
             knowable_values = {atom: atom.compute_marginal(prob_array)
                                for atom in self.knowable_atoms}
         else:
-            knowable_values = dict()
+            knowable_values = {}
 
         self.set_values(knowable_values,
                         use_lpi_constraints=use_lpi_constraints,
@@ -882,7 +882,7 @@ def certificate_as_dict(self,
                  "polynomial constraints, the certificate is not guaranteed " +
                  "to apply to other distributions.")
         if np.allclose(list(dual.values()), 0.):
-            return dict()
+            return {}
         if clean:
             dual = clean_coefficients(dual, chop_tol, round_decimals)
         return {self.monomial_from_name[k]: v for k, v in dual.items()
@@ -1586,7 +1586,7 @@ def _sanitise_dict(self, input_dict: Any) -> Dict:
                 input_dict_copy = {k: float(v) for k, v in sp.expand(
                     input_dict).as_coefficients_dict().items()}
             else:
-                input_dict_copy = dict()
+                input_dict_copy = {}
         else:
             input_dict_copy = input_dict
         output_dict = defaultdict(int)
@@ -1835,7 +1835,7 @@ def _discover_normalization_eqns(self) -> List[Tuple[int, List[int]]]:
 
         # This will allow for easy substitution of operators with the last
         # outcome with the rest of the operators orthogonal to it
-        lexmon_to_orthogroup = dict()
+        lexmon_to_orthogroup = {}
         for group in self.InflationProblem._ortho_groups:
             last_outcome_op = \
                 self.mon_to_lexrepr(np.expand_dims(group[-1], axis=0))[0]
@@ -1970,7 +1970,7 @@ def _cleanup_after_set_values(self) -> None:
             for mon in nonzero_known_monomials:
                 self.moment_lowerbounds[mon] = 1.
                 del self.known_moments[mon]
-            self.semiknown_moments = dict()
+            self.semiknown_moments = {}
 
         self._update_bounds("lo")
         self._update_bounds("up")
@@ -1999,7 +1999,7 @@ def _reset_lowerbounds(self) -> None:
     def _reset_upperbounds(self) -> None:
         """Reset the list of upper bounds."""
         self._reset_solution()
-        self.moment_upperbounds = dict()
+        self.moment_upperbounds = {}
 
     def _reset_objective(self) -> None:
         """Reset the objective function."""
@@ -2011,8 +2011,8 @@ def _reset_objective(self) -> None:
     def _reset_values(self) -> None:
         """Reset the known values."""
         self._reset_solution()
-        self.known_moments     = dict()
-        self.semiknown_moments = dict()
+        self.known_moments     = {}
+        self.semiknown_moments = {}
         if self.momentmatrix_has_a_zero:
             self.known_moments[self.Zero] = 0.
         self.known_moments[self.One] = 1.

inflation/sdp/quantum_tools.py

@@ -117,7 +117,7 @@ def calculate_momentmatrix_1d_internal(cols: List,
         string representation to integer representation.
     """
     nrcols = len(cols)
-    canonical_mon_to_idx = dict()
+    canonical_mon_to_idx = {}
     momentmatrix = np.zeros((nrcols, nrcols), dtype=np.uint32)
     varidx = 1  # We start from 1 because 0 is reserved for 0
     for (i, mon1), (j, mon2) in tqdm(

inflation/sdp/writer_utils.py

@@ -33,13 +33,13 @@ def convert_to_human_readable(problem):
     constants = {moment.idx: str(value)
                  for moment, value in problem.known_moments.items()}
     # Replacer for semiknowns
-    semiknowns = dict()
+    semiknowns = {}
     for key, val in problem.semiknown_moments.items():
         val_str = val[1].name.replace(", ", ";")
         semiknowns[key.idx] = f"{val[0]}*{val_str}"
     semiknown_replacer = np.vectorize(lambda x: semiknowns.get(x, str(x)))
     # Replacer for remaining symbols
-    monomials = dict()
+    monomials = {}
     for mon in problem.moments:
         monomials[mon.idx] = mon.name.replace(", ", ";")
 

inflation/utils.py

@@ -238,7 +238,7 @@ def make_numerical(symbolic_expressions: Dict[Any, sympy.core.expr.Expr],
     Dict[Any, float]
         The dictionary with same keys and evaluated expressions as values.
     """
-    numeric_values = dict()
+    numeric_values = {}
     for k, v in symbolic_expressions.items():
         try:
             numeric_values[k] = float(v.evalf(subs=symbols_to_values))