38254: have is_recoverable check all symmetry mutants

src/sage/knots/free_knotinfo_monoid.py

@@ -318,15 +318,14 @@ def hp_mirr(hp):
                             res_rec = search_composition(max_cr - c, h)
                             if res_rec:
                                 res += [Kgen * k for k in res_rec]
-                res_t = tuple(res)
-                if c > former_cr and res_t:
-                    k = self._check_elements(knot, res_t)
+                if c > former_cr and res:
+                    k = self._check_elements(knot, tuple(res))
                     if k:
                         # matching item found
                         return tuple([k])
                     former_cr = c
 
-            return tuple(sorted(set(res_t)))
+            return tuple(sorted(set(res)))
 
         hp = knot.homfly_polynomial(normalization='vz')
         return search_composition(13, hp)

src/sage/knots/knotinfo.py

@@ -2259,7 +2259,7 @@ def is_recoverable(self, unique=True):
             sage: L5a1_0.is_recoverable(unique=False)
             True
         """
-        def recover(mirror, braid):
+        def recover(sym_mut, braid):
             r"""
             Check if ``self`` can be recovered form its associated
             Sage link.
@@ -2268,41 +2268,42 @@ def recover(mirror, braid):
                 l = self.link(self.items.braid_notation)
             else:
                 l = self.link()
-            if mirror:
-                if self.is_amphicheiral():
-                    # no need to test again
-                    return True
+            if sym_mut is SymmetryMutant.mirror_image:
                 l = l.mirror_image()
+            elif sym_mut is SymmetryMutant.reverse:
+                l = l.reverse()
+            elif sym_mut is SymmetryMutant.concordance_inverse:
+                l = l.mirror_image().reservse()
 
-            def check_result(L, m):
+            def check_result(res):
                 r"""
                 Check a single result from ``get_knotinfo``.
                 """
+                if type(res) is tuple:
+                    L, s = res
+                else:
+                    L, s = res.to_knotinfo()[0]
+                if not isinstance(L, KnotInfoBase):
+                    return False
                 if L != self:
                     return False
-                if mirror:
-                    return m is SymmetryMutant.mirror_image
-                else:
-                    return m is SymmetryMutant.itself
+                return s == sym_mut
 
             try:
-                ki = l.get_knotinfo()
-                if type(ki) is tuple:
-                    L, m = ki
-                else:
-                    L, m = l.get_knotinfo().to_knotinfo()[0]
-                if isinstance(L, KnotInfoBase):
-                    return check_result(L, m)
-                elif unique:
-                    return False
+                res = l.get_knotinfo(unique=unique)
             except NotImplementedError:
-                if unique:
-                    return False
-            Llist = l.get_knotinfo(unique=False)
-            return any(check_result(L, m) for (L, m) in Llist)
+                return False
+            if unique:
+                return check_result(res)
+            else:
+                return any(check_result(r) for r in res)
 
         from sage.misc.misc import some_tuples
-        return all(recover(mirror, braid) for mirror, braid in some_tuples([True, False], 2, 4))
+        if SymmetryMutant.unknown.matches(self):
+            sym_muts = [SymmetryMutant.unknown]
+        else:
+            sym_muts = [s for s in SymmetryMutant if s.is_minimal(self)]
+        return all(recover(sym, braid) for sym, braid in some_tuples(sym_muts, 2, 8))
 
     def inject(self, verbose=True):
         """