kibi-core 0.23.0 → 0.26.1

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

@@ -72,6 +72,7 @@
     check_req_contradiction/1,
     normalize_term_atom/2,
     normalize_term_atom_list/2,
+    normalize_literal_atom_list/2,
     changeset/4, % Export for testing
     kb_uri/1
 ]).
@@ -85,7 +86,7 @@
 :- use_module(library(sha), [sha_hash/3, hash_atom/2]).
 :- use_module(library(http/json)).
 :- use_module(library(aggregate), [aggregate_all/3]).
-:- use_module(library(lists), [sum_list/2]).
+:- use_module(library(lists), [sum_list/2, subtract/3, intersection/3]).
 :- use_module(library(ordsets)).
 :- use_module(library(solution_sequences), [distinct/1, limit/2, offset/2, order_by/2]).
 :- use_module('../schema/entities.pl', [entity_type/1, entity_property/3, required_property/2]).
@@ -3080,6 +3081,23 @@ normalize_term_atom_list(Raw, Atoms) :-
     !,
     maplist(normalize_term_atom, Value, Atoms).
 
+%% normalize_literal_atom_list(+Raw, -Atoms)
+% The members of a stored list as atoms, verbatim. Unlike
+% normalize_term_atom_list it keeps a member's '/' segments, so set members
+% such as rxjs/operators, GET /api/users or finance/de stay whole.
+normalize_literal_atom_list(Raw, Atoms) :-
+    unwrap_rdf_value(Raw, Value),
+    is_list(Value),
+    maplist(normalize_literal_atom, Value, Atoms).
+
+normalize_literal_atom(Raw, Atom) :-
+    unwrap_rdf_value(Raw, Value),
+    (   atom(Value) -> Atom = Value
+    ;   string(Value) -> atom_string(Atom, Value)
+    ;   number(Value) -> atom_number(Atom, Value)
+    ;   term_string(Value, String), atom_string(Atom, String)
+    ).
+
 normalize_term_integer(Raw, Integer) :-
     unwrap_rdf_value(Raw, Value),
     (   integer(Value)
@@ -3121,6 +3139,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_literal_atom_list(ValueRaw, Atoms),
+    !,
+    sort(Atoms, Value).
 value_from_props(_, _, '').
 
 %% unwrap_rdf_value(+Raw, -Value)
@@ -3219,6 +3244,35 @@ same_value(TypeA, ValA, TypeB, ValB) :-
 values_conflict(eq, ValA, eq, ValB, Type) :-
     \+ same_value(Type, ValA, Type, ValB).
 
+% A set fact with includes says every member of its set has the property;
+% eq on a set says exactly those members do. Two includes facts always agree
+% (the members having the property include both sets); includes conflicts
+% with eq only when it names a member the eq set leaves out.
+% implements REQ-kibi-non-numeric-proof-kinds
+values_conflict(includes, Included, eq, Exact, set) :-
+    \+ subtract(Included, Exact, []).
+values_conflict(eq, Exact, includes, Included, set) :-
+    \+ subtract(Included, Exact, []).
+
+% subset_of says every member with the property is in its set, excludes that
+% no member of its set has it.  subset_of conflicts with a set that must have
+% the property (eq or includes) when that set names a member outside it;
+% excludes conflicts when the two sets share a member.  subset_of and excludes
+% never conflict with each other or themselves: the empty set satisfies them.
+% implements REQ-kibi-source-proof-kinds
+values_conflict(subset_of, Allowed, Op, Required, set) :-
+    memberchk(Op, [eq, includes]),
+    \+ subtract(Required, Allowed, []).
+values_conflict(Op, Required, subset_of, Allowed, set) :-
+    memberchk(Op, [eq, includes]),
+    \+ subtract(Required, Allowed, []).
+values_conflict(excludes, Excluded, Op, Required, set) :-
+    memberchk(Op, [eq, includes]),
+    intersection(Excluded, Required, [_|_]).
+values_conflict(Op, Required, excludes, Excluded, set) :-
+    memberchk(Op, [eq, includes]),
+    intersection(Excluded, Required, [_|_]).
+
 % Eq/neq conflict on the same scalar value.
 values_conflict(eq, ValA, neq, ValB, Type) :-
     same_value(Type, ValA, Type, ValB).