[jdsika]

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

Proposed upstream description (2026-10-30), not yet applied to linkml#4028; it is copied there after review.

Merge order of this series: linkml#3716 → linkml#4168 → linkml#3993 → linkml#4144 → linkml#4171 → linkml#3989 → linkml#3990 → linkml#4156 → linkml#4157 → linkml#4158 → linkml#4028 → linkml#4169 → linkml#4170 → linkml#3446. A stack is rebased when its base lands.

Read first: generators/common/class_expression.py (150 lines, the shared semantics), then shaclgen.py (430) and jsonschemagen.py (174); the rest is tests, snapshots and docs.

Summary

Class-level any_of, all_of, exactly_one_of and none_of now mean the same in gen-shacl and gen-json-schema.

• gen-shacl used to drop them silently, so a class stating "a code or a name is required" got shapes that accepted everything.
• gen-json-schema translated them only for the declaring class, and read absent slots differently depending on nesting.

GeodeticReferenceSystem:
  slots: [code, name]
  any_of:
    - slot_conditions: {code: {required: true}}
    - slot_conditions: {name: {required: true}}

This becomes sh:or ( [sh:property [sh:path ex:code ; sh:minCount 1]] … ) and JSON Schema anyOf, on this class and on every subclass.

Semantics

The semantics live in one shared module, linkml.generators.common.class_expression, so the generators can't drift apart.

• Inheritance: a class carries the expressions of its ancestors and mixins, translated in its own context, so slot_usage applies.

• Absent slots: the spec doesn't define what a slot condition means for an absent slot (Specification: define what a slot condition means for an absent slot in class-level boolean expressions #49). This PR reads it as an SQL CHECK constraint reads null (ISO/IEC 9075 §4.10.2: "satisfied if and only if the specified search condition is not false"):

  • a condition that doesn't decide whether its slot may be absent is unknown;
  • an instance is invalid only when an expression is definitely false.

  The deciding conditions are value_presence: PRESENT / ABSENT, required: true, a minimum or exact cardinality ≥ 1, and a maximum or exact cardinality of 0.

• exactly_one_of: holds when exactly one member is definitely true, whatever the others are. This is what sh:xone and oneOf compute over the members' "definitely true" forms. It is stricter than a Kleene reading, which would leave {} and an instance meeting no member unknown, and so valid; the compliance suite's exactly_one_of cases decide neither way, because their members use required.

Expression	{}	{label: A}	{label: B}
any_of: [label = A]	valid	valid	invalid
none_of: [label = A]	valid	invalid	valid
exactly_one_of: [label = A, note = B]	invalid	valid	invalid

Why this reading:

• It composes. all_of: [none_of: [X]] means none_of: [X], and none_of: [none_of: [X]] means X.
• It keeps the compliance suite's expectations that all-absent instances are valid.
• It fixes gen-json-schema's exactly_one_of, which rejected {label: A} and accepted {label: B}.

The vacuous reading (JSON Schema properties, SHACL Core) and the existential one (XPath, ShEx) each contradict the compliance suite.

• is_a: a member's is_a is read through class membership: it adds nothing for a class every instance belongs to, sh:class / a $ref for a class some instances belong to through a descendant, and a shape nothing conforms to for any other class. A linkml:Any class stays undetermined.

Rules keep their closed-world reading (linkml#3989, linkml#3990).

Translation

• gen-shacl:
  • emits sh:or / sh:and / sh:xone / sh:not over anonymous member shapes. These are the operators' exact_mappings (SHACL §4.6).
  • Each expression is emitted in its "not false" form; under sh:not, in its "definitely true" form, where a non-deciding condition adds sh:minCount 1.
  • An is_a member names a class every instance of the shape's class belongs to (nothing is emitted), one that only some belong to through a descendant (sh:class, or sh:node with native names), or one that none belongs to (a shape nothing conforms to). An instance belongs to its class and that class's ancestors, by is_a and by mixins; a class that may also be another is declared as a subclass with that mixin.
  • exactly_one_of becomes sh:xone over the "definitely true" member forms.
  • A single-valued parameter needed twice goes into sh:and (§2.1.1).
• gen-json-schema:
  • builds the same forms with anyOf / allOf / oneOf / not;
  • resolves conditions on the induced slot;
  • reads an is_a member the same way; where only some instances belong to the class, the instance must match that class's definition, since a JSON object carries no type.
  • now also enforces cardinalities (minItems / maxItems, or minProperties / maxProperties for a slot inlined as a dict, whose values are the values of the dict) and range in class-level conditions.
  • value_presence: ABSENT on several slots requires each to be absent, rules included (fixes gen-json-schema: multiple value_presence: ABSENT postconditions in one rule compile to "not both present" instead of "neither present" linkml/linkml#3719).
• Untranslatable members (for example has_member or a slot-level boolean inside a condition): gen-shacl skips the operator whole, with one warning naming the affected shapes.

Areas of uncertainty

• Inheritance: class-level expressions now apply to subclasses in gen-json-schema too (it applied them only to the declaring class). This is feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989's question 1, for expressions.
• Absent slots: expressions are three-valued here, rules closed-world (feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989, feat(gen-shacl): add a compositional fallback for rule-to-SPARQL conversion linkml/linkml#3990); one decision for both would be better.
• Shared helpers: _type_uri, _is_string_range, _slot_iri, _set_operator_fields and _NON_OPERATOR_FIELDS are identical in feat(gen-shacl): translate presence-implies-value rules to SHACL-SPARQL linkml/linkml#3989; whichever of the two lands second drops its copies when rebased.

Testing

• Out-of-tree check during development: 15,222 fuzzed instances over 360 random class expressions, nested two levels deep, over string, integer, enum and multivalued slots. gen-shacl and gen-json-schema agreed on every one, both matched an independent three-valued model, and every shapes graph passed meta-SHACL. That harness is not part of this PR; the reproducible evidence is below.
• test_shaclgen.py:
  • a semantics table where SHACL = JSON Schema = expected (39 cases);
  • inheritance: subclasses, mixins, slot_usage, shared class_uri, warnings;
  • skip paths and mapping structure.
• test_jsonschemagen.py: inheritance, several ABSENT slots, conditions on induced slots.
• Mutation testing: 23 mutants, 21 killed; the other 2 are equivalent.
• Compliance: test_class_any_of, test_class_any_of_with_required and test_class_boolean_with_expressions now run for SHACL; the last skips the schemas whose harness data writes a reference as an untyped node, which the slot's sh:class rejects.

Behaviour changes in gen-json-schema

• Subclasses now inherit class expressions (gen-json-schema: class-level any_of / all_of / exactly_one_of / none_of are not applied to subclasses #48).
• Nested negations, and exactly_one_of with absent slots, follow the table above.
• Class-level conditions now enforce their cardinalities and range.

owlgen is unchanged. OWL is open-world and can't express closed-world presence.

Closes #48 (class expressions not applied to subclasses in gen-json-schema).

Follow-ups: #49 (spec: absent-slot semantics) and #50 (spec: two-operand none_of is NOR, not XOR).