kibi-core 0.22.5 → 0.23.0

package/src/certificates.pl

@@ -0,0 +1,237 @@
+% Module: certificates
+% implements REQ-kibi-kb-certificates
+%
+% Finds a certificate for every KB theorem that certificate_check.pl states:
+% a model for each consistent property context, predicate atom and decision
+% key, an irreducible core (with a model per dropped fact) for each
+% contradiction, and a stratum assignment (or a negation cycle) for the
+% stored rules.  This module may search; certificate_check.pl re-checks
+% everything it emits without trusting it.
+
+:- module(certificates, [
+    kb_certificates/1,
+    kb_write_certificates/2
+]).
+
+:- encoding(utf8).
+
+:- use_module(library(http/json)).
+:- use_module(library(apply)).
+:- use_module(library(lists)).
+:- use_module(library(aggregate)).
+:- use_module('kb.pl', []).
+:- use_module('intervals.pl', [numeric_constraint_holds/3]).
+:- use_module('certificate_check.pl', [
+    certificate_property_contexts/1,
+    certificate_predicate_groups/1,
+    certificate_decision_groups/1,
+    certificate_rule_edges/1,
+    certificate_member_holds/3,
+    certificate_members_satisfiable/2
+]).
+
+%% kb_write_certificates(+Path, -JsonString)
+% Write the certificate bundle for the current KB to Path and return a
+% summary (certificate count per kind) as a JSON string.
+kb_write_certificates(Path, JsonString) :-
+    kb_certificates(Bundle),
+    setup_call_cleanup(
+        open(Path, write, Stream, [encoding(utf8)]),
+        ( json_write_dict(Stream, Bundle, [width(0)]), nl(Stream) ),
+        close(Stream)),
+    findall(Kind, (member(Certificate, Bundle.certificates), get_dict(kind, Certificate, Kind)), Kinds0),
+    msort(Kinds0, Kinds),
+    clumped(Kinds, Counts),
+    findall(Kind-Count, member(Kind-Count, Counts), Pairs),
+    dict_pairs(ByKind, _, Pairs),
+    length(Bundle.certificates, Total),
+    with_output_to(string(JsonString),
+        json_write_dict(current_output, _{path: Path, certificates: Total, byKind: ByKind}, [width(0)])).
+
+%% kb_certificates(-Bundle)
+kb_certificates(_{version: 'kibi.certificates.v1', certificates: Certificates}) :-
+    certificate_property_contexts(Contexts),
+    convlist(property_certificate, Contexts, PropertyCertificates),
+    certificate_predicate_groups(AtomGroups),
+    convlist(group_certificate(predicate), AtomGroups, PredicateCertificates),
+    certificate_decision_groups(DecisionGroups),
+    convlist(group_certificate(decision), DecisionGroups, DecisionCertificates),
+    certificate_rule_edges(Edges),
+    rule_certificates(Edges, RuleCertificates),
+    append([PropertyCertificates, PredicateCertificates, DecisionCertificates, RuleCertificates], Certificates).
+
+% ------------------------------------------------------------------
+% Property contexts
+% ------------------------------------------------------------------
+
+property_certificate(context(Subject, Property, Scope, Domain, Members), Certificate) :-
+    Base = _{subjectKey: Subject, propertyKey: Property, scope: Scope, domain: Domain},
+    (   members_model(Domain, Members, Value)
+    ->  findall(Fact, member(m(Fact, _, _, _, _), Members), Facts),
+        Certificate = Base.put(_{kind: property_model, value: Value, facts: Facts})
+    ;   irreducible_core(Domain, Members, Core),
+        findall(_{factId: Fact, value: Value},
+            (   member(Dropped, Core),
+                Dropped = m(Fact, _, _, _, _),
+                exclude(==(Dropped), Core, Rest),
+                members_model(Domain, Rest, Value)
+            ),
+            DropModels),
+        findall(Fact, member(m(Fact, _, _, _, _), Core), CoreFacts),
+        (   core_windows_overlap(Core)
+        ->  Kind = property_contradiction
+        ;   Kind = property_unresolved
+        ),
+        Certificate = Base.put(_{kind: Kind, core: CoreFacts, dropModels: DropModels})
+    ).
+
+%% members_model(+Domain, +Members, -Value)
+% A value satisfying every member, found among finitely many candidates that
+% meet every region the members' bounds cut the line into.
+members_model(Domain, Members, Value) :-
+    model_candidates(Domain, Members, Candidates),
+    member(Value, Candidates),
+    forall(member(Member, Members), certificate_member_holds(Domain, Member, Value)),
+    !.
+
+model_candidates(Domain, Members, Candidates) :-
+    memberchk(Domain, [int, number]),
+    !,
+    findall(Bound, member(m(_, _, Bound, _, _), Members), Bounds0),
+    sort(Bounds0, Bounds),
+    (   Domain == int
+    ->  findall(Candidate,
+            (   member(Bound, Bounds),
+                member(Base, [floor(Bound), ceiling(Bound)]),
+                member(Offset, [-1, 0, 1]),
+                Candidate is Base + Offset
+            ),
+            Candidates0)
+    ;   findall(Candidate,
+            (   member(Bound, Bounds), member(Offset, [-1, 0, 1]), Candidate is Bound + Offset
+            ;   nextto(Low, High, Bounds), Candidate is (Low + High) / 2
+            ),
+            Candidates0)
+    ),
+    sort([0|Candidates0], Candidates).
+model_candidates(bool, _Members, [true, false]) :- !.
+model_candidates(string, Members, Candidates) :-
+    findall(Bound, member(m(_, _, Bound, _, _), Members), Bounds0),
+    sort(Bounds0, Bounds),
+    fresh_text(Bounds, 0, Fresh),
+    append(Bounds, [Fresh], Candidates).
+
+fresh_text(Bounds, Index, Fresh) :-
+    format(string(Candidate), "kibi:model:~w", [Index]),
+    (   member(Bound, Bounds), text_value(Bound, Candidate)
+    ->  Next is Index + 1,
+        fresh_text(Bounds, Next, Fresh)
+    ;   Fresh = Candidate
+    ).
+
+text_value(Value, Text) :- atom(Value), !, atom_string(Value, Text).
+text_value(Value, Text) :- string(Value), !, Text = Value.
+
+%% irreducible_core(+Domain, +Members, -Core)
+% Deletion filter: drop each member whose removal keeps the set
+% unsatisfiable.  What remains admits no value, and every proper subset
+% does.
+irreducible_core(Domain, Members, Core) :-
+    foldl(core_step(Domain), Members, Members, Core).
+
+core_step(Domain, Member, Current, Next) :-
+    exclude(==(Member), Current, Without),
+    (   Without \== [],
+        \+ certificate_members_satisfiable(Domain, Without)
+    ->  Next = Without
+    ;   Next = Current
+    ).
+
+core_windows_overlap(Core) :-
+    forall((member(m(_, _, _, FromA, ToA), Core), member(m(_, _, _, FromB, ToB), Core)),
+        kb:intervals_overlap(FromA, ToA, FromB, ToB)).
+
+% ------------------------------------------------------------------
+% Predicate atoms and decision keys
+% ------------------------------------------------------------------
+
+group_certificate(Prefix, group(Label, Members), Certificate) :-
+    atom_concat(Prefix, '_model', ModelKind),
+    atom_concat(Prefix, '_contradiction', ContradictionKind),
+    findall(Value, member(p(_, Value), Members), Values0),
+    sort(Values0, Values),
+    (   Values = [Value]
+    ->  findall(Fact, member(p(Fact, _), Members), Facts),
+        Certificate = Label.put(_{kind: ModelKind, value: Value, facts: Facts})
+    ;   Members = [p(FactA, ValueA)|_],
+        member(p(FactB, ValueB), Members),
+        ValueB \== ValueA,
+        !,
+        Certificate = Label.put(_{kind: ContradictionKind, core: [FactA, FactB]})
+    ).
+
+% ------------------------------------------------------------------
+% Rule stratification
+% ------------------------------------------------------------------
+
+rule_certificates([], []) :- !.
+rule_certificates(Edges, [Certificate]) :-
+    findall(Signature, (member(edge(Head, Body, _), Edges), member(Signature, [Head, Body])), Signatures0),
+    sort(Signatures0, Signatures),
+    findall(Signature-0, member(Signature, Signatures), Initial),
+    length(Signatures, Count),
+    Rounds is Count + 1,
+    (   relax_strata(Rounds, Edges, Initial, Strata)
+    ->  findall(_{namespace: Namespace, name: Name, arity: Arity, stratum: Stratum},
+            member(predicate(Namespace, Name, Arity)-Stratum, Strata),
+            Entries),
+        Certificate = _{kind: rule_strata, strata: Entries}
+    ;   negation_cycle(Edges, Cycle),
+        findall(_{head: HeadDict, body: BodyDict, sign: Sign},
+            (   member(edge(Head, Body, Sign), Cycle),
+                signature_dict(Head, HeadDict),
+                signature_dict(Body, BodyDict)
+            ),
+            Entries),
+        Certificate = _{kind: rule_negation_cycle, cycle: Entries}
+    ).
+
+signature_dict(predicate(Namespace, Name, Arity), _{namespace: Namespace, name: Name, arity: Arity}).
+
+% Raise each head to at least its body's stratum (one more across a negated
+% edge) until nothing changes.  Without a negation cycle that happens within
+% one round per predicate; a cycle keeps raising, and relaxation fails.
+relax_strata(0, _Edges, _Strata, _Final) :- !, fail.
+relax_strata(Rounds, Edges, Strata, Final) :-
+    foldl(relax_edge, Edges, Strata, Next),
+    (   Next == Strata
+    ->  Final = Strata
+    ;   Remaining is Rounds - 1,
+        relax_strata(Remaining, Edges, Next, Final)
+    ).
+
+relax_edge(edge(Head, Body, Sign), Strata, Next) :-
+    memberchk(Head-HeadStratum, Strata),
+    memberchk(Body-BodyStratum, Strata),
+    (   Sign == negative -> Required is BodyStratum + 1 ; Required = BodyStratum ),
+    (   HeadStratum < Required
+    ->  selectchk(Head-HeadStratum, Strata, Head-Required, Next)
+    ;   Next = Strata
+    ).
+
+% A negated edge Head -> Body with a dependency path from Body back to Head.
+negation_cycle(Edges, [edge(Head, Body, negative)|Path]) :-
+    member(edge(Head, Body, negative), Edges),
+    dependency_path(Body, Head, Edges, [Body], Path),
+    !.
+
+dependency_path(Current, Target, _Edges, _Seen, []) :-
+    Current == Target,
+    !.
+dependency_path(Current, Target, Edges, Seen, [edge(Current, Next, Sign)|Path]) :-
+    member(edge(Current, Next, Sign), Edges),
+    (   Next == Target
+    ->  Path = []
+    ;   \+ memberchk(Next, Seen),
+        dependency_path(Next, Target, Edges, [Next|Seen], Path)
+    ).

package/src/checks.pl

@@ -50,6 +50,8 @@
     check_subject_key_identity/1,
     check_subject_key_shape/1,
     check_ontology_quality/1,
+    check_kb_consistency/1,
+    check_kb_consistency_unresolved/1,
     run_checks_json/0,              % Entry point for JSON output
     violation_id_text/2             % Extract text from entity ID term (exported for testing)
 ]).
@@ -75,6 +77,7 @@
 :- use_module('logic_ir.pl', [logic_rule_safety/2, logic_rule_from_props/2, logic_rule_render/2, logic_rule_conflict/3, logic_rule_conflict_witness/4, logic_rules_stratified/1, logic_rule_missing_keys/4, functional_predicate_declarations/1, logic_rule_property_form/2]).
 % GENERATED registry facts; single source is schema/rule-registry.json.
 :- use_module('rule_registry.pl', [known_rule/1]).
+:- use_module('kb_consistency.pl', [check_kb_consistency/1, check_kb_consistency_unresolved/1]).
 
 % Required fields for all entities
 required_fields([id, title, status, created_at, updated_at, source]).
@@ -125,6 +128,8 @@ check_all(ViolationsDict) :-
     check_subject_key_identity(SubjectKeyIdentity),
     check_subject_key_shape(SubjectKeyShape),
     check_ontology_quality(OntologyQuality),
+    check_kb_consistency(KbConsistency),
+    check_kb_consistency_unresolved(KbConsistencyUnresolved),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -159,7 +164,9 @@ check_all(ViolationsDict) :-
         domain_implication: DomainImplication,
         subject_key_identity: SubjectKeyIdentity,
         subject_key_shape: SubjectKeyShape,
-        ontology_quality: OntologyQuality
+        ontology_quality: OntologyQuality,
+        kb_consistency: KbConsistency,
+        kb_consistency_unresolved: KbConsistencyUnresolved
     }.
 
 %% check_must_priority_coverage(-Violations)
@@ -3663,7 +3670,9 @@ check_selected_dispatch(Rules, _{
     domain_implication: DomainImplication,
     subject_key_identity: SubjectKeyIdentity,
     subject_key_shape: SubjectKeyShape,
-    ontology_quality: OntologyQuality
+    ontology_quality: OntologyQuality,
+    kb_consistency: KbConsistency,
+    kb_consistency_unresolved: KbConsistencyUnresolved
 }) :-
     selected_rule(Rules, 'must-priority-coverage', check_must_priority_coverage, MustPriority),
     selected_rule(Rules, 'symbol-coverage', check_symbol_coverage, SymbolCoverage),
@@ -3698,7 +3707,9 @@ check_selected_dispatch(Rules, _{
     selected_rule(Rules, 'domain-implication', check_domain_implication, DomainImplication),
     selected_rule(Rules, 'subject-key-identity', check_subject_key_identity, SubjectKeyIdentity),
     selected_rule(Rules, 'subject-key-shape', check_subject_key_shape, SubjectKeyShape),
-    selected_rule(Rules, 'ontology-quality', check_ontology_quality, OntologyQuality).
+    selected_rule(Rules, 'ontology-quality', check_ontology_quality, OntologyQuality),
+    selected_rule(Rules, 'kb-consistency', check_kb_consistency, KbConsistency),
+    selected_rule(Rules, 'kb-consistency-unresolved', check_kb_consistency_unresolved, KbConsistencyUnresolved).
 
 selected_rule(Rules, Name, Goal, Violations) :-
     (   memberchk(Name, Rules)
@@ -3770,6 +3781,8 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
     check_subject_key_identity(SubjectKeyIdentity),
     check_subject_key_shape(SubjectKeyShape),
     check_ontology_quality(OntologyQuality),
+    check_kb_consistency(KbConsistency),
+    check_kb_consistency_unresolved(KbConsistencyUnresolved),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -3803,7 +3816,9 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
         domain_implication: DomainImplication,
         subject_key_identity: SubjectKeyIdentity,
         subject_key_shape: SubjectKeyShape,
-        ontology_quality: OntologyQuality
+        ontology_quality: OntologyQuality,
+        kb_consistency: KbConsistency,
+        kb_consistency_unresolved: KbConsistencyUnresolved
     }.
 
 %% violations_dict_to_json(+ViolationsDict, -JsonDict)

package/src/discovery.pl

@@ -398,7 +398,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
@@ -1127,7 +1127,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 +1138,8 @@ coverage_summary(Rows, Summary) :-
     length(MissingScenarioRows, MissingScenario),
     length(MissingTestRows, MissingTest),
     length(MissingBothRows, MissingScenarioAndTest),
-    length(ProofProvenRows, ProofProven),
+    length(ProofTestedRows, ProofTested),
+    evidence_level_counts(Rows, EvidenceLevels),
     length(ProofUnresolvedRows, ProofUnresolved),
     length(ProofMissingRows, ProofMissing),
     length(ProofNotApplicableRows, ProofNotApplicable),
@@ -1151,12 +1152,20 @@ coverage_summary(Rows, Summary) :-
         missingScenario: MissingScenario,
         missingTest: MissingTest,
         missingScenarioAndTest: MissingScenarioAndTest,
-        proofProven: ProofProven,
+        proofTested: ProofTested,
         proofUnresolved: ProofUnresolved,
         proofMissing: ProofMissing,
-        proofNotApplicable: ProofNotApplicable
+        proofNotApplicable: ProofNotApplicable,
+        evidenceLevels: EvidenceLevels
     }.
 
+% 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 +1184,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 +1386,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/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]).