diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 9a332f7..d522e05 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -25,7 +25,7 @@ jobs:
           python-version: "3.10"
 
       - name: Install test dependencies
-        run: python -m pip install "ifcopenshell[advanced]" pytest pyparsing
+        run: python -m pip install "ifcopenshell[advanced]" pytest pyparsing rdflib tabulate xlsxwriter
 
       - name: Install the checked-out MVD modules
         shell: bash
diff --git a/README.md b/README.md
index 9535dab..53c2158 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,13 @@ concept templates returns a tuple of `template` objects instead. Invalid XML
 and missing template references raise `ValueError` with the relevant document
 or template identifier. Recursive template branches are expanded once.
 
+When a referenced template's `applicableEntity` differs from its anchor entity,
+the parsed tree includes an additional `EntityRule` for that type. Consecutive
+entity rules apply to the same IFC instance; sibling entity rules are alternative
+specializations. Matching roots are expanded without an extra rule. This keeps
+type restrictions visible to traversal, extraction and SPARQL conversion.
+Serialization writes these restrictions as partial-template references again.
+
 ### Graphviz concept templates
 
 The lightweight concept graphs used by the buildingSMART IFC4.x documentation
diff --git a/graphviz.py b/graphviz.py
index a75e5dd..f046b17 100644
--- a/graphviz.py
+++ b/graphviz.py
@@ -76,15 +76,18 @@ def parse(
     root = min(graph.in_degree(), key=lambda item: item[1])[0]
     resolved_references = _reference_lookup(references or {})
 
-    def build(node: str, top_level_attribute: bool = False) -> tuple[rule, ...]:
+    def build(node: str, top_level_attribute: bool = False, anchor: str = "") -> tuple[rule, ...]:
         node_type = graph.nodes[node].get("type", "EntityRule")
         if node_type == "Reference":
             try:
-                return resolved_references[_normalise_reference(node)].rules
+                referenced = resolved_references[_normalise_reference(node)]
             except KeyError as error:
                 raise ValueError(
                     f"Unknown Graphviz template reference: {node}"
                 ) from error
+            if referenced.entity and referenced.entity.casefold() != anchor.casefold():
+                return (rule("EntityRule", referenced.entity, referenced.rules),)
+            return referenced.rules
 
         if node_type == "Constraint":
             try:
@@ -99,6 +102,7 @@ def build(node: str, top_level_attribute: bool = False) -> tuple[rule, ...]:
             itertools.chain.from_iterable(
                 build(
                     child,
+                    anchor=node.split("_", 1)[0] if node_type == "EntityRule" else anchor,
                     top_level_attribute=(
                         node == root
                         and graph.nodes[child].get("type") == "AttributeRule"
diff --git a/model.py b/model.py
index 8dda104..02067b1 100644
--- a/model.py
+++ b/model.py
@@ -167,7 +167,22 @@ def extract(self, ifc_data: ifcopenshell.entity_instance | Any) -> extracted_dat
                 return []
 
             to_combine: list[extracted_data] = []
+            # Sibling entity rules represent alternative specializations of
+            # this instance, just as entity rules under an attribute do.
+            entity_alternatives = [
+                child for child in self.nodes if child.tag == "EntityRule"
+            ]
+            if entity_alternatives:
+                to_combine.append(
+                    [
+                        values
+                        for child in entity_alternatives
+                        for values in child.extract(ifc_data)
+                    ]
+                )
             for child in self.nodes:
+                if child.tag == "EntityRule":
+                    continue
                 if child.tag == "Constraint":
                     on_node = child.attribute[0][0].c.replace("'", "")
                     if isinstance(ifc_data, ifcopenshell.entity_instance):
@@ -249,12 +264,18 @@ def extract(self, ifc_data: ifcopenshell.entity_instance | Any) -> extracted_dat
     def binding_for(self, target: rule) -> str | None:
         binding: str | None = None
 
-        def find(rule: rule, parent: rule | None) -> None:
+        def find(rule: rule, parents: tuple[rule | None, ...]) -> None:
             nonlocal binding
             if rule is target:
-                binding = rule.bind or (parent.bind if parent else None)
-
-        self.traverse(find)
+                binding = rule.bind
+                for parent in reversed(parents):
+                    if binding or parent is None:
+                        break
+                    binding = parent.bind
+                    if parent.tag != "EntityRule":
+                        break
+
+        self.traverse(find, with_parents=True)
         return binding
 
 
diff --git a/mvd.py b/mvd.py
index 6f3d83d..bb9c84e 100644
--- a/mvd.py
+++ b/mvd.py
@@ -1,5 +1,6 @@
 import ifcopenshell
 import ifcopenshell.geom
+from .model import rule
 
 import itertools
 import os
@@ -36,6 +37,9 @@ def extract_data(mvd_node, ifc_data):
 
 
     """
+    if isinstance(mvd_node, rule):
+        return mvd_node.extract(ifc_data)
+
     to_combine = []
     return_value = []
 
diff --git a/parser.py b/parser.py
index 663cd77..6401a97 100644
--- a/parser.py
+++ b/parser.py
@@ -42,6 +42,7 @@ def parse_template(
 
         parsed_rules: list[rule] = []
         next_visited = visited | {template_key}
+        entity = root.getAttribute("applicableEntity")
         # Only the template's own <Rules> are in scope. Nested <SubTemplates>
         # form a hierarchy of separate templates, so they must not contribute
         # rules (and therefore entity scope) to the parent template.
@@ -51,7 +52,7 @@ def parse_template(
             for node in _elements(rules_node):
                 # A <References> child unions one or more <Template>
                 # references, so a single child may expand to several rules.
-                parsed_rules.extend(self._visit_rule(node, "", next_visited))
+                parsed_rules.extend(self._visit_rule(node, "", next_visited, entity))
 
         return template(
             entity=(
@@ -70,12 +71,14 @@ def _visit_rule(
         node: Element,
         prefix: str,
         visited: frozenset[str],
+        anchor: str,
     ) -> tuple[rule, ...]:
         attribute: Any = None
         bind: str | None = None
         optional = False
         target = node
         child_prefix = prefix
+        tag = node.localName
 
         if node.localName == "AttributeRule":
             attribute = node.attributes["AttributeName"].value
@@ -89,6 +92,7 @@ def _visit_rule(
                 )
         elif node.localName == "EntityRule":
             attribute = node.attributes["EntityName"].value
+            anchor = attribute
         elif node.localName == "Template":
             reference = node.attributes["ref"].value
             reference_key = reference.casefold()
@@ -103,6 +107,13 @@ def _visit_rule(
             if "IdPrefix" in node.attributes:
                 child_prefix += node.attributes["IdPrefix"].value
             visited = visited | {reference_key}
+            entity = target.getAttribute("applicableEntity")
+            if entity and entity.casefold() != anchor.casefold():
+                # A reference may specialize its anchor without following an
+                # attribute. Keep that type restriction in the rule tree.
+                tag = "EntityRule"
+                attribute = entity
+                anchor = entity
         elif node.localName == "Constraint":
             attribute = mvdxml_expression.parse(node.attributes["Expression"].value)
         elif node.localName in {
@@ -121,13 +132,13 @@ def _visit_rule(
         children = tuple(
             parsed
             for child in _elements(target)
-            for parsed in self._visit_rule(child, child_prefix, visited)
+            for parsed in self._visit_rule(child, child_prefix, visited, anchor)
         )
 
         if attribute is not None:
             return (
                 rule(
-                    tag=node.localName,
+                    tag=tag,
                     attribute=attribute,
                     nodes=children,
                     bind=child_prefix + bind if bind else None,
diff --git a/serializer.py b/serializer.py
index ebfa8e0..3ece585 100644
--- a/serializer.py
+++ b/serializer.py
@@ -52,7 +52,7 @@ def token(value: mvdxml_expression.node | str) -> str:
 }
 
 
-def _rule(parent: ET.Element, value: rule) -> None:
+def _rule(parent: ET.Element, value: rule, referenced: list[tuple[str, template]]) -> None:
     attributes: dict[str, str] = {}
     if value.tag == "AttributeRule":
         attributes = {"AttributeName": str(value.attribute)}
@@ -67,12 +67,30 @@ def _rule(parent: ET.Element, value: rule) -> None:
 
     element = _add(parent, value.tag, **attributes)
     for tag, children in groupby(value.nodes, key=lambda child: child.tag):
+        if value.tag == "EntityRule" and tag == "EntityRule":
+            # Consecutive entity rules are an in-memory type restriction.
+            # Write them as partial-template references in mvdXML.
+            container = _add(element, "References")
+            for child in children:
+                identifier = str(uuid.uuid4())
+                _add(container, "Template", ref=identifier)
+                referenced.append(
+                    (identifier, template(child.attribute, None, child.nodes))
+                )
+            continue
         container = _add(element, _CONTAINERS[tag])
         for child in children:
-            _rule(container, child)
+            _rule(container, child, referenced)
 
 
-def _template(parent: ET.Element, value: template, identifier: str) -> None:
+def _template(
+    parent: ET.Element,
+    value: template,
+    identifier: str,
+    referenced: list[tuple[str, template]],
+    *,
+    partial: bool = False,
+) -> None:
     element = _add(
         parent,
         "ConceptTemplate",
@@ -81,11 +99,12 @@ def _template(parent: ET.Element, value: template, identifier: str) -> None:
         status="sample",
         applicableSchema="IFC4",
         applicableEntity=value.entity,
+        isPartial="true" if partial else None,
     )
     if value.rules:
         rules = _add(element, "Rules")
         for item in value.rules:
-            _rule(rules, item)
+            _rule(rules, item, referenced)
 
 
 def _key(value: template) -> str | int:
@@ -138,8 +157,15 @@ def serialize(items: Iterable[mvd_item], destination: str | Path) -> None:
         {"uuid": str(uuid.uuid4()), "name": "", "status": "sample"},
     )
     template_elements = _add(document, "Templates")
+    referenced: list[tuple[str, template]] = []
     for key, value in templates.items():
-        _template(template_elements, value, template_ids[key])
+        _template(template_elements, value, template_ids[key], referenced)
+    # Serializing a partial template can discover further specializations.
+    index = 0
+    while index < len(referenced):
+        identifier, value = referenced[index]
+        _template(template_elements, value, identifier, referenced, partial=True)
+        index += 1
 
     roots = [item for item in parsed if isinstance(item, concept_root)]
     if roots:
diff --git a/sparql.py b/sparql.py
index af5bedd..6136730 100644
--- a/sparql.py
+++ b/sparql.py
@@ -59,9 +59,12 @@ def withschema(fn):
 
     def _(*args, **kwargs):
         schema_name = STANDARD_PREFIXES["ifcowl"].split("/")[-1][:-2]
-        if "_" in schema_name:
-            schema_name = schema_name.split("_")[0]
-        S = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name)
+        try:
+            S = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name)
+        except RuntimeError:
+            if "_" not in schema_name:
+                raise
+            S = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name.split("_")[0])
         return fn(S, *args, **kwargs)
 
     return _
@@ -365,6 +368,18 @@ def build(rule, parents):
                 return_value = lambda: bld.append(INDENT + "}")
 
             if rule.tag == "EntityRule":
+                siblings = [
+                    child
+                    for child in getattr(parents[-1], "nodes", ())
+                    if child.tag == "EntityRule"
+                ]
+                if len(siblings) > 1:
+                    bld.append(INDENT + "{")
+
+                    def close_alternative():
+                        bld.append(INDENT + ("} UNION" if rule is not siblings[-1] else "}"))
+
+                    return_value = close_alternative
                 # G.nm = G.next_nm
 
                 if not ifcOwl.is_select(rule.attribute):
diff --git a/tests/test_specialized_references.py b/tests/test_specialized_references.py
new file mode 100644
index 0000000..5345d98
--- /dev/null
+++ b/tests/test_specialized_references.py
@@ -0,0 +1,409 @@
+# This file was generated with the assistance of an AI coding tool.
+
+"""A Body SweptSolid template restricted to the extrusion partial template.
+
+Both IFC models provide the same profile attributes. Only the referenced root
+type can distinguish the extrusion from the revolution.
+"""
+
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+import ifcopenshell
+import pytest
+from rdflib import Graph, Literal, Namespace, RDF
+
+from ifcopenshell.mvd import concept_or_applicability, parse, rule, serialize, template
+from ifcopenshell.mvd import mvd as legacy
+from ifcopenshell.mvd import sparql
+
+
+def body_template(
+    tmp_path: Path,
+    *,
+    revolved: bool = False,
+    same_root: bool = False,
+    leaf: bool = False,
+    layout: str = "references",
+):
+    partial_entity = "IfcSweptAreaSolid" if same_root else "IfcExtrudedAreaSolid"
+    profile = (
+        """
+      <AttributeRule AttributeName="SweptArea" RuleID="Profile"><EntityRules>
+        <EntityRule EntityName="IfcArbitraryClosedProfileDef"><AttributeRules>
+          <AttributeRule AttributeName="OuterCurve" RuleID="Curve"><EntityRules>
+            <EntityRule EntityName="IfcIndexedPolyCurve" />
+          </EntityRules></AttributeRule>
+        </AttributeRules></EntityRule>
+      </EntityRules></AttributeRule>
+    """
+        if not leaf
+        else ""
+    )
+    references = '<Template ref="extrusion" IdPrefix="E_" />'
+    if revolved:
+        references += '<Template ref="revolution" IdPrefix="R_" />'
+    if layout == "references":
+        item_rules = f'<EntityRule EntityName="IfcSweptAreaSolid"><References>{references}</References></EntityRule>'
+        partials = f"""
+        <ConceptTemplate uuid="extrusion" name="Extruded Area PolyCurve Profile"
+            applicableEntity="{partial_entity}" isPartial="true"><Rules>{profile}</Rules></ConceptTemplate>
+        <ConceptTemplate uuid="revolution" name="Revolved Area PolyCurve Profile"
+            applicableEntity="IfcRevolvedAreaSolid" isPartial="true"><Rules>{profile}</Rules></ConceptTemplate>
+        """
+    else:
+        # Spell out the same branches without any template references. The
+        # chained layout keeps the generalization; direct puts both entity
+        # alternatives immediately below Items' AttributeRule.
+        branches = []
+        for entity, prefix in [(partial_entity, "E_")] + (
+            [("IfcRevolvedAreaSolid", "R_")] if revolved else []
+        ):
+            attributes = profile.replace('RuleID="', f'RuleID="{prefix}')
+            branches.append(
+                f'<EntityRule EntityName="{entity}"><AttributeRules>{attributes}</AttributeRules></EntityRule>'
+            )
+        item_rules = "".join(branches)
+        if layout == "chained":
+            item_rules = f'<EntityRule EntityName="IfcSweptAreaSolid"><EntityRules>{item_rules}</EntityRules></EntityRule>'
+        partials = ""
+    filename = tmp_path / "body.mvdxml"
+    filename.write_text(
+        f"""<mvdXML xmlns="http://buildingsmart-tech.org/mvd/XML/1.1">
+      <Templates>
+        <ConceptTemplate uuid="body" name="Body SweptSolid PolyCurve Geometry" applicableEntity="IfcWall">
+          <Rules><AttributeRule AttributeName="Representation" RuleID="Representation"><EntityRules>
+            <EntityRule EntityName="IfcProductDefinitionShape"><AttributeRules>
+              <AttributeRule AttributeName="Representations" RuleID="Representations"><EntityRules>
+                <EntityRule EntityName="IfcShapeRepresentation"><AttributeRules>
+                  <AttributeRule AttributeName="Items" RuleID="Geometry"><EntityRules>
+                    {item_rules}
+                  </EntityRules></AttributeRule>
+                </AttributeRules></EntityRule>
+              </EntityRules></AttributeRule>
+            </AttributeRules></EntityRule>
+          </EntityRules></AttributeRule></Rules>
+          <SubTemplates><ConceptTemplate uuid="unrelated" applicableEntity="IfcSphere">
+            <Rules><EntityRule EntityName="IfcSphere" /></Rules>
+          </ConceptTemplate></SubTemplates>
+        </ConceptTemplate>
+        {partials}
+      </Templates>
+    </mvdXML>""",
+        encoding="utf-8",
+    )
+    return next(t for t in parse(filename) if t.uuid == "body")
+
+
+@pytest.fixture
+def geometry_models():
+    models = []
+    for entity in ("IfcExtrudedAreaSolid", "IfcRevolvedAreaSolid"):
+        model = ifcopenshell.file(schema="IFC4X3_ADD2")
+        points = model.create_entity(
+            "IfcCartesianPointList2D",
+            CoordList=((0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (0.0, 0.0)),
+        )
+        curve = model.create_entity("IfcIndexedPolyCurve", Points=points)
+        profile = model.create_entity(
+            "IfcArbitraryClosedProfileDef", ProfileType="AREA", OuterCurve=curve
+        )
+        solid = model.create_entity(entity, SweptArea=profile)
+        representation = model.create_entity("IfcShapeRepresentation", Items=[solid])
+        shape = model.create_entity(
+            "IfcProductDefinitionShape", Representations=[representation]
+        )
+        wall = model.create_entity(
+            "IfcWall", GlobalId=ifcopenshell.guid.new(), Representation=shape
+        )
+        models.append((model, wall))
+    return models
+
+
+def entity_paths(parsed):
+    paths = []
+    parsed.traverse(
+        lambda rule, parents: (
+            paths.append(
+                tuple(parent.attribute for parent in parents if parent)
+                + (rule.attribute,)
+            )
+            if rule.tag == "EntityRule"
+            else None
+        ),
+        with_parents=True,
+    )
+    return paths
+
+
+@pytest.mark.parametrize("leaf", [False, True])
+def test_extrusion_only_filters_revolution_and_traverses_specialization(
+    tmp_path, geometry_models, leaf
+):
+    parsed = body_template(tmp_path, leaf=leaf)
+    extrusion, revolution = [wall for _, wall in geometry_models]
+    assert parsed.extract(extrusion)
+    assert parsed.extract(revolution) == []
+    assert legacy.extract_data(parsed.root_rule(), extrusion)
+    assert legacy.extract_data(parsed.root_rule(), revolution) == []
+    paths = entity_paths(parsed)
+    assert any(
+        path[-2:] == ("IfcSweptAreaSolid", "IfcExtrudedAreaSolid") for path in paths
+    )
+    assert not any(
+        "IfcRevolvedAreaSolid" in path or "IfcSphere" in path for path in paths
+    )
+    if not leaf:
+        assert any(
+            path[-4:]
+            == (
+                "IfcSweptAreaSolid",
+                "IfcExtrudedAreaSolid",
+                "SweptArea",
+                "IfcArbitraryClosedProfileDef",
+            )
+            for path in paths
+        )
+        bindings = []
+        parsed.traverse(lambda rule, parent: bindings.append(rule.bind))
+        assert "E_Profile" in bindings
+
+
+def test_traversal_close_callbacks_remain_balanced(tmp_path):
+    parsed = body_template(tmp_path)
+    stack = []
+
+    def visit(rule, parent):
+        if stack:
+            assert parent is stack[-1]
+        stack.append(rule)
+
+        def close():
+            assert stack.pop() is rule
+
+        return close
+
+    parsed.traverse(visit)
+    assert not stack
+
+
+def test_same_root_is_not_wrapped(tmp_path, geometry_models):
+    parsed = body_template(tmp_path, same_root=True)
+    assert all(
+        path[-2:] != ("IfcSweptAreaSolid", "IfcSweptAreaSolid")
+        for path in entity_paths(parsed)
+    )
+    assert all(parsed.extract(wall) for _, wall in geometry_models)
+
+
+def test_nested_references_track_anchor_and_compose_prefixes(tmp_path, geometry_models):
+    filename = tmp_path / "nested.mvdxml"
+    filename.write_text(
+        """<mvdXML xmlns="http://buildingsmart-tech.org/mvd/XML/1.1">
+      <Templates>
+        <ConceptTemplate uuid="main" applicableEntity="IfcSweptAreaSolid">
+          <Rules><References><Template ref="bridge" IdPrefix="B_" /></References></Rules>
+        </ConceptTemplate>
+        <ConceptTemplate uuid="bridge" applicableEntity="IfcSweptAreaSolid" isPartial="true">
+          <Rules><References><Template ref="extrusion" IdPrefix="E_" /></References></Rules>
+        </ConceptTemplate>
+        <ConceptTemplate uuid="extrusion" applicableEntity="IfcExtrudedAreaSolid" isPartial="true">
+          <Rules><References><Template ref="profile" IdPrefix="P_" /></References></Rules>
+        </ConceptTemplate>
+        <ConceptTemplate uuid="profile" applicableEntity="IfcExtrudedAreaSolid" isPartial="true">
+          <Rules><AttributeRule AttributeName="SweptArea" RuleID="Profile" /></Rules>
+        </ConceptTemplate>
+      </Templates>
+    </mvdXML>""",
+        encoding="utf-8",
+    )
+    parsed = parse(filename)[0]
+    assert entity_paths(parsed) == [("IfcExtrudedAreaSolid",)]
+    assert parsed.rules[0].nodes[0].bind == "B_E_P_Profile"
+    solids = [model.by_type("IfcSweptAreaSolid")[0] for model, _ in geometry_models]
+    assert [bool(parsed.extract(solid)) for solid in solids] == [True, False]
+
+
+def test_multiple_specializations_are_alternatives(tmp_path, geometry_models):
+    parsed = body_template(tmp_path, revolved=True)
+    assert all(parsed.extract(wall) for _, wall in geometry_models)
+    paths = entity_paths(parsed)
+    for entity in ("IfcExtrudedAreaSolid", "IfcRevolvedAreaSolid"):
+        assert any(path[-2:] == ("IfcSweptAreaSolid", entity) for path in paths)
+
+
+@pytest.mark.parametrize("revolved", [False, True])
+@pytest.mark.parametrize("leaf", [False, True])
+def test_references_chained_entities_and_direct_attribute_entities_are_equivalent(
+    tmp_path, geometry_models, monkeypatch, revolved, leaf
+):
+    """Entity alternatives have the same semantics with or without references.
+
+    references: Items -> IfcSweptAreaSolid -> partial-template references
+    chained:    Items -> IfcSweptAreaSolid -> explicit specialized EntityRules
+    direct:     Items -> explicit specialized EntityRules
+
+    Exercise both the extrusion-only restriction and extrusion OR revolution,
+    comparing actual extracted bindings and SPARQL rows, not only match flags.
+    """
+    monkeypatch.setitem(
+        sparql.STANDARD_PREFIXES, "ifcowl", "<http://example.org/IFC4X3_ADD2#>"
+    )
+    extraction = {}
+    query_results = {}
+    paths = {}
+    for layout in ("references", "chained", "direct"):
+        directory = tmp_path / layout
+        directory.mkdir()
+        parsed = body_template(directory, revolved=revolved, leaf=leaf, layout=layout)
+        if layout != "references":
+            document = ET.parse(directory / "body.mvdxml")
+            assert not document.findall(".//{*}Template")
+        paths[layout] = entity_paths(parsed)
+        extraction[layout] = [
+            [
+                {parsed.binding_for(key): value for key, value in values.items()}
+                for values in parsed.extract(wall)
+            ]
+            for _, wall in geometry_models
+        ]
+        assert [bool(values) for values in extraction[layout]] == [True, revolved]
+        query = sparql.convertor.template(parsed)
+        query.bind(sparql.STANDARD_PREFIXES)
+        query_results[layout] = [
+            [row.asdict() for row in owl_graph(model).query(str(query))]
+            for model, _ in geometry_models
+        ]
+        assert [bool(rows) for rows in query_results[layout]] == [True, revolved]
+
+    assert extraction["references"] == extraction["chained"] == extraction["direct"]
+    assert (
+        query_results["references"]
+        == query_results["chained"]
+        == query_results["direct"]
+    )
+    assert paths["references"] == paths["chained"]
+    # Direct alternatives omit only the redundant generalization in traversal.
+    assert paths["direct"] == [
+        tuple(step for step in path if step != "IfcSweptAreaSolid")
+        for path in paths["references"]
+        if path[-1] != "IfcSweptAreaSolid"
+    ]
+
+
+@pytest.mark.parametrize("revolved", [False, True])
+def test_serialize_roundtrip_preserves_type_restriction(
+    tmp_path, geometry_models, revolved
+):
+    parsed = body_template(tmp_path, revolved=revolved)
+    filename = tmp_path / "roundtrip.mvdxml"
+    serialize([parsed], filename)
+    ns = {"m": "http://buildingsmart-tech.org/mvd/XML/1.1"}
+    document = ET.parse(filename)
+    assert not document.findall(".//m:EntityRule/m:EntityRules", ns)
+    assert document.findall('.//m:ConceptTemplate[@isPartial="true"]', ns)
+    restored = parse(filename)[0]
+    assert entity_paths(restored) == entity_paths(parsed)
+    assert [bool(restored.extract(wall)) for _, wall in geometry_models] == [
+        True,
+        revolved,
+    ]
+
+
+def test_binding_passes_through_specialization_for_validation(
+    tmp_path, geometry_models
+):
+    parsed = body_template(tmp_path, leaf=True)
+    leaf = []
+    parsed.traverse(
+        lambda rule, parent: (
+            leaf.append(rule) if rule.attribute == "IfcExtrudedAreaSolid" else None
+        )
+    )
+    assert parsed.binding_for(leaf[0]) == "Geometry"
+    from ifcopenshell.mvd.mvdxml_expression import parse as parse_expression
+
+    concept = concept_or_applicability(
+        "Geometry",
+        parsed,
+        template_rules=(parse_expression("Geometry[Type]=IfcExtrudedAreaSolid"),),
+    )
+    assert concept.validate(parsed.extract(geometry_models[0][1]))[0]
+
+
+@pytest.mark.parametrize("same_root", [False, True])
+def test_graphviz_reference_matches_xml_specialization(
+    tmp_path, geometry_models, same_root
+):
+    partial = template(
+        "IfcSweptAreaSolid" if same_root else "IfcExtrudedAreaSolid",
+        "Extrusion",
+        (rule("AttributeRule", "SweptArea", (rule("EntityRule", "IfcProfileDef"),)),),
+    )
+    parsed = template.from_graphviz(
+        """```
+concept {
+    IfcWall:Representation -> IfcProductDefinitionShape
+    IfcProductDefinitionShape:Representations -> IfcShapeRepresentation
+    IfcShapeRepresentation:Items -> IfcSweptAreaSolid
+    IfcSweptAreaSolid -> Extrusion
+}
+```""",
+        references={"Extrusion": partial},
+    )
+    assert [bool(parsed.extract(wall)) for _, wall in geometry_models] == [
+        True,
+        same_root,
+    ]
+    assert any(
+        path[-2:] == ("IfcSweptAreaSolid", "IfcExtrudedAreaSolid")
+        for path in entity_paths(parsed)
+    ) == (not same_root)
+
+
+def owl_graph(model):
+    graph = Graph()
+    owl = Namespace("http://example.org/IFC4X3_ADD2#")
+    inst = Namespace("http://example.org/instances/")
+    express = Namespace("https://w3id.org/express#")
+    schema = ifcopenshell.schema_by_name("IFC4X3_ADD2")
+    for entity in model:
+        subject = inst[str(entity.id())]
+        decl = schema.declaration_by_name(entity.is_a())
+        while decl:
+            graph.add((subject, RDF.type, owl[decl.name()]))
+            decl = decl.supertype()
+        for attr in (
+            "Representation",
+            "Representations",
+            "Items",
+            "SweptArea",
+            "OuterCurve",
+        ):
+            value = getattr(entity, attr, None)
+            if value is None:
+                continue
+            predicate = owl[sparql.ifcOwl.name(entity.is_a(), attr).split(":", 1)[1]]
+            for child in value if isinstance(value, tuple) else (value,):
+                graph.add((subject, predicate, inst[str(child.id())]))
+        if entity.is_a("IfcRoot"):
+            box = inst[f"guid-{entity.id()}"]
+            graph.add((subject, owl.globalId_IfcRoot, box))
+            graph.add((box, express.hasString, Literal(entity.GlobalId)))
+    return graph
+
+
+@pytest.mark.parametrize("revolved", [False, True])
+@pytest.mark.parametrize("leaf", [False, True])
+def test_sparql_executes_specialized_type_filter(
+    tmp_path, geometry_models, monkeypatch, revolved, leaf
+):
+    monkeypatch.setitem(
+        sparql.STANDARD_PREFIXES, "ifcowl", "<http://example.org/IFC4X3_ADD2#>"
+    )
+    parsed = body_template(tmp_path, revolved=revolved, leaf=leaf)
+    query = sparql.convertor.template(parsed)
+    query.bind(sparql.STANDARD_PREFIXES)
+    assert [
+        bool(list(owl_graph(model).query(str(query)))) for model, _ in geometry_models
+    ] == [True, revolved]