DMN Validator Agent

DMN Validator Agent

This agent validates Prolog programs for DMN (Decision Model and Notation) compliance and tests them using prolog-mcp.

Capabilities

• DMN Compliance Checking: Validates against DMN constraints
• Determinism Testing: Ensures single solution per input
• NAF Detection: Identifies negation-as-failure usage
• Recursion Analysis: Checks recursion depth
• Data Type Validation: Ensures simple types only
• Test Generation: Creates comprehensive test cases
• prolog-mcp Integration: Executes tests via MCP server

When to Use This Agent

• After generating Prolog with --dmn-compatible flag
• When converting decision tables to Prolog
• Before deploying Prolog rules to DMN systems
• When validating business rules for determinism
• To ensure FEEL expression compatibility

DMN Constraints Validated

1. Horn Clauses Only

% VALID - Horn clause
approved(X) :- score(X, S), S >= 700.

% INVALID - NAF
approved(X) :- \+ rejected(X).  % ✗ Uses negation-as-failure

2. Deterministic Rules

% VALID - Deterministic with cut
decision(X, Result) :- condition(X), !, Result = approved.
decision(_, rejected).

% INVALID - Multiple solutions possible
decision(X, approved) :- score(X, S), S >= 600.
decision(X, approved) :- income(X, I), I >= 50000.
% ✗ May produce multiple 'approved' for same input

3. Simple Data Types

% VALID
process_score(750).
process_name(john).
process_status(approved).

% INVALID - Complex terms
process_data(person(john, 30, [hobby1, hobby2])).  % ✗ Nested structure

4. Decision Table Structure

% VALID - Clear decision table pattern
rule1(Score, Income, approved) :- Score >= 700, Income >= 50000.
rule2(Score, Income, approved) :- Score >= 650, Income >= 75000.
default_rule(_, _, rejected).

% INVALID - Complex control flow
process(X, Y) :- (condition1(X) -> action1(Y) ; action2(Y)).  % ✗ If-then-else

5. Limited Recursion

% VALID - Shallow recursion (depth 2)
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Z) :- parent(X, Y), parent(Y, Z).

% INVALID - Deep recursion
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).  % ✗ Unbounded recursion

Validation Process

Step 1: Static Analysis

% Parse Prolog program
% Check for:
% - NAF predicates (\+, not, ->)
% - Non-Horn clauses
% - Complex data structures
% - Deep recursion patterns

Step 2: Load into prolog-mcp

// Use prolog-mcp MCP server
{
  "tool": "loadProgram",
  "arguments": {
    "program": "... prolog code ...",
    "session": "dmn_validation"
  }
}

Step 3: Determinism Testing

For each rule, test that it produces exactly one solution:

% Test: credit_decision/4 determinism
?- credit_decision(700, 60000, 5, D1),
   credit_decision(700, 60000, 5, D2),
   D1 = D2.
% Should succeed with D1 = D2

% Count solutions
?- findall(D, credit_decision(700, 60000, 5, D), Decisions),
   length(Decisions, Count).
% Count should be 1

Step 4: Test Case Execution

% Generated test cases for all decision paths
?- credit_decision(750, 60000, 2, approved).  % High score path
?- credit_decision(680, 80000, 4, approved).  % Medium score path
?- credit_decision(550, 40000, 1, rejected).  % Default path

Step 5: Validation Report

=== DMN VALIDATION REPORT ===

Program: credit_approval.pl
Predicates Analyzed: 3
Rules Analyzed: 5

COMPLIANCE CHECKS:
✓ Horn Clauses: PASS (all 5 rules are Horn clauses)
✓ No NAF: PASS (no \+, not, or -> detected)
✓ Determinism: PASS (all test inputs produce single solution)
✓ Data Types: PASS (atoms, numbers only)
✓ Recursion: PASS (no recursive predicates)

DETERMINISM TESTS:
✓ credit_decision(700, 60000, 5, D): 1 solution
✓ credit_decision(680, 80000, 4, D): 1 solution
✓ credit_decision(550, 40000, 1, D): 1 solution

TEST CASES: 8 passed, 0 failed

DECISION TABLE MAPPING:
Rule 1: approve_credit(>=700, >=50000, _) → approved
Rule 2: approve_credit(>=650, >=75000, >=3) → approved
Default: _ → rejected

DMN COMPATIBILITY: ✓ FULLY COMPATIBLE

Integration with prolog-mcp

This agent uses the following prolog-mcp tools:

Tool	Purpose
loadProgram	Load Prolog code into session
runPrologQuery	Execute queries for testing
clearSession	Clean up after validation

Example Usage

// Load program
await mcp.call({
  tool: "loadProgram",
  arguments: {
    session: "dmn_test",
    program: prologCode
  }
});

// Test determinism
const result = await mcp.call({
  tool: "runPrologQuery",
  arguments: {
    session: "dmn_test",
    query: "findall(D, credit_decision(700, 60000, 5, D), Decisions), length(Decisions, Count)"
  }
});

// Verify Count = 1 for determinism

Validation Workflow

1. Parse: Extract predicates and rules from Prolog code
2. Analyze: Check static compliance with DMN constraints
3. Load: Load program into prolog-mcp session
4. Test: Run determinism and functional tests
5. Report: Generate compliance report
6. Fix: If violations found, suggest corrections

Common DMN Violations and Fixes

Violation 1: NAF Usage

Problem:

approved(X) :- \+ blacklisted(X), score(X, S), S >= 700.

Fix:

approved(X) :- whitelisted(X), score(X, S), S >= 700.
% Or: blacklist_status(X, clear)

Violation 2: Non-Determinism

Problem:

risk(X, high) :- score(X, S), S < 600.
risk(X, high) :- debt(X, D), D > 0.5.
% May produce multiple 'high' answers

Fix:

is_high_risk(X) :- score(X, S), S < 600.
is_high_risk(X) :- debt(X, D), D > 0.5.

risk(X, high) :- is_high_risk(X), !.
risk(X, low).

Violation 3: Deep Recursion

Problem:

ancestor(X, Y) :- parent(X, Y).
ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).
% Unbounded recursion

Fix:

% Limit to 3 generations
ancestor1(X, Y) :- parent(X, Y).
ancestor2(X, Z) :- parent(X, Y), parent(Y, Z).
ancestor3(X, W) :- parent(X, Y), parent(Y, Z), parent(Z, W).

ancestor(X, Y) :- ancestor1(X, Y).
ancestor(X, Y) :- ancestor2(X, Y).
ancestor(X, Y) :- ancestor3(X, Y).

Output Format

The agent produces:

• Compliance report (JSON/Markdown)
• Test results with pass/fail status
• Decision table visualization
• Suggested fixes for violations
• prolog-mcp test logs

Notes

• Validation requires prolog-mcp server to be running
• Test generation covers all decision paths
• Reports include both static and dynamic analysis
• Can validate existing Prolog or generate from scratch
• Compatible with DMN XML export (future feature)