kibi-core 0.23.0 → 0.24.0

package/src/code_certificates.pl

@@ -0,0 +1,297 @@
+% Module: code_certificates
+% implements REQ-kibi-code-proof-kinds
+%
+% Re-checks the kibi.code-certificate.v1 a certificate-kind proof contract
+% leaves in its receipt.  A receipt counts as proved only when its
+% certificate re-checks here, so a test that claims to have covered every
+% case cannot earn proved by saying so.  The checks never search:
+%
+%   exhaustive  The domain lists at least one member, no member twice, and
+%               the results name every member exactly once, each passed.
+%               (Kibi checks at ingest that the proof imported the domain
+%               from its source instead of hand-listing it.)
+%   typecheck   The witness names a file and its sha256 and the compiler
+%               that accepted it; the outcome is passed.  (Kibi checks at
+%               ingest that the witness is the file in the workspace and
+%               imports the domain.)
+%   arithmetic  The assumptions on one variable are satisfiable and entail
+%               the claim, decided exactly by intervals.pl: the assumptions
+%               plus the negated claim admit no value.
+%   smt         The query asks (check-sat) and the solver answered unsat.
+%               (Kibi re-runs the solver on the query at ingest.)
+%
+% The digest a receipt records is the sha256 of the certificate's canonical
+% JSON as canonical_json/2 below spells it. The CLI records the digest this
+% module returns at ingest, so ingest and every later re-check hash the
+% certificate the same way.
+
+:- module(code_certificates, [
+    code_certificate_check/2,
+    code_certificate_digest/2,
+    code_certificate_check_json/2
+]).
+
+:- use_module(library(http/json)).
+:- use_module(library(crypto)).
+:- use_module(library(apply)).
+:- use_module(library(lists)).
+:- use_module('intervals.pl', [
+    numeric_constraints_satisfiable/2,
+    numeric_constraint_entailed/3
+]).
+
+code_certificate_version("kibi.code-certificate.v1").
+
+%% code_certificate_check(+Certificate, -Result)
+% Result is ok or rejected(Reason) with Reason a string naming what failed.
+code_certificate_check(Certificate, Result) :-
+    (   catch(certificate_problem(Certificate, Reason), _, (Reason = "the certificate is malformed"))
+    ->  Result = rejected(Reason)
+    ;   Result = ok
+    ).
+
+%% code_certificate_digest(+Certificate, -Digest)
+code_certificate_digest(Certificate, Digest) :-
+    canonical_json(Certificate, Json),
+    crypto_data_hash(Json, Digest, [algorithm(sha256), encoding(utf8)]).
+
+%% code_certificate_check_json(+CertificateJson, -ResultJson)
+% Entry point for the CLI: {"accepted": true, "digest": D} or
+% {"accepted": false, "reason": R}.
+code_certificate_check_json(CertificateJson, ResultJson) :-
+    (   catch(atom_json_dict(CertificateJson, Certificate, [value_string_as(string)]), _, fail),
+        is_dict(Certificate)
+    ->  code_certificate_check(Certificate, Result),
+        code_certificate_digest(Certificate, Digest),
+        (   Result == ok
+        ->  Out = _{accepted: true, digest: Digest}
+        ;   Result = rejected(Reason),
+            Out = _{accepted: false, digest: Digest, reason: Reason}
+        )
+    ;   Out = _{accepted: false, reason: "the certificate is not a JSON object"}
+    ),
+    with_output_to(string(ResultJson), json_write_dict(current_output, Out, [width(0)])).
+
+% certificate_problem(+Certificate, -Reason) succeeds with the first problem.
+certificate_problem(Certificate, Reason) :-
+    \+ is_dict(Certificate), !,
+    Reason = "the certificate is not an object".
+certificate_problem(Certificate, Reason) :-
+    code_certificate_version(Version),
+    \+ get_dict(version, Certificate, Version), !,
+    format(string(Reason), "the certificate version is not ~w", [Version]).
+certificate_problem(Certificate, Reason) :-
+    \+ (get_dict(test_id, Certificate, TestId), nonempty_string(TestId)), !,
+    Reason = "the certificate names no test_id".
+certificate_problem(Certificate, Reason) :-
+    (   get_dict(kind, Certificate, KindString), string(KindString)
+    ->  atom_string(Kind, KindString)
+    ;   Kind = none
+    ),
+    (   kind_problem(Kind, Certificate, Reason0)
+    ->  Reason = Reason0
+    ;   \+ memberchk(Kind, [exhaustive, typecheck, arithmetic, smt])
+    ->  Reason = "the certificate kind is not exhaustive, typecheck, arithmetic or smt"
+    ).
+
+kind_problem(exhaustive, Certificate, Reason) :-
+    field(Certificate, domain, Domain),
+    field(Domain, symbol_id, Symbol),
+    field(Domain, members, Members),
+    field(Certificate, results, Results),
+    (   \+ is_dict(Domain)
+    ->  Reason = "the certificate has no domain"
+    ;   \+ nonempty_string(Symbol)
+    ->  Reason = "the domain names no symbol_id"
+    ;   \+ (is_list(Members), Members \== [])
+    ->  Reason = "the domain lists no members"
+    ;   \+ maplist(nonempty_string, Members)
+    ->  Reason = "every domain member must be a non-empty string"
+    ;   msort(Members, Sorted), sort(Members, Unique), Sorted \== Unique
+    ->  Reason = "the domain lists a member twice"
+    ;   \+ is_list(Results)
+    ->  Reason = "the certificate has no results"
+    ;   \+ maplist(result_row, Results)
+    ->  Reason = "every result must name a member and an outcome"
+    ;   findall(M, (member(Row, Results), get_dict(member, Row, M)), Named),
+        msort(Named, NamedSorted),
+        msort(Members, MembersSorted),
+        NamedSorted \== MembersSorted
+    ->  Reason = "the results do not name every domain member exactly once"
+    ;   member(Row, Results),
+        get_dict(outcome, Row, Outcome),
+        Outcome \== "passed"
+    ->  get_dict(member, Row, Failed),
+        format(string(Reason), "member ~w did not pass", [Failed])
+    ).
+kind_problem(typecheck, Certificate, Reason) :-
+    field(Certificate, witness, Witness),
+    field(Witness, path, Path),
+    field(Witness, sha256, Hash),
+    field(Certificate, domain, Domain),
+    field(Domain, symbol_id, Symbol),
+    field(Certificate, compiler, Compiler),
+    field(Compiler, name, Name),
+    field(Compiler, version, CompilerVersion),
+    field(Certificate, outcome, Outcome),
+    (   \+ nonempty_string(Path)
+    ->  Reason = "the certificate names no witness path"
+    ;   \+ sha256_string(Hash)
+    ->  Reason = "the witness has no sha256"
+    ;   \+ nonempty_string(Symbol)
+    ->  Reason = "the certificate names no domain symbol_id"
+    ;   \+ (nonempty_string(Name), nonempty_string(CompilerVersion))
+    ->  Reason = "the certificate names no compiler and version"
+    ;   Outcome \== "passed"
+    ->  Reason = "the type checker did not accept the witness"
+    ).
+kind_problem(arithmetic, Certificate, Reason) :-
+    field(Certificate, variable, Variable),
+    field(Certificate, value_type, Type),
+    field(Certificate, assumptions, Assumptions),
+    field(Certificate, claim, Claim),
+    (   \+ nonempty_string(Variable)
+    ->  Reason = "the certificate names no variable"
+    ;   \+ memberchk(Type, ["int", "real"])
+    ->  Reason = "value_type must be int or real"
+    ;   \+ (is_list(Assumptions), Assumptions \== [])
+    ->  Reason = "the certificate states no assumptions"
+    ;   \+ maplist(arithmetic_constraint(_), Assumptions, _)
+    ->  Reason = "every assumption must be {operator, value} with a comparison operator and a number"
+    ;   \+ arithmetic_constraint(_, Claim, _)
+    ->  Reason = "the claim must be {operator, value} with a comparison operator and a number"
+    ;   maplist(arithmetic_constraint(X), Assumptions, Premises),
+        arithmetic_constraint(X, Claim, Goal),
+        integer_variables(Type, X, Integers),
+        (   \+ numeric_constraints_satisfiable(Premises, Integers)
+        ->  Reason = "the assumptions admit no value, so the claim holds vacuously"
+        ;   \+ numeric_constraint_entailed(Premises, Goal, Integers)
+        ->  Reason = "the assumptions do not entail the claim: some value satisfies them and breaks it"
+        )
+    ).
+kind_problem(smt, Certificate, Reason) :-
+    field(Certificate, solver, Solver),
+    field(Solver, name, Name),
+    field(Solver, version, SolverVersion),
+    field(Certificate, query, Query),
+    field(Certificate, result, Result),
+    (   \+ (nonempty_string(Name), nonempty_string(SolverVersion))
+    ->  Reason = "the certificate names no solver and version"
+    ;   \+ nonempty_string(Query)
+    ->  Reason = "the certificate has no query"
+    ;   \+ sub_string(Query, _, _, _, "(check-sat)")
+    ->  Reason = "the query never asks (check-sat)"
+    ;   Result \== "unsat"
+    ->  Reason = "the solver did not answer unsat"
+    ).
+
+% field(+Dict, +Key, -Value): the value, or '$missing' when absent.
+field(Dict, Key, Value) :-
+    (   is_dict(Dict), get_dict(Key, Dict, Value0)
+    ->  Value = Value0
+    ;   Value = '$missing'
+    ).
+
+result_row(Row) :-
+    is_dict(Row),
+    get_dict(member, Row, _),
+    get_dict(outcome, Row, _).
+
+arithmetic_constraint(X, Row, c(Op, X, Value)) :-
+    is_dict(Row),
+    get_dict(operator, Row, OpString),
+    string(OpString),
+    atom_string(Op, OpString),
+    memberchk(Op, [eq, neq, lt, lte, gt, gte]),
+    get_dict(value, Row, Value),
+    number(Value).
+
+integer_variables("int", X, [X]).
+integer_variables("real", _, []).
+
+nonempty_string(Value) :-
+    string(Value),
+    Value \== "".
+
+sha256_string(Value) :-
+    string(Value),
+    string_length(Value, 64),
+    string_codes(Value, Codes),
+    forall(member(C, Codes), (code_type(C, digit) ; between(0'a, 0'f, C))).
+
+% The canonical JSON is spelled out here rather than left to json_write, so
+% it does not depend on the stream encoding or on how a key was read (a YAML
+% key and a JSON key for the same text are the same key): object keys sorted
+% by code point, no whitespace, ", \ and the JSON control escapes, other
+% control characters and every non-ASCII character as \u escapes of their
+% UTF-16 code units, integers in decimal.
+canonical_json(Value, Json) :-
+    is_dict(Value), !,
+    dict_pairs(Value, _, Pairs0),
+    maplist(string_keyed, Pairs0, Pairs1),
+    keysort(Pairs1, Pairs),
+    maplist(canonical_pair, Pairs, Parts),
+    atomics_to_string(Parts, ",", Body),
+    format(string(Json), "{~s}", [Body]).
+canonical_json(Value, Json) :-
+    is_list(Value), !,
+    maplist(canonical_json, Value, Parts),
+    atomics_to_string(Parts, ",", Body),
+    format(string(Json), "[~s]", [Body]).
+canonical_json(Value, Json) :-
+    string(Value), !,
+    canonical_string(Value, Json).
+canonical_json(Value, Json) :-
+    integer(Value), !,
+    format(string(Json), "~d", [Value]).
+canonical_json(Value, Json) :-
+    memberchk(Value, [true, false, null]), !,
+    atom_string(Value, Json).
+canonical_json(Value, Json) :-
+    atom(Value), !,
+    atom_string(Value, String),
+    canonical_string(String, Json).
+canonical_json(Value, Json) :-
+    with_output_to(string(Json), json_write(current_output, Value, [width(0)])).
+
+% Keys as code lists, so keysort orders them by code point whatever the
+% reader made of them (an atom, or a small integer for a numeric key).
+string_keyed(Key-Value, Codes-Value) :-
+    format(string(String), "~w", [Key]),
+    string_codes(String, Codes).
+
+canonical_pair(Codes-Value, Json) :-
+    string_codes(Key, Codes),
+    canonical_string(Key, KeyJson),
+    canonical_json(Value, ValueJson),
+    format(string(Json), "~s:~s", [KeyJson, ValueJson]).
+
+canonical_string(String, Json) :-
+    string_codes(String, Codes),
+    phrase(escaped_codes(Codes), Escaped),
+    string_codes(Body, Escaped),
+    format(string(Json), "\"~s\"", [Body]).
+
+escaped_codes([]) --> [].
+escaped_codes([C|Cs]) --> escaped_code(C), escaped_codes(Cs).
+
+escaped_code(0'") --> !, "\\\"".
+escaped_code(0'\\) --> !, "\\\\".
+escaped_code(0'\b) --> !, "\\b".
+escaped_code(0'\f) --> !, "\\f".
+escaped_code(0'\n) --> !, "\\n".
+escaped_code(0'\r) --> !, "\\r".
+escaped_code(0'\t) --> !, "\\t".
+escaped_code(C) --> { C >= 0x20, C =< 0x7e }, !, [C].
+escaped_code(C) -->
+    { C > 0xffff }, !,
+    { V is C - 0x10000,
+      High is 0xd800 + (V >> 10),
+      Low is 0xdc00 + (V /\ 0x3ff) },
+    unit_escape(High),
+    unit_escape(Low).
+escaped_code(C) --> unit_escape(C).
+
+unit_escape(Unit) -->
+    { format(codes(Codes), "\\u~|~`0t~16r~4+", [Unit]) },
+    Codes.

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
@@ -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),
@@ -1140,6 +1255,8 @@ coverage_summary(Rows, Summary) :-
     length(MissingBothRows, MissingScenarioAndTest),
     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),
@@ -1156,9 +1273,50 @@ coverage_summary(Rows, Summary) :-
         proofUnresolved: ProofUnresolved,
         proofMissing: ProofMissing,
         proofNotApplicable: ProofNotApplicable,
-        evidenceLevels: EvidenceLevels
+        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),

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)