Add neural-symbolic parsing with Prolog validation

Integrate Prolog-based grammatical validation layer on top of Stanza
neural parser for enhanced error detection and grammatical analysis.

Changes:
1. Added Prolog files:
- coptic_grammar.pl (13K) - DCG grammar rules
- coptic_lexicon.pl (486K) - Coptic lexicon
- coptic_prolog_rules.py (28K) - Python-Prolog interface

2. Updated Dockerfile:
- Install SWI-Prolog (swi-prolog package)
- Required for symbolic grammatical validation

3. Updated requirements.txt:
- Added pyswip>=0.2.10 for Python-Prolog integration

4. Extended coptic_parser_core.py:
- Added _init_prolog() to initialize Prolog engine
- Added _validate_with_prolog() for grammatical validation
- Modified parse_text() to include optional Prolog validation
- Returns validation results (patterns detected, warnings, errors)

Neural-Symbolic Architecture:
- Neural layer (Stanza): Dependency parsing, POS tagging, lemmatization
- Symbolic layer (Prolog): Grammatical rule validation, error detection
- Hybrid output: Parse tree + validation feedback

This creates a scholarly tool combining statistical and rule-based approaches,
ideal for Coptic language research and education.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Dockerfile

@@ -1,5 +1,10 @@
 FROM python:3.9
 
+# Install SWI-Prolog for neural-symbolic parsing
+RUN apt-get update && apt-get install -y \
+    swi-prolog \
+    && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /code
 
 COPY requirements.txt .

coptic_grammar.pl

@@ -0,0 +1,400 @@
+%******************************************************************************
+% COPTIC_DEPENDENCY_RULES.PL - Prolog Dependency Grammar for Coptic
+%******************************************************************************
+%
+% This module demonstrates the adaptation from DCG (DETECT5.PRO style)
+% to modern dependency grammar formalism.
+%
+% PARADIGM SHIFT:
+%   DCG:         sentence --> NP, VP.  (hierarchical constituents)
+%   Dependency:  dep(verb, subject, nsubj).  (head-dependent relations)
+%
+% Based on Universal Dependencies annotation scheme adapted for Coptic
+% linguistic patterns (VSO word order, tripartite sentences, etc.)
+%
+% Author: Adapted from DETECT5.PRO (André Linden, 1989-91)
+% Date: 2025
+%
+%******************************************************************************
+
+:- module(coptic_dependency_rules, [
+    dependency_pattern/3,
+    validate_dependency/4,
+    suggest_parse/3,
+    apply_dependency_rules/3
+]).
+
+:- ensure_loaded(coptic_lexicon).
+
+%******************************************************************************
+% CORE DEPENDENCY PATTERNS
+%******************************************************************************
+
+% Pattern 1: VSO Transitive Sentence
+% Example: ⲥⲱⲧⲙ ⲡⲣⲱⲙⲉ ⲡϣⲁϫⲉ (hear the-man the-word = "The man hears the word")
+%
+% Dependency structure:
+%   ⲥⲱⲧⲙ (VERB, root)
+%   ├── ⲡⲣⲱⲙⲉ (NOUN, nsubj)
+%   └── ⲡϣⲁϫⲉ (NOUN, obj)
+%
+dependency_pattern(vso_transitive,
+    Words,
+    [dep(Subj, SubjPOS, SIdx, Verb, VIdx, nsubj),
+     dep(Obj, ObjPOS, OIdx, Verb, VIdx, obj)]) :-
+    % Verb at position VIdx
+    nth1(VIdx, Words, word(Verb, VerbPOS, _)),
+    member(VerbPOS, ['VERB', 'AUX']),
+
+    % Subject at position SIdx
+    nth1(SIdx, Words, word(Subj, SubjPOS, _)),
+    member(SubjPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    % Object at position OIdx
+    nth1(OIdx, Words, word(Obj, ObjPOS, _)),
+    member(ObjPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    % VSO word order constraint (crucial for Coptic!)
+    VIdx < SIdx,
+    SIdx < OIdx,
+
+    % Verify verb is transitive
+    is_transitive(Verb).
+
+% Pattern 2: VS Intransitive Sentence
+% Example: ⲃⲱⲕ ⲡⲣⲱⲙⲉ (go the-man = "The man goes")
+%
+dependency_pattern(vs_intransitive,
+    Words,
+    [dep(Subj, SubjPOS, SIdx, Verb, VIdx, nsubj)]) :-
+    % Verb
+    nth1(VIdx, Words, word(Verb, VerbPOS, _)),
+    member(VerbPOS, ['VERB', 'AUX']),
+
+    % Subject
+    nth1(SIdx, Words, word(Subj, SubjPOS, _)),
+    member(SubjPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    % VS word order
+    VIdx < SIdx,
+
+    % Verify verb is intransitive
+    is_intransitive(Verb).
+
+% Pattern 3: Tripartite Nominal Sentence
+% Example: ⲁⲛⲟⲕ ⲡⲉ ⲡⲛⲟⲩⲧⲉ (I am the-god = "I am God")
+%
+% Structure: Subject + Copula + Predicate
+% In UD: Predicate is head, Subject and Copula depend on it
+%
+%   ⲡⲛⲟⲩⲧⲉ (NOUN, root)
+%   ├── ⲁⲛⲟⲕ (PRON, nsubj)
+%   └── ⲡⲉ (AUX, cop)
+%
+dependency_pattern(tripartite,
+    Words,
+    [dep(Subj, SubjPOS, SIdx, Pred, PIdx, nsubj),
+     dep(Cop, 'AUX', CIdx, Pred, PIdx, cop)]) :-
+    % Subject (first position, typically)
+    nth1(SIdx, Words, word(Subj, SubjPOS, _)),
+    member(SubjPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    % Copula (ⲡⲉ, ⲧⲉ, ⲛⲉ)
+    nth1(CIdx, Words, word(Cop, 'AUX', _)),
+    member(Cop, ['ⲡⲉ', 'ⲧⲉ', 'ⲛⲉ']),
+
+    % Predicate (nominal or adjectival)
+    nth1(PIdx, Words, word(Pred, PredPOS, _)),
+    member(PredPOS, ['NOUN', 'ADJ', 'PROPN']),
+
+    % Typical order: S - Cop - Pred (but can vary)
+    SIdx < PIdx,
+
+    % Gender/number agreement between copula and predicate
+    copula_agrees_with_predicate(Cop, Pred).
+
+% Pattern 4: Converted Tripartite (Predicate-Subject-Copula)
+% Example: ⲡⲛⲟⲩⲧⲉ ⲁⲛⲟⲕ ⲡⲉ (God I am = "I am God" - emphatic)
+%
+dependency_pattern(tripartite_converted,
+    Words,
+    [dep(Subj, SubjPOS, SIdx, Pred, PIdx, nsubj),
+     dep(Cop, 'AUX', CIdx, Pred, PIdx, cop)]) :-
+    nth1(PIdx, Words, word(Pred, PredPOS, _)),
+    member(PredPOS, ['NOUN', 'ADJ', 'PROPN']),
+
+    nth1(SIdx, Words, word(Subj, SubjPOS, _)),
+    member(SubjPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    nth1(CIdx, Words, word(Cop, 'AUX', _)),
+    member(Cop, ['ⲡⲉ', 'ⲧⲉ', 'ⲛⲉ']),
+
+    % Converted order: Pred before Subj
+    PIdx < SIdx,
+
+    copula_agrees_with_predicate(Cop, Pred).
+
+% Pattern 5: Determiner + Noun
+% Example: ⲡⲣⲱⲙⲉ (the-man)
+%
+% In Coptic, articles often attach as prefixes, but in tokenized form:
+%   ⲡⲣⲱⲙⲉ
+%   ├── ⲡ (DET, det)
+%
+dependency_pattern(determiner_noun,
+    Words,
+    [dep(Det, 'DET', DIdx, Noun, NIdx, det)]) :-
+    nth1(DIdx, Words, word(Det, 'DET', _)),
+    nth1(NIdx, Words, word(Noun, 'NOUN', _)),
+
+    % Determiner precedes noun in Coptic
+    DIdx < NIdx,
+
+    % Adjacent or nearly adjacent
+    NIdx - DIdx =< 2,
+
+    % Gender agreement
+    determiner_gender_agrees(Det, Noun).
+
+% Pattern 6: Adjective Modification
+% Example: ⲡⲣⲱⲙⲉ ⲛⲁⲛⲟⲩϥ (the-man good = "the good man")
+%
+% In Coptic, adjectives typically follow nouns
+%   ⲣⲱⲙⲉ (NOUN)
+%   └── ⲛⲁⲛⲟⲩϥ (ADJ, amod)
+%
+dependency_pattern(noun_adjective,
+    Words,
+    [dep(Adj, 'ADJ', AIdx, Noun, NIdx, amod)]) :-
+    nth1(NIdx, Words, word(Noun, 'NOUN', _)),
+    nth1(AIdx, Words, word(Adj, 'ADJ', _)),
+
+    % Coptic: Adjective follows noun (typically)
+    NIdx < AIdx,
+
+    % Should be adjacent or nearly so
+    AIdx - NIdx =< 2,
+
+    % Gender/number agreement
+    adjective_agrees(Adj, Noun).
+
+% Pattern 7: Prepositional Phrase
+% Example: ϩⲛ ⲧⲡⲟⲗⲓⲥ (in the-city)
+%
+%   ⲧⲡⲟⲗⲓⲥ (NOUN, head in larger structure)
+%   ├── ϩⲛ (ADP, case)
+%
+dependency_pattern(prepositional_phrase,
+    Words,
+    [dep(Prep, 'ADP', PIdx, Noun, NIdx, case)]) :-
+    nth1(PIdx, Words, word(Prep, 'ADP', _)),
+    nth1(NIdx, Words, word(Noun, NounPOS, _)),
+    member(NounPOS, ['NOUN', 'PRON', 'PROPN']),
+
+    % Preposition before noun
+    PIdx < NIdx,
+
+    % Adjacent
+    NIdx - PIdx =< 2.
+
+% Pattern 8: Conjunction
+% Example: ⲡⲣⲱⲙⲉ ⲙⲛ ⲧⲉϣⲓⲙⲉ (the-man and the-woman)
+%
+dependency_pattern(coordination,
+    Words,
+    [dep(Conj, 'CCONJ', CIdx, Head, HIdx, cc),
+     dep(Coord2, Coord2POS, C2Idx, Head, HIdx, conj)]) :-
+    nth1(HIdx, Words, word(Head, HeadPOS, _)),
+    member(HeadPOS, ['NOUN', 'VERB', 'ADJ']),
+
+    nth1(CIdx, Words, word(Conj, 'CCONJ', _)),
+
+    nth1(C2Idx, Words, word(Coord2, Coord2POS, _)),
+    Coord2POS = HeadPOS,  % Same POS as head
+
+    % Order: Head < Conj < Coord2
+    HIdx < CIdx,
+    CIdx < C2Idx.
+
+%******************************************************************************
+% CONSTRAINT CHECKING
+%******************************************************************************
+
+% Check if verb is transitive (requires object)
+is_transitive(Verb) :-
+    coptic_verb(Verb, Features),
+    member(transitive, Features), !.
+is_transitive(_).  % Default: assume transitive if unknown
+
+% Check if verb is intransitive (no object)
+is_intransitive(Verb) :-
+    coptic_verb(Verb, Features),
+    member(intransitive, Features), !.
+is_intransitive(_).  % Default: allow intransitive
+
+% Copula-predicate agreement
+copula_agrees_with_predicate(Cop, Pred) :-
+    coptic_noun(Pred, Gender, Number), !,
+    copula_form(Cop, Gender, Number).
+copula_agrees_with_predicate(_, _).  % Allow if not in lexicon
+
+copula_form('ⲡⲉ', masc, sing).
+copula_form('ⲧⲉ', fem, sing).
+copula_form('ⲛⲉ', _, plur).
+copula_form('ⲛⲉ', masc, plur).
+copula_form('ⲛⲉ', fem, plur).
+
+% Determiner-noun gender agreement
+determiner_gender_agrees(Det, Noun) :-
+    coptic_noun(Noun, Gender, Number), !,
+    determiner_form(Det, Gender, Number).
+determiner_gender_agrees(_, _).  % Allow if not in lexicon
+
+determiner_form('ⲡ', masc, sing).
+determiner_form('ⲧ', fem, sing).
+determiner_form('ⲛ', _, plur).
+determiner_form('ⲟⲩ', _, _).  % Indefinite: any gender/number
+
+% Adjective-noun agreement
+adjective_agrees(Adj, Noun) :-
+    coptic_noun(Noun, Gender, Number),
+    coptic_adjective(Adj, Gender, Number), !.
+adjective_agrees(_, _).  % Allow if not in lexicon
+
+%******************************************************************************
+% VALIDATION AND ERROR DETECTION
+%******************************************************************************
+
+% validate_dependency(+Token, +Head, +Relation, +Words)
+% Check if a proposed dependency is valid according to Coptic grammar
+validate_dependency(Token, Head, Relation, Words) :-
+    % Find positions
+    nth1(TokenIdx, Words, word(Token, TokenPOS, _)),
+    nth1(HeadIdx, Words, word(Head, HeadPOS, _)),
+
+    % Check if relation is valid for this POS pair
+    valid_relation(TokenPOS, HeadPOS, Relation),
+
+    % Check linguistic constraints
+    check_constraints(Token, TokenPOS, TokenIdx, Head, HeadPOS, HeadIdx, Relation, Words).
+
+% Valid dependency relations (simplified from UD)
+valid_relation('NOUN', 'VERB', nsubj).
+valid_relation('PRON', 'VERB', nsubj).
+valid_relation('PROPN', 'VERB', nsubj).
+valid_relation('NOUN', 'VERB', obj).
+valid_relation('PRON', 'VERB', obj).
+valid_relation('NOUN', 'NOUN', nmod).
+valid_relation('ADJ', 'NOUN', amod).
+valid_relation('DET', 'NOUN', det).
+valid_relation('ADP', 'NOUN', case).
+valid_relation('ADP', 'PRON', case).
+valid_relation('AUX', 'NOUN', cop).
+valid_relation('AUX', 'ADJ', cop).
+valid_relation('CCONJ', 'NOUN', cc).
+valid_relation('CCONJ', 'VERB', cc).
+valid_relation(_, _, root).  % Root can be anything
+
+% Constraint checking
+check_constraints(_Token, _TokenPOS, TokenIdx, _Head, HeadPOS, HeadIdx, Relation, _Words) :-
+    % Word order constraints
+    (   Relation = nsubj,
+        member(HeadPOS, ['VERB', 'AUX'])
+    ->  % In VSO, subject follows verb
+        TokenIdx > HeadIdx
+    ;   true
+    ),
+
+    (   Relation = obj,
+        HeadPOS = 'VERB'
+    ->  % Object follows subject in VSO
+        TokenIdx > HeadIdx
+    ;   true
+    ),
+
+    (   Relation = det
+    ->  % Determiner precedes noun
+        TokenIdx < HeadIdx
+    ;   true
+    ),
+
+    (   Relation = amod
+    ->  % Adjective typically follows noun in Coptic
+        TokenIdx > HeadIdx
+    ;   true
+    ).
+
+%******************************************************************************
+% PARSING WITH DEPENDENCY RULES
+%******************************************************************************
+
+% suggest_parse(+Words, +POSTags, -Dependencies)
+% Use dependency rules to suggest a parse
+suggest_parse(Words, POSTags, Dependencies) :-
+    % Build word structures
+    length(Words, N),
+    build_word_list(Words, POSTags, 1, N, WordList),
+
+    % Try to match patterns
+    findall(Deps, dependency_pattern(_, WordList, Deps), AllDeps),
+
+    % Combine non-overlapping dependencies
+    flatten(AllDeps, FlatDeps),
+    sort(FlatDeps, Dependencies).
+
+build_word_list([], [], _, _, []).
+build_word_list([W|Ws], [P|Ps], Idx, N, [word(W, P, Idx)|Rest]) :-
+    NextIdx is Idx + 1,
+    build_word_list(Ws, Ps, NextIdx, N, Rest).
+
+% apply_dependency_rules(+Tokens, +POSTags, -ParseTree)
+% Full parsing using dependency rules
+apply_dependency_rules(Tokens, POSTags, ParseTree) :-
+    suggest_parse(Tokens, POSTags, Dependencies),
+
+    % Find root
+    (   select(dep(Root, RootPOS, RootIdx, _, 0, root), Dependencies, OtherDeps)
+    ->  true
+    ;   % No root found - pick first verb or noun
+        nth1(RootIdx, POSTags, RootPOS),
+        member(RootPOS, ['VERB', 'NOUN', 'AUX']),
+        nth1(RootIdx, Tokens, Root),
+        OtherDeps = Dependencies
+    ),
+
+    ParseTree = dep_tree{
+        root: Root,
+        root_pos: RootPOS,
+        root_index: RootIdx,
+        dependencies: OtherDeps,
+        parser: 'Dependency Rules'
+    }.
+
+%******************************************************************************
+% COMPARISON: DCG vs DEPENDENCY
+%******************************************************************************
+
+% EXAMPLE: How DETECT5.PRO might have encoded a rule
+%
+% DCG Style (old):
+%   sentence --> verb_phrase.
+%   verb_phrase --> verb(V, trans), noun_phrase(Subj), noun_phrase(Obj),
+%                   {vso_order(V, Subj, Obj)}.
+%   noun_phrase --> determiner(D), noun(N), {gender_agrees(D, N)}.
+%
+% Dependency Style (new):
+%   dependency_pattern(vso,
+%       [verb(V, VIdx), noun(S, SIdx), noun(O, OIdx)],
+%       [dep(S, SIdx, V, VIdx, nsubj),
+%        dep(O, OIdx, V, VIdx, obj)]) :-
+%       VIdx < SIdx, SIdx < OIdx.
+%
+% KEY DIFFERENCES:
+% 1. DCG builds hierarchical structure (VP contains NPs)
+% 2. Dependency expresses direct relations (verb governs subject)
+% 3. Dependency is more flexible for free word order
+% 4. Dependency better matches modern neural parser output
+
+%******************************************************************************
+% END OF MODULE
+%******************************************************************************

coptic_parser_core.py

@@ -2,6 +2,9 @@
 """
 Coptic Dependency Parser - Core Module (Web-Compatible)
 
+Neural-Symbolic Hybrid Parser combining Stanza (neural) with Prolog (symbolic)
+for enhanced grammatical validation and error detection.
+
 Extracted from coptic-parser.py for integration with web interfaces.
 Author: André Linden (2025)
 License: CC BY-NC-SA 4.0
@@ -12,11 +15,25 @@ import warnings
 warnings.filterwarnings('ignore')
 
 class CopticParserCore:
-    """Lightweight Coptic parser for web applications"""
+    """Lightweight neural-symbolic Coptic parser for web applications"""
 
     def __init__(self):
         self.nlp = None
         self.diaparser = None
+        self.prolog = None  # Prolog engine for grammatical validation
+        self._init_prolog()
+
+    def _init_prolog(self):
+        """Initialize Prolog engine for grammatical validation (optional)"""
+        try:
+            from coptic_prolog_rules import create_prolog_engine
+            self.prolog = create_prolog_engine()
+            if self.prolog and self.prolog.prolog_initialized:
+                print("✓ Prolog engine initialized successfully")
+        except Exception as e:
+            print(f"ℹ  Prolog validation not available: {e}")
+            print("   Parser will continue with neural-only mode")
+            self.prolog = None
 
     def load_parser(self):
         """Initialize Stanza parser with Coptic models"""
@@ -33,7 +50,7 @@ class CopticParserCore:
                 download_method=None,
                 verbose=False
             )
-            print("✓ Coptic parser loaded successfully")
+            print("✓ Coptic neural parser loaded successfully")
 
         except Exception as e:
             # If models not found, download them
@@ -58,12 +75,13 @@ class CopticParserCore:
                 print(f"❌ Failed to load parser: {e}")
                 raise
 
-    def parse_text(self, text):
+    def parse_text(self, text, include_prolog_validation=True):
         """
-        Parse Coptic text and return structured results
+        Parse Coptic text and return structured results with optional Prolog validation
 
         Args:
             text: Coptic text to parse
+            include_prolog_validation: Whether to run Prolog grammatical validation (default: True)
 
         Returns:
             dict with:
@@ -71,6 +89,7 @@ class CopticParserCore:
                 - total_sentences: int
                 - total_tokens: int
                 - text: original text
+                - prolog_validation: dict with validation results (if enabled and available)
         """
         if not text or not text.strip():
             return None
@@ -78,7 +97,7 @@ class CopticParserCore:
         # Ensure parser is loaded
         self.load_parser()
 
-        # Parse with Stanza
+        # Parse with Stanza (neural)
         doc = self.nlp(text)
 
         if not doc.sentences:
@@ -112,13 +131,68 @@ class CopticParserCore:
                 'words': words_data
             })
 
-        return {
+        result = {
             'sentences': sentences,
             'total_sentences': len(sentences),
             'total_tokens': total_tokens,
             'text': text
         }
 
+        # Add Prolog validation (symbolic) if available and requested
+        if include_prolog_validation and self.prolog and hasattr(self.prolog, 'prolog_initialized') and self.prolog.prolog_initialized:
+            try:
+                validation = self._validate_with_prolog(sentences)
+                result['prolog_validation'] = validation
+            except Exception as e:
+                print(f"ℹ  Prolog validation skipped: {e}")
+                result['prolog_validation'] = None
+
+        return result
+
+    def _validate_with_prolog(self, sentences):
+        """
+        Validate parsed sentences using Prolog grammatical rules
+
+        Args:
+            sentences: List of parsed sentence data
+
+        Returns:
+            dict with validation results including patterns detected and warnings
+        """
+        if not self.prolog:
+            return None
+
+        validation_results = {
+            'patterns_detected': [],
+            'warnings': [],
+            'has_errors': False
+        }
+
+        for sentence in sentences:
+            # Extract tokens, POS tags, heads, and dependency relations
+            tokens = [word['form'] for word in sentence['words']]
+            pos_tags = [word['upos'] for word in sentence['words']]
+            heads = [word['head'] for word in sentence['words']]
+            deprels = [word['deprel'] for word in sentence['words']]
+
+            # Validate with Prolog
+            try:
+                sent_validation = self.prolog.validate_parse_tree(tokens, pos_tags, heads, deprels)
+
+                if sent_validation:
+                    # Merge results
+                    if sent_validation.get('patterns'):
+                        validation_results['patterns_detected'].extend(sent_validation['patterns'])
+
+                    if sent_validation.get('warnings'):
+                        validation_results['warnings'].extend(sent_validation['warnings'])
+                        validation_results['has_errors'] = True
+
+            except Exception as e:
+                print(f"ℹ  Prolog validation error for sentence: {e}")
+
+        return validation_results
+
     def format_conllu(self, parse_result):
         """Format parse result as CoNLL-U"""
         if not parse_result:

coptic_prolog_rules.py

@@ -0,0 +1,671 @@
+#!/usr/bin/env python3
+"""
+Coptic Prolog Rules - Neural-Symbolic Integration
+==================================================
+
+Integrates Prolog logic programming with neural dependency parsing
+to enhance parsing accuracy through explicit grammatical rules.
+
+Uses janus (SWI-Prolog Python interface) for bidirectional integration.
+
+Author: Coptic NLP Project
+License: CC BY-NC-SA 4.0
+"""
+
+from pyswip import Prolog
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class CopticPrologRules:
+    """
+    Prolog-based grammatical rule engine for Coptic parsing validation
+    and enhancement.
+    """
+
+    def __init__(self):
+        """Initialize Prolog engine and load Coptic grammar rules"""
+        self.prolog_initialized = False
+        self.prolog = None
+        self._initialize_prolog()
+
+    def _initialize_prolog(self):
+        """Initialize SWI-Prolog and define Coptic grammatical rules"""
+        try:
+            # Initialize pyswip Prolog instance
+            self.prolog = Prolog()
+
+            # Define Coptic-specific grammatical rules
+            self._load_coptic_grammar()
+
+            self.prolog_initialized = True
+            print("✓ Prolog engine initialized successfully")
+
+        except Exception as e:
+            print(f"⚠️  Warning: Prolog initialization failed: {e}")
+            print("   Parser will continue without Prolog validation")
+            self.prolog_initialized = False
+
+    def _load_dcg_grammar(self):
+        """
+        Load DCG-based grammar rules from coptic_grammar.pl
+        and Coptic lexicon from coptic_lexicon.pl
+
+        This adds more sophisticated pattern matching using Definite Clause Grammars,
+        adapted from the French DETECT5.PRO error detector.
+        """
+        try:
+            from pathlib import Path
+
+            # Get path to DCG grammar file
+            # Note: The grammar file will load the lexicon automatically via ensure_loaded
+            current_dir = Path(__file__).parent
+            grammar_file = current_dir / "coptic_grammar.pl"
+
+            # Load grammar rules (which will load the lexicon)
+            if grammar_file.exists():
+                # Convert path to Prolog-compatible format
+                grammar_path = str(grammar_file.absolute()).replace('\\', '/')
+
+                # Load the module
+                query = f"consult('{grammar_path}')"
+                list(self.prolog.query(query))
+
+                print(f"✓ DCG grammar rules and lexicon loaded from {grammar_file.name}")
+                self.dcg_loaded = True
+            else:
+                print(f"ℹ  DCG grammar file not found at {grammar_file}")
+                self.dcg_loaded = False
+
+        except Exception as e:
+            print(f"⚠️  Warning: Could not load DCG grammar: {e}")
+            self.dcg_loaded = False
+
+    def _load_coptic_grammar(self):
+        """Load Coptic linguistic rules into Prolog"""
+
+        # Try to load DCG grammar file if it exists
+        self._load_dcg_grammar()
+
+        # ===================================================================
+        # COPTIC MORPHOLOGICAL RULES
+        # ===================================================================
+
+        # Article system: definite articles
+        self.prolog.assertz("definite_article('ⲡ')")      # masculine singular
+        self.prolog.assertz("definite_article('ⲧ')")      # feminine singular
+        self.prolog.assertz("definite_article('ⲛ')")      # plural
+        self.prolog.assertz("definite_article('ⲡⲉ')")     # masculine singular (variant)
+        self.prolog.assertz("definite_article('ⲧⲉ')")     # feminine singular (variant)
+        self.prolog.assertz("definite_article('ⲛⲉ')")     # plural (variant)
+
+        # Pronominal system - Independent pronouns
+        self.prolog.assertz("independent_pronoun('ⲁⲛⲟⲕ')")     # I
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲟⲕ')")     # you (m.sg)
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲟ')")      # you (f.sg)
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲟϥ')")     # he
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲟⲥ')")     # she
+        self.prolog.assertz("independent_pronoun('ⲁⲛⲟⲛ')")     # we
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲱⲧⲛ')")    # you (pl)
+        self.prolog.assertz("independent_pronoun('ⲛⲧⲟⲟⲩ')")    # they
+
+        # Suffix pronouns (enclitic)
+        self.prolog.assertz("suffix_pronoun('ⲓ')")   # my/me
+        self.prolog.assertz("suffix_pronoun('ⲕ')")   # your (m.sg)
+        self.prolog.assertz("suffix_pronoun('ϥ')")   # his/him
+        self.prolog.assertz("suffix_pronoun('ⲥ')")   # her
+        self.prolog.assertz("suffix_pronoun('ⲛ')")   # our/us
+        self.prolog.assertz("suffix_pronoun('ⲧⲛ')")  # your (pl)
+        self.prolog.assertz("suffix_pronoun('ⲟⲩ')")  # their/them
+
+        # Coptic verbal system - Conjugation bases (tense/aspect markers)
+        self.prolog.assertz("conjugation_base('ⲁ')")      # Perfect (aorist)
+        self.prolog.assertz("conjugation_base('ⲛⲉ')")     # Imperfect/past
+        self.prolog.assertz("conjugation_base('ϣⲁ')")     # Future/conditional
+        self.prolog.assertz("conjugation_base('ⲙⲡⲉ')")    # Negative perfect
+        self.prolog.assertz("conjugation_base('ⲙⲛ')")     # Negative existential
+        self.prolog.assertz("conjugation_base('ⲉⲣϣⲁⲛ')")  # Conditional
+
+        # Auxiliary verbs (copulas)
+        self.prolog.assertz("copula('ⲡⲉ')")          # is (m.sg)
+        self.prolog.assertz("copula('ⲧⲉ')")          # is (f.sg)
+        self.prolog.assertz("copula('ⲛⲉ')")          # are (pl)
+
+        # ===================================================================
+        # COPTIC SYNTACTIC RULES
+        # ===================================================================
+
+        # Noun phrase structure rules
+        # Valid NP structure: Article + Noun
+        self.prolog.assertz("valid_np(Article, Noun) :- definite_article(Article), noun_compatible(Noun)")
+
+        # Helper: Any word can be a noun (simplified)
+        self.prolog.assertz("noun_compatible(_)")
+
+        # Definiteness agreement rule - In Coptic, definiteness is marked by articles
+        self.prolog.assertz("requires_definiteness(Noun, Article) :- definite_article(Article)")
+
+        # Tripartite nominal sentence pattern
+        # Coptic tripartite pattern: Subject - Copula - Predicate
+        # Example: ⲁⲛⲟⲕ ⲡⲉ ⲡⲛⲟⲩⲧⲉ (I am God)
+        self.prolog.assertz("tripartite_sentence(Subject, Copula, Predicate) :- independent_pronoun(Subject), copula(Copula), noun_compatible(Predicate)")
+
+        # Verbal sentence patterns
+        # Verbal sentence: Conjugation + Subject + Verb
+        self.prolog.assertz("verbal_sentence(Conj, Subject, Verb) :- conjugation_base(Conj), (independent_pronoun(Subject) ; definite_article(Subject)), verb_compatible(Verb)")
+
+        # Helper: Any word can be a verb (simplified)
+        self.prolog.assertz("verb_compatible(_)")
+
+        # ===================================================================
+        # DEPENDENCY VALIDATION RULES
+        # ===================================================================
+
+        # Validate subject-verb relationship
+        self.prolog.assertz("valid_subject_verb(Subject, Verb, SubjPOS, VerbPOS) :- member(SubjPOS, ['PRON', 'NOUN', 'PROPN']), member(VerbPOS, ['VERB', 'AUX'])")
+
+        # Validate determiner-noun relationship
+        self.prolog.assertz("valid_det_noun(Det, Noun, DetPOS, NounPOS) :- DetPOS = 'DET', member(NounPOS, ['NOUN', 'PROPN'])")
+
+        # Validate modifier relationships
+        self.prolog.assertz("valid_modifier(Head, Modifier, ModPOS) :- member(ModPOS, ['ADJ', 'ADV', 'DET'])")
+
+        # Validate punctuation assignments - content words should NOT be punct
+        # Only actual punctuation marks (PUNCT POS tag) should have punct relation
+        self.prolog.assertz("invalid_punct(Word, POS, Relation) :- Relation = 'punct', member(POS, ['VERB', 'NOUN', 'PRON', 'PROPN', 'DET', 'ADJ', 'ADV', 'AUX', 'NUM'])")
+
+        # ===================================================================
+        # ERROR CORRECTION RULES
+        # ===================================================================
+
+        # Suggest correct relation for DET (determiner)
+        # DET before NOUN should be 'det' relation
+        self.prolog.assertz("suggest_correction('DET', _, 'det')")
+
+        # Suggest correct relation for PRON (pronoun)
+        # PRON is typically subject (nsubj), object (obj), or possessive
+        self.prolog.assertz("suggest_correction('PRON', 'VERB', 'nsubj')")  # Pronoun before verb = subject
+        self.prolog.assertz("suggest_correction('PRON', 'AUX', 'nsubj')")   # Pronoun before aux = subject
+        self.prolog.assertz("suggest_correction('PRON', _, 'nsubj')")       # Default for pronoun
+
+        # Suggest correct relation for NOUN
+        self.prolog.assertz("suggest_correction('NOUN', 'VERB', 'obj')")    # Noun after verb = object
+        self.prolog.assertz("suggest_correction('NOUN', 'AUX', 'nsubj')")   # Noun after copula = predicate nominal
+        self.prolog.assertz("suggest_correction('NOUN', _, 'obl')")         # Default for noun
+
+        # Suggest correct relation for VERB
+        # Main verbs are often root, ccomp (complement clause), or advcl (adverbial clause)
+        self.prolog.assertz("suggest_correction('VERB', 'SCONJ', 'ccomp')") # Verb after subordinator = complement
+        self.prolog.assertz("suggest_correction('VERB', 'VERB', 'ccomp')")  # Verb after verb = complement
+        self.prolog.assertz("suggest_correction('VERB', _, 'root')")        # Default for verb
+
+        # Suggest correct relation for AUX (auxiliary/copula)
+        self.prolog.assertz("suggest_correction('AUX', _, 'cop')")          # Copula relation
+
+        # Suggest correct relation for ADJ (adjective)
+        self.prolog.assertz("suggest_correction('ADJ', 'NOUN', 'amod')")    # Adjective modifying noun
+
+        # Suggest correct relation for ADV (adverb)
+        self.prolog.assertz("suggest_correction('ADV', _, 'advmod')")       # Adverbial modifier
+
+        # Suggest correct relation for NUM (number)
+        self.prolog.assertz("suggest_correction('NUM', 'NOUN', 'nummod')") # Number modifying noun
+        self.prolog.assertz("suggest_correction('NUM', _, 'obl')")         # Default for number (temporal/oblique)
+
+        # ===================================================================
+        # MORPHOLOGICAL ANALYSIS RULES
+        # ===================================================================
+
+        # Clitic attachment patterns
+        self.prolog.assertz("has_suffix_pronoun(Word, Base, Suffix) :- atom_concat(Base, Suffix, Word), suffix_pronoun(Suffix), atom_length(Base, BaseLen), BaseLen > 0")
+
+        # Article stripping for lemmatization
+        self.prolog.assertz("strip_article(Word, Lemma) :- definite_article(Article), atom_concat(Article, Lemma, Word), atom_length(Lemma, LemmaLen), LemmaLen > 0")
+
+        # If no article found, word is its own lemma
+        self.prolog.assertz("strip_article(Word, Word) :- \\+ (definite_article(Article), atom_concat(Article, _, Word))")
+
+        print("✓ Coptic grammatical rules loaded into Prolog")
+
+    # ===================================================================
+    # PYTHON INTERFACE METHODS
+    # ===================================================================
+
+    def validate_dependency(self, head_word, dep_word, head_pos, dep_pos, relation):
+        """
+        Validate a dependency relation using Prolog rules
+
+        Args:
+            head_word: The head word text
+            dep_word: The dependent word text
+            head_pos: POS tag of head
+            dep_pos: POS tag of dependent
+            relation: Dependency relation (nsubj, obj, det, etc.)
+
+        Returns:
+            dict: Validation result with status and suggestions
+        """
+        if not self.prolog_initialized:
+            return {"valid": True, "message": "Prolog not available"}
+
+        try:
+            result = {"valid": True, "warnings": [], "suggestions": []}
+
+            # Check subject-verb relationships
+            if relation in ['nsubj', 'csubj']:
+                query = f"valid_subject_verb('{dep_word}', '{head_word}', '{dep_pos}', '{head_pos}')"
+                query_result = list(self.prolog.query(query))
+                if not query_result:
+                    result["warnings"].append(
+                        f"Unusual subject-verb: {dep_word} ({dep_pos}) → {head_word} ({head_pos})"
+                    )
+
+            # Check determiner-noun relationships
+            elif relation == 'det':
+                query = f"valid_det_noun('{dep_word}', '{head_word}', '{dep_pos}', '{head_pos}')"
+                query_result = list(self.prolog.query(query))
+                if not query_result:
+                    result["warnings"].append(
+                        f"Unusual det-noun: {dep_word} → {head_word}"
+                    )
+
+            # Check for incorrect punctuation assignments and suggest corrections
+            query = f"invalid_punct('{dep_word}', '{dep_pos}', '{relation}')"
+            query_result = list(self.prolog.query(query))
+            if query_result:
+                # Query for suggested correction
+                correction_query = f"suggest_correction('{dep_pos}', '{head_pos}', Suggestion)"
+                correction_result = list(self.prolog.query(correction_query))
+
+                if correction_result and 'Suggestion' in correction_result[0]:
+                    suggested_rel = correction_result[0]['Suggestion']
+                    result["warnings"].append(
+                        f"⚠️  PARSER ERROR: '{dep_word}' ({dep_pos}) incorrectly labeled as 'punct' → SUGGESTED: '{suggested_rel}'"
+                    )
+                    result["suggestions"].append({
+                        "word": dep_word,
+                        "pos": dep_pos,
+                        "incorrect": relation,
+                        "suggested": suggested_rel,
+                        "head_pos": head_pos
+                    })
+                else:
+                    result["warnings"].append(
+                        f"⚠️  PARSER ERROR: '{dep_word}' ({dep_pos}) incorrectly labeled as 'punct' - should be a content relation"
+                    )
+
+            return result
+
+        except Exception as e:
+            return {"valid": True, "message": f"Validation error: {e}"}
+
+    def check_tripartite_pattern(self, words, pos_tags):
+        """
+        Check if a sentence follows the Coptic tripartite nominal pattern
+
+        Args:
+            words: List of word forms
+            pos_tags: List of POS tags
+
+        Returns:
+            dict: Pattern analysis results
+        """
+        if not self.prolog_initialized or len(words) < 3:
+            return {"is_tripartite": False}
+
+        try:
+            # Check for tripartite pattern: Pronoun - Copula - Noun
+            subj, cop, pred = words[0], words[1], words[2]
+
+            query = f"tripartite_sentence('{subj}', '{cop}', '{pred}')"
+            query_result = list(self.prolog.query(query))
+            is_tripartite = len(query_result) > 0
+
+            return {
+                "is_tripartite": is_tripartite,
+                "pattern": f"{subj} - {cop} - {pred}" if is_tripartite else None,
+                "description": "Tripartite nominal sentence" if is_tripartite else None
+            }
+
+        except Exception as e:
+            return {"is_tripartite": False, "error": str(e)}
+
+    def analyze_morphology(self, word):
+        """
+        Analyze word morphology using Prolog rules
+
+        Args:
+            word: Coptic word to analyze
+
+        Returns:
+            dict: Morphological analysis
+        """
+        if not self.prolog_initialized:
+            return {"word": word, "analyzed": False}
+
+        try:
+            analysis = {"word": word, "components": []}
+
+            # Check for definite article
+            article_query = f"strip_article('{word}', Lemma)"
+            results = list(self.prolog.query(article_query))
+            if results:
+                result = results[0]
+                if 'Lemma' in result:
+                    lemma = result['Lemma']
+                    if lemma != word:
+                        analysis["has_article"] = True
+                        analysis["lemma"] = lemma
+                        analysis["article"] = word.replace(lemma, '')
+
+            # Check for suffix pronouns
+            suffix_query = f"has_suffix_pronoun('{word}', Base, Suffix)"
+            results = list(self.prolog.query(suffix_query))
+            if results:
+                result = results[0]
+                analysis["has_suffix"] = True
+                analysis["base"] = result.get('Base')
+                analysis["suffix"] = result.get('Suffix')
+
+            return analysis
+
+        except Exception as e:
+            return {"word": word, "error": str(e)}
+
+    def validate_parse_tree(self, words, pos_tags, heads, deprels):
+        """
+        Validate an entire parse tree using Prolog constraints
+
+        Args:
+            words: List of word forms
+            pos_tags: List of POS tags
+            heads: List of head indices
+            deprels: List of dependency relations
+
+        Returns:
+            dict: Overall validation results with warnings and suggestions
+        """
+        if not self.prolog_initialized:
+            return {"validated": False, "reason": "Prolog not available"}
+
+        try:
+            results = {
+                "validated": True,
+                "warnings": [],
+                "suggestions": [],
+                "patterns_found": []
+            }
+
+            # Check for tripartite pattern (basic assertz-based)
+            tripartite = self.check_tripartite_pattern(words, pos_tags)
+            if tripartite.get("is_tripartite"):
+                results["patterns_found"].append(tripartite)
+
+            # If DCG grammar is loaded, use advanced pattern matching
+            if hasattr(self, 'dcg_loaded') and self.dcg_loaded:
+                try:
+                    dcg_results = self._validate_with_dcg(words, pos_tags, heads, deprels)
+                    if dcg_results and isinstance(dcg_results, dict):
+                        # Merge DCG results
+                        if "patterns_found" in dcg_results and dcg_results["patterns_found"]:
+                            results["patterns_found"].extend(dcg_results["patterns_found"])
+                        if "warnings" in dcg_results and dcg_results["warnings"]:
+                            results["warnings"].extend(dcg_results["warnings"])
+                except Exception as e:
+                    print(f"Warning: DCG validation failed: {e}")
+                    # Continue with basic validation even if DCG fails
+
+            # Validate each dependency (existing validation)
+            for i, (word, pos, head, rel) in enumerate(zip(words, pos_tags, heads, deprels)):
+                if head > 0 and head <= len(words):  # Not root
+                    head_word = words[head - 1]
+                    head_pos = pos_tags[head - 1]
+
+                    validation = self.validate_dependency(head_word, word, head_pos, pos, rel)
+                    if validation.get("warnings"):
+                        results["warnings"].extend(validation["warnings"])
+
+            return results
+
+        except Exception as e:
+            return {"validated": False, "error": str(e)}
+
+    def _validate_with_dcg(self, words, pos_tags, heads, deprels):
+        """
+        Validate parse tree using DCG grammar rules
+
+        Args:
+            words: List of word tokens
+            pos_tags: List of POS tags
+            heads: List of head indices
+            deprels: List of dependency relations
+
+        Returns:
+            dict: DCG validation results
+        """
+        try:
+            # Convert Python lists to Prolog format
+            words_pl = self._list_to_prolog_atoms(words)
+            pos_pl = self._list_to_prolog_atoms(pos_tags)
+            heads_pl = '[' + ','.join(map(str, heads)) + ']'
+            deprels_pl = self._list_to_prolog_atoms(deprels)
+
+            # Query the DCG validation predicate
+            query = f"coptic_grammar:validate_parse_tree({words_pl}, {pos_pl}, {heads_pl}, {deprels_pl})"
+
+            # Execute query - it asserts patterns and warnings
+            list(self.prolog.query(query))
+
+            # Retrieve patterns
+            patterns = []
+            pattern_query = "coptic_grammar:pattern_found(P)"
+            try:
+                for result in self.prolog.query(pattern_query):
+                    if isinstance(result, dict) and 'P' in result:
+                        pattern_data = result.get('P')
+                        if pattern_data:
+                            formatted = self._format_prolog_term(pattern_data)
+                            patterns.append(formatted)
+            except Exception as e:
+                print(f"Warning: Error retrieving patterns: {e}")
+
+            # Retrieve warnings
+            warnings = []
+            warning_query = "coptic_grammar:warning(W)"
+            try:
+                for result in self.prolog.query(warning_query):
+                    if isinstance(result, dict) and 'W' in result:
+                        warning_data = result.get('W')
+                        if warning_data:
+                            formatted = self._format_prolog_term(warning_data)
+                            warnings.append(formatted)
+            except Exception as e:
+                print(f"Warning: Error retrieving warnings: {e}")
+
+            # Clean up dynamic predicates
+            try:
+                list(self.prolog.query("coptic_grammar:retractall(pattern_found(_))"))
+                list(self.prolog.query("coptic_grammar:retractall(warning(_))"))
+            except Exception as e:
+                print(f"Warning: Error cleaning up Prolog predicates: {e}")
+
+            return {
+                "patterns_found": patterns,
+                "warnings": warnings
+            }
+
+        except Exception as e:
+            print(f"DCG validation error: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "patterns_found": [],
+                "warnings": []
+            }
+
+    def _list_to_prolog_atoms(self, python_list):
+        """
+        Convert Python list of strings to Prolog list with properly quoted atoms
+
+        Args:
+            python_list: Python list of strings
+
+        Returns:
+            str: Prolog list syntax
+        """
+        if not python_list:
+            return "[]"
+
+        # Quote and escape each string
+        items = []
+        for item in python_list:
+            # Escape single quotes
+            escaped = str(item).replace("'", "\\'")
+            items.append(f"'{escaped}'")
+
+        return '[' + ','.join(items) + ']'
+
+    def _format_prolog_term(self, term):
+        """
+        Format a Prolog term for Python display
+
+        Args:
+            term: Prolog term (can be atom, list, or compound)
+
+        Returns:
+            dict: Formatted representation (always a dict)
+        """
+        if isinstance(term, list):
+            result = {}
+            for item in term:
+                if hasattr(item, 'name') and hasattr(item, 'args'):
+                    # Compound term like pattern_name('...')
+                    key = item.name
+                    value = item.args[0] if len(item.args) > 0 else None
+                    result[key] = str(value) if value is not None else ''
+            return result if result else {'data': str(term)}
+        elif isinstance(term, str):
+            # Simple string/atom - wrap in dict
+            return {'type': term, 'data': term}
+        else:
+            # Other types - convert to string and wrap
+            return {'data': str(term)}
+
+    def query_prolog(self, query_string):
+        """
+        Direct Prolog query interface for custom queries
+
+        Args:
+            query_string: Prolog query as string
+
+        Returns:
+            Query result or None
+        """
+        if not self.prolog_initialized:
+            return None
+
+        try:
+            results = list(self.prolog.query(query_string))
+            return results[0] if results else None
+        except Exception as e:
+            print(f"Prolog query error: {e}")
+            return None
+
+    def cleanup(self):
+        """
+        Cleanup Prolog engine and threads properly
+        """
+        if self.prolog_initialized and self.prolog is not None:
+            try:
+                # Try to properly halt the Prolog engine
+                # This attempts to stop all Prolog threads
+                try:
+                    # Query halt to stop Prolog cleanly
+                    list(self.prolog.query("halt"))
+                except:
+                    # halt will raise an exception as Prolog stops, which is expected
+                    pass
+
+                # Clean up the Prolog instance
+                self.prolog = None
+                self.prolog_initialized = False
+                print("✓ Prolog engine cleaned up successfully")
+            except Exception as e:
+                print(f"Warning: Error during Prolog cleanup: {e}")
+
+
+# ===================================================================
+# CONVENIENCE FUNCTIONS
+# ===================================================================
+
+def create_prolog_engine():
+    """Factory function to create and initialize Prolog engine"""
+    return CopticPrologRules()
+
+
+# ===================================================================
+# EXAMPLE USAGE
+# ===================================================================
+
+if __name__ == "__main__":
+    print("="*70)
+    print("Coptic Prolog Rules - Test Suite")
+    print("="*70)
+
+    # Initialize engine
+    prolog = create_prolog_engine()
+
+    if not prolog.prolog_initialized:
+        print("\n⚠️  Prolog not available. Cannot run tests.")
+        exit(1)
+
+    print("\n" + "="*70)
+    print("TEST 1: Tripartite Pattern Recognition")
+    print("="*70)
+
+    # Test tripartite sentence: ⲁⲛⲟⲕ ⲡⲉ ⲡⲛⲟⲩⲧⲉ (I am God)
+    words = ['ⲁⲛⲟⲕ', 'ⲡⲉ', 'ⲡⲛⲟⲩⲧⲉ']
+    pos_tags = ['PRON', 'AUX', 'NOUN']
+
+    result = prolog.check_tripartite_pattern(words, pos_tags)
+    print(f"\nInput: {' '.join(words)}")
+    print(f"Result: {result}")
+
+    print("\n" + "="*70)
+    print("TEST 2: Morphological Analysis")
+    print("="*70)
+
+    # Test article stripping
+    test_words = ['ⲡⲛⲟⲩⲧⲉ', 'ⲧⲃⲁϣⲟⲣ', 'ⲛⲣⲱⲙⲉ']
+    for word in test_words:
+        analysis = prolog.analyze_morphology(word)
+        print(f"\nWord: {word}")
+        print(f"Analysis: {analysis}")
+
+    print("\n" + "="*70)
+    print("TEST 3: Dependency Validation")
+    print("="*70)
+
+    # Test subject-verb relationship
+    validation = prolog.validate_dependency(
+        head_word='ⲡⲉ',
+        dep_word='ⲁⲛⲟⲕ',
+        head_pos='AUX',
+        dep_pos='PRON',
+        relation='nsubj'
+    )
+    print(f"\nDependency: ⲁⲛⲟⲕ (PRON) --nsubj--> ⲡⲉ (AUX)")
+    print(f"Validation: {validation}")
+
+    print("\n" + "="*70)
+    print("TEST 4: Custom Prolog Query")
+    print("="*70)
+
+    # Test custom query
+    result = prolog.query_prolog("definite_article(X)")
+    print(f"\nQuery: definite_article(X)")
+    print(f"Result: {result}")
+
+    print("\n" + "="*70)
+    print("All tests completed!")
+    print("="*70)

requirements.txt

@@ -5,3 +5,4 @@ stanza
 torch
 transformers>=4.30.0
 sentencepiece>=0.1.99
+pyswip>=0.2.10