Fix merge errors

Author: apozas

inflation/lp/InflationLP.py

@@ -159,14 +159,14 @@ def __init__(self,
         # them to inequalities when the LHS is non_CG but childless-only.
         if np.any(self.does_not_have_children):
             bad_boolvecs_for_ineqs = [bool_array[-1] for bool_array in self._CG_adjusting_ortho_groups_as_boolarrays]
-            self._boolvec_for_not_being_in_CG_notation = np.bitwise_or.reduce(bad_boolvecs_for_ineqs, axis=0)
+            self._boolvec_for_CG_ineqs = np.bitwise_or.reduce(bad_boolvecs_for_ineqs, axis=0)
         else:
-            self._boolvec_for_not_being_in_CG_notation = self.blank_bool_vec
+            self._boolvec_for_CG_ineqs = self.blank_bool_vec
         if np.any(self.has_children):
-            bad_boolvecs_for_eqs = [bool_array[-1] for bool_array in self._CG_nonadjusting_ortho_groups_as_boolarrays]
-            self._boolvec_to_trigger_equality_generation = np.bitwise_or.reduce(bad_boolvecs_for_eqs, axis=0)
+            bad_boolvecs_for_eqs = [bool_array[0] for bool_array in self._CG_nonadjusting_ortho_groups_as_boolarrays]
+            self._boolvec_for_FR_eqs = np.bitwise_or.reduce(bad_boolvecs_for_eqs, axis=0)
         else:
-            self._boolvec_to_trigger_equality_generation = self.blank_bool_vec
+            self._boolvec_for_FR_eqs = self.blank_bool_vec
 
         if self.verbose > 1:
             print("Number of single operator measurements per party:", end="")
@@ -1294,7 +1294,7 @@ def _generate_lp(self) -> None:
         self.monomial_from_name[self.constant_term_name] = self.Constant_Term
 
         self.raw_n_columns = len(self._raw_monomials_as_lexboolvecs)
-        self.n_maximal_events = len(self._maximal_event_as_lexboolvecs)
+        self.raw_n_columns_non_CG = len(self._raw_monomials_as_lexboolvecs_non_CG)
 
         self._raw_lookup_dict = {bitvec.tobytes(): i for i, bitvec in
                                  enumerate(self._raw_monomials_as_lexboolvecs)}
@@ -1315,26 +1315,26 @@ def _generate_lp(self) -> None:
             self.num_CG = len(old_reps_CG)
 
             orbits_non_CG = self._discover_inflation_orbits(
-                self._maximal_event_as_lexboolvecs)
+                self._raw_monomials_as_lexboolvecs_non_CG)
             old_reps_non_CG, unique_indices_non_CG, inverse_non_CG = np.unique(
                 orbits_non_CG, return_index=True, return_inverse=True)
-            self.n_representative_maximal_events = len(old_reps_non_CG)
+            self.num_non_CG = len(old_reps_non_CG)
             if self.verbose > 1:
                 print(f"Orbits discovered! {self.num_CG} unique monomials.")
             # Obtain the real generating monomials after accounting for symmetry
         else:
             self.num_CG = self.raw_n_columns
             unique_indices_CG = np.arange(self.num_CG)
             inverse_CG = unique_indices_CG
-            self.n_representative_maximal_events = self.n_maximal_events
-            unique_indices_non_CG = np.arange(self.n_representative_maximal_events)
+            self.num_non_CG = self.raw_n_columns_non_CG
+            unique_indices_non_CG = np.arange(self.num_non_CG)
         self.inverse = inverse_CG
 
         self._monomials_as_lexboolvecs = self._raw_monomials_as_lexboolvecs[unique_indices_CG]
-        self._representative_maximal_events_as_lexboolvecs = self._maximal_event_as_lexboolvecs[unique_indices_non_CG]
+        self._monomials_as_lexboolvecs_non_CG = self._raw_monomials_as_lexboolvecs_non_CG[unique_indices_non_CG]
         self.n_columns = len(self._monomials_as_lexboolvecs)
 
-        self.nof_collins_gisin_inequalities = self.n_representative_maximal_events
+        self.nof_collins_gisin_inequalities = self.num_non_CG
 
         if self.verbose > 0:
             eprint("Number of variables in the LP:",
@@ -1343,11 +1343,9 @@ def _generate_lp(self) -> None:
                     self.nof_collins_gisin_inequalities)
 
         # Associate Monomials to the remaining entries.
-        _monomials = []
-        _monomial_names = []
-        _compmonomial_from_idx = {}
-        _compmonomial_to_idx = {}
-        boolvec2mon = {}
+        _compmonomial_to_idx = dict()
+        self.extra_inverse = np.arange(self.n_columns, dtype=int)
+        first_free_index = 0
         for idx, mon_as_lexboolvec in tqdm(enumerate(self._monomials_as_lexboolvecs),
                              disable=not self.verbose,
                              desc="Initializing monomials   ",
@@ -1437,9 +1435,9 @@ def _raw_monomials_as_lexboolvecs(self) -> np.ndarray:
         ])
 
     @cached_property
-    def _maximal_event_as_lexboolvecs(self) -> np.ndarray:
+    def _raw_monomials_as_lexboolvecs_non_CG(self) -> np.ndarray:
         r"""Creates the generating set of monomials (as boolvecs),
-        of MAXIMAL lengths, NOT limited to Collins-Gisin notation.
+        of ALL lengths, limited to Collins-Gisin notation.
         """
         return np.vstack([
             self._template_to_event_boolarray(clique, self._all_ortho_groups_as_boolarrays)
@@ -1452,10 +1450,10 @@ def minimal_sparse_equalities(self) -> coo_array:
         notation."""
         eq_row, eq_col, eq_data = [], [], []
         nof_equalities = 0
-        if np.any(self._boolvec_to_trigger_equality_generation):
-            alternatives_as_boolarrays = {v: np.pad(r[:-1], ((1, 0), (0, 0)))
+        if np.any(self._boolvec_for_FR_eqs):
+            alternatives_as_boolarrays = {v: np.pad(r[1:], ((1, 0), (0, 0)))
                                           for v, r in zip(
-                    np.flatnonzero(self._boolvec_to_trigger_equality_generation).flat,
+                    np.flatnonzero(self._boolvec_for_FR_eqs).flat,
                     self._CG_nonadjusting_ortho_groups_as_boolarrays)}
             alternatives_as_signs = {
                 i: np.count_nonzero(bool_array, axis=1).astype(bool)
@@ -1464,7 +1462,7 @@ def minimal_sparse_equalities(self) -> coo_array:
             for bool_vec in tqdm(self._monomials_as_lexboolvecs,
                     disable=not self.verbose,
                     desc="Discovering equalities   "):
-                critical_boolvec_intersection = np.bitwise_and(bool_vec, self._boolvec_to_trigger_equality_generation)
+                critical_boolvec_intersection = np.bitwise_and(bool_vec, self._boolvec_for_FR_eqs)
                 if np.any(critical_boolvec_intersection):
 
                     absent_c_boolvec = bool_vec.copy()
@@ -1525,16 +1523,16 @@ def minimal_sparse_inequalities(self) -> coo_array:
         nof_inequalities = 0
         alternatives_as_boolarrays = {v: np.pad(r[:-1], ((1, 0), (0, 0)))
                                       for v, r in zip(
-                np.flatnonzero(self._boolvec_for_not_being_in_CG_notation).flat,
+                np.flatnonzero(self._boolvec_for_CG_ineqs).flat,
                 self._CG_adjusting_ortho_groups_as_boolarrays)}
         alternatives_as_signs = {
             i: np.count_nonzero(bool_array, axis=1).astype(bool)
             for i, bool_array in alternatives_as_boolarrays.items()}
-        for bool_vec in tqdm(self._representative_maximal_events_as_lexboolvecs,
+        for bool_vec in tqdm(self._monomials_as_lexboolvecs_non_CG,
                              disable=not self.verbose,
                              desc="Discovering inequalities   "):
             critical_boolvec_intersection = np.bitwise_and(bool_vec,
-                                                           self._boolvec_for_not_being_in_CG_notation)
+                                                           self._boolvec_for_CG_ineqs)
             if critical_boolvec_intersection.any():
                 absent_c_boolvec = bool_vec.copy()
                 absent_c_boolvec[critical_boolvec_intersection] = False
@@ -2102,4 +2100,4 @@ def mon_to_boolvec(self, mon: np.ndarray) -> np.ndarray:
         """
         boolvec = self.blank_bool_vec.copy()
         boolvec[self.mon_to_lexrepr(mon)] = True
-        return boolvec
+        return boolvec