feat(gen-shacl): add a compositional fallback for rule-to-SPARQL conversion

[jdsika]

Mirror of linkml#3990, same head. Review there; this PR tracks the fork stack.

Summary

When no named pattern from linkml#3989 matches a rule, this PR composes the rule's SHACL-SPARQL constraint from the operators it uses. Each precondition becomes filters on $this. The single postcondition becomes the union of the ways to violate it, with the offending value bound to ?value (SHACL §5.3.1, §5.3.2).

rules:
  - preconditions:  {slot_conditions: {level: {minimum_value: 10, maximum_value: 20}}}
    postconditions: {slot_conditions: {note: {equals_string_in: [low, high]}}}

With this rule, a Thing whose level is between 10 and 20 violates the constraint when its note is missing, or for each note value other than low or high.

Supported operators (in any condition, including nested ones): value_presence, required, equals_string, equals_string_in, minimum_value, maximum_value, range_expression and has_member.

Anything else is skipped with a warning, as is a rule with empty pre- or postconditions or with several postcondition slots. A rule is never partially translated.

Semantics

These follow jsonschemagen's if / then.

• Presence: value_presence decides first, then required, then a default:
  • a precondition requires its slot;
  • a postcondition requires its slot unless the rule is open_world;
  • a nested condition never does.
• Every value: value operators and range_expression apply to every value, as jsonschemagen does through items. The spec matches slot checks against "all members of the collection" (05validation.md) but doesn't define when a rule condition is satisfied, so this reading is a choice (Rules: value operators on a multivalued slot in rule conditions mean "every value" in some generators and "some value" in others #41). has_member needs only one value. For example, the precondition levels: {minimum_value: 10} holds for [12, 15] but not for [12, 3].
• Range checks:
  • equals_string(_in) is translated only on string, enum and boolean slots (the same check as in feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989).
  • Bounds are translated only on the numeric datatypes (SPARQL 1.1 §17.1).
  • Comparing a non-number with a number is a type error (§17.3), but rdflib's default mode orders "15" >= 10 as true. Bounds are therefore guarded with isNumeric.
• Shared with feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989: slot resolution (inner slots resolve on the range class), inheritance into subclass shapes, and warnings. A rule skipped part-way now reports only why it was skipped.
• Equivalent forms give the same verdicts. A guard written as {required: true} is composed, while {value_presence: PRESENT} matches the named pattern; the tests check both against JSON Schema. Rules that feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989 skipped, such as equals_string together with equals_string_in, or an ABSENT guard, are now translated exactly.

Differences from jsonschemagen

• jsonschemagen drops has_member inside rule conditions (gen-json-schema rules: deactivated rules enforced; cardinality, has_member and all_members dropped in rule conditions; class-level multivalued ignored #42); this PR enforces it.
• jsonschemagen merges several value_presence: ABSENT into "not all present" (gen-json-schema: multiple value_presence: ABSENT postconditions in one rule compile to "not both present" instead of "neither present" linkml/linkml#3719); this PR requires each slot to be absent.
• The exclusive-value pattern (feat(gen-shacl): generate sh:sparql constraints from LinkML rules linkml/linkml#3451) still reads a bare multivalued equals_string as "one of the values", with a warning. Every other rule reads it as "every value" (question 3 on feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989).
• JSON Schema treats [] as present. In RDF an empty list leaves no triple, so the slot counts as absent.
• On a non-inlined reference, a nested condition sees only an id string in JSON. In RDF it checks the referenced node's triples, when the data graph has them.

Limitations

• One postcondition slot only. Rules with several are skipped (gen-shacl rules: translate rules with several postcondition slots #47).
• Not supported: pattern, equals_number, cardinalities, and slot-level any_of / none_of.
• Ill-typed literals: rdflib's isNumeric returns true for literals such as "abc"^^xsd:integer, so they are still compared. The property shape reports them anyway.

Testing

• Agreement with JSON Schema: 61 rule and instance pairs, plus open-world, equivalent-guard and conjunction cases. Each instance is validated by the generated JSON Schema and, through the generated JSON-LD context, by the generated SHACL. The verdicts must agree, for the declaring class and for a subclass.
• Explicit pyshacl expectations where jsonschemagen differs or has no counterpart:
  • has_member;
  • several ABSENT conditions;
  • references;
  • sh:value;
  • booleans;
  • all 16 numeric datatypes, with non-numeric types and values;
  • every skip reason.
• Mutation testing: 41 mutants of the new code, all killed.

Upstream stack: linkml#3989 → linkml#3990 → linkml#3991 (docs).
Fork stack: #19 → #20 → #23 (docs) and #35 (tests).

[jdsika]

Adversarial audit findings (fallback converters, audited at stack tip incl. the hardening PR)

Findings demonstrated with pyshacl end-to-end probes against the stack tip; all apply equally to the consolidated branch of #18.

B1 — real bug: M4/M5 inner-slot paths resolve against the OUTER class.
_member_conditions calls self._slot_uri(sv, inner_name, cls) with the container class, but the inner slot lives on the container slot's range class (the neighboring _resolve_member_enum_ref gets this right for enums; the path resolution does not). Two demonstrated failure modes:

• False negative: child class overrides the inner slot's slot_uri via slot_usage → sh:path on the child shape uses the overridden IRI, the SPARQL body queries the base IRI → the constraint silently never fires.
• False positive: the inner slot name also exists on the outer class with a different slot_usage URI → the outer induced slot wins, the member pattern queries a predicate no member has, FILTER NOT EXISTS is vacuously true → conforming data flagged.
  Related: _resolve_member_enum_ref uses sv.get_slot(container_slot_name) (non-induced), so a slot_usage range-narrowing of the container slot on the outer class resolves enum values against the wrong enum.
  Fix direction: resolve inner_name (and the container range) against the container slot's induced range class, mirroring what _resolve_member_enum_ref does for enums.

B2 — real bug: recognized+unrecognized operator mixes are silently under-translated → false positives (contract violation).
The hardening PR fixed combining of recognized scalar operators, but a condition mixing a recognized with an unrecognized operator still translates with the unrecognized conjunct dropped: {equals_string: fog, pattern: "^f.*"} emits only the equals filter; expression-level any_of/all_of/none_of on pre/postconditions are ignored entirely (demonstrated: dropping an any_of precondition conjunct widened the trigger and pyshacl flagged a conforming instance). Postcondition side drops conjuncts too ({required: true, pattern: ...} → only required).
Fix direction: enumerate the set fields on each condition/expression and return None (skip) if anything outside the supported set is present.

B3 — real bug (artifact-poisoning edge): _sparql_number renders non-numeric bounds raw.
minimum_value/maximum_value have metamodel range Anything (the docstring's "LinkML parses as int or float" is incorrect). Demonstrated: minimum_value: "abc" → FILTER ( ?pre0 >= abc ) → pyshacl raises ParseException on every validation run against the generated shapes graph (one bad bound poisons validation of all data); a YAML date 2020-01-01 parses as the arithmetic expression 2020−01−01 = 2018 → constraint silently never fires; .nan/.inf also unparseable.
Fix direction: gate on isinstance(value, (int, float)) and not isinstance(value, bool) (covers the extended_* runtime subclasses) and propagate a skip otherwise.

B4 — edge case: elseconditions silently dropped.
bidirectional/open_world rules get explicit logger.warnings, but a rule with elseconditions is translated forward-only with no signal at all (the rule isn't skipped, so the DEBUG skip log doesn't fire). Demonstrated: a node failing only the else branch conforms.
Fix direction: warn (or skip) when elseconditions is set, consistent with the neighboring warnings.

Verified clean (attacked, held up): M2 conjunction semantics for multivalued slots (correct existential violation, deduplicated reports); M3 numeric promotion for well-typed data; M5 zero-member semantics (flagged, as "must contain a member" requires — though no test locks this in: suggest adding a zero-member violating instance); variable namespaces (?pre{i}/?post/?mem) are collision-free; deactivated/bidirectional handled before the fallback; pure value_presence: ABSENT preconditions are correctly rejected (skip).

Suggest addressing B1–B3 as a follow-up commit on this stack before upstreaming; the probe scripts are reusable as regression-test seeds.

[jdsika]

Status (head c89faac, mirrored as linkml#3990): all four findings are fixed in this PR's single commit. #21 and #22 were closed unmerged, and their fixes were folded into that commit.

• B1: inner slots resolve on the container slot's range class. Test: test_compose_inner_slot_resolved_on_range_class.
• B2: each condition may use only supported operators, and expression-level operators skip the rule. Tests: test_compose_untranslatable_rule_skipped, test_rule_expression_level_operator_skipped.
• B3: bounds must be finite numbers on a numeric range. Tests: test_compose_non_numeric_bound_skipped, test_compose_bounds_only_on_numeric_ranges.
• B4: elseconditions now triggers a warning. Test: test_rule_problems_reported_per_rule_and_per_problem.

Two "verified clean" statements above no longer describe the code:

• a pure value_presence: ABSENT precondition is now translated;
• multivalued preconditions read every value (Rules: value operators on a multivalued slot in rule conditions mean "every value" in some generators and "some value" in others #41).

[jdsika]

Mirrored upstream as linkml#3990.