Projection Ordering and Non-Commutativity¶

# WRONG ORDER: Normalize, then truncate
projection = RecencyProjection(10) >> LowercaseProjection()
# Input:  "The Quick Brown Fox Jumps Over"
# → Truncate: "rown Fox J"  (loses "The Quick B")
# → Lowercase: "rown fox j"  (normalized after truncation)

# RIGHT ORDER: Normalize, then truncate
projection = LowercaseProjection() >> RecencyProjection(10)
# Input:  "The Quick Brown Fox Jumps Over"
# → Lowercase: "the quick brown fox jumps over"
# → Truncate: "umps over"  (preserves more normalized context)

# RIGHT ORDER: Fix typos, then find synonyms
projection = EditDistanceProjection(max_distance=2) >> SynonymProjection()
# Input:  "the quik cat"
# → Fix typo: "the quick cat"
# → Synonyms: "the fast feline"

# WRONG ORDER: Find synonyms, then fix typos
projection = SynonymProjection() >> EditDistanceProjection(max_distance=2)
# Input:  "the quik cat"
# → Synonyms: "the quik feline"  (no synonym for misspelled "quik")
# → Fix typo: "the quick feline"  (partial correction)

# RIGHT ORDER: Expand synonyms, then find longest match
projection = SynonymProjection() >> LongestSuffixProjection()
# Input:  "the cat sat"
# → Synonyms: "the feline sat"
# → Longest suffix in corpus: "the feline sat on the mat"  (longer match)

# WRONG ORDER: Find longest match, then expand synonyms
projection = LongestSuffixProjection() >> SynonymProjection()
# Input:  "the cat sat"
# → Longest suffix: "cat sat"  (shorter match, "cat" not in corpus)
# → Synonyms: "feline sat"  (too late, already truncated)

# These commute:
projection1 = LowercaseProjection() >> WhitespaceProjection()
projection2 = WhitespaceProjection() >> LowercaseProjection()

# Input:  "Hello  World"
# Both produce: "hello world"

projection = (
    # 1. Error correction
    EditDistanceProjection(max_distance=1) >>

    # 2. Normalization
    WhitespaceProjection() >>
    LowercaseProjection() >>
    UnicodeNormalizationProjection('NFC') >>

    # 3. Semantic expansion
    SynonymProjection(wordnet_synsets=3) >>

    # 4. Structural matching
    LongestSuffixProjection(min_length=5) >>

    # 5. Lossy operations
    RecencyProjection(max_length=100)
)

# These are equivalent:
LowercaseProjection() >> WhitespaceProjection()
WhitespaceProjection() >> LowercaseProjection()

# These are equivalent:
UnicodeNormalizationProjection('NFC') >> LowercaseProjection()
LowercaseProjection() >> UnicodeNormalizationProjection('NFC')

# Different results:
RecencyProjection(5) >> LowercaseProjection()
LowercaseProjection() >> RecencyProjection(5)

def test_commutativity(proj1, proj2, test_cases):
    """Test if two projections commute on given test cases."""
    for context, corpus in test_cases:
        result1 = (proj1 >> proj2).project(context, corpus)
        result2 = (proj2 >> proj1).project(context, corpus)

        if result1 != result2:
            print(f"Non-commutative: {result1} ≠ {result2}")
            return False

    return True

# Example usage
test_cases = [
    (list("Hello  World".encode('utf-8')), []),
    (list("the quik cat".encode('utf-8')), []),
]

is_commutative = test_commutativity(
    LowercaseProjection(),
    WhitespaceProjection(),
    test_cases
)

class SynonymProjection(Projection):
    """
    Synonym projection using WordNet.

    Ordering constraints:
    - AFTER: EditDistanceProjection (fix typos first)
    - BEFORE: LongestSuffixProjection (expand before matching)
    - COMMUTES WITH: LowercaseProjection, WhitespaceProjection
    """

class MultiOrderProjection(Projection):
    """Try multiple projection orders and return best match."""

    def __init__(self, projections: List[Projection]):
        self.projections = projections

    def project_multi(self, context: List[int], corpus: List[int]) -> Set[Tuple[int, ...]]:
        results = set()

        # Try all permutations of projection orderings
        from itertools import permutations
        for order in permutations(self.projections):
            # Apply projections in this order
            result = context
            for proj in order:
                result = proj.project(result, corpus)
            results.add(tuple(result))

        return results

class LearnedOrderProjection(Projection):
    """Learn optimal projection order based on context."""

    def __init__(self, projections: List[Projection], order_model):
        self.projections = projections
        self.order_model = order_model  # Neural network or decision tree

    def project(self, context: List[int], corpus: List[int]) -> List[int]:
        # Use learned model to predict best ordering
        order = self.order_model.predict_order(context, corpus)

        result = context
        for idx in order:
            result = self.projections[idx].project(result, corpus)

        return result

# Clear intent: apply left-to-right
pipeline = (
    EditDistanceProjection() >>  # First
    LowercaseProjection() >>      # Second
    SynonymProjection() >>        # Third
    LongestSuffixProjection()     # Last
)

class StandardPipeline(Projection):
    """
    Standard projection pipeline.

    Order:
    1. Error correction (edit distance ≤ 1)
    2. Normalization (lowercase, whitespace, Unicode NFC)
    3. Truncation (last 100 tokens)
    """

    def __init__(self):
        self.pipeline = (
            EditDistanceProjection(max_distance=1) >>
            WhitespaceProjection() >>
            LowercaseProjection() >>
            UnicodeNormalizationProjection('NFC') >>
            RecencyProjection(max_length=100)
        )

    def project(self, context: List[int], corpus: List[int]) -> List[int]:
        return self.pipeline.project(context, corpus)

def validate_pipeline(pipeline: Projection):
    """Warn about potential ordering issues."""

    # Example: Warn if lossy operation comes before normalization
    if isinstance(pipeline, SequentialProjection):
        first, second = pipeline.first, pipeline.second

        if is_lossy(first) and is_normalizing(second):
            warnings.warn(
                f"Lossy projection {first} before normalizing {second}. "
                f"Consider reversing order."
            )

# WRONG: Synonym first might miss typos
SynonymProjection() >> EditDistanceProjection()

# RIGHT: Fix typos, then expand synonyms
EditDistanceProjection(max_distance=2) >>
LowercaseProjection() >>
SynonymProjection(max_synsets=3) >>
LongestSuffixProjection()

# 1. Normalize whitespace (code formatting varies)
WhitespaceProjection() >>

# 2. Keep recent tokens only (local context matters in code)
RecencyProjection(max_length=50) >>

# 3. Find longest matching suffix (exact match preferred)
LongestSuffixProjection(min_length=3)

# Note: No case normalization (code is case-sensitive)
# Note: No synonym expansion (code tokens are literal)

# 1. Aggressive normalization (chat has inconsistent formatting)
WhitespaceProjection() >>
LowercaseProjection() >>
PunctuationRemovalProjection() >>

# 2. Expand with common chat abbreviations
ChatAbbreviationExpansion() >>  # lol → laughing out loud, etc.

# 3. Emoji normalization
EmojiNormalizationProjection() >>

# 4. Find similar message
EditDistanceProjection(max_distance=3)

StandardTextProjection = (
    EditDistanceProjection(max_distance=1) >>  # Fix typos
    WhitespaceProjection() >>                  # Normalize whitespace
    LowercaseProjection() >>                   # Case-insensitive
    UnicodeNormalizationProjection('NFC') >>   # Unicode consistency
    RecencyProjection(max_length=100)          # Keep recent context
)