fix(owlgen): skip covering axiom for abstract class with single child

The covering axiom code emits AbstractClass rdfs:subClassOf unionOf(children)
for abstract classes.  When there is exactly one child, _union_of([C]) returns
the child URI directly (single-element optimisation in _boolean_expression),
producing the bare triple AbstractClass rdfs:subClassOf Child.

Combined with the already-present Child rdfs:subClassOf AbstractClass (from
the is_a declaration), this creates a bidirectional rdfs:subClassOf -- which
per W3C OWL 2 Primer section 4.2 is semantically identical to owl:equivalentClass.
This unintended equivalence causes any class later added as a second child of
the abstract parent to inherit all constraints of the first child via RDFS
transitivity.

Fix: change 'if children:' to 'if len(children) > 1:' so the covering axiom
is only emitted when the union is meaningful (>= 2 members).  Also update the
field docstring and CLI help text to reflect the new >= 2 threshold, add
regression tests to the existing test_owlgen.py module, and update OWL
snapshots (meta.owl, biolink.owl.ttl).

Refs:
- W3C OWL 2 Primer section 4.2 (bidirectional SubClassOf = EquivalentClasses)
- W3C OWL 2 Syntax section 9.1.4 (DisjointUnion as proper covering construct)

Signed-off-by: jdsika <carlo.van-driesten@bmw.de>

Author: jdsika

packages/linkml/src/linkml/generators/owlgen.py

@@ -198,10 +198,11 @@ class OwlSchemaGenerator(Generator):
     skip_abstract_class_as_unionof_subclasses: bool = False
     """If True, suppress the generation of ``rdfs:subClassOf owl:unionOf(subclasses)`` covering axioms
     for abstract classes.  By default such axioms are emitted: for every abstract class that has at least
-    one direct ``is_a`` child, the generator adds
+    two direct ``is_a`` children, the generator adds
     ``AbstractClass rdfs:subClassOf (Child1 or Child2 or …)``, expressing the open-world covering
     constraint that every instance of the abstract class must also be an instance of one of its
-    direct subclasses."""
+    direct subclasses.  (Single-child abstract classes are excluded because the covering axiom
+    would degenerate to equivalence — see the inline comment in ``add_class`` for details.)"""
 
     def as_graph(self) -> Graph:
         """
@@ -469,9 +470,14 @@ def condition_to_bnode(expr: AnonymousClassExpression) -> BNode | None:
         # Abstract covering axiom: abstract class rdfs:subClassOf (child1 or child2 or …)
         # This expresses the open-world constraint that every instance of the abstract class
         # must be an instance of at least one of its direct subclasses.
+        # Guard: require ≥ 2 children.  With exactly one child C, _union_of([C]) returns the
+        # URI directly (single-element optimisation), which would produce the spurious triple
+        # `AbstractClass rdfs:subClassOf C` — reversing the intended hierarchy.  Even
+        # wrapping a single child in owl:unionOf would assert equivalence (A ⊑ C ∧ C ⊑ A),
+        # which is too strong for extensible ontologies where more children may be added later.
         if cls.abstract and not self.skip_abstract_class_as_unionof_subclasses:
             children = sorted(sv.class_children(cls.name, imports=self.mergeimports, mixins=False, is_a=True))
-            if children:
+            if len(children) > 1:
                 child_uris = [self._class_uri(child) for child in children]
                 union_node = self._union_of(child_uris)
                 self.graph.add((cls_uri, RDFS.subClassOf, union_node))
@@ -1569,7 +1575,7 @@ def slot_owl_type(self, slot: SlotDefinition) -> URIRef:
     show_default=True,
     help=(
         "If true, suppress rdfs:subClassOf owl:unionOf(subclasses) covering axioms for abstract classes. "
-        "By default such axioms are emitted for every abstract class that has direct is_a children."
+        "By default such axioms are emitted for every abstract class that has two or more direct is_a children."
     ),
 )
 @click.version_option(__version__, "-V", "--version")

tests/linkml/test_base/__snapshots__/meta.owl

@@ -87,7 +87,6 @@ linkml:value_specification_constant a owl:ObjectProperty,
 linkml:ClassLevelRule a owl:Class,
         linkml:ClassDefinition ;
     rdfs:label "class_level_rule" ;
-    rdfs:subClassOf linkml:ClassRule ;
     skos:definition "A rule that is applied to classes" ;
     skos:inScheme linkml:meta .
 

tests/linkml/test_biolink_model/__snapshots__/biolink.owl.ttl

@@ -1729,7 +1729,6 @@ biolink:xenologous_to a owl:ObjectProperty,
 biolink:Annotation a owl:Class,
         linkml:ClassDefinition ;
     rdfs:label "annotation" ;
-    rdfs:subClassOf biolink:QuantityValue ;
     skos:definition "Biolink Model root class for entity annotations." ;
     skos:inScheme <https://w3id.org/biolink/biolink-model> .
 
@@ -7903,8 +7902,7 @@ biolink:ActivityAndBehavior a owl:Class,
 biolink:AdministrativeEntity a owl:Class,
         linkml:ClassDefinition ;
     rdfs:label "administrative entity" ;
-    rdfs:subClassOf biolink:Agent,
-        biolink:NamedThing ;
+    rdfs:subClassOf biolink:NamedThing ;
     skos:inScheme <https://w3id.org/biolink/biolink-model> .
 
 biolink:AnatomicalEntityToAnatomicalEntityOntogenicAssociation a owl:Class,

tests/linkml/test_generators/test_owlgen.py

@@ -460,6 +460,77 @@ def test_abstract_class_without_subclasses_gets_no_union_of_axiom():
     assert _union_members(g, EX.Orphan) is None
 
 
+def test_abstract_class_with_single_child_gets_no_covering_axiom():
+    """An abstract class with exactly one is_a child must NOT get a covering axiom.
+
+    Regression test: _union_of([single_child]) returns the child URI directly
+    (single-element optimisation in _boolean_expression), which would produce
+    ``Parent rdfs:subClassOf Child`` — reversing the intended hierarchy and
+    creating an unintended equivalence (Parent ≡ Child).
+
+    Per OWL 2 Primer §4.2, bidirectional rdfs:subClassOf is equivalent to
+    owl:equivalentClass.  Combined with the existing ``Child rdfs:subClassOf
+    Parent`` (from is_a), this makes the two classes identical, causing any
+    downstream schema that adds a second child (e.g. harbour's NaturalPerson
+    is_a Participant) to inherit all constraints of the first child
+    (LegalPerson.registrationNumber etc.).
+
+    See: W3C OWL 2 Syntax §9.1.4 (DisjointUnion) for the proper covering
+    construct.
+    """
+    sb = SchemaBuilder()
+    sb.add_class("GrandParent")
+    sb.add_class("Parent", is_a="GrandParent", abstract=True)
+    sb.add_class("Child", is_a="Parent")
+    sb.add_defaults()
+    g = _owl_graph(sb)
+
+    # Must NOT have Parent rdfs:subClassOf Child (the buggy triple)
+    assert (EX.Parent, RDFS.subClassOf, EX.Child) not in g, (
+        "Abstract class with single child must not get a covering axiom that "
+        "reverses the hierarchy (Parent rdfs:subClassOf Child)"
+    )
+    # Must still have the correct hierarchy
+    assert (EX.Parent, RDFS.subClassOf, EX.GrandParent) in g
+    assert (EX.Child, RDFS.subClassOf, EX.Parent) in g
+    # No union-of axiom either
+    assert _union_members(g, EX.Parent) is None
+
+
+def test_single_child_covering_axiom_does_not_create_transitive_equivalence():
+    """Downstream extensions must not inherit sibling constraints via a buggy covering axiom.
+
+    Simulates an extensible ontology: GrandParent → Parent (abstract) → Child.
+    A downstream schema adds Child2 is_a Parent.  With the old bug, the covering
+    axiom would create Parent ≡ Child, so Child2 would transitively become a
+    subclass of Child — inheriting all of Child's constraints.
+
+    Per W3C OWL 2 Primer §4.2, bidirectional rdfs:subClassOf is equivalent to
+    owl:equivalentClass.
+    """
+    sb = SchemaBuilder()
+    sb.add_class("GrandParent")
+    sb.add_class("Parent", is_a="GrandParent", abstract=True)
+    sb.add_class("Child", is_a="Parent")
+    sb.add_defaults()
+    g = _owl_graph(sb)
+
+    # Simulate a downstream extension adding Child2 is_a Parent
+    g.add((EX.Child2, RDF.type, OWL.Class))
+    g.add((EX.Child2, RDFS.subClassOf, EX.Parent))
+
+    # Walk 2 levels of rdfs:subClassOf to check transitive reach
+    child2_supers = set()
+    for mid in g.objects(EX.Child2, RDFS.subClassOf):
+        child2_supers.add(mid)
+        for top in g.objects(mid, RDFS.subClassOf):
+            child2_supers.add(top)
+
+    assert EX.Child not in child2_supers, "Child2 became a subclass of Child via unintended equivalence Parent ≡ Child"
+    assert EX.Parent in child2_supers
+    assert EX.GrandParent in child2_supers
+
+
 @pytest.mark.parametrize("skip", [False, True])
 def test_union_of_axiom_only_covers_direct_children(skip: bool):
     """Union-of axiom lists only direct is_a children, not grandchildren.