kibi-core 0.14.1 → 0.15.1

package/src/discovery.pl

@@ -11,7 +11,8 @@
     requirement_proof_json/5,
     requirement_proof_json/7,
     symbol_proof_json/7,
-    graph_expand_json/8
+    graph_expand_json/8,
+    search_answer_verdicts_json/2
 ]).
 
 % Source contains non-ASCII text; do not depend on the host locale.
@@ -25,7 +26,9 @@
 :- use_module('kb.pl').
 :- use_module(library(semweb/rdf_db), [rdf_generation/1]).
 :- use_module('requirement_proof.pl', [requirement_proof_context/1, requirement_proof_context/4, requirement_proof_context/6, requirement_proof/4]).
-:- use_module('status.pl', [status_meta_dict/1]).
+:- use_module('checks.pl', [scenario_feasibility_outcome/2, infeasible_scenario/5]).
+:- use_module('logic_ir.pl', [logic_rule_conflict/3, logic_rule_conflict/4]).
+:- use_module('status.pl', [status_meta_dict/1, status_scope_dict/1]).
 :- use_module('../schema/relationships.pl', [relationship_type/1]).
 
 find_gaps_json(TypeFilter, MissingRelationships, PresentRelationships, Tags, SourceFilter, Limit, Offset, JsonString) :-
@@ -99,6 +102,214 @@ symbol_explain_role(SymbolId, Role) :-
     !.
 symbol_explain_role(_SymbolId, unknown).
 
+%% search_answer_verdicts_json(+ReqIds, -JsonString)
+% implements REQ-kibi-search-answer-layer-v2
+% What the existing checks report about the requirements a kb_search answer
+% names, in one engine round trip and bounded to those requirements:
+%   contradictions  strict-property and predicate witnesses from
+%                   kb:req_conflict_witness/3, and rule witnesses from the
+%                   pair generator and rule comparison the
+%                   domain-contradictions check uses (disjoint pairs omitted)
+%   scenarios       scenario_feasibility_outcome/2 of each scenario the
+%                   requirement specifies
+%   forbids         other scenarios infeasible_scenario/5 says it forbids
+%   inventory       the semantic-inventory stage of the proof ladder, with
+%                   the propositions still ambiguous or ontology gaps
+% Whole-KB scans (check_domain_contradiction_witnesses/1) are deliberately
+% not used: they take seconds on a large KB. The functional-predicate
+% declarations a rule comparison reads are collected once per call rather
+% than once per compared pair, which dominated the cost for requirements with
+% many rules. A requirement whose checks raise an error reports that error
+% instead of failing the answer. Scope names the snapshot the verdicts were
+% computed from.
+search_answer_verdicts_json(ReqIds, JsonString) :-
+    search_answer_functional(Functional),
+    maplist(search_answer_verdict(Functional), ReqIds, Verdicts),
+    status_scope_dict(Scope),
+    dict_json_string(_{requirements: Verdicts, scope: Scope}, JsonString).
+
+% The declarations logic_rule_conflict/3 would read for every pair; when they
+% cannot be read here, each comparison reads them itself.
+search_answer_functional(some(Functional)) :-
+    catch(logic_ir:functional_predicate_declarations(Functional), _, fail),
+    !.
+search_answer_functional(none).
+
+search_answer_rule_status(some(Functional), RuleA, RuleB, Status) :-
+    !,
+    logic_rule_conflict(RuleA, RuleB, Functional, Status).
+search_answer_rule_status(none, RuleA, RuleB, Status) :-
+    logic_rule_conflict(RuleA, RuleB, Status).
+
+search_answer_verdict(Functional, ReqId, Verdict) :-
+    catch(search_answer_verdict_(Functional, ReqId, Verdict0), Error, true),
+    (   var(Error)
+    ->  Verdict = Verdict0
+    ;   format(string(Text0), "~q", [Error]),
+        search_answer_clip(Text0, 300, Text),
+        Verdict = _{id: ReqId, error: Text}
+    ).
+
+search_answer_verdict_(Functional, ReqId, _{
+    id: ReqId,
+    contradictions: Contradictions,
+    scenarios: Scenarios,
+    forbids: Forbids,
+    inventory: Inventory
+}) :-
+    findall(C, search_answer_contradiction(Functional, ReqId, C), Contradictions0),
+    sort(Contradictions0, Contradictions),
+    findall(S, search_answer_scenario_outcome(ReqId, S), Scenarios0),
+    sort(Scenarios0, Scenarios),
+    findall(F, search_answer_forbidden_scenario(ReqId, F), Forbids0),
+    sort(Forbids0, Forbids),
+    search_answer_inventory(ReqId, Inventory).
+
+search_answer_contradiction(_Functional, ReqId, _{
+    kind: Kind,
+    status: Status,
+    with: Other,
+    facts: Facts,
+    reason: Reason
+}) :-
+    (   req_conflict_witness(ReqId, Other, Witness)
+    ;   req_conflict_witness(Other, ReqId, Witness)
+    ),
+    get_dict(kind, Witness, Kind),
+    get_dict(status, Witness, Status),
+    get_dict(reason, Witness, RawReason),
+    search_answer_text(RawReason, Reason),
+    findall(FactId,
+        (   member(SideKey, [left, right]),
+            get_dict(SideKey, Witness, Side),
+            get_dict(factId, Side, FactId)
+        ),
+        Facts).
+search_answer_contradiction(Functional, ReqId, _{
+    kind: rule,
+    status: Status,
+    with: Other,
+    facts: [FactA, FactB],
+    reason: Reason
+}) :-
+    % The check orders each pair; compare it in that order and only then
+    % orient the result towards ReqId.
+    (   checks:opposing_rule_requirement_facts(ReqId, Other, FactA, FactB, RuleLeft, RuleRight),
+        LeftReq = ReqId, RightReq = Other
+    ;   checks:opposing_rule_requirement_facts(Other, ReqId, FactB, FactA, RuleLeft, RuleRight),
+        LeftReq = Other, RightReq = ReqId
+    ),
+    search_answer_rule_status(Functional, RuleLeft, RuleRight, Status),
+    Status \== disjoint,
+    format(string(Reason), "Rule conflict (~w) between ~w and ~w", [Status, LeftReq, RightReq]).
+
+search_answer_scenario_outcome(ReqId, Outcome) :-
+    kb_relationship(specified_by, ReqId, ScenarioId),
+    scenario_feasibility_outcome(ScenarioId, Result),
+    search_answer_outcome(ScenarioId, Result, Outcome).
+
+search_answer_outcome(ScenarioId, infeasible(witness(ReqIds, AssumedFacts, ReqFacts, RawReason)), _{
+    scenario: ScenarioId,
+    outcome: infeasible,
+    requirement: ReqId,
+    requirements: ReqIds,
+    assumed: AssumedFacts,
+    fact: ReqFacts,
+    reason: Reason
+}) :-
+    !,
+    ( ReqIds = [ReqId|_] -> true ; ReqId = '' ),
+    search_answer_text(RawReason, Reason).
+search_answer_outcome(ScenarioId, unknown(Reason), _{
+    scenario: ScenarioId,
+    outcome: unknown,
+    reason: Reason,
+    facts: []
+}) :-
+    atom(Reason),
+    !.
+search_answer_outcome(ScenarioId, unknown(Compound), _{
+    scenario: ScenarioId,
+    outcome: unknown,
+    reason: Reason,
+    facts: Ids
+}) :-
+    compound(Compound),
+    Compound =.. [Reason, Ids0],
+    is_list(Ids0),
+    !,
+    Ids = Ids0.
+search_answer_outcome(ScenarioId, not_applicable(Compound), _{
+    scenario: ScenarioId,
+    outcome: not_applicable,
+    reason: Reason,
+    facts: Ids
+}) :-
+    compound(Compound),
+    Compound =.. [Reason, Ids],
+    is_list(Ids),
+    !.
+search_answer_outcome(ScenarioId, Result, _{scenario: ScenarioId, outcome: Outcome}) :-
+    (   atom(Result)
+    ->  Outcome = Result
+    ;   format(atom(Outcome), "~q", [Result])
+    ).
+
+search_answer_forbidden_scenario(ReqId, _{
+    scenario: ScenarioId,
+    assumed: AssumedFacts,
+    fact: ReqFacts,
+    reason: Reason
+}) :-
+    infeasible_scenario(ScenarioId, ReqIds, AssumedFacts, ReqFacts, RawReason),
+    memberchk(ReqId, ReqIds),
+    \+ kb_relationship(specified_by, ReqId, ScenarioId),
+    search_answer_text(RawReason, Reason).
+
+search_answer_inventory(ReqId, _{
+    status: Status,
+    propositionCount: Count,
+    unresolved: Unresolved
+}) :-
+    kb_entity(ReqId, req, Props),
+    !,
+    requirement_proof:semantic_inventory_stage(Props, Stage, Entries),
+    get_dict(status, Stage, Status),
+    get_dict(propositionCount, Stage, Count),
+    findall(_{claim: Claim, status: EntryStatus},
+        (   member(Entry, Entries),
+            requirement_proof:inventory_entry_unresolved(Entry),
+            requirement_proof:inventory_entry_status(Entry, EntryStatus),
+            requirement_proof:inventory_entry_field(Entry, claim_text, RawClaim),
+            search_answer_text(RawClaim, Claim0),
+            search_answer_clip(Claim0, 300, Claim)
+        ),
+        Unresolved).
+search_answer_inventory(_ReqId, _{status: unknown, propositionCount: 0, unresolved: []}).
+
+search_answer_text(^^(Value, _Type), Text) :-
+    !,
+    search_answer_text(Value, Text).
+search_answer_text(Value, Text) :-
+    string(Value),
+    !,
+    Text = Value.
+search_answer_text(Value, Text) :-
+    atom(Value),
+    !,
+    atom_string(Value, Text).
+search_answer_text(Value, Text) :-
+    format(string(Text), "~w", [Value]).
+
+search_answer_clip(Text, Max, Clipped) :-
+    string_length(Text, Length),
+    (   Length =< Max
+    ->  Clipped = Text
+    ;   Keep is Max - 1,
+        sub_string(Text, 0, Keep, _, Prefix),
+        string_concat(Prefix, "…", Clipped)
+    ).
+
 % Slim per-requirement proof evidence for quality diagnostics (W1 push-down).
 % Projects only the fields the quality diagnostics consume - proof status,
 % the passing-e2e stage summary, and receipt-related gap codes - instead of
@@ -167,7 +378,7 @@ coverage_report_json(By, Tags, IncludePassing, BindingMode, TestBindings, Includ
     Response = _{summary: Summary, rows: Rows, meta: Meta},
     dict_json_string(Response, JsonString).
 
-% implements REQ-kibi-coverage-status-filter
+% implements REQ-kibi-conservative-requirement-proof
 % Proof-status filtered report. The status filter selects requirement rows by
 % proofStatus (proven, missing, unresolved, not_applicable) and replaces the
 % default include-passing filtering, so callers can enumerate exactly one

package/src/intervals.pl

@@ -0,0 +1,175 @@
+% implements REQ-kibi-truthful-consistency
+%
+% Exact satisfiability for one-variable numeric comparisons.
+%
+% A constraint is c(Op, Variable, Value) where Op is one of eq, neq, lt, lte,
+% gt, gte and Value is a number.  Variables are ordinary Prolog variables and
+% are compared by identity, never bound.  Each variable ranges over the reals
+% unless the caller names it as integer-valued; the conjunction is
+% satisfiable exactly when every variable's set is non-empty.  Strict bounds,
+% non-integer bounds on integer variables and excluded points are handled
+% without scaling or labelling, so the answer is exact and terminates in
+% linear time.
+:- module(intervals, [
+    numeric_constraints_satisfiable/1,
+    numeric_constraints_satisfiable/2,
+    numeric_constraint_entailed/2,
+    numeric_constraint_entailed/3,
+    numeric_constraint_negation/2,
+    numeric_constraint_holds/3
+]).
+
+%% numeric_constraints_satisfiable(+Constraints)
+% True when some assignment of reals satisfies every constraint.
+numeric_constraints_satisfiable(Constraints) :-
+    numeric_constraints_satisfiable(Constraints, []).
+
+%% numeric_constraints_satisfiable(+Constraints, +IntegerVariables)
+% As numeric_constraints_satisfiable/1, but every variable in
+% IntegerVariables (compared by identity) ranges over the integers: no
+% integer lies strictly between 0 and 1, and eq 0.5 has no integer solution.
+% IntegerVariables may also be the atom `all`, making every variable integral.
+numeric_constraints_satisfiable(Constraints, IntegerVariables) :-
+    term_variables(Constraints, Variables),
+    forall(
+        member(Variable, Variables),
+        (   integer_variable(Variable, IntegerVariables)
+        ->  integer_variable_feasible(Variable, Constraints)
+        ;   variable_feasible(Variable, Constraints)
+        )
+    ).
+
+%% numeric_constraint_entailed(+Premises, +Constraint)
+% True when every assignment that satisfies Premises satisfies Constraint.
+numeric_constraint_entailed(Premises, Constraint) :-
+    numeric_constraint_entailed(Premises, Constraint, []).
+
+%% numeric_constraint_entailed(+Premises, +Constraint, +IntegerVariables)
+numeric_constraint_entailed(Premises, Constraint, IntegerVariables) :-
+    numeric_constraint_negation(Constraint, Negated),
+    \+ numeric_constraints_satisfiable([Negated|Premises], IntegerVariables).
+
+integer_variable(_, all) :- !.
+integer_variable(Variable, IntegerVariables) :-
+    is_list(IntegerVariables),
+    member(Candidate, IntegerVariables),
+    Candidate == Variable,
+    !.
+
+%% numeric_constraint_negation(+Constraint, -Negated)
+numeric_constraint_negation(c(Op, Variable, Value), c(Negated, Variable, Value)) :-
+    negated_operator(Op, Negated).
+
+negated_operator(eq, neq).
+negated_operator(neq, eq).
+negated_operator(lt, gte).
+negated_operator(gte, lt).
+negated_operator(lte, gt).
+negated_operator(gt, lte).
+
+%% numeric_constraint_holds(+Op, +Left, +Right)
+% Evaluate a comparison between two numbers.
+numeric_constraint_holds(eq, Left, Right) :- Left =:= Right.
+numeric_constraint_holds(neq, Left, Right) :- Left =\= Right.
+numeric_constraint_holds(lt, Left, Right) :- Left < Right.
+numeric_constraint_holds(lte, Left, Right) :- Left =< Right.
+numeric_constraint_holds(gt, Left, Right) :- Left > Right.
+numeric_constraint_holds(gte, Left, Right) :- Left >= Right.
+
+variable_feasible(Variable, Constraints) :-
+    findall(Op-Value, (member(c(Op, Other, Value), Constraints), Other == Variable), Bounds),
+    foldl(apply_bound, Bounds, interval(ninf, open, pinf, open, []), Interval),
+    interval_non_empty(Interval).
+
+% interval(Low, LowKind, High, HighKind, Excluded)
+apply_bound(eq-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo1, LoK1, Hi1, HiK1, Ex)) :-
+    raise_low(Lo, LoK, Value, closed, Lo1, LoK1),
+    lower_high(Hi, HiK, Value, closed, Hi1, HiK1).
+apply_bound(neq-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo, LoK, Hi, HiK, [Value|Ex])).
+apply_bound(lt-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo, LoK, Hi1, HiK1, Ex)) :-
+    lower_high(Hi, HiK, Value, open, Hi1, HiK1).
+apply_bound(lte-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo, LoK, Hi1, HiK1, Ex)) :-
+    lower_high(Hi, HiK, Value, closed, Hi1, HiK1).
+apply_bound(gt-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo1, LoK1, Hi, HiK, Ex)) :-
+    raise_low(Lo, LoK, Value, open, Lo1, LoK1).
+apply_bound(gte-Value, interval(Lo, LoK, Hi, HiK, Ex), interval(Lo1, LoK1, Hi, HiK, Ex)) :-
+    raise_low(Lo, LoK, Value, closed, Lo1, LoK1).
+
+raise_low(ninf, _, Value, Kind, Value, Kind) :- !.
+raise_low(Lo, _, Value, Kind, Value, Kind) :- Value > Lo, !.
+raise_low(Lo, LoK, Value, Kind, Lo, Kind1) :- Value =:= Lo, !, tighter_kind(LoK, Kind, Kind1).
+raise_low(Lo, LoK, _, _, Lo, LoK).
+
+lower_high(pinf, _, Value, Kind, Value, Kind) :- !.
+lower_high(Hi, _, Value, Kind, Value, Kind) :- Value < Hi, !.
+lower_high(Hi, HiK, Value, Kind, Hi, Kind1) :- Value =:= Hi, !, tighter_kind(HiK, Kind, Kind1).
+lower_high(Hi, HiK, _, _, Hi, HiK).
+
+tighter_kind(closed, closed, closed) :- !.
+tighter_kind(_, _, open).
+
+% An unbounded or non-degenerate real interval cannot be emptied by finitely
+% many excluded points.  A degenerate interval is a single closed point.
+interval_non_empty(interval(ninf, _, _, _, _)) :- !.
+interval_non_empty(interval(_, _, pinf, _, _)) :- !.
+interval_non_empty(interval(Lo, _, Hi, _, _)) :- Lo < Hi, !.
+interval_non_empty(interval(Lo, closed, Hi, closed, Excluded)) :-
+    Lo =:= Hi,
+    \+ ( member(Value, Excluded), Value =:= Lo ).
+
+% Integer variables: every strict or fractional bound is tightened to the
+% nearest admissible integer, so the set is an integer range [Lo, Hi] minus
+% finitely many excluded integers.  An eq bound with a fractional value admits
+% no integer at all.
+integer_variable_feasible(Variable, Constraints) :-
+    findall(Op-Value, (member(c(Op, Other, Value), Constraints), Other == Variable), Bounds),
+    foldl(apply_integer_bound, Bounds, ibox(ninf, pinf, []), Box),
+    integer_box_non_empty(Box).
+
+apply_integer_bound(_, empty, empty) :- !.
+apply_integer_bound(eq-Value, ibox(Lo, Hi, Ex), Box) :- !,
+    (   integral_value(Value, Integer)
+    ->  integer_raise_low(Lo, Integer, Lo1),
+        integer_lower_high(Hi, Integer, Hi1),
+        Box = ibox(Lo1, Hi1, Ex)
+    ;   Box = empty
+    ).
+apply_integer_bound(neq-Value, ibox(Lo, Hi, Ex), ibox(Lo, Hi, Ex1)) :- !,
+    (   integral_value(Value, Integer)
+    ->  Ex1 = [Integer|Ex]
+    ;   Ex1 = Ex
+    ).
+apply_integer_bound(gt-Value, ibox(Lo, Hi, Ex), ibox(Lo1, Hi, Ex)) :- !,
+    Bound is floor(Value) + 1,
+    integer_raise_low(Lo, Bound, Lo1).
+apply_integer_bound(gte-Value, ibox(Lo, Hi, Ex), ibox(Lo1, Hi, Ex)) :- !,
+    Bound is ceiling(Value),
+    integer_raise_low(Lo, Bound, Lo1).
+apply_integer_bound(lt-Value, ibox(Lo, Hi, Ex), ibox(Lo, Hi1, Ex)) :- !,
+    Bound is ceiling(Value) - 1,
+    integer_lower_high(Hi, Bound, Hi1).
+apply_integer_bound(lte-Value, ibox(Lo, Hi, Ex), ibox(Lo, Hi1, Ex)) :- !,
+    Bound is floor(Value),
+    integer_lower_high(Hi, Bound, Hi1).
+
+integral_value(Value, Integer) :-
+    number(Value),
+    Integer is round(Value),
+    Integer =:= Value.
+
+integer_raise_low(ninf, Bound, Bound) :- !.
+integer_raise_low(Lo, Bound, Lo1) :- Lo1 is max(Lo, Bound).
+
+integer_lower_high(pinf, Bound, Bound) :- !.
+integer_lower_high(Hi, Bound, Hi1) :- Hi1 is min(Hi, Bound).
+
+% An unbounded integer range cannot be emptied by finitely many exclusions.
+integer_box_non_empty(empty) :- !, fail.
+integer_box_non_empty(ibox(ninf, _, _)) :- !.
+integer_box_non_empty(ibox(_, pinf, _)) :- !.
+integer_box_non_empty(ibox(Lo, Hi, Excluded)) :-
+    Lo =< Hi,
+    findall(Value, (member(Value, Excluded), Value >= Lo, Value =< Hi), Inside0),
+    sort(Inside0, Inside),
+    length(Inside, ExcludedCount),
+    Hi - Lo + 1 > ExcludedCount.

package/src/kb.pl

@@ -26,6 +26,7 @@
     kb_query_entities/8,
     kb_search_entities/6,
     kb_list_search_candidates/5,
+    kb_list_search_candidates/6,
     kb_entity_ids/1,
     kb_rebuild_indexes/0,
     kb_entity/3,
@@ -59,6 +60,7 @@
     deprecated_no_successor/1,
     symbol_no_req_coverage/2,
     predicate_schema/6,
+    predicate_schema_keys/4,
     predicate_fact/5,
     canonical_property_tuple/9,
     contradicting_reqs/3,
@@ -85,6 +87,7 @@
 :- use_module('../schema/entities.pl', [entity_type/1, entity_property/3, required_property/2]).
 :- use_module('../schema/relationships.pl', [relationship_type/1, valid_relationship/3]).
 :- use_module('units.pl', [canonical_quantity/6]).
+:- use_module('intervals.pl', [numeric_constraints_satisfiable/2]).
 :- use_module('../schema/validation.pl', [validate_entity/2, validate_relationship/3]).
 
 % Constants
@@ -1814,14 +1817,22 @@ kb_search_entities(TypeFilter, Query, Limit, Offset, Rows, Count) :-
 % candidate rows, ordered by id. Semantic discovery uses it when no lexical
 % token can pre-filter the candidate set.
 kb_list_search_candidates(TypeFilter, Limit, Offset, Rows, Count) :-
+    kb_list_search_candidates(TypeFilter, none, Limit, Offset, Rows, Count).
+
+%% kb_list_search_candidates(+Type, +Source, +Limit, +Offset, -Rows, -Count)
+% As kb_list_search_candidates/5, optionally restricted to entities whose
+% indexed source contains Source (the kb_query_entities/8 source filter).
+% Source-located search uses it so candidates stay projected rows instead of
+% complete entities.
+% implements REQ-mcp-search-discovery, REQ-kibi-intent-aware-source-discovery
+kb_list_search_candidates(TypeFilter, SourceFilter, Limit, Offset, Rows, Count) :-
     integer(Limit),
     integer(Offset),
     Limit >= 0,
     Offset >= 0,
     kb_ensure_indexes,
     findall(Id,
-            ( kb_index_entity(Id, _),
-              (TypeFilter == none -> true ; kb_index_type(TypeFilter, Id)) ),
+            indexed_entity_match(TypeFilter, none, [], SourceFilter, Id),
             RawIds),
     sort(RawIds, Ids),
     length(Ids, Count),
@@ -2569,8 +2580,8 @@ req_conflict_witness(ReqA, ReqB, Witness) :-
     intervals_overlap(ValidFromA, ValidToA, ValidFromB, ValidToB),
     % Compare canonical quantities (30 min == 1800 s); witnesses keep the
     % authored values so evidence still points at the source text.
-    canonical_quantity(ValTypeA, ValA, UnitA, CanonTypeA, CanonValA, CanonUnitA),
-    canonical_quantity(ValTypeB, ValB, UnitB, CanonTypeB, CanonValB, CanonUnitB),
+    comparison_quantity(ValTypeA, ValA, UnitA, CanonTypeA, CanonValA, CanonUnitA),
+    comparison_quantity(ValTypeB, ValB, UnitB, CanonTypeB, CanonValB, CanonUnitB),
     (   polarity_conflict(SubjectKey, PropertyKey, OpA, CanonTypeA, CanonValA, CanonUnitA, ScopeA, PolarityA,
                           OpB, CanonTypeB, CanonValB, CanonUnitB, ScopeB, PolarityB, Reason)
     ;   property_conflict(SubjectKey, PropertyKey, OpA, CanonTypeA, CanonValA, CanonUnitA, PolarityA,
@@ -2728,6 +2739,21 @@ canonical_property_tuple(FactId, Subject, Property, Op, CanonType, CanonValue, C
     fact_property_tuple(FactId, Subject, Property, Op, ValType, Value, Unit, Scope, Polarity),
     canonical_quantity(ValType, Value, Unit, CanonType, CanonValue, CanonUnit).
 
+%% comparison_quantity(+ValType, +Value, +Unit, -Type, -CanonValue, -CanonUnit)
+% implements REQ-kibi-truthful-consistency
+% canonical_quantity/6 for comparisons that depend on the value domain.
+% Canonicalization reports any integral value as int, but a value declared
+% `number` keeps real semantics: number gt 0 and number lt 1 do not conflict
+% even though 0 and 1 are integral.  An int that scales to a fraction
+% (int 1 ms is 0.001 s) is compared as a number, which only admits more
+% values.
+comparison_quantity(ValType, Value, Unit, Type, CanonValue, CanonUnit) :-
+    canonical_quantity(ValType, Value, Unit, CanonType, CanonValue, CanonUnit),
+    (   ValType == number, CanonType == int
+    ->  Type = number
+    ;   Type = CanonType
+    ).
+
 %% predicate_schema(+FactId, -Namespace, -Name, -Arity, -ArgumentNames, -ArgumentTypes)
 % Read one project-local ontology predicate schema fact.
 predicate_schema(FactId, Namespace, Name, Arity, ArgumentNames, ArgumentTypes) :-
@@ -2744,6 +2770,27 @@ predicate_schema(FactId, Namespace, Name, Arity, ArgumentNames, ArgumentTypes) :
     memberchk(argument_types=ArgumentTypesRaw, Props),
     normalize_term_atom_list(ArgumentTypesRaw, ArgumentTypes).
 
+%% predicate_schema_keys(?Namespace, ?Name, ?Arity, -KeyPositions)
+% implements REQ-kibi-truthful-consistency
+% A predicate_schema that declares key_arguments states a functional
+% dependency: the remaining arguments are determined by the key arguments.
+% KeyPositions are the 1-based positions of the named key arguments.  A
+% predicate without this declaration is treated as multivalued, so two atoms
+% of it are never assumed to describe the same fact.
+predicate_schema_keys(Namespace, Name, Arity, KeyPositions) :-
+    predicate_schema(FactId, Namespace, Name, Arity, ArgumentNames, _ArgumentTypes),
+    kb_entity(FactId, fact, Props),
+    memberchk(key_arguments=KeysRaw, Props),
+    normalize_term_atom_list(KeysRaw, KeyNames),
+    KeyNames \= [],
+    length(ArgumentNames, Arity),
+    maplist(argument_name_position(ArgumentNames), KeyNames, Positions0),
+    sort(Positions0, KeyPositions).
+
+argument_name_position(ArgumentNames, KeyName, Position) :-
+    nth1(Position, ArgumentNames, KeyName),
+    !.
+
 %% predicate_fact(+FactId, -Namespace, -Name, -Args, -Polarity)
 % Read one ground ontology predicate fact.
 predicate_fact(FactId, Namespace, Name, Args, Polarity) :-
@@ -2842,9 +2889,23 @@ property_conflict(Subject, Property, OpA, TypeA, ValA, UnitA, Polarity,
                   OpB, TypeB, ValB, UnitB, Polarity, Reason) :-
     unit_compatible(UnitA, UnitB),
     compatible_types(TypeA, TypeB),
-    values_conflict(OpA, ValA, OpB, ValB, TypeA),
+    conflict_value_type(TypeA, TypeB, Type),
+    values_conflict(OpA, ValA, OpB, ValB, Type),
     format(atom(Reason), 'Value conflict on ~w.~w: ~w ~w vs ~w ~w', [Subject, Property, OpA, ValA, OpB, ValB]).
 
+%% conflict_value_type(+TypeA, +TypeB, -Type)
+% The value domain both constraints are compared in.  A property is treated as
+% integer-valued only when both sides declare int; a mixed int/number pair is
+% compared over the reals so a conflict is never claimed from one side's
+% narrower declaration.
+% implements REQ-kibi-truthful-consistency
+conflict_value_type(int, int, int) :- !.
+conflict_value_type(TypeA, TypeB, number) :-
+    is_numeric_type(TypeA),
+    is_numeric_type(TypeB),
+    !.
+conflict_value_type(Type, _, Type).
+
 %% compatible_types(+TypeA, +TypeB)
 % Types are compatible if they are the same or both numeric.
 compatible_types(T, T) :- !.
@@ -2898,33 +2959,28 @@ values_conflict(eq, ValA, neq, ValB, Type) :-
 values_conflict(neq, ValA, eq, ValB, Type) :-
     same_value(Type, ValA, Type, ValB).
 
-% Numeric gap conflict: lte X vs gte Y where X < Y
-values_conflict(lte, ValA, gte, ValB, Type) :-
-    is_numeric_type(Type),
-    ValA < ValB.
-values_conflict(gte, ValB, lte, ValA, Type) :-
-    is_numeric_type(Type),
-    ValA < ValB.
-
-% Also catch lt/gt variants
-values_conflict(lt, ValA, gt, ValB, Type) :-
-    is_numeric_type(Type),
-    ValA =< ValB.
-values_conflict(gt, ValB, lt, ValA, Type) :-
-    is_numeric_type(Type),
-    ValA =< ValB.
-values_conflict(lt, ValA, gte, ValB, Type) :-
-    is_numeric_type(Type),
-    ValA =< ValB.
-values_conflict(gte, ValB, lt, ValA, Type) :-
-    is_numeric_type(Type),
-    ValA =< ValB.
-values_conflict(lte, ValA, gt, ValB, Type) :-
-    is_numeric_type(Type),
-    ValA < ValB.
-values_conflict(gt, ValB, lte, ValA, Type) :-
+% Numeric conflict: the two comparisons admit no common value of the type's
+% domain.  `number` ranges over the reals; `int` ranges over the integers, so
+% gt 0 and lt 1 conflict for int (no integer lies strictly between them) but
+% not for number.  This covers every operator pair (eq/gt, lte/gt at the same
+% bound, gte/gt, ...) instead of a hand-written table.  neq/neq never
+% conflicts and eq/neq is handled above.
+% implements REQ-kibi-truthful-consistency
+values_conflict(OpA, ValA, OpB, ValB, Type) :-
     is_numeric_type(Type),
-    ValA < ValB.
+    numeric_operator(OpA),
+    numeric_operator(OpB),
+    \+ ( OpA == eq, OpB == eq ),
+    \+ ( OpA == eq, OpB == neq ),
+    \+ ( OpA == neq, OpB == eq ),
+    number(ValA), number(ValB),
+    numeric_type_integer_variables(Type, IntegerVariables),
+    \+ numeric_constraints_satisfiable([c(OpA, X, ValA), c(OpB, X, ValB)], IntegerVariables).
+
+numeric_type_integer_variables(int, all) :- !.
+numeric_type_integer_variables(_, []).
+
+numeric_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte]).
 
 %% is_numeric_type(+Type)
 % True for numeric value types.