kibi-core 0.7.0 → 0.8.1

package/src/checks.pl

@@ -18,6 +18,10 @@
     check_strict_req_fact_pairing/1,% Returns list of malformed strict req/fact pairing violations
     check_strict_readiness/1,       % Returns list of strict readiness audit violations
     check_predicate_verifiability/1,% Returns list of unverifiable predicate-lane requirement links
+    check_logic_coverage/1,         % Returns list of incomplete declared logical claim manifests
+    check_rule_safety/1,
+    check_rule_verifiability/1,
+    check_semantic_completeness/1,
     run_checks_json/0,              % Entry point for JSON output
     violation_id_text/2             % Extract text from entity ID term (exported for testing)
 ]).
@@ -27,6 +31,7 @@
 :- use_module('kb.pl').
 :- use_module('../schema/entities.pl', [entity_type/1, required_property/2]).
 :- use_module('../schema/relationships.pl', [relationship_type/1]).
+:- use_module('logic_ir.pl', [logic_rule_safety/2, logic_rule_from_props/2, logic_rule_conflict/3, logic_rules_stratified/1]).
 
 % Required fields for all entities
 required_fields([id, title, status, created_at, updated_at, source]).
@@ -34,7 +39,7 @@ required_fields([id, title, status, created_at, updated_at, source]).
 % Relationship types to check for dangling references
 all_relationship_types([
     depends_on, verified_by, validates, specified_by,
-    constrains, requires_property, requires_predicate, supersedes, relates_to
+    constrains, requires_property, requires_predicate, requires_rule, supersedes, relates_to
 ]).
 
 %% check_all(-ViolationsDict)
@@ -54,6 +59,10 @@ check_all(ViolationsDict) :-
     check_strict_req_fact_pairing(StrictReqFactPairing),
     check_strict_readiness(StrictReadiness),
     check_predicate_verifiability(PredicateVerifiability),
+    check_logic_coverage(LogicCoverage),
+    check_rule_safety(RuleSafety),
+    check_rule_verifiability(RuleVerifiability),
+    check_semantic_completeness(SemanticCompleteness),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -66,7 +75,11 @@ check_all(ViolationsDict) :-
         strict_fact_shape: StrictFactShape,
         strict_req_fact_pairing: StrictReqFactPairing,
         strict_readiness: StrictReadiness,
-        predicate_verifiability: PredicateVerifiability
+        predicate_verifiability: PredicateVerifiability,
+        logic_coverage: LogicCoverage,
+        rule_safety: RuleSafety,
+        rule_verifiability: RuleVerifiability,
+        semantic_completeness: SemanticCompleteness
     }.
 
 %% check_must_priority_coverage(-Violations)
@@ -405,9 +418,25 @@ strict_fact_shape_violation(violation(
             Description = First,
             Suggestion = "Ensure predicate facts have predicate_name, non-empty predicate_args, canonical_key, and assert/deny polarity when present"
         )
+    ;   Kind = rule_schema
+    ->  findall(Msg, rule_schema_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure rule_schema facts declare rule_name plus same-length argument_names and argument_types"
+        )
+    ;   Kind = rule
+    ->  findall(Msg, rule_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure rule facts contain a safe kibi.logic.v1 rule_ir, full rule_hash, rule_schema_id, rule_name, and semantic_key"
+        )
     ;   % Unknown fact_kind - report as malformed
         format(string(Description), "Unknown fact_kind: ~w", [Kind]),
-        Suggestion = "Use one of: subject, property_value, observation, meta, predicate_schema, predicate"
+        Suggestion = "Use one of: subject, property_value, observation, meta, predicate_schema, predicate, rule_schema, rule"
     ),
     
     (   memberchk(source=Source0, Props)
@@ -500,6 +529,42 @@ predicate_shape_error(Props, "Predicate fact polarity must be assert or deny") :
     normalize_term_atom(RawPolarity, Polarity),
     \+ memberchk(Polarity, [assert, deny]).
 
+rule_schema_shape_error(Props, "Rule schema fact missing required field: rule_name") :-
+    \+ memberchk(rule_name=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact missing required field: argument_names") :-
+    memberchk(rule_name=_, Props),
+    \+ memberchk(argument_names=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact missing required field: argument_types") :-
+    memberchk(argument_names=_, Props),
+    \+ memberchk(argument_types=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact argument_names and argument_types must have equal lengths") :-
+    memberchk(argument_names=RawNames, Props),
+    memberchk(argument_types=RawTypes, Props),
+    checks_normalize_atom_list(RawNames, Names),
+    checks_normalize_atom_list(RawTypes, Types),
+    length(Names, NameCount),
+    length(Types, TypeCount),
+    NameCount =\= TypeCount.
+
+rule_shape_error(Props, "Rule fact missing required field: rule_ir") :-
+    \+ memberchk(rule_ir=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_hash") :-
+    memberchk(rule_ir=_, Props),
+    \+ memberchk(rule_hash=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_schema_id") :-
+    memberchk(rule_hash=_, Props),
+    \+ memberchk(rule_schema_id=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_name") :-
+    memberchk(rule_schema_id=_, Props),
+    \+ memberchk(rule_name=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: semantic_key") :-
+    memberchk(rule_name=_, Props),
+    \+ memberchk(semantic_key=_, Props).
+rule_shape_error(Props, "Rule fact rule_ir failed kibi.logic.v1 safety validation") :-
+    memberchk(rule_ir=_, Props),
+    logic_rule_safety(Props, Errors),
+    Errors \= [].
+
 checks_normalize_integer(Raw, Integer) :-
     (   Raw = ^^(Value, _Type)
     ->  checks_normalize_integer(Value, Integer)
@@ -534,8 +599,41 @@ check_domain_contradictions(Violations) :-
             format(string(EntityId), "~w/~w", [ReqA, ReqB]),
             format(string(Description), "~w [strict-readiness: contradiction-ready]", [Reason])
         ),
-        Violations
-    ).
+        StrictViolations
+    ),
+    findall(
+        violation(
+            'domain-contradictions',
+            EntityId,
+            Description,
+            "Align the opposing rule heads, separate their scopes, or add an explicit supersedes relationship",
+            ""
+        ),
+        (   opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB),
+            logic_rule_conflict(RuleA, RuleB, Conflict),
+            Conflict \= disjoint,
+            format(string(EntityId), "~w/~w", [ReqA, ReqB]),
+            format(string(Description), "Rule conflict (~w) between ~w and ~w", [Conflict, ReqA, ReqB])
+        ),
+        RuleViolations
+    ),
+    append(StrictViolations, RuleViolations, Violations).
+
+opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB) :-
+    kb:current_req(ReqA),
+    kb:current_req(ReqB),
+    ReqA @< ReqB,
+    kb_relationship(requires_rule, ReqA, FactA),
+    kb_relationship(requires_rule, ReqB, FactB),
+    FactA @< FactB,
+    kb_entity(FactA, fact, PropsA),
+    kb_entity(FactB, fact, PropsB),
+    memberchk(fact_kind=KindA, PropsA),
+    memberchk(fact_kind=KindB, PropsB),
+    normalize_term_atom(KindA, rule),
+    normalize_term_atom(KindB, rule),
+    logic_rule_from_props(PropsA, RuleA),
+    logic_rule_from_props(PropsB, RuleB).
 
 %% check_strict_req_fact_pairing(-Violations)
 % Finds current requirements attempting strict-lane modeling with incomplete
@@ -800,6 +898,313 @@ predicate_verifiability_kind_label(legacy, "a legacy fact without fact_kind").
 predicate_verifiability_kind_label(Kind, Label) :-
     format(string(Label), "fact_kind=~w", [Kind]).
 
+%% check_logic_coverage(-Violations)
+% Validates explicitly declared atomic requirement claim manifests. Legacy
+% requirements without logic_claims remain eligible for gradual backfill; once
+% a manifest exists, every key must be grounded by a linked strict-property or
+% predicate fact carrying the same claim_key.
+check_logic_coverage(Violations) :-
+    findall(Violation, logic_coverage_violation(Violation), Violations0),
+    sort(Violations0, Violations).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Ground every declared claim with a property_value, predicate, or rule fact via its typed relationship, preserving the same claim_key",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    requirement_logic_claims(ReqId, ClaimKeys),
+    member(ClaimKey, ClaimKeys),
+    \+ grounded_requirement_claim(ReqId, ClaimKey),
+    format(
+        string(Description),
+        "Requirement declares logical claim ~w but has no matching ground fact",
+        [ClaimKey]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Keep a one-to-one mapping between each atomic claim key and its linked ground fact; split compound clauses before grounding",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    grounded_requirement_claim_fact(ReqId, ClaimKey, FactA),
+    grounded_requirement_claim_fact(ReqId, ClaimKey, FactB),
+    FactA @< FactB,
+    format(
+        string(Description),
+        "Requirement grounds logical claim ~w more than once through ~w and ~w",
+        [ClaimKey, FactA, FactB]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Remove punctuation or wording variants from the atomic inventory and keep one claim key for each distinct logical term",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    grounded_requirement_claim_fact(ReqId, ClaimA, FactA),
+    grounded_requirement_claim_fact(ReqId, ClaimB, FactB),
+    ClaimA \= ClaimB,
+    FactA @< FactB,
+    logical_ground_signature(FactA, Signature),
+    logical_ground_signature(FactB, Signature),
+    format(
+        string(Description),
+        "Requirement declares duplicate logical ground term ~w through claim keys ~w and ~w",
+        [Signature, ClaimA, ClaimB]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Append the linked fact claim_key to the requirement logic_claims manifest, or remove the stale logical link",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    requirement_logic_claims(ReqId, ClaimKeys),
+    grounded_requirement_claim(ReqId, ClaimKey),
+    \+ memberchk(ClaimKey, ClaimKeys),
+    format(
+        string(Description),
+        "Requirement links ground logical claim ~w but omits it from logic_claims",
+        [ClaimKey]
+    ),
+    violation_source(ReqId, req, Source).
+
+requirement_logic_claims(ReqId, ClaimKeys) :-
+    kb_entity(ReqId, req, Props),
+    memberchk(logic_claims=RawClaimKeys, Props),
+    kb:normalize_term_atom_list(RawClaimKeys, ClaimKeys).
+
+grounded_requirement_claim(ReqId, ClaimKey) :-
+    grounded_requirement_claim_fact(ReqId, ClaimKey, _FactId).
+
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_property, ReqId, FactId),
+    ground_fact_claim_key(FactId, property_value, ClaimKey).
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_predicate, ReqId, FactId),
+    ground_fact_claim_key(FactId, predicate, ClaimKey).
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_rule, ReqId, FactId),
+    ground_fact_claim_key(FactId, rule, ClaimKey).
+
+logical_ground_signature(FactId, predicate(Namespace, Name, Args, Polarity)) :-
+    kb:predicate_fact(FactId, Namespace, Name, Args, Polarity).
+logical_ground_signature(
+    FactId,
+    property(Subject, Property, Operator, ValueType, Value, Unit, Scope, Polarity)
+) :-
+    kb:fact_property_tuple(
+        FactId,
+        Subject,
+        Property,
+        Operator,
+        ValueType,
+        Value,
+        Unit,
+        Scope,
+        Polarity
+    ).
+logical_ground_signature(FactId, rule(SemanticKey)) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    (   memberchk(semantic_key=RawKey, Props)
+    ->  normalize_term_atom(RawKey, SemanticKey)
+    ;   memberchk(rule_hash=RawKey, Props), normalize_term_atom(RawKey, SemanticKey)
+    ).
+
+ground_fact_claim_key(FactId, ExpectedKind, ClaimKey) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, ExpectedKind),
+    memberchk(claim_key=RawClaimKey, Props),
+    normalize_term_atom(RawClaimKey, ClaimKey),
+    memberchk(claim_text=RawClaimText, Props),
+    normalize_term_atom(RawClaimText, ClaimText),
+    ClaimText \= ''.
+
+%% check_rule_safety(-Violations)
+% Every stored rule must decode through the closed Logic IR vocabulary and
+% pass the independent Prolog-side safety checks.
+check_rule_safety(Violations) :-
+    findall(Violation, rule_safety_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+rule_safety_violation(violation(
+    'rule-safety',
+    FactId,
+    Description,
+    "Use kibi.logic.v1 typed IR; remove raw Prolog, unsafe variables, or unstratified negation",
+    Source
+)) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_safety(Props, Errors),
+    Errors \= [],
+    format(string(Description), "Rule fact ~w failed safety validation: ~w", [FactId, Errors]),
+    violation_source(FactId, fact, Source).
+
+% Local rule checks cannot detect a negation cycle spanning multiple facts.
+% Run the finite dependency-graph check over the complete stored rule set and
+% report each participating negated rule as infrastructure-grade unsafe IR.
+rule_safety_violation(violation(
+    'rule-safety',
+    FactId,
+    "Stored rules contain an unstratified negation dependency cycle",
+    "Separate the negated dependency into strata or replace it with an explicit closed-world fact",
+    Source
+)) :-
+    findall(Rule, stored_rule_term(Rule), Rules),
+    Rules \= [],
+    \+ logic_rules_stratified(Rules),
+    stored_rule_fact(FactId, _Props, Rule),
+    rule_contains_negation(Rule),
+    violation_source(FactId, fact, Source).
+
+stored_rule_term(Rule) :-
+    kb_entity(_FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_from_props(Props, Rule).
+
+stored_rule_fact(FactId, Props, Rule) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_from_props(Props, Rule).
+
+rule_contains_negation(rule(_, _, _Head, Body, Exceptions, _Scope, _From, _To, _Schema, _Variables)) :-
+    ( expression_contains_negation(Body)
+    ; member(Exception, Exceptions), expression_contains_negation(Exception)
+    ),
+    !.
+
+expression_contains_negation(not(_)).
+expression_contains_negation(all(Items)) :- member(Item, Items), expression_contains_negation(Item).
+expression_contains_negation(any(Items)) :- member(Item, Items), expression_contains_negation(Item).
+expression_contains_negation(count(Atom, _Operator, _Value)) :- expression_contains_negation(Atom).
+
+%% check_rule_verifiability(-Violations)
+% A requires_rule edge is meaningful only when it reaches a rule fact whose
+% schema endpoint exists and whose rule IR is safe.
+check_rule_verifiability(Violations) :-
+    findall(Violation, rule_verifiability_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+rule_verifiability_violation(violation(
+    'rule-verifiability',
+    ReqId,
+    Description,
+    "Link requires_rule to fact_kind=rule with a valid rule_schema_id and safe kibi.logic.v1 IR",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    kb_relationship(requires_rule, ReqId, FactId),
+    kb_entity(FactId, fact, Props),
+    rule_verifiability_description(Props, FactId, Description),
+    violation_source(ReqId, req, Source).
+
+rule_verifiability_description(Props, FactId, Description) :-
+    (   memberchk(fact_kind=RawKind, Props)
+    ->  normalize_term_atom(RawKind, Kind)
+    ;   Kind = legacy
+    ),
+    Kind \= rule,
+    format(string(Description), "Requirement uses requires_rule ~w but target is fact_kind=~w", [FactId, Kind]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    \+ memberchk(rule_schema_id=_, Props),
+    format(string(Description), "Rule fact ~w has no rule_schema_id", [FactId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    memberchk(rule_schema_id=SchemaId, Props),
+    \+ kb_entity(SchemaId, fact, _),
+    format(string(Description), "Rule fact ~w references missing rule schema ~w", [FactId, SchemaId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    memberchk(rule_schema_id=SchemaId, Props),
+    kb_entity(SchemaId, fact, SchemaProps),
+    \+ valid_rule_schema_props(SchemaProps),
+    format(string(Description), "Rule fact ~w references ~w, which is not a rule_schema fact", [FactId, SchemaId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_safety(Props, Errors),
+    Errors \= [],
+    format(string(Description), "Rule fact ~w is not safe: ~w", [FactId, Errors]).
+
+valid_rule_schema_props(Props) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule_schema),
+    memberchk(rule_name=Name, Props),
+    nonempty_normalized(Name),
+    memberchk(argument_names=RawNames, Props),
+    memberchk(argument_types=RawTypes, Props),
+    checks_normalize_atom_list(RawNames, Names),
+    checks_normalize_atom_list(RawTypes, Types),
+    same_length(Names, Types).
+
+nonempty_normalized(Value) :-
+    normalize_term_atom(Value, Atom),
+    Atom \= ''.
+
+%% check_semantic_completeness(-Violations)
+% The proposition ledger is additive and optional during migration. When it is
+% present, every assertive proposition must either be modeled or explicitly
+% recorded as an unresolved review state; silently missing entries are errors.
+check_semantic_completeness(Violations) :-
+    findall(Violation, semantic_completeness_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+semantic_completeness_violation(violation(
+    'semantic-completeness',
+    ReqId,
+    Description,
+    "Run kb_semantic_advisor again, preserve every proposition span, and model or explicitly classify each assertive proposition",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    kb_entity(ReqId, req, Props),
+    memberchk(semantic_inventory=RawInventory, Props),
+    inventory_entries(RawInventory, Entries),
+    member(Entry, Entries),
+    inventory_entry_status(Entry, Status),
+    memberchk(Status, [missing]),
+    format(string(Description), "Requirement proposition ledger contains an unclassified assertive span (~w)", [Entry]),
+    violation_source(ReqId, req, Source).
+
+inventory_entries(Raw, Entries) :-
+    (   is_list(Raw) -> Entries = Raw
+    ;   Raw = ^^(Value, _) -> inventory_entries(Value, Entries)
+    ;   (atom(Raw) ; string(Raw)),
+        catch(atom_json_term(Raw, JsonEntries, [value_string_as(string)]), _, fail),
+        is_list(JsonEntries)
+    ->  Entries = JsonEntries
+    ;   Entries = []
+    ).
+
+inventory_entry_status(Entry, Status) :-
+    is_dict(Entry), get_dict(status, Entry, Raw), normalize_term_atom(Raw, Status).
+inventory_entry_status(Entry, Status) :-
+    is_list(Entry), memberchk(status=Raw, Entry), normalize_term_atom(Raw, Status).
+
 strict_readiness_has_fact_link(ReqId) :-
     kb_relationship(constrains, ReqId, FactId),
     kb_entity(FactId, fact, _),
@@ -873,6 +1278,10 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
     check_strict_req_fact_pairing(StrictReqFactPairing),
     check_strict_readiness(StrictReadiness),
     check_predicate_verifiability(PredicateVerifiability),
+    check_logic_coverage(LogicCoverage),
+    check_rule_safety(RuleSafety),
+    check_rule_verifiability(RuleVerifiability),
+    check_semantic_completeness(SemanticCompleteness),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -885,7 +1294,11 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
         strict_fact_shape: StrictFactShape,
         strict_req_fact_pairing: StrictReqFactPairing,
         strict_readiness: StrictReadiness,
-        predicate_verifiability: PredicateVerifiability
+        predicate_verifiability: PredicateVerifiability,
+        logic_coverage: LogicCoverage,
+        rule_safety: RuleSafety,
+        rule_verifiability: RuleVerifiability,
+        semantic_completeness: SemanticCompleteness
     }.
 
 %% violations_dict_to_json(+ViolationsDict, -JsonDict)

package/src/kb.pl

@@ -45,6 +45,7 @@
     contradicting_reqs/3,
     check_req_contradiction/1,
     normalize_term_atom/2,
+    normalize_term_atom_list/2,
     changeset/4, % Export for testing
     kb_uri/1
 ]).
@@ -636,7 +637,7 @@ value_to_literal(Key, Value, Literal) :-
     ;   string(Value)
     ->  Literal = Value^^'http://www.w3.org/2001/XMLSchema#string'
     ;   is_list(Value)
-    ->  format(atom(ListStr), '~w', [Value]),
+    ->  with_output_to(atom(ListStr), write_term(Value, [quoted(true)])),
         Literal = ListStr^^'http://www.w3.org/2001/XMLSchema#string'
     ;   format(atom(Str), '~w', [Value]),
         Literal = Str^^'http://www.w3.org/2001/XMLSchema#string'
@@ -1005,6 +1006,26 @@ req_conflict(ReqA, ReqB, Reason) :-
     ;   property_conflict(SubjectKey, PropertyKey, OpA, ValTypeA, ValA, UnitA, PolarityA,
                           OpB, ValTypeB, ValB, UnitB, PolarityB, Reason)
     ).
+req_conflict(ReqA, ReqB, Reason) :-
+    effective_req_predicate(ReqA, FactA, Namespace, Name, Args, PolarityA),
+    effective_req_predicate(ReqB, FactB, Namespace, Name, Args, PolarityB),
+    FactA \= FactB,
+    opposite_predicate_polarity(PolarityA, PolarityB),
+    atomic_list_concat(Args, ',', ArgsText),
+    format(
+        string(Reason),
+        "Predicate conflict on ~w:~w(~w): ~w asserts ~w while ~w asserts ~w",
+        [Namespace, Name, ArgsText, ReqA, PolarityA, ReqB, PolarityB]
+    ).
+
+%% effective_req_predicate(+ReqId, -FactId, -Namespace, -Name, -Args, -Polarity)
+% Ground predicate claim required by a requirement.
+effective_req_predicate(ReqId, FactId, Namespace, Name, Args, Polarity) :-
+    kb_relationship(requires_predicate, ReqId, FactId),
+    predicate_fact(FactId, Namespace, Name, Args, Polarity).
+
+opposite_predicate_polarity(assert, deny).
+opposite_predicate_polarity(deny, assert).
 
 %% fact_subject_key(+FactId, -SubjectKey)
 % Extract the normalized subject key for strict subject facts.