kibi-core 0.22.5 → 0.24.0

package/src/discovery.pl

@@ -7,10 +7,13 @@
     coverage_report_json/10,
     coverage_report_json/11,
     coverage_report_json/12,
+    coverage_report_json/13,
     coverage_evidence_json/5,
+    evidence_floor_json/6,
     requirement_proof_json/5,
     requirement_proof_json/7,
     symbol_proof_json/7,
+    test_receipt_states_json/6,
     graph_expand_json/8,
     search_answer_verdicts_json/2,
     ask_predicate_json/9,
@@ -29,7 +32,7 @@
 :- use_module(library(pairs)).
 :- 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('requirement_proof.pl', [requirement_proof_context/1, requirement_proof_context/4, requirement_proof_context/6, requirement_proof/4, test_receipt_evidence/4]).
 :- 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]).
@@ -78,6 +81,21 @@ requirement_proof_json(ReqId, BindingMode, TestBindings, VerificationSnapshot, C
     put_dict(id, Proof, ReqId, ProofWithId),
     dict_json_string(ProofWithId, JsonString).
 
+% implements REQ-kibi-verification-evidence-contract
+% The receipt state of every proof-bearing test under the given binding, as
+% `kibi prove --stale` selects them: passed means a current passing receipt.
+test_receipt_states_json(BindingMode, TestBindings, VerificationSnapshot, CheckedAt, MaxAgeSeconds, JsonString) :-
+    requirement_proof_context(VerificationSnapshot, CheckedAt, MaxAgeSeconds, BindingMode, TestBindings, Context),
+    findall(TestId-State,
+        (kb_entity(TestId, test, Props),
+         memberchk(proof_contract=_, Props),
+         test_receipt_evidence(Context, [unit, integration, end_to_end], TestId, Evidence),
+         State = Evidence.state),
+        Pairs0),
+    sort(Pairs0, Pairs),
+    dict_pairs(States, _, Pairs),
+    dict_json_string(_{states: States}, JsonString).
+
 symbol_proof_json(SymbolId, BindingMode, TestBindings, VerificationSnapshot, CheckedAt, MaxAgeSeconds, JsonString) :-
     requirement_proof_context(VerificationSnapshot, CheckedAt, MaxAgeSeconds, BindingMode, TestBindings, Context),
     kb_entity(SymbolId, symbol, _),
@@ -344,6 +362,77 @@ coverage_evidence_json(Tags, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Jso
     Response = _{rows: Evidences},
     dict_json_string(Response, JsonString).
 
+% implements REQ-kibi-evidence-floors
+% Every current requirement whose evidence level is below its floor, for the
+% evidence-floor check rule: the rows that fail (status below) or that only
+% need kibi prove re-run (status pending_reproof), plus how many current
+% requirements were evaluated.  Requirements outside proof scope carry no
+% floor.
+evidence_floor_json(BindingMode, TestBindings, VerificationSnapshot, CheckedAt, MaxAgeSeconds, JsonString) :-
+    requirement_proof_context(VerificationSnapshot, CheckedAt, MaxAgeSeconds, BindingMode, TestBindings, Context),
+    findall(Id-Proof,
+        (   kb_entity(Id, req, Props),
+            requirement_proof(Id, Props, Context, Proof),
+            get_dict(evidenceFloor, Proof, _)
+        ),
+        Evaluated),
+    findall(Row,
+        (   member(Id-Proof, Evaluated),
+            Floor = Proof.evidenceFloor,
+            Floor.status \== met,
+            Row = _{
+                id: Id,
+                evidenceLevel: Proof.evidenceLevel,
+                requiredEvidence: Floor.required,
+                requiredEvidenceSource: Floor.source,
+                status: Floor.status,
+                proofStatus: Proof.proofStatus,
+                proofGaps: Proof.proofGaps,
+                gapDetails: Details
+            },
+            evidence_floor_gap_details(Proof, Details)
+        ),
+        Rows0),
+    sort(id, @<, Rows0, Rows),
+    length(Evaluated, Count),
+    dict_json_string(_{evaluated: Count, rows: Rows}, JsonString).
+
+% The entities behind an evidence-floor row's gaps, so a person sees what to
+% fix without one kibi proof explain per requirement: the tests whose
+% receipts are missing, stale, failed or invalid, the production symbols no
+% qualifying test covers and the symbols without source coordinates.  Empty
+% lists are left out.
+evidence_floor_gap_details(Proof, Details) :-
+    (   get_dict(proofStages, Proof, Stages)
+    ->  true
+    ;   Stages = _{}
+    ),
+    findall(Key-Ids,
+        (   evidence_floor_gap_field(Key, StageKey, Field),
+            get_dict(StageKey, Stages, Stage),
+            get_dict(Field, Stage, Ids),
+            Ids \== []
+        ),
+        Pairs0),
+    % implements REQ-kibi-claim-bound-proofs
+    % Under a proved floor, the claims no certificate binding derives.
+    (   get_dict(evidenceFloor, Proof, Floor),
+        get_dict(required, Floor, proved),
+        get_dict(unprovedClaims, Proof, Unproved),
+        Unproved \== []
+    ->  Pairs = [unprovedClaims-Unproved|Pairs0]
+    ;   Pairs = Pairs0
+    ),
+    dict_pairs(Details, _, Pairs).
+
+evidence_floor_gap_field(failedReceiptTests, passingE2e, failedReceiptTests).
+evidence_floor_gap_field(missingReceiptTests, passingE2e, missingReceiptTests).
+evidence_floor_gap_field(staleReceiptTests, passingE2e, staleReceiptTests).
+evidence_floor_gap_field(invalidReceiptTests, passingE2e, invalidReceiptTests).
+evidence_floor_gap_field(contractMismatchReceiptTests, passingE2e, contractMismatchReceiptTests).
+evidence_floor_gap_field(uncoveredSymbols, productionSymbols, uncoveredSymbols).
+evidence_floor_gap_field(missingCoordinateSymbols, sourceCoordinates, missingSymbols).
+
 coverage_evidence_row(Id, Proof, Evidence) :-
     (   get_dict(proofStatus, Proof, ProofStatus)
     ->  true
@@ -398,7 +487,7 @@ coverage_report_json(By, Tags, IncludePassing, BindingMode, TestBindings, Includ
 
 % 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
+% proofStatus (tested, missing, unresolved, not_applicable) and replaces the
 % default include-passing filtering, so callers can enumerate exactly one
 % slice — e.g. every not_applicable row together with its typed applicability
 % reason — without diffing full exports by hand. The summary is always
@@ -414,6 +503,28 @@ coverage_report_json(By, Tags, IncludePassing, StatusFilter, IncludeTransitive,
     Response = _{summary: Summary, rows: Rows, meta: Meta},
     dict_json_string(Response, JsonString).
 
+% Proof-status filtered report with per-contract receipt binding: the same
+% rows and whole-KB summary as the unfiltered report under that binding mode,
+% so a status filter never judges receipts more strictly than kb_coverage,
+% kibi proof explain or the evidence-floor rule do.
+coverage_report_json(By, Tags, IncludePassing, StatusFilter, BindingMode, TestBindings, IncludeTransitive, Limit, Offset, VerificationSnapshot, CheckedAt, MaxAgeSeconds, JsonString) :-
+    memo_sorted_coverage(
+        status_binding(By, Tags, IncludePassing, StatusFilter, BindingMode, TestBindings, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds),
+        status_binding_coverage_rows(By, Tags, IncludePassing, StatusFilter, BindingMode, TestBindings, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds),
+        SortedRows,
+        Summary),
+    paginate_rows(SortedRows, Offset, Limit, Rows),
+    status_meta_dict(Meta),
+    Response = _{summary: Summary, rows: Rows, meta: Meta},
+    dict_json_string(Response, JsonString).
+
+status_binding_coverage_rows(req, Tags, _IncludePassing, StatusFilter, BindingMode, TestBindings, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, MatchedRows, Summary) :-
+    !,
+    coverage_rows(req, Tags, true, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, BindingMode, TestBindings, Rows0, Summary),
+    include(req_row_proof_status_in(StatusFilter), Rows0, MatchedRows).
+status_binding_coverage_rows(By, Tags, IncludePassing, StatusFilter, _BindingMode, _TestBindings, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Rows, Summary) :-
+    status_filtered_coverage_rows(By, Tags, IncludePassing, StatusFilter, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Rows, Summary).
+
 binding_coverage_rows(req, Tags, IncludePassing, BindingMode, TestBindings, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Rows, Summary) :-
     !,
     coverage_rows(req, Tags, IncludePassing, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, BindingMode, TestBindings, Rows, Summary).
@@ -1118,6 +1229,10 @@ symbol_coverage_row(Tags, Row) :-
         coverageStatus: CoverageStatus
     }.
 
+% Link coverage (evaluated, fullyCovered, uncovered, notApplicable and the
+% missing* counts) judges only priority: must requirements; linkCoverageScope
+% says so, so a project without must requirements does not read as having
+% evaluated nothing next to its proof counts.
 coverage_summary(Rows, Summary) :-
     length(Rows, Total),
     include(req_row_evaluated, Rows, EvaluatedRows),
@@ -1127,7 +1242,7 @@ coverage_summary(Rows, Summary) :-
     include(req_row_missing_scenario, Rows, MissingScenarioRows),
     include(req_row_missing_test, Rows, MissingTestRows),
     include(req_row_missing_both, Rows, MissingBothRows),
-    include(req_row_proof_proven, Rows, ProofProvenRows),
+    include(req_row_proof_tested, Rows, ProofTestedRows),
     include(req_row_proof_unresolved, Rows, ProofUnresolvedRows),
     include(req_row_proof_missing, Rows, ProofMissingRows),
     include(req_row_proof_not_applicable, Rows, ProofNotApplicableRows),
@@ -1138,7 +1253,10 @@ coverage_summary(Rows, Summary) :-
     length(MissingScenarioRows, MissingScenario),
     length(MissingTestRows, MissingTest),
     length(MissingBothRows, MissingScenarioAndTest),
-    length(ProofProvenRows, ProofProven),
+    length(ProofTestedRows, ProofTested),
+    evidence_level_counts(Rows, EvidenceLevels),
+    claim_level_counts(Rows, ProofClaims),
+    evidence_floor_counts(Rows, EvidenceFloors),
     length(ProofUnresolvedRows, ProofUnresolved),
     length(ProofMissingRows, ProofMissing),
     length(ProofNotApplicableRows, ProofNotApplicable),
@@ -1151,12 +1269,61 @@ coverage_summary(Rows, Summary) :-
         missingScenario: MissingScenario,
         missingTest: MissingTest,
         missingScenarioAndTest: MissingScenarioAndTest,
-        proofProven: ProofProven,
+        proofTested: ProofTested,
         proofUnresolved: ProofUnresolved,
         proofMissing: ProofMissing,
-        proofNotApplicable: ProofNotApplicable
+        proofNotApplicable: ProofNotApplicable,
+        evidenceLevels: EvidenceLevels,
+        proofClaims: ProofClaims,
+        evidenceFloors: EvidenceFloors,
+        linkCoverageScope: priority_must
     }.
 
+% implements REQ-kibi-claim-bound-proofs
+% The applicable requirement claims across Rows, by the level their evidence
+% reaches: a claim is proved only through a derived certificate binding.
+claim_level_counts(Rows, _{applicable: Applicable, proved: Proved, attested: Attested,
+                           tested: Tested, unresolved: Unresolved}) :-
+    claim_count_sum(Rows, applicable, Applicable),
+    claim_count_sum(Rows, proved, Proved),
+    claim_count_sum(Rows, attested, Attested),
+    claim_count_sum(Rows, tested, Tested),
+    claim_count_sum(Rows, unresolved, Unresolved).
+
+claim_count_sum(Rows, Key, Sum) :-
+    aggregate_all(sum(N),
+        (   member(Row, Rows),
+            get_dict(claimSummary, Row, Summary),
+            get_dict(Key, Summary, N),
+            number(N)
+        ),
+        Sum).
+
+% implements REQ-kibi-evidence-floors
+% Current requirements with a floor (required_evidence, or tested for a firm
+% requirement), by whether their evidence level reaches it.  A floor of
+% unverified accepts anything and is not counted.
+evidence_floor_counts(Rows, _{met: Met, below: Below, pendingReproof: Pending}) :-
+    evidence_floor_status_count(Rows, met, Met),
+    evidence_floor_status_count(Rows, below, Below),
+    evidence_floor_status_count(Rows, pending_reproof, Pending).
+
+evidence_floor_status_count(Rows, Status, Count) :-
+    aggregate_all(count,
+        (   member(Row, Rows),
+            get_dict(evidenceFloor, Row, Floor),
+            Floor.get(required) \== unverified,
+            Floor.get(status) == Status
+        ),
+        Count).
+
+% implements REQ-kibi-evidence-levels
+evidence_level_counts(Rows, _{proved: Proved, tested: Tested, asserted: Asserted, unverified: Unverified}) :-
+    aggregate_all(count, (member(Row, Rows), Row.get(evidenceLevel) == proved), Proved),
+    aggregate_all(count, (member(Row, Rows), Row.get(evidenceLevel) == tested), Tested),
+    aggregate_all(count, (member(Row, Rows), Row.get(evidenceLevel) == asserted), Asserted),
+    aggregate_all(count, (member(Row, Rows), Row.get(evidenceLevel) == unverified), Unverified).
+
 req_row_fully_covered(Row) :-
     CoverageStatus = Row.get(coverageStatus),
     CoverageStatus = fully_covered.
@@ -1175,8 +1342,8 @@ req_row_missing_test(Row) :-
     Row.gaps = [missing_test].
 req_row_missing_both(Row) :-
     Row.gaps = [missing_scenario_and_test].
-req_row_proof_proven(Row) :-
-    Row.proofStatus == proven.
+req_row_proof_tested(Row) :-
+    Row.proofStatus == tested.
 req_row_proof_unresolved(Row) :-
     Row.proofStatus == unresolved.
 req_row_proof_missing(Row) :-
@@ -1377,7 +1544,7 @@ filter_req_coverage_rows(false, Rows, Filtered) :-
 
 req_row_proof_passing(Row) :-
     Status = Row.proofStatus,
-    memberchk(Status, [proven, not_applicable]).
+    memberchk(Status, [tested, not_applicable]).
 
 filter_symbol_coverage_rows(true, Rows, Rows).
 filter_symbol_coverage_rows(false, Rows, Filtered) :-

package/src/intervals.pl

@@ -30,6 +30,7 @@ numeric_constraints_satisfiable(Constraints) :-
 % 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) :-
+    maplist(finite_constraint, Constraints),
     term_variables(Constraints, Variables),
     forall(
         member(Variable, Variables),
@@ -49,6 +50,16 @@ numeric_constraint_entailed(Premises, Constraint, IntegerVariables) :-
     numeric_constraint_negation(Constraint, Negated),
     \+ numeric_constraints_satisfiable([Negated|Premises], IntegerVariables).
 
+% A NaN or infinite bound has no place on the number line the intervals
+% model, so it is an error rather than an answer.
+finite_constraint(c(_Op, _Variable, Value)) :-
+    (   float(Value),
+        float_class(Value, Class),
+        memberchk(Class, [nan, infinite])
+    ->  domain_error(finite_number, Value)
+    ;   true
+    ).
+
 integer_variable(_, all) :- !.
 integer_variable(Variable, IntegerVariables) :-
     is_list(IntegerVariables),

package/src/kb.pl

@@ -3121,6 +3121,13 @@ value_from_props(Props, string, Value) :- memberchk(value_string=ValueRaw, Props
 value_from_props(Props, int, Value) :- memberchk(value_int=ValueRaw, Props), !, unwrap_rdf_value(ValueRaw, Value).
 value_from_props(Props, number, Value) :- memberchk(value_number=ValueRaw, Props), !, unwrap_rdf_value(ValueRaw, Value).
 value_from_props(Props, bool, Value) :- memberchk(value_bool=ValueRaw, Props), !, unwrap_rdf_value(ValueRaw, Value).
+% A set value is its sorted, unique members, so two facts naming the same set
+% in any order compare equal.
+value_from_props(Props, set, Value) :-
+    memberchk(value_set=ValueRaw, Props),
+    normalize_term_atom_list(ValueRaw, Atoms),
+    !,
+    sort(Atoms, Value).
 value_from_props(_, _, '').
 
 %% unwrap_rdf_value(+Raw, -Value)

package/src/kb_consistency.pl

@@ -0,0 +1,213 @@
+% Module: kb_consistency
+% implements REQ-kibi-kb-certificates
+% The kb-consistency check rules.  Each run produces the certificate bundle
+% (certificates.pl), round-trips it through JSON exactly as a saved bundle
+% would be read, and re-checks it with the independent checker
+% (certificate_check.pl).  Only what the checker accepts becomes a finding:
+%
+%   kb-consistency             a re-verified contradiction (an irreducible
+%                              core of property facts, two facts that
+%                              disagree on an atom or a decision, or a
+%                              negation cycle among stored rules), or a
+%                              certificate the checker rejects
+%   kb-consistency-unresolved  a context the checker cannot compare (mixed
+%                              types or units, unsupported operators or
+%                              polarities, windows that never overlap)
+:- module(kb_consistency, [
+    check_kb_consistency/1,
+    check_kb_consistency_unresolved/1
+]).
+
+:- encoding(utf8).
+
+:- use_module(library(apply)).
+:- use_module(library(lists)).
+:- use_module(library(http/json)).
+:- use_module('kb.pl', [kb_entity/3, kb_relationship/3]).
+:- use_module('certificates.pl', [kb_certificates/1]).
+:- use_module('certificate_check.pl', [verify_certificates/2]).
+
+%% check_kb_consistency(-Violations)
+check_kb_consistency(Violations) :-
+    consistency_verification(Bundle, Report),
+    numbered_certificates(Bundle, Numbered),
+    findall(Index, (member(Failure, Report.rejected), get_dict(certificate, Failure, Index)), Rejected),
+    findall(Violation,
+        (   member(Index-Certificate, Numbered),
+            \+ memberchk(Index, Rejected),
+            contradiction_violation(Certificate, Violation)
+        ),
+        Contradictions),
+    findall(Violation,
+        (   member(Failure, Report.rejected),
+            rejected_violation(Failure, Violation)
+        ),
+        RejectedViolations),
+    append(Contradictions, RejectedViolations, Unsorted),
+    sort(Unsorted, Violations).
+
+%% check_kb_consistency_unresolved(-Violations)
+check_kb_consistency_unresolved(Violations) :-
+    consistency_verification(_Bundle, Report),
+    findall(Violation,
+        (   member(Theorem, Report.theorems),
+            get_dict(unresolved, Theorem, Entries),
+            member(Entry, Entries),
+            unresolved_violation(Theorem.theorem, Entry, Violation)
+        ),
+        Unsorted),
+    sort(Unsorted, Violations).
+
+consistency_verification(Bundle, Report) :-
+    kb_certificates(Produced),
+    with_output_to(string(Json), json_write_dict(current_output, Produced, [width(0)])),
+    open_string(Json, Stream),
+    json_read_dict(Stream, Bundle, [value_string_as(string)]),
+    verify_certificates(Bundle, Report).
+
+numbered_certificates(Bundle, Numbered) :-
+    findall(Index-Certificate, nth1(Index, Bundle.certificates, Certificate), Numbered).
+
+% ------------------------------------------------------------------
+% Re-verified contradictions
+% ------------------------------------------------------------------
+
+contradiction_violation(Certificate, violation('kb-consistency', EntityId, Description, Suggestion, "", _{certificate: Certificate})) :-
+    get_dict(kind, Certificate, KindText),
+    atom_string(Kind, KindText),
+    contradiction_text(Kind, Certificate, Facts, Description),
+    fact_requirements(Facts, Requirements),
+    entity_label(Requirements, Facts, EntityId),
+    suggestion_text(Kind, Requirements, Suggestion).
+
+contradiction_text(property_contradiction, Certificate, Facts, Description) :-
+    Facts = Certificate.core,
+    context_text(Certificate, Context),
+    atomic_list_concat(Facts, ', ', FactText),
+    findall(Text,
+        (   member(Drop, Certificate.dropModels),
+            format(string(Text), "~w: ~w", [Drop.factId, Drop.value])
+        ),
+        DropTexts),
+    atomic_list_concat(DropTexts, ', ', DropText),
+    format(string(Description),
+        "Facts ~w cannot all hold for ~w: no value satisfies them together, and dropping any one leaves a value (~w)",
+        [FactText, Context, DropText]).
+contradiction_text(predicate_contradiction, Certificate, Facts, Description) :-
+    Facts = Certificate.core,
+    Facts = [FactA, FactB],
+    atom_text(Certificate, Atom),
+    format(string(Description),
+        "Facts ~w and ~w give ~w opposite truth values", [FactA, FactB, Atom]).
+contradiction_text(decision_contradiction, Certificate, Facts, Description) :-
+    Facts = Certificate.core,
+    Facts = [FactA, FactB],
+    decision_text(Certificate, Decision),
+    format(string(Description),
+        "Facts ~w and ~w decide ~w differently: one allows it and the other denies it", [FactA, FactB, Decision]).
+contradiction_text(rule_negation_cycle, Certificate, [], Description) :-
+    findall(Text,
+        (   member(Edge, Certificate.cycle),
+            signature_text(Edge.head, Head),
+            signature_text(Edge.body, Body),
+            (   atom_string(negative, Edge.sign) -> Arrow = "depends on not" ; Arrow = "depends on" ),
+            format(string(Text), "~w ~w ~w", [Head, Arrow, Body])
+        ),
+        Texts),
+    atomic_list_concat(Texts, "; ", CycleText),
+    format(string(Description),
+        "Stored rules are not stratified: a predicate depends on its own negation (~w)", [CycleText]).
+
+suggestion_text(rule_negation_cycle, _Requirements,
+    "Break the cycle: change one rule so no predicate depends on its own negation, or supersede the requirement that stores it") :- !.
+suggestion_text(_Kind, Requirements, Suggestion) :-
+    atomic_list_concat(Requirements, ', ', RequirementText),
+    format(string(Suggestion),
+        "Supersede or change one of ~w so the facts can hold together; kibi check --write-certificates <file> saves the certificate",
+        [RequirementText]).
+
+% ------------------------------------------------------------------
+% Rejected certificates and unresolved contexts
+% ------------------------------------------------------------------
+
+rejected_violation(Failure, violation('kb-consistency', "kb-certificates", Description,
+        "Kibi produced a certificate its own checker rejects. Report it with the bundle from kibi check --write-certificates <file>", "")) :-
+    (   get_dict(group, Failure, Group)
+    ->  group_text(Group, Where)
+    ;   format(string(Where), "certificate ~w (~w)", [Failure.certificate, Failure.kind])
+    ),
+    format(string(Description),
+        "The independent checker rejected ~w: ~w", [Where, Failure.reason]).
+
+unresolved_violation(_Theorem, Entry, violation('kb-consistency-unresolved', EntityId, Description, Suggestion, "")) :-
+    group_text(Entry, Where),
+    (   get_dict(reason, Entry, Reason)
+    ->  true
+    ;   Reason = "the contradicting facts' validity windows never overlap"
+    ),
+    entry_facts(Entry, Facts),
+    fact_requirements(Facts, Requirements),
+    entity_label(Requirements, Facts, EntityId0),
+    (   EntityId0 == "" -> EntityId = Where ; EntityId = EntityId0 ),
+    format(string(Description),
+        "Kibi cannot decide whether the facts for ~w hold together: ~w. It never counts as consistent", [Where, Reason]),
+    Suggestion = "Align the facts' value_type, unit, operator or polarity so they can be compared, or accept that this context stays unchecked".
+
+entry_facts(Entry, Facts) :-
+    get_dict(subjectKey, Entry, Subject),
+    !,
+    get_dict(propertyKey, Entry, Property),
+    findall(Fact,
+        (   kb:current_req(Req),
+            kb:effective_req_property_fact(Req, Subject, Fact, Property, _, _, _, _, _, _, _, _)
+        ),
+        Facts0),
+    sort(Facts0, Facts).
+entry_facts(_Entry, []).
+
+% ------------------------------------------------------------------
+% Text helpers
+% ------------------------------------------------------------------
+
+fact_requirements(Facts, Requirements) :-
+    findall(Req,
+        (   member(FactText, Facts),
+            atom_string(Fact, FactText),
+            member(Type, [requires_property, requires_predicate, requires_rule]),
+            kb_relationship(Type, Req, Fact),
+            kb:current_req(Req)
+        ),
+        Requirements0),
+    sort(Requirements0, Requirements).
+
+entity_label([], [], "") :- !.
+entity_label([], Facts, Label) :- !, atomic_list_concat(Facts, '/', Label0), atom_string(Label0, Label).
+entity_label(Requirements, _Facts, Label) :- atomic_list_concat(Requirements, '/', Label0), atom_string(Label0, Label).
+
+context_text(Label, Text) :-
+    (   get_dict(scope, Label, Scope0) -> atom_string(Scope0, Scope) ; Scope = "" ),
+    (   Scope == ""
+    ->  format(string(Text), "~w.~w", [Label.subjectKey, Label.propertyKey])
+    ;   format(string(Text), "~w.~w (scope ~w)", [Label.subjectKey, Label.propertyKey, Scope])
+    ).
+
+group_text(Group, Text) :-
+    (   get_dict(subjectKey, Group, _)
+    ->  context_text(Group, Text)
+    ;   get_dict(args, Group, _)
+    ->  atom_text(Group, Text)
+    ;   get_dict(key, Group, _)
+    ->  decision_text(Group, Text)
+    ;   format(string(Text), "~w", [Group])
+    ).
+
+atom_text(Label, Text) :-
+    atomic_list_concat(Label.args, ', ', Args),
+    format(string(Text), "~w:~w(~w)", [Label.namespace, Label.name, Args]).
+
+decision_text(Label, Text) :-
+    atomic_list_concat(Label.key, ', ', Key),
+    format(string(Text), "~w:~w/~w for (~w)", [Label.namespace, Label.name, Label.arity, Key]).
+
+signature_text(Signature, Text) :-
+    format(string(Text), "~w:~w/~w", [Signature.namespace, Signature.name, Signature.arity]).