[] pattern notation for specifying sequences of arguments

Author: telmomenezes

src/hyperbase/hyperedge.py

@@ -590,7 +590,7 @@ def arguments_with_role(self, argrole: str) -> list[Hyperedge]:
         argroles = connector.argroles()
         if len(argroles) > 0 and argroles[0] == "{":
             argroles = argroles[1:-1]
-        argroles = argroles.replace(",", "")
+        argroles = argroles.replace(",", "").replace("[", "").replace("]", "")
         for pos, role in enumerate(argroles):
             if role == argrole and pos < len(self) - 1:
                 edges.append(self[pos + 1])
@@ -1129,7 +1129,8 @@ def normalise(self) -> Atom:
                     unordered = True
                 else:
                     unordered = False
-                ar = "".join(sorted(ar, key=lambda argrole: argrole_order[argrole]))
+                if "[" not in ar:
+                    ar = "".join(sorted(ar, key=lambda argrole: argrole_order[argrole]))
                 if unordered:
                     ar = f"{{{ar}}}"
                 return self.replace_argroles(ar)
@@ -1156,7 +1157,7 @@ def is_pattern(self) -> bool:
         - argument role matcher (unordered argument roles surrounded by curly brackets)
         - functional patterns (var, atoms, lemma, ...)
         """
-        return self.is_wildcard() or "{" in self.argroles()
+        return self.is_wildcard() or "{" in self.argroles() or "[" in self.argroles()
 
     def is_fun_pattern(self) -> bool:
         return False

src/hyperbase/patterns/matcher.py

@@ -189,12 +189,30 @@ def _matches_atomic_pattern(edge: Hyperedge, atomic_pattern: Hyperedge) -> bool:
                 e_argroles = e_role[1]
                 if len(ap_argroles_posopt) > 0 and ap_argroles_posopt[0] == "{":
                     ap_argroles_posopt = ap_argroles_posopt[1:-1]
-                else:
+                elif "[" not in ap_argroles_posopt:
                     ap_argroles_posopt = ap_argroles_posopt.replace(",", "")
                     if len(e_argroles) > len(ap_argroles_posopt):
                         return False
                     else:
                         return ap_argroles_posopt.startswith(e_argroles)  # type: ignore[no-any-return]
+                # else: has [...] ordered subsequence brackets, fall through
+
+                # check [...] contiguity constraints
+                if "[" in ap_argroles_posopt:
+                    i = 0
+                    while i < len(ap_argroles_posopt):
+                        if ap_argroles_posopt[i] == "[":
+                            j = ap_argroles_posopt.index("]", i)
+                            group = ap_argroles_posopt[i + 1 : j]
+                            if group not in e_argroles:
+                                return False
+                            i = j + 1
+                        else:
+                            i += 1
+                    # strip brackets for count checking below
+                    ap_argroles_posopt = ap_argroles_posopt.replace("[", "").replace(
+                        "]", ""
+                    )
 
                 ap_argroles_parts = ap_argroles_posopt.split(",")
                 ap_posroles = ap_argroles_parts[0]
@@ -413,10 +431,14 @@ def match(
         if len(argroles_posopt) > 0 and argroles_posopt[0] == "{":
             match_by_order = False
             argroles_posopt = argroles_posopt[1:-1]
+        elif "[" in argroles_posopt:
+            match_by_order = False
         else:
             match_by_order = True
-        argroles = argroles_posopt.split(",")[0]
-        argroles_opt = argroles_posopt.replace(",", "")
+        argroles = argroles_posopt.replace("[", "").replace("]", "").split(",")[0]
+        argroles_opt = (
+            argroles_posopt.replace("[", "").replace("]", "").replace(",", "")
+        )
 
         if len(argroles) > 0:
             min_len = 1 + len(argroles)

tests/test_patterns.py

@@ -584,6 +584,160 @@ def test_match_pattern_argroles_optionals2(self):
             {"X": hedge("hyperbase/Cp.s"), "Y": hedge("great/C"), "Z": hedge("today/J")}
         ]
 
+    # [] ordered subsequence brackets -- is_pattern detection
+
+    def test_is_pattern_brackets1(self):
+        assert hedge("go/Pd.[so]").is_pattern()
+
+    def test_is_pattern_brackets2(self):
+        assert hedge("go/Pd.{[so]x}").is_pattern()
+
+    def test_is_pattern_brackets3(self):
+        assert hedge("(go/Pd.[so] x/C y/C)").is_pattern()
+
+    # [] ordered subsequence brackets -- inside {}
+
+    def test_match_pattern_argroles_brackets1(self):
+        """[so] in {}: s,o must be contiguous in order, x anywhere"""
+        assert match_pattern(
+            "(is/Pd.sox hyperbase/Cp.s great/C today/C)",
+            "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+        ) == [{"X": hedge("great/C"), "Y": hedge("today/C")}]
+
+    def test_match_pattern_argroles_brackets2(self):
+        """[so] in {}: x can appear before the [so] group"""
+        assert match_pattern(
+            "(is/Pd.xso today/C hyperbase/Cp.s great/C)",
+            "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+        ) == [{"X": hedge("great/C"), "Y": hedge("today/C")}]
+
+    def test_match_pattern_argroles_brackets3(self):
+        """[so] in {}: fails when s,o are not contiguous (s_x_o)"""
+        assert (
+            match_pattern(
+                "(is/Pd.sxo hyperbase/Cp.s today/C great/C)",
+                "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_brackets4(self):
+        """[so] in {}: fails when s,o are in wrong order (os)"""
+        assert (
+            match_pattern(
+                "(is/Pd.osx great/C hyperbase/Cp.s today/C)",
+                "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_brackets5(self):
+        """[so] in {}: fails when required role x is missing"""
+        assert (
+            match_pattern(
+                "(is/Pd.so hyperbase/Cp.s great/C)",
+                "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_brackets6(self):
+        """[so] in {}: extra roles are allowed"""
+        assert match_pattern(
+            "(is/Pd.xsoy today/C hyperbase/Cp.s great/C extra/C)",
+            "(is/Pd.{[so]x} hyperbase/Cp.s *X *Y)",
+        ) == [{"X": hedge("great/C"), "Y": hedge("today/C")}]
+
+    def test_match_pattern_argroles_brackets7(self):
+        """larger bracket group [sor]"""
+        assert match_pattern(
+            "(is/Pd.sorx hyperbase/Cp.s great/C extra/C today/C)",
+            "(is/Pd.{[sor]x} hyperbase/Cp.s *O *R *X)",
+        ) == [{"O": hedge("great/C"), "R": hedge("extra/C"), "X": hedge("today/C")}]
+
+    def test_match_pattern_argroles_brackets8(self):
+        """larger bracket group [sor] fails when not contiguous"""
+        assert (
+            match_pattern(
+                "(is/Pd.soxr hyperbase/Cp.s great/C today/C extra/C)",
+                "(is/Pd.{[sor]x} hyperbase/Cp.s *O *R *X)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_brackets9(self):
+        """multiple bracket groups [so][xr]"""
+        assert match_pattern(
+            "(is/Pd.soxr hyperbase/Cp.s great/C today/C extra/C)",
+            "(is/Pd.{[so][xr]} hyperbase/Cp.s *O *X *R)",
+        ) == [{"O": hedge("great/C"), "X": hedge("today/C"), "R": hedge("extra/C")}]
+
+    def test_match_pattern_argroles_brackets10(self):
+        """multiple bracket groups can appear in any order"""
+        assert match_pattern(
+            "(is/Pd.xrso today/C extra/C hyperbase/Cp.s great/C)",
+            "(is/Pd.{[so][xr]} hyperbase/Cp.s *O *X *R)",
+        ) == [{"O": hedge("great/C"), "X": hedge("today/C"), "R": hedge("extra/C")}]
+
+    def test_match_pattern_argroles_brackets11(self):
+        """multiple bracket groups: fails when one group is not contiguous"""
+        assert (
+            match_pattern(
+                "(is/Pd.soRx hyperbase/Cp.s great/C extra/C today/C)",
+                "(is/Pd.{[so][xr]} hyperbase/Cp.s *O *X *R)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_brackets_no_vars(self):
+        """bracket matching without variables"""
+        assert match_pattern(
+            "(is/Pd.sox hyperbase/Cp.s great/C today/C)",
+            "(is/Pd.{[so]x} hyperbase/Cp.s * *)",
+        ) == [{}]
+
+    # [] ordered subsequence brackets -- outside {} (bare)
+
+    def test_match_pattern_argroles_bare_brackets1(self):
+        """[so] outside {}: matches exact argroles"""
+        assert match_pattern(
+            "(is/Pd.so hyperbase/Cp.s great/C)", "(is/Pd.[so] hyperbase/Cp.s *X)"
+        ) == [{"X": hedge("great/C")}]
+
+    def test_match_pattern_argroles_bare_brackets2(self):
+        """[so] outside {}: matches with extras before"""
+        assert match_pattern(
+            "(is/Pd.xso today/C hyperbase/Cp.s great/C)",
+            "(is/Pd.[so] hyperbase/Cp.s *X)",
+        ) == [{"X": hedge("great/C")}]
+
+    def test_match_pattern_argroles_bare_brackets3(self):
+        """[so] outside {}: matches with extras after"""
+        assert match_pattern(
+            "(is/Pd.sox hyperbase/Cp.s great/C today/C)",
+            "(is/Pd.[so] hyperbase/Cp.s *X)",
+        ) == [{"X": hedge("great/C")}]
+
+    def test_match_pattern_argroles_bare_brackets4(self):
+        """[so] outside {}: fails when reversed"""
+        assert (
+            match_pattern(
+                "(is/Pd.os great/C hyperbase/Cp.s)",
+                "(is/Pd.[so] hyperbase/Cp.s *X)",
+            )
+            == []
+        )
+
+    def test_match_pattern_argroles_bare_brackets5(self):
+        """[so] outside {}: fails when not contiguous"""
+        assert (
+            match_pattern(
+                "(is/Pd.sxo hyperbase/Cp.s today/C great/C)",
+                "(is/Pd.[so] hyperbase/Cp.s *X)",
+            )
+            == []
+        )
+
     def test_match_pattern_match_connectors1(self):
         assert match_pattern(
             "(is/P hyperbase/Cp.s great/C)", "(PRED/P hyperbase/Cp.s X ...)"