Add comprehensive tests demonstrating contiguous vs non-contiguous patterns

- Added test_contiguous_vs_non_contiguous_patterns to show patterns found in both modes
- Added test_non_contiguous_with_longer_gaps to test matching with large gaps
- Added test_order_sensitivity to verify order requirements
- Added test_is_subsequence_contiguous_vs_non_contiguous in utils tests
- Added test_is_subsequence_with_gaps to test various gap sizes
- All 44 tests pass (5 new tests added)

Co-authored-by: jacksonpradolima <7774063+jacksonpradolima@users.noreply.github.com>

Author: Copilot

tests/test_gsp.py

@@ -275,6 +275,102 @@ def test_non_contiguous_subsequences() -> None:
     assert level_2_patterns[("a", "c")] == 3, f"Expected support 3 for ('a', 'c'), got {level_2_patterns[('a', 'c')]}"
 
 
+def test_contiguous_vs_non_contiguous_patterns() -> None:
+    """
+    Comprehensive test demonstrating the difference between contiguous and non-contiguous patterns.
+
+    This test shows patterns that would ONLY be found in non-contiguous matching (current implementation)
+    vs patterns that would be found in BOTH contiguous and non-contiguous matching.
+
+    The current implementation uses non-contiguous (ordered) matching, which is the standard GSP behavior.
+    """
+    sequences = [
+        ["X", "Y", "Z"],  # Contains X->Y, Y->Z, X->Z (contiguous: X->Y, Y->Z only)
+        ["X", "Z"],  # Contains X->Z (contiguous: X->Z)
+        ["Y", "Z", "X"],  # Contains Y->Z, Y->X, Z->X (contiguous: Y->Z, Z->X only)
+        ["X", "Y", "Z", "W"],  # Contains many patterns
+    ]
+
+    gsp = GSP(sequences)
+    result = gsp.search(min_support=0.5)  # Need at least 2/4 sequences
+
+    # Level 2 patterns
+    level_2_patterns = result[1] if len(result) >= 2 else {}
+
+    # Patterns that would be found in BOTH contiguous and non-contiguous:
+    # ('X', 'Y') appears contiguously in: ['X', 'Y', 'Z'], ['X', 'Y', 'Z', 'W']
+    # ('Y', 'Z') appears contiguously in: ['X', 'Y', 'Z'], ['Y', 'Z', 'X'], ['X', 'Y', 'Z', 'W']
+    assert ("X", "Y") in level_2_patterns, "('X', 'Y') should be found (contiguous in 2 sequences)"
+    assert ("Y", "Z") in level_2_patterns, "('Y', 'Z') should be found (contiguous in 3 sequences)"
+
+    # Pattern that would ONLY be found in non-contiguous matching:
+    # ('X', 'Z') appears with gap in: ['X', 'Y', 'Z'], ['X', 'Y', 'Z', 'W']
+    # and contiguously in: ['X', 'Z']
+    # Total support = 3 (>= 2 threshold)
+    assert ("X", "Z") in level_2_patterns, (
+        "('X', 'Z') should be found with non-contiguous matching. "
+        "This pattern has gaps in some sequences but is still ordered."
+    )
+    assert level_2_patterns[("X", "Z")] == 3, f"Expected support 3 for ('X', 'Z'), got {level_2_patterns[('X', 'Z')]}"
+
+
+def test_non_contiguous_with_longer_gaps() -> None:
+    """
+    Test non-contiguous matching with longer gaps between elements.
+
+    This demonstrates that the algorithm correctly finds patterns even when
+    there are multiple elements between the pattern elements.
+    """
+    sequences = [
+        ["A", "B", "C", "D", "E"],  # Contains A->E with 3 elements in between
+        ["A", "X", "Y", "Z", "E"],  # Contains A->E with 3 different elements in between
+        ["A", "E"],  # Contains A->E with no gap
+        ["E", "A"],  # Does NOT contain A->E (wrong order)
+    ]
+
+    gsp = GSP(sequences)
+    result = gsp.search(min_support=0.5)  # Need at least 2/4 sequences
+
+    # ('A', 'E') should be found with support = 3
+    level_2_patterns = result[1] if len(result) >= 2 else {}
+    assert ("A", "E") in level_2_patterns, "('A', 'E') should be found despite large gaps"
+    assert level_2_patterns[("A", "E")] == 3, f"Expected support 3 for ('A', 'E'), got {level_2_patterns[('A', 'E')]}"
+
+    # ('E', 'A') should NOT be found (wrong order)
+    assert ("E", "A") not in level_2_patterns, "('E', 'A') should not be found (wrong order)"
+
+
+def test_order_sensitivity() -> None:
+    """
+    Test that the algorithm is sensitive to order - patterns must appear in sequence order.
+
+    This verifies that even with non-contiguous matching, the order of elements matters.
+    """
+    sequences = [
+        ["P", "Q", "R"],  # Contains P->Q, P->R, Q->R
+        ["P", "R", "Q"],  # Contains P->R, P->Q, R->Q
+        ["Q", "P", "R"],  # Contains Q->P, Q->R, P->R
+        ["R", "Q", "P"],  # Contains R->Q, R->P, Q->P
+    ]
+
+    gsp = GSP(sequences)
+    result = gsp.search(min_support=0.5)  # Need at least 2/4 sequences
+
+    level_2_patterns = result[1] if len(result) >= 2 else {}
+
+    # ('P', 'R') appears in correct order in: ['P', 'Q', 'R'], ['P', 'R', 'Q'], ['Q', 'P', 'R']
+    assert ("P", "R") in level_2_patterns, "('P', 'R') should be found (support = 3)"
+    assert level_2_patterns[("P", "R")] == 3
+
+    # ('Q', 'P') appears in correct order in: ['Q', 'P', 'R'], ['R', 'Q', 'P']
+    assert ("Q", "P") in level_2_patterns, "('Q', 'P') should be found (support = 2)"
+    assert level_2_patterns[("Q", "P")] == 2
+
+    # ('R', 'P') appears in correct order in: ['R', 'Q', 'P']
+    # Support = 1, below threshold of 2
+    assert ("R", "P") not in level_2_patterns, "('R', 'P') should not be found (support = 1, below threshold)"
+
+
 @pytest.mark.parametrize("min_support", [0.1, 0.2, 0.3, 0.4, 0.5])
 def test_benchmark(benchmark: BenchmarkFixture, supermarket_transactions: List[List[str]], min_support: float) -> None:
     """

tests/test_utils.py

@@ -67,6 +67,64 @@ def test_is_subsequence_in_list():
     assert not is_subsequence_in_list((1, 2, 3, 4), (1, 2, 3)), "Failed to reject long subsequence"
 
 
+def test_is_subsequence_contiguous_vs_non_contiguous():
+    """
+    Test cases that demonstrate the difference between contiguous and non-contiguous matching.
+
+    The current implementation uses non-contiguous (ordered) matching.
+    This test documents patterns that would differ between the two approaches.
+    """
+    # Pattern that appears with gaps (non-contiguous)
+    # In contiguous mode: would NOT match
+    # In non-contiguous mode: DOES match
+    assert is_subsequence_in_list(("a", "c"), ("a", "b", "c")), (
+        "Non-contiguous: ('a', 'c') should match in ('a', 'b', 'c')"
+    )
+    assert is_subsequence_in_list(("a", "d"), ("a", "b", "c", "d")), (
+        "Non-contiguous: ('a', 'd') should match in ('a', 'b', 'c', 'd')"
+    )
+    assert is_subsequence_in_list((1, 4), (1, 2, 3, 4, 5)), (
+        "Non-contiguous: (1, 4) should match in (1, 2, 3, 4, 5)"
+    )
+
+    # Pattern that appears contiguously (would match in both modes)
+    assert is_subsequence_in_list(("a", "b"), ("a", "b", "c")), (
+        "Contiguous: ('a', 'b') should match in ('a', 'b', 'c')"
+    )
+    assert is_subsequence_in_list((2, 3), (1, 2, 3, 4)), (
+        "Contiguous: (2, 3) should match in (1, 2, 3, 4)"
+    )
+
+    # Pattern with wrong order (would NOT match in either mode)
+    assert not is_subsequence_in_list(("c", "a"), ("a", "b", "c")), (
+        "Wrong order: ('c', 'a') should NOT match in ('a', 'b', 'c')"
+    )
+    assert not is_subsequence_in_list((3, 1), (1, 2, 3, 4)), (
+        "Wrong order: (3, 1) should NOT match in (1, 2, 3, 4)"
+    )
+
+
+def test_is_subsequence_with_gaps():
+    """
+    Test non-contiguous matching with various gap sizes.
+    """
+    # Small gap
+    assert is_subsequence_in_list(("x", "z"), ("x", "y", "z")), "Failed with 1 element gap"
+
+    # Medium gap
+    assert is_subsequence_in_list(("a", "e"), ("a", "b", "c", "d", "e")), "Failed with 3 element gap"
+
+    # Large gap
+    assert is_subsequence_in_list((1, 10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), "Failed with 8 element gap"
+
+    # Multiple gaps in longer pattern
+    assert is_subsequence_in_list((1, 3, 5), (1, 2, 3, 4, 5)), "Failed with multiple gaps"
+    assert is_subsequence_in_list(("a", "c", "e"), ("a", "b", "c", "d", "e")), "Failed with multiple gaps"
+
+    # No gap (adjacent elements still work)
+    assert is_subsequence_in_list((1, 2), (1, 2, 3)), "Failed with no gap (contiguous)"
+
+
 def test_generate_candidates_from_previous():
     """
     Test the `generate_candidates_from_previous` utility function.