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.

2026-10-13: rebased onto the updated linkml#3989 and signed off. Since the last review round: rules with several postcondition slots are translated, with one constraint per slot; the compliance suite runs SHACL for rules; the tests for nested range_expression postconditions are included; and linkml#3989 now reads a bare equals_string as "every value" too, so all rules agree.

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. Each postcondition slot gets its own constraint: the union of the ways to violate that slot's condition, with the offending value bound to ?value. A rule P → A ∧ B is violated exactly when P ∧ ¬A or P ∧ ¬B holds (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. 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. This reading is the decision recorded in Rules: value operators on a multivalued slot in rule conditions mean "every value" in some generators and "some value" in others #41, and feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989 follows it too. 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.
• 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

• 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.
• Several postcondition slots: agreement with JSON Schema for each slot failing alone and both failing, a slot absent, the precondition unmet, and open_world. Each violated slot is reported with its own sh:resultPath.
• Nested range_expression postconditions: open_world with an omitted or empty wrapper, an empty wrapper in a closed world, a multivalued wrapper with one failing member (checked against JSON Schema in the class and a subclass), an enum value with a meaning resolved on the range class, and a condition on the range class's identifier, which is skipped with a warning.
• Compliance suite: the three rule tests in test_boolean_slot_compliance.py now run SHACL. A rule gen-shacl translates is checked for every instance; for a rule it skips, only valid instances are checked.
• Mutation testing: 41 mutants of the code before this revision, all killed.

Closes #39 (compliance runs SHACL for rules) and closes #47 (rules with several postcondition slots).

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

[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 c48bb2a, 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.