ArchiMate 4.0 Primer & Modelling Guide — Enterprise Architecture with Linked.Archi¶
Tailor · Model · Validate · Derive · Present · Link
Moving to ArchiMate 4.0 means rethinking layer-based models as domain-based ones, and diagram-only tools give you no way to query that structure, validate it against governance rules, or trace impact across domains. Linked.Archi treats ArchiMate 4.0 as a queryable knowledge graph, so the merged Common-Domain elements and the new domain organization become something you can validate, derive facts from, and query directly.
This guide introduces ArchiMate 4.0 (the "Hexagonion") as formalized in Linked.Archi, and walks through everything the language and its semantic assets let you do: read a model, author one, validate it, derive new facts from it, present it to different audiences, tailor it to your organization, and link it to other notations.
It is both breadth-complete and self-contained: every capability is demonstrated here with enough depth to be actionable, including the full reference patterns, the derivation mechanics, and the validation pipeline.
Orientation¶
What ArchiMate 4.0 is¶
ArchiMate is an open and independent enterprise architecture modelling language published by The Open Group. Version 4.0 — nicknamed the "Hexagonion" — introduces a fundamental restructuring from the layer-based model of 3.x to a domain-based organization.
Key changes from 3.x:
- Layers → Domains — Business, Application, Technology layers replaced by Common, Business, Application, Technology, Strategy, Motivation, and Implementation & Migration domains
- Merged behaviour elements — per-layer duplicates (BusinessProcess, ApplicationProcess, TechnologyProcess) merged into single cross-domain elements (Process, Function, Event, Service)
- Common Domain — new domain for generic, domain-independent concepts (Role, Collaboration, Path, Grouping, Location)
- Physical elements in the Technology Domain — the physical elements, an extension of the 3.x Technology Layer, are part of the Technology Domain (Equipment, Facility, Distribution Network, Material)
- Removed elements — Interaction, Contract, Representation, Gap, ImplementationEvent, Constraint removed
ArchiMate 4.0 specification: https://pubs.opengroup.org/architecture/archimate4-doc/
What Linked.Archi adds¶
In Linked.Archi, ArchiMate 4.0 is not a diagramming convention — it is a formally defined modelling language whose definition is a queryable knowledge graph. The language is published as a set of W3C-standard semantic assets, tied together by a single manifest. Each W3C standard plays one role, with no overlap:
- OWL defines what the concepts mean — the element and relationship vocabulary and its hierarchy.
- SHACL defines what a conforming model must satisfy — closed-world validation rules.
- SKOS defines how concepts are classified and navigated — the taxonomies behind palettes, filters, and views.
- SPARQL is how you query and traverse the model.
This is what turns "boxes and arrows" into something a machine can validate, reason over, and generate documents from.
The manifest is your map¶
A Linked.Archi metamodel (arch:Metamodel) is a manifest — a single resource that aggregates all the assets making up the language. The ArchiMate 4.0 manifest lives at https://meta.linked.archi/archimate4/metamodel# and ties together the resources below. Keep this picture in mind; every section of this guide "lights up" one node of it.
The manifest aggregates all semantic assets making up the language definition.
Browse the live manifest ▶
am4mm:ArchiMate4
a arch:Metamodel ;
arch:modelConcepts <https://meta.linked.archi/archimate4/onto#> ;
arch:conceptClassification <https://meta.linked.archi/archimate4/tax#> ;
arch:paletteGrouping am4tax:PaletteGrouping ;
arch:diagramGroupOrder am4tax:DiagramGroupOrder ;
arch:formalRules <https://meta.linked.archi/archimate4/shapes#> ,
<https://meta.linked.archi/archimate4/element-shapes#> ,
<https://meta.linked.archi/archimate4/principle-shapes#> ;
arch:derivationRules <https://meta.linked.archi/archimate4/derivation#> ;
arch:architectureViewpoints <https://meta.linked.archi/archimate4/viewpoints#> ;
arch:viewpointLibrary am4vp:ViewpointCatalog ;
arch:hasDeliverableTemplate am4dt:ArchitectureDefinitionDocument ,
am4dt:ArchitectureRequirementsSpec ,
am4dt:ArchitecturePrinciplesDocument ;
arch:referenceData am4rd:ArchiMateReferenceData ;
arch:referenceModels am4rm:ArchiMateReferenceModels ;
arch:presentationContextScheme am4pc:ArchiMatePresentationContexts ;
arch:notationSet am4not:ArchiMate40StandardNotation .
File structure¶
| File | Purpose |
|---|---|
archimate4-metamodel.ttl |
Metamodel manifest aggregating all constituent resources |
archimate4-onto.ttl |
Element classes, abstract hierarchy, and 11 relationship types (three-declaration pattern) |
archimate4-tax.ttl |
SKOS taxonomy classifying elements by domain and aspect |
archimate4-element-shapes.ttl |
SHACL shapes for structural integrity: names, self-loops and cycles, junctions, attributes |
archimate4-relationship-shapes.ttl |
SHACL shapes for valid source/target pairs (relationship validity matrix) |
archimate4-relationship-tables.ttl |
The same relationship tables as lookups; the derivation rules read them |
archimate4-principle-shapes.ttl |
SHACL shapes for architecture governance principles |
archimate4-viewpoint-shapes.ttl |
Viewpoint conformance: imports the rules from core-shapes, which states them once for every language |
archimate4-viewpoints.ttl |
The 25 example viewpoints of Appendix C — elements, stakeholders, concerns, purposes and scope |
archimate4-derivation-rules.ttl |
The derivation rules of Appendix B (DR1–DR8, PDR1–PDR12) as SHACL SPARQL rules, with PROV-O provenance |
archimate4-deliverable-templates.ttl |
Document templates (ADD, ARS, APD) |
archimate4-reference-data.ttl |
Reference data (access types, etc.) |
archimate4-reference-models.ttl |
Architecture patterns |
archimate4-presentation-contexts.ttl |
Stakeholder-specific rendering themes |
archimate4-notation.ttl |
Visual notation set |
icons/ |
SVG icons for all element types |
Prerequisites¶
To author and validate a model, load the assets in this order (foundation first):
core/core-onto.ttl # shared foundation (arch:*)
modelingLanguages/archimate/4.0/archimate4-onto.ttl # elements + relationships
modelingLanguages/archimate/4.0/archimate4-tax.ttl # SKOS taxonomy
modelingLanguages/archimate/4.0/archimate4-element-shapes.ttl
modelingLanguages/archimate/4.0/archimate4-relationship-shapes.ttl
modelingLanguages/archimate/4.0/archimate4-viewpoints.ttl
modelingLanguages/archimate/4.0/archimate4-notation.ttl
modelingLanguages/archimate/4.0/archimate4-metamodel.ttl # the manifest (entry point)
Throughout, these prefixes are assumed:
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
@prefix sh: <http://www.w3.org/ns/shacl#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix arch: <https://meta.linked.archi/core#> .
@prefix am4: <https://meta.linked.archi/archimate4/onto#> .
@prefix am4vp: <https://meta.linked.archi/archimate4/viewpoints#> .
@prefix am4rd: <https://meta.linked.archi/archimate4/reference-data#> .
Part 1 — The Language¶
ArchiMate 4.0 classifies every element along two orthogonal dimensions: by aspect (what kind of thing it is) and by domain (where it belongs). In Linked.Archi both dimensions are real, queryable structures, not just prose — they are the tax SKOS concept scheme.
By Aspect (what kind of thing)¶
The aspect hierarchy — see the full ArchiMate 4 Taxonomy for all elements under each aspect.
The six aspect dimensions of ArchiMate 4.
- Behaviour — dynamic aspects (what happens)
- Internal Behaviour
- Service
- Event
- Strategy Behaviour
- Work Package
- Structure — entities that exist
- Resource
- Active Structure
- Internal Active Structure
- External Active Structure
- Path, Communication Network, Distribution Network
- Passive Structure
- Motivation — context and reasons behind the architecture
- Composite — elements combining multiple aspects or domains
By Domain (where it belongs)¶
Seven architecture domains replace the traditional layer model — see the full ArchiMate 4 Taxonomy for all elements under each domain.
| Domain | Scope | Key elements |
|---|---|---|
| Common | Domain-independent | Process, Function, Event, Service, Role, Collaboration, Path, Grouping, Location |
| Business | Business-specific | Business Actor, Business Interface, Business Object, Product |
| Application | Software systems | Application Component, Application Interface, Data Object |
| Technology | Infrastructure & physical | Node, Device, System Software, Technology Interface, Communication Network, Distribution Network, Equipment, Facility, Artifact, Material |
| Strategy | Strategic planning | Resource, Capability, Value Stream, Course of Action |
| Motivation | Why architecture exists | Stakeholder, Driver, Assessment, Goal, Outcome, Principle, Requirement, Meaning, Value |
| Implementation & Migration | Change management | Work Package, Deliverable, Plateau |
The bridge — these dimensions are an asset. Both dimensions are published as one SKOS concept scheme (tax). Each element is classified twice — once under a domain, once under an aspect — so a single SPARQL query can ask "every Behaviour element" or "every Common-Domain element" without enumerating types by hand. Each dimension is a concept — Domain and Aspect — its groups narrower than it; the order of the groups is kept apart, in an ISO 25964 thesaurus array that iso-thes:superOrdinate attaches to the dimension:
@prefix am4tax: <https://meta.linked.archi/archimate4/tax#> .
@prefix iso-thes: <http://purl.org/iso25964/skos-thes#> .
<https://meta.linked.archi/archimate4/tax#> a skos:ConceptScheme ;
skos:hasTopConcept am4tax:Domain , am4tax:Aspect , am4tax:Relationship , am4tax:Junction .
# The domains, in order:
am4tax:DomainOrder a skos:OrderedCollection , iso-thes:ThesaurusArray ;
iso-thes:superOrdinate am4tax:Domain ;
skos:memberList ( am4tax:CommonDomain am4tax:BusinessDomain am4tax:ApplicationDomain
am4tax:TechnologyDomain am4tax:StrategyDomain am4tax:MotivationDomain
am4tax:ImplementationAndMigrationDomain ) .
# A domain lists the element types that are part of it (and names their abstract class):
am4tax:CommonDomain a skos:Concept ;
skos:broader am4tax:Domain ;
iso-thes:broaderGeneric am4tax:Domain ;
rdfs:seeAlso am4:CommonDomainElement ;
skos:narrower am4:Role , am4:Collaboration , am4:Path ,
am4:Service , am4:Process , am4:Function , am4:Event ,
am4:Grouping , am4:Location ;
iso-thes:narrowerPartitive am4:Role , am4:Collaboration , … .
# … and so does an aspect — so "Process" is classified on BOTH axes:
am4tax:InternalBehavior a skos:Concept ;
skos:broader am4tax:BehaviorAspect ;
iso-thes:broaderGeneric am4tax:BehaviorAspect ;
skos:narrower am4:Process , am4:Function ;
iso-thes:narrowerPartitive am4:Process , am4:Function .
Each link also carries its ISO 25964 type next to the SKOS one (DD-37): a domain is a kind of Domain and an aspect a kind of Aspect (iso-thes:broaderGeneric), and an element type is part of its domain and of its aspect (iso-thes:narrowerPartitive). What kind of element it is, the OWL class says.
Note the rdfs:seeAlso bridge: the SKOS concept and the OWL class are kept as separate resources (Linked.Archi never puns an IRI as both). The class carries logical semantics for reasoners and shapes; the concept carries navigation for palettes and filters.
The palette and the diagram — two orders. The taxonomy also says how a tool presents the dimensions, and the manifest points to both lists. A palette groups element types by the dimensions of am4tax:PaletteGrouping (arch:paletteGrouping): a section for each domain, in the order of am4tax:DomainOrder, its element types in the order of their aspects, am4tax:AspectOrder — but for the Common Domain, which gives its own order, am4tax:CommonDomainOrder: process, function, service, event, role, collaboration, path, grouping, location. Junctions belong to no domain or aspect: the taxonomy classifies them under am4tax:Junction, a top concept of their own, and a palette gives them a section after the domains. A diagram laid out in bands follows am4tax:DiagramGroupOrder (arch:diagramGroupOrder): motivation and strategy at the top, then business, application, technology, and implementation and migration. The Common Domain is not listed there — its elements are used in every domain, so each is placed with the elements it is related to:
am4tax:PaletteGrouping a skos:OrderedCollection ;
skos:memberList ( am4tax:Domain am4tax:Aspect ) .
am4tax:DiagramGroupOrder a skos:OrderedCollection ;
skos:memberList ( am4tax:MotivationDomain am4tax:StrategyDomain am4tax:BusinessDomain
am4tax:ApplicationDomain am4tax:TechnologyDomain
am4tax:ImplementationAndMigrationDomain ) .
Elements by Domain — Visual Notation¶
Below, each domain's concrete elements are shown with their notation. Under each table is one representative OWL declaration so you can see the shape of an element class.
Common Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Process | Internal Behaviour | am4:Process |
|
| Function | Internal Behaviour | am4:Function |
|
| Event | Event | am4:Event |
|
| Service | External Behaviour | am4:Service |
|
| Role | Internal Active Structure | am4:Role |
|
| Collaboration | Internal Active Structure | am4:Collaboration |
|
| Path | Active Structure | am4:Path |
|
| Grouping | Composite | am4:Grouping |
|
| Location | Composite | am4:Location |
am4:Process a owl:Class ;
rdfs:subClassOf am4:InternalBehaviorElement , am4:CommonDomainElement ;
skos:prefLabel "Process"@en ;
skos:altLabel "Business Process"@en , "Application Process"@en , "Workflow"@en ;
skos:definition "A process represents a sequence of behaviors that achieves a specific result."@en .
The 4.0 headline.
am4:Process,am4:Function,am4:Event, andam4:Serviceare single Common-Domain classes — the merge of the per-layer duplicates from 3.x. A process in the business and a process in the application use the same class, distinguished (if you wish) by what they are assigned to and what they serve, not by their type.
Business Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Business Actor | Internal Active Structure | am4:BusinessActor |
|
| Business Interface | External Active Structure | am4:BusinessInterface |
|
| Business Object | Passive Structure | am4:BusinessObject |
|
| Product | Composite | am4:Product |
am4:BusinessObject a owl:Class ;
rdfs:subClassOf am4:BusinessDomainElement , am4:PassiveStructureElement ;
arch:isAbstractClass false ;
skos:prefLabel "Business Object"@en .
Application Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Application Component | Internal Active Structure | am4:ApplicationComponent |
|
| Application Interface | External Active Structure | am4:ApplicationInterface |
|
| Data Object | Passive Structure | am4:DataObject |
am4:ApplicationComponent a owl:Class ;
rdfs:subClassOf am4:ApplicationDomainElement , am4:InternalActiveStructureElement ;
arch:isAbstractClass false ;
skos:prefLabel "Application Component"@en .
Technology Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Node | Internal Active Structure | am4:Node |
|
| Device | Internal Active Structure | am4:Device |
|
| System Software | Internal Active Structure | am4:SystemSoftware |
|
| Technology Interface | External Active Structure | am4:TechnologyInterface |
|
| Communication Network | Active Structure | am4:CommunicationNetwork |
|
| Distribution Network | Active Structure | am4:DistributionNetwork |
|
| Equipment | Internal Active Structure | am4:Equipment |
|
| Facility | Internal Active Structure | am4:Facility |
|
| Artifact | Passive Structure | am4:Artifact |
|
| Material | Passive Structure | am4:Material |
am4:Node a owl:Class ;
rdfs:subClassOf am4:TechnologyDomainElement , am4:InternalActiveStructureElement ;
arch:isAbstractClass false ;
skos:prefLabel "Node"@en .
Strategy Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Capability | Strategy Behaviour | am4:Capability |
|
| Resource | Structure | am4:Resource |
|
| Value Stream | Strategy Behaviour | am4:ValueStream |
|
| Course of Action | Strategy Behaviour | am4:CourseOfAction |
am4:Capability a owl:Class ;
rdfs:subClassOf am4:StrategyBehaviorElement ; # itself a BehaviorElement and a StrategyElement
skos:prefLabel "Capability"@en .
Motivation Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Stakeholder | Motivation | am4:Stakeholder |
|
| Driver | Motivation | am4:Driver |
|
| Assessment | Motivation | am4:Assessment |
|
| Goal | Motivation | am4:Goal |
|
| Outcome | Motivation | am4:Outcome |
|
| Principle | Motivation | am4:Principle |
|
| Requirement | Motivation | am4:Requirement |
|
| Meaning | Motivation | am4:Meaning |
|
| Value | Motivation | am4:Value |
am4:Requirement a owl:Class ;
rdfs:subClassOf am4:MotivationElement ;
skos:prefLabel "Requirement"@en .
Implementation & Migration Domain¶
| Element | Notation | Aspect | IRI |
|---|---|---|---|
| Work Package | Behaviour | am4:WorkPackage |
|
| Deliverable | Passive Structure | am4:Deliverable |
|
| Plateau | Composite | am4:Plateau |
am4:WorkPackage a owl:Class ;
rdfs:subClassOf am4:BehaviorElement , am4:ImplementationAndMigrationDomainElement ;
skos:prefLabel "Work Package"@en .
Abstract vs Concrete Classes¶
The two hierarchies above are anchored by abstract classes — marked arch:isAbstractClass true. They are not instantiable (you never type an element as am4:BehaviorElement); they exist so that queries, shapes, and tool palettes can generalize. Because rdfs:subClassOf carries monotonic inference, anything typed as am4:Process is automatically an am4:InternalBehaviorElement, an am4:BehaviorElement, an am4:CommonDomainElement, and an arch:Element — without you asserting it.
| Abstract (by aspect) | Abstract (by domain) | Concrete examples |
|---|---|---|
BehaviorElement |
CommonDomainElement |
Process, Function, Event, Service |
ActiveStructureElement |
BusinessDomainElement |
Business Actor, Business Interface |
InternalActiveStructureElement |
ApplicationDomainElement |
Application Component |
ExternalActiveStructureElement |
TechnologyDomainElement |
Node, Device, System Software |
PassiveStructureElement |
StrategyElement |
Resource, Capability, Value Stream |
StrategyBehaviorElement |
Capability, Value Stream, Course of Action | |
MotivationElement |
ImplementationAndMigrationDomainElement |
Work Package, Plateau |
CompositeElement |
Grouping, Location |
Relationships (11 types)¶
Eleven relationship types organized by category.
The categories are those of the specification's Chapter 5; Association is the weakest dependency relationship
(§5.2.4), not an "other" one. The taxonomy publishes them as the categories
of Relationship, each a kind of relationship,
in the specification's order,
am4tax:RelationshipOrder — the order a
palette groups the relationship types in — and with the order of strength the derivation rules apply — weakest first, realization, assignment, aggregation,
composition for structural relationships, and association, influence, access, serving for dependency ones — as
am4tax:StructuralStrength and
am4tax:DependencyStrength. A palette lists each category's relationships strongest first, the specification's order, from the arrays under the categories — am4tax:StructuralRelationshipOrder, am4tax:DependencyRelationshipOrder and am4tax:DynamicRelationshipOrder.
The taxonomy also gives the orders in which a modelling tool proposes relationships when you connect two elements,
and the manifest names them (arch:relationshipProposalOrder). A tool proposes first what the tables let you draw
directly, then what they permit only as the conclusion of a derivation, then association, the one to use where no
other fits; within each, a relationship takes the place the most specific order that lists it gives it.
am4tax:ProposalOrder applies to every
pair, the strongest first: composition, aggregation, assignment, realization, serving, access, influence, triggering,
flow, specialization, and association last — the specification's order of the categories and of the relationships in
each. The others apply to kinds of element, named by the ontology's abstract classes: between two behaviour elements
triggering and flow come first, then composition and aggregation — one process triggers the next before it is made
of it; from a process or function to a service, realization; between strategy behaviour elements, realization and
then serving — a capability realizes a course of action and serves a value stream; between two motivation elements,
realization and then influence; to a meaning or a value, association; and from a grouping, a location, a product or a
plateau, aggregation. Two name element types: composition between two capabilities, and aggregation from a
collaboration to the elements that work together in it. This is Linked.Archi's modelling guidance, not the
specification's.
What the metamodel draws is published with the relationship tables: the specification's metamodel figures, edge by
edge, as am4rt:drawsAssignment
and its siblings beside the permits… lookups, each relationship citing the figures that draw it. Where a figure
relates abstract types, only the pairs beneath them that the tables permit directly count as drawn; a pair a figure
names itself counts as the figure has it — an interface serving an actor, which the tables give only as derived. What
the figures draw is what the specification illustrates; a tool may say so, and the order of proposal does not depend
on it.
| Category | Relationship | Meaning | IRI |
|---|---|---|---|
| Structural | Composition | Element consists of other elements (existence dependency) | am4:composedOf |
| Structural | Aggregation | Element combines other elements | am4:aggregates |
| Structural | Assignment | Active structure performs behaviour — or is responsible for, stores or deploys passive structure (below) | am4:assignedTo |
| Structural | Realization | Element plays a critical role in creation or operation of another | am4:realizes |
| Dependency | Serving | Element provides its functionality to another | am4:serves |
| Dependency | Access | Behaviour or active structure observes or acts upon passive structure | am4:accesses |
| Dependency | Influence | Element affects the implementation or achievement of a motivation element | am4:influences |
| Dependency | Association | Unspecified relationship, or one not represented by another type | am4:associatedWith |
| Dynamic | Triggering | Temporal or causal relationship between elements | am4:triggers |
| Dynamic | Flow | Transfer from one element to another | am4:flowsTo |
| Other | Specialization | Element is a particular kind of another element | am4:specializes |
Kinds of access and of association. The kind of access is a subclass of am4:Access:
am4:ReadAccess,
am4:WriteAccess and
am4:ReadWriteAccess. A plain
am4:Access is unspecified. A directed association is an
am4:DirectedAssociation. Each
kind shares its class's predicate and is drawn as the specification draws it: an open arrowhead at the source for
read access, at the target for write access, at both ends for read-write access, and a half arrowhead at the target
for a directed association. am4:accessType is deprecated in favour of these classes
(DD-31).
:qr-booking-shipment a am4:WriteAccess ;
arch:source :BookingProcess ;
arch:target :Shipment .
:BookingProcess am4:accesses :Shipment . # the direct triple is the same for every kind
The Three-Declaration Relationship Pattern¶
This is the single most distinctive Linked.Archi pattern. Every relationship type has three representations, because enterprise architecture needs both cheap graph traversal and rich relationship management. Using Serving as the example:
## 1. Direct predicate — for fast SPARQL traversal and analytics
am4:serves a owl:ObjectProperty ;
skos:prefLabel "Serves"@en ;
arch:domainIncludes arch:Element ; # tooling hint, not a constraint
arch:rangeIncludes arch:Element .
## 2. Qualified relationship class — a reified resource carrying metadata, lifecycle, provenance
am4:Serving a owl:Class ;
rdfs:subClassOf arch:QualifiedRelationship ;
arch:unqualifiedForm am4:serves ;
skos:prefLabel "Serving"@en .
## 3. Qualified property — navigates from a source to its qualified resource
am4:qualifiedServing a owl:ObjectProperty ;
rdfs:range am4:Serving ;
arch:unqualifiedForm am4:serves .
Why three? The direct predicate (am4:serves) answers "what serves what?" in one cheap triple pattern. But suppose the same component serves the same process in two different ways, each with its own lifecycle state and owner — a bare predicate cannot tell those edges apart. The qualified am4:Serving resource can, because it is a thing in its own right with arch:source, arch:target, and any metadata you attach. The RDF 1.2 reification bridge ties the two together:
# The cheap edge — always present
ex:BookingService am4:serves ex:FreightOperations .
# The same fact as its resource — every relationship has one — here with metadata
ex:serving-001 a am4:Serving ;
arch:source ex:BookingService ;
arch:target ex:FreightOperations ;
ap:atLifecycleStage ap:Active ; # the architecture-processes extension
dcterms:created "2025-06-27"^^xsd:date ;
rdf:reifies <<( ex:BookingService am4:serves ex:FreightOperations )>> . # RDF 1.2 bridge
Rule of thumb: write every relationship both ways — the direct predicate for traversal, and the qualified resource, the relationship itself, which carries anything said about it (provenance, lifecycle, multiple distinct edges, confidence). Converters and modelling tools write both; a graph trimmed to the direct predicates is a projection for traversal. The full rationale is in the Relationship Modelling Guide.
Part 2 — Authoring a Model¶
Everything from here on uses one running example, NordFreight Logistics — a Scandinavian freight company modernising its shipment-tracking platform and integrating with EU customs systems for post-Brexit trade compliance. The complete, validatable model is at examples/nordfreight/nordfreight-model.ttl.
Model Header¶
A model is an arch:Model that declares which metamodel it conforms to:
@prefix : <https://model.nordfreight.example/> .
:NordFreightModel
a arch:Model ;
skos:prefLabel "NordFreight Logistics — Architecture Model"@en ;
arch:modelConformsToMetamodel <https://meta.linked.archi/archimate4/metamodel#ArchiMate4> ;
dcterms:created "2025-06-27"^^xsd:date .
Element Patterns¶
Each element needs only rdf:type and a language-tagged skos:prefLabel to be valid. In the model each also names the model it belongs to (arch:inModel :NordFreightModel), which the questions about a model read; it is left out below for brevity. Grouped by domain:
## Motivation
:EUCustomsCompliance a am4:Requirement ; skos:prefLabel "EU Customs Compliance"@en .
:OperationalEfficiency a am4:Goal ; skos:prefLabel "Operational Efficiency"@en .
:ShipperStakeholder a am4:Stakeholder ; skos:prefLabel "Shipper"@en .
## Strategy
:ShipmentTracking a am4:Capability ; skos:prefLabel "Shipment Tracking"@en .
:FreightBooking a am4:Capability ; skos:prefLabel "Freight Booking"@en .
:CustomsClearance a am4:Capability ; skos:prefLabel "Customs Clearance"@en .
## Business + Common-Domain behaviour
:BookingProcess a am4:Process ; skos:prefLabel "Booking Process"@en .
:TrackingService a am4:Service ; skos:prefLabel "Shipment Tracking Service"@en .
:FreightOperations a am4:Role ; skos:prefLabel "Freight Operations"@en .
:Shipment a am4:BusinessObject ; skos:prefLabel "Shipment"@en .
## Application — Functions (behaviour performed by components)
:BookingFunction a am4:Function ; skos:prefLabel "Booking Function"@en .
:TrackingFunction a am4:Function ; skos:prefLabel "Tracking Function"@en .
:CustomsFunction a am4:Function ; skos:prefLabel "Customs Processing"@en .
## Application — Services (exposed to consumers)
:BookingService a am4:Service ; skos:prefLabel "Booking Service"@en .
## Application — Components (active structure)
:TMS a am4:ApplicationComponent ; skos:prefLabel "Transport Management System"@en .
:TrackingPortal a am4:ApplicationComponent ; skos:prefLabel "Tracking Portal"@en .
:CustomsGateway a am4:ApplicationComponent ; skos:prefLabel "Customs Gateway"@en .
:ShipmentData a am4:DataObject ; skos:prefLabel "Shipment Data"@en .
## Technology
:AzureCloud a am4:Node ; skos:prefLabel "Azure North Europe"@en .
:K8sCluster a am4:SystemSoftware ; skos:prefLabel "AKS Kubernetes Cluster"@en .
:IoTGateway a am4:Device ; skos:prefLabel "IoT Tracking Gateway"@en .
## Implementation & Migration
:PlatformModernisation a am4:WorkPackage ; skos:prefLabel "Platform Modernisation"@en .
:TargetState a am4:Plateau ; skos:prefLabel "Target Architecture 2027"@en .
Relationship Patterns¶
The relationships, written here as their direct predicates — in the model each also has its qualified resource, as converters and modelling tools write it:
## Assignment — active structure performs behaviour
:FreightOperations am4:assignedTo :BookingProcess .
## Application layer — the proper Component → Function → Service → Consumer pattern
:TMS am4:assignedTo :BookingFunction . # component performs function
:BookingFunction am4:realizes :BookingService . # function provides service
:BookingService am4:serves :FreightOperations . # service serves the role
:TrackingPortal am4:assignedTo :TrackingFunction .
:TrackingFunction am4:realizes :TrackingService .
:TrackingService am4:serves :FreightOperations .
:CustomsGateway am4:assignedTo :CustomsFunction . # component performs function
:CustomsFunction am4:realizes :CustomsClearance . # function realizes capability directly
## Realization — process/service realizes a capability
:BookingProcess am4:realizes :FreightBooking .
:TrackingService am4:realizes :ShipmentTracking .
## Serving — technology layer (valid: infra serves component)
:K8sCluster am4:serves :TMS . # system software serves the application
:AzureCloud am4:serves :K8sCluster . # node serves the system software
## Access — behaviour accesses passive structure
:BookingProcess am4:accesses :Shipment .
:TMS am4:accesses :ShipmentData . # the component uses the data (derived: component → function → data)
## Assignment to passive structure — new in 4.0
:TMS am4:assignedTo :ShipmentData . # TMS is the system of record for shipment data
## Structural + dynamic
:AzureCloud am4:composedOf :K8sCluster .
:TMS am4:flowsTo :CustomsGateway .
:BookingProcess am4:triggers :TrackingService .
:CustomsGateway am4:realizes :EUCustomsCompliance .
:PlatformModernisation am4:realizes :TargetState . # a work package realizes a plateau
Assignment or access?¶
ArchiMate 4.0 lets an active structure element be assigned to a passive one in two new cases, both printed in upper case — drawn directly — in the relationship tables:
- an application component to a data object, "to express that the application is the repository, golden source, or single source of truth of that data" (§9.2.1). The Application Structure metamodel (§9.1) draws exactly this edge;
- a business actor to a business object, "to express that someone is responsible for some specific information or another kind of business object" (§8.2.1).
ArchiMate 3.2 has neither: its only assignments to passive structure deploy an artifact on a device or system software, and store material with equipment, and 4.0 keeps those. Between an application component and a data object 3.2 offers Access, as the conclusion of a derivation (the component is assigned to a function that accesses the data), and 4.0 still does — but in lower case, so it is no longer the relationship the metamodel draws.
The two say different things, so choose by what you mean:
| You mean | Relationship | |
|---|---|---|
| this application is where the data lives — its system of record | Assignment | direct; what the metamodel draws |
| this application reads or writes the data | Access (or Read / Write / Read-Write Access) | derived: the component's function accesses it |
A modelling tool that follows the tables proposes Assignment first for this pair, and la-gram does. Modellers used to 3.2 expect Access there; pick it from the list when the component only uses the data.
Read One Fragment Three Ways¶
To make the pairing concrete, here is the Customs Gateway corner of the model — as a diagram, as direct predicates, and as a qualified resource:
The Customs Gateway corner — component realizes requirement, component assigned to function, function realizes capability, flow from TMS.
View source model · Try it out ▶
# Direct predicates (the diagram, literally)
:CustomsGateway am4:realizes :EUCustomsCompliance .
:CustomsGateway am4:assignedTo :CustomsFunction .
:CustomsFunction am4:realizes :CustomsClearance .
:TMS am4:flowsTo :CustomsGateway .
# The assignment's resource, carrying why and since when
:cg-assigned-customs-fn a am4:Assignment ;
arch:source :CustomsGateway ;
arch:target :CustomsFunction ;
ap:atLifecycleStage ap:Plan ;
dcterms:created "2025-06-27"^^xsd:date ;
rdf:reifies <<( :CustomsGateway am4:assignedTo :CustomsFunction )>> .
A Cross-Domain View¶
A cross-domain layered view spanning motivation, strategy, business, application, and technology.
View source model · Try it out ▶
This view conforms to the Layered viewpoint — we will make that conformance checkable in Part 5.
Layered View¶
A complete layered architecture view spanning motivation, strategy, business, application, and technology.
View source model · Try it out ▶
Part 3 — Validating the Model with SHACL¶
ArchiMate semantics that constrain a model live in SHACL, not OWL. This is deliberate: OWL works under the open-world assumption (a missing fact is merely unknown), whereas governance needs the closed-world opposite — "every application must have an owner" should be a checkable rule whose violation is an error, not an invitation to infer a missing owner. The manifest publishes three shape families, each answering a different question.
3.1 Element & Metamodel Validation (element-shapes)¶
Are the elements well-formed? 12 shapes for what the relationship tables cannot express: names, self-loops and cycles of composition and aggregation, a part in one whole, junctions joining relationships of one type, attribute values, deep specialization chains. Which element types a relationship may connect is the relationship shapes' alone. The simplest shape requires every element to carry exactly one language-tagged label:
am4elsh:ArchiMateElementShape a sh:NodeShape ;
# Every 4.0 element except junctions — through the domain and aspect roots.
sh:targetClass am4:BusinessDomainElement , am4:ApplicationDomainElement , am4:TechnologyDomainElement ,
am4:ImplementationAndMigrationDomainElement , am4:CommonDomainElement ,
am4:StrategyElement , am4:MotivationElement , am4:BehaviorElement ,
am4:StructureElement , am4:CompositeElement ;
sh:property [
sh:path skos:prefLabel ;
sh:minCount 1 ;
sh:datatype rdf:langString ;
sh:message "Every ArchiMate element instance must have at least one skos:prefLabel, and it must be language-tagged (rdf:langString), e.g. \"Billing\"@en. Junctions are exempt — they are connectors and are conventionally unnamed."@en ;
] .
Passing: :TMS a am4:ApplicationComponent ; skos:prefLabel "Transport Management System"@en .
Failing, and the report it produces:
# Offending data
:Orphan a am4:ApplicationComponent . # no prefLabel
# Validation result
[ a sh:ValidationResult ;
sh:focusNode :Orphan ;
sh:resultPath skos:prefLabel ;
sh:sourceShape am4elsh:ArchiMateElementShape ;
sh:resultSeverity sh:Violation ;
sh:resultMessage "Every ArchiMate element instance must have at least one skos:prefLabel, …"@en ] .
3.2 Relationship-Validity Validation (shapes)¶
Is this edge legal? ArchiMate's relationship rules state which element types may connect via which relationship — the validity matrix in Appendix B of the specification. Linked.Archi generates SHACL from that matrix. For example, Assignment runs from an active-structure element to a behaviour element:
# Qualified relationships: the pairs each source may reach (excerpt).
am4sh:AssignmentShape a sh:NodeShape ;
sh:targetClass am4:Assignment ;
sh:or (
[ sh:and (
[ sh:property [ sh:path arch:source ; sh:class am4:Role ] ]
[ sh:property [ sh:path arch:target ; sh:or (
[ sh:class am4:Event ] [ sh:class am4:Function ] [ sh:class am4:Process ] [ sh:class am4:Service ] …
) ] ]
) ]
…
) .
# Direct triples: what each source type may connect to — and the predicates it may not use at all.
am4sh:DataObjectUnqualifiedShape a sh:NodeShape ;
sh:targetClass am4:DataObject ;
sh:property [
sh:path am4:assignedTo ;
sh:maxCount 0 ;
sh:message "DataObject cannot have assignment to anything — the ArchiMate 4.0 relationship tables permit none."@en ;
] .
:FreightOperations am4:assignedTo :BookingProcess passes (Role → Process). The following fails, because a Data Object is passive structure, not behaviour:
:ShipmentData am4:assignedTo :BookingProcess . # ✗ source is passive structure
# → sh:ValidationResult: "DataObject cannot have assignment to anything — the ArchiMate 4.0 relationship tables permit none."
The complete Appendix B matrix — all 11 relationships against all element pairs — is published as SHACL in
archimate4-relationship-shapes.ttl. The shapes are generated directly from the specification's validity tables.The same tables are published a second time, as lookups, in
archimate4-relationship-tables.ttl—am4:Artifact am4rt:permitsRealization am4:BusinessObject , …. Both are generated from one matrix, so they say the same; they serve different uses. The shapes validate: SHACL Core, which any SHACL engine runs, reporting a relationship the tables forbid. The tables answer may this relationship go from this type to that one? with one triple pattern. A tool may use either — validate with the shapes, and look relationships up in the tables or read the table back out of the shapes'sh:orlists. The tables also keep the specification's case: upper case permitted directly — a relationship a modeller may draw,am4rt:permitsDirectRealization— lower case only as the conclusion of a derivation (an artifact may realize a business object, but only by derivation:am4rt:permitsRealization, notam4rt:permitsDirectRealization).
3.3 Principle Validation (principle-shapes)¶
Does the model satisfy our governance rules? This is where SHACL becomes architecture compliance as code — rules you run in CI/CD on every commit, not in a quarterly review. A common principle: every Application Component must have an owner.
@prefix bs: <https://meta.linked.archi/backstage/onto#> .
# Your own principle: ownership as Backstage records it (bs:ownedBy applies to any arch:Element).
:AppComponentOwnerPrinciple a sh:NodeShape ;
sh:targetClass am4:ApplicationComponent ;
sh:property [
sh:path bs:ownedBy ;
sh:minCount 1 ;
sh:severity sh:Violation ;
sh:message "Every Application Component must declare an owner."@en ;
] .
The published principle-shapes carry the same intent as am4psh:ApplicationComponentOwnershipShape, through a business actor or role associated with the component — ArchiMate has no ownership relationship, and its tables do not let an actor or role be assigned to an application component. Run against NordFreight as authored so far, :TMS, :TrackingPortal, and :CustomsGateway all fail — none has an owner. We will fix this in Part 7 without editing the ArchiMate model at all, by linking to the Backstage catalogue that already knows the owners.
3.4 Viewpoint Conformance (viewpoint-shapes)¶
Does this view show only what its viewpoint allows? A arch:View that declares conformance to a viewpoint can be checked against the element types that viewpoint permits — data-driven, reading the viewpoint definition from the graph. (See Part 5 for the viewpoint definitions this checks against.) The rules use no ArchiMate term, so they are in core-shapes — archsh:ViewElementConformanceShape and four others — and judge custom viewpoints and other frameworks' alike; the ArchiMate viewpoint-shapes document imports them.
Running It¶
Validate NordFreight against all shape families in one pass, these as the shapes graph:
data: nordfreight-model.ttl
shapes: core/core-shapes.ttl
modelingLanguages/archimate/4.0/archimate4-element-shapes.ttl
modelingLanguages/archimate/4.0/archimate4-relationship-shapes.ttl
modelingLanguages/archimate/4.0/archimate4-principle-shapes.ttl
You now understand every file in it: element well-formedness, relationship legality, and governance principles, in one pass — and, since core-shapes carries them, viewpoint conformance too.
Part 4 — Deriving and Inferring New Facts with SPARQL Rules¶
A model states some relationships explicitly; many more are implied. ArchiMate's derivation rules say that a valid chain of relationships permits a derived relationship between its endpoints. In Linked.Archi these are sh:SPARQLRules, and every derived fact is annotated with provenance (PROV-O) and a confidence level — so inferred knowledge never silently masquerades as asserted knowledge.
One Derivation Rule¶
If an application component is assigned to a function, and that function realizes a capability, then the component realizes the capability. That is the specification's DR2: two structural relationships in line give the weaker of the two (realization is weaker than assignment). The published rule, with the restrictions of Appendix B.4 abridged:
@prefix am4deriv: <https://meta.linked.archi/archimate4/derivation#> .
am4deriv:DR2-DerivationBetweenStructuralRelationships a sh:NodeShape ;
sh:targetClass arch:ModelConcept ;
sh:rule am4deriv:DR2 .
am4deriv:DR2 a sh:SPARQLRule , prov:Plan ;
skos:prefLabel "DR2: Derivation between structural relationships"@en ;
dcterms:source <https://pubs.opengroup.org/architecture/archimate4-doc/appendixb.html#sec-Derivation-Rules-for-Valid-Relationships> ;
sh:construct """
CONSTRUCT {
$this ?u ?c .
$this ?_qualified ?_resource .
?_resource a ?_class ;
arch:source $this ;
arch:target ?c ;
rdf:reifies <<( $this ?u ?c )>> ;
:derivationCertainty :Valid ;
prov:wasDerivedFrom ?_premise1 , ?_premise2 ;
prov:wasGeneratedBy ?_activity .
?_activity a prov:Activity ;
prov:qualifiedAssociation ?_association .
?_association a prov:Association ;
prov:hadPlan :DR2 .
}
WHERE {
VALUES (?s ?sStrength) { (am4:realizes 1) (am4:assignedTo 2) (am4:aggregates 3) (am4:composedOf 4) }
VALUES (?t ?tStrength) { (am4:realizes 1) (am4:assignedTo 2) (am4:aggregates 3) (am4:composedOf 4) }
# The premises: relationships that hold — their triple is asserted, by the modeller or a valid derivation — not the potential derivation of one, unless the modeller confirmed it.
$this ?s ?b .
?_premise1 arch:source $this ; arch:target ?b ; rdf:type/arch:unqualifiedForm ?s .
FILTER NOT EXISTS { ?_premise1 :derivationCertainty :Potential . FILTER NOT EXISTS { $this ?_leads ?_premise1 } }
?b ?t ?c .
?_premise2 arch:source ?b ; arch:target ?c ; rdf:type/arch:unqualifiedForm ?t .
FILTER NOT EXISTS { ?_premise2 :derivationCertainty :Potential . FILTER NOT EXISTS { ?b ?_leads ?_premise2 } }
BIND(IF(?sStrength <= ?tStrength, ?s, ?t) AS ?u) # the weaker of the two
FILTER($this != ?c)
# Not there yet: its triple is not asserted. There only as potential, a valid derivation makes it valid.
FILTER NOT EXISTS { $this ?u ?c }
# Appendix B.4: the domains of the derived relationship's ends, whether they are
# passive structure, and the element the two relationships join at
…
# The derivation's resource: the relationship's class, and an IRI in the model's namespace;
# its derivation activity's, and the association naming the rule as its plan, from the same key.
OPTIONAL { ?_class arch:unqualifiedForm ?u ; rdfs:subClassOf+ arch:QualifiedRelationship . FILTER NOT EXISTS { ?_class rdfs:subClassOf+ ?_general . ?_general arch:unqualifiedForm ?u } }
OPTIONAL { ?_qualified arch:unqualifiedForm ?u ; rdfs:range ?_class }
OPTIONAL { SELECT (IF(COUNT(DISTINCT ?_namespace) = 1, SAMPLE(?_namespace), "urn:linked-archi:") AS ?_modelNamespace) WHERE { ?_model a arch:Model ; vann:preferredNamespaceUri ?_namespace } }
BIND(COALESCE(STR(?_modelNamespace), "urn:linked-archi:") AS ?_base)
BIND(SHA1(CONCAT("DR2", " ", STR($this), " ", STR(?s), " ", STR(?b), " ", STR(?b), " ", STR(?t), " ", STR(?c))) AS ?_key)
BIND(IRI(CONCAT(?_base, "derivation-", ?_key)) AS ?_resource)
BIND(IRI(CONCAT(?_base, "derivation-activity-", ?_key)) AS ?_activity)
BIND(IRI(CONCAT(?_base, "derivation-activity-", ?_key, "-association")) AS ?_association)
}
""" .
The shape says where the rule applies — its focus nodes, $this — and the rule is a resource of its own, am4deriv:DR2: the plan of the activity that generated a derivation, so a derivation leads to the rule's definition, source and query. The file implements all twenty rules of Appendix B: DR1–DR8, whose results are valid in any model, and PDR1–PDR12, whose results may hold and are marked am4deriv:Potential for the modeller to confirm. A rule is plain SPARQL 1.2 over the focus node $this, so any SPARQL 1.2 engine runs it; each derivation — its rule, certainty and premises — is tested on an example with a case of every rule.
What a rule derives follows its certainty. Appendix B separates derivations "certainly true in any model where these rules apply" from those "potentially true but uncertain", and RDF 1.2 has a form for each. A valid derivation is a statement: the direct triple, the qualified predicate and the resource, a relationship like any other, so a query for ?a am4:realizes ?b finds it. A potential derivation is a proposition: the resource alone, which reifies the triple with RDF 1.2's rdf:reifies without asserting it, so a query by triple does not find it until the modeller confirms it. Either way the resource is a qualified relationship of the relationship's class — am4:Realization for am4:realizes — and carries what only a derived relationship has: its certainty, its premises (prov:wasDerivedFrom) and the activity that generated it (prov:wasGeneratedBy) — the derivation activity, the rule applied to those premises.
The rules match their premises as qualified relationships too: a relationship of the premise's kind — its class's arch:unqualifiedForm — from one element to the other, the modeller's or derived. A premise holds: its triple is asserted, by the modeller or a valid derivation. A potential derivation is not taken unless the modeller confirmed it — their qualified predicate leads to it — nor any other resource whose triple is not asserted. The class is the relationship's own, not a superclass: am4:Composition is a subclass of am4:Aggregation, and a composition is not an aggregation premise. So that every premise is a resource, a shape that runs before the rules (am4deriv:QualifyRelationships, sh:order -1, which SHACL-AF orders across shapes) gives each relationship the model states only as a triple a qualified relationship of its class that reifies it, as a modeller may. That also suits RDF 1.2, which expects further statements to be made about a reifier rather than a triple term, and PROV, which derives from entities. A premise derived in more than one way gives each of its derivations.
The IRIs are in the model's namespace (the vann:preferredNamespaceUri of its arch:Model; with no model loaded, or several, urn:linked-archi:): a derivation's is named from its rule and premises, and so are its derivation activity's and the association's; a qualified asserted relationship's from its triple. Deriving again gives the same resources, and each way a relationship is derived has its own: a rule derives a relationship that is not there yet, or there only as potential, along every chain at once.
Valid and Potential¶
Every derived relationship records how sure it is. DR1–DR8 derive valid relationships, and the specification lets them chain ("these rules can be applied repeatedly"), so a valid relationship is itself a premise. PDR1–PDR12 derive potential ones, which "might be relevant but may also be wrong … it is up to the modeler to decide on this" — so a potential relationship is never a premise. Every rule derives only from relationships that are asserted, or derived as valid: the result is the full closure of valid derivations and one layer of potential ones, and nothing is called valid that rests on a guess. When a valid rule later derives a relationship that so far is only potential, it becomes valid, and its triple is asserted.
A potential rule also asks the relationship tables. B.4 restricts derivations by domain and by passive structure, which lets through relationships the tables of Appendix B.5 forbid between the two element types: an artifact may specialize a material, which realizes equipment, but an artifact may not realize equipment. PDR12 asks for the check in so many words ("only if the metamodel allows"), and every potential rule makes it, against archimate4-relationship-tables.ttl: the relationship's am4rt:permittedBy gives the annotation to look up, such as am4rt:permitsRealization, on the source's type. The rules look the tables up rather than read the shapes because a SHACL rule queries the data graph, where the shapes are not, and reading the shapes' lists in SPARQL is slow. So the tables are loaded with the model when the rules run — the rules file says so (dcterms:requires); without them, the potential rules derive nothing. The valid rules need no such check: on every relationship the tables permit, B.4 keeps all eight within them.
The tables go one step further than the rules. Run over every relationship the tables print as direct — one element of each type, all but grouping and location, whose relationships the tables mostly take from Appendix B.6 (a grouping may be the source or target of any relationship) rather than from derivation — the rules derive nothing the tables forbid, and 1,850 of the 1,888 relationships the tables print as derived: 1,457 as valid, 393 as potential, which shows that the tables count potential derivations as derived. The other 38 the rules do not derive, and leave out on purpose: 37 are reached only through a potential relationship. PDR11 proposes that a process may trigger an application interface; the tables then take that, with the interface's realization of a path, through DR7, and have the process trigger the path. The rules do not take a potential relationship as a premise — it is for the modeller to confirm, and once it is asserted, they derive the rest. (The 38th needs two nodes, which a model of one element per type cannot have.)
The certainty sits on the derivation's resource, beside its provenance. In NordFreight, the Azure cloud serves the tracking service — valid, derived through the Kubernetes cluster that realizes the tracking portal — and the event bus is part of the Azure cloud. PDR6 proposes that the event bus may serve the tracking service too; whether it does is for the modeller to say:
# Potential: the resource alone — it names the triple, and does not assert it
:derivation-7e7be46403ce16127c960718460388e0816c9f71 a am4:Serving ;
arch:source :EventBus ;
arch:target :TrackingService ;
rdf:reifies <<( :EventBus am4:serves :TrackingService )>> ;
am4deriv:derivationCertainty am4deriv:Potential ;
prov:wasDerivedFrom :qr-AzureCloud-composedOf-EventBus , # asserted
:derivation-36622001a704a7654e9e1a0ea69b65d2165e42d3 ; # itself valid, derived
prov:wasGeneratedBy :derivation-activity-7e7be46403ce16127c960718460388e0816c9f71 .
# What generated it: PDR6, applied to those premises
:derivation-activity-7e7be46403ce16127c960718460388e0816c9f71 a prov:Activity ;
prov:qualifiedAssociation :derivation-activity-7e7be46403ce16127c960718460388e0816c9f71-association .
:derivation-activity-7e7be46403ce16127c960718460388e0816c9f71-association a prov:Association ;
prov:hadPlan am4deriv:PDR6 .
# Asserted: the triple, its qualified predicate and its resource
:AzureCloud am4:composedOf :EventBus .
:AzureCloud am4:qualifiedComposition :qr-AzureCloud-composedOf-EventBus .
:qr-AzureCloud-composedOf-EventBus a am4:Composition ; arch:inModel :NordFreightModel ;
arch:source :AzureCloud ; arch:target :EventBus ;
rdf:reifies <<( :AzureCloud am4:composedOf :EventBus )>> .
# Valid: a statement — the triple, its qualified predicate and its resource
:AzureCloud am4:serves :TrackingService .
:AzureCloud am4:qualifiedServing :derivation-36622001a704a7654e9e1a0ea69b65d2165e42d3 .
:derivation-36622001a704a7654e9e1a0ea69b65d2165e42d3 a am4:Serving ;
arch:source :AzureCloud ;
arch:target :TrackingService ;
rdf:reifies <<( :AzureCloud am4:serves :TrackingService )>> ;
am4deriv:derivationCertainty am4deriv:Valid ;
prov:wasDerivedFrom :derivation-5bfad9ca2fcece99a299c3fef3a09c4bb220139e , # the cloud realizes the portal
:qr-TrackingPortal-serves-TrackingService ; # the portal serves the service
prov:wasGeneratedBy :derivation-activity-36622001a704a7654e9e1a0ea69b65d2165e42d3 . # DR3, applied to them
What is left for the modeller to decide is a query away:
SELECT ?source ?relationship ?target ?rule WHERE {
?derivation rdf:reifies <<( ?source ?relationship ?target )>> ;
am4deriv:derivationCertainty am4deriv:Potential ;
prov:wasGeneratedBy/prov:qualifiedAssociation/prov:hadPlan ?rule .
FILTER NOT EXISTS { ?source ?relationship ?target } # not confirmed, nor derived as valid: its triple is not asserted
}
Confirming one means asserting its triple in the model, with its qualified predicate leading to the derivation's resource, which then records that the relationship was derived; derivation then runs again from what is asserted, and the confirmed relationship is a premise like any other. A valid derivation needs no confirming. A relationship derived more than once has a derivation for each way it was derived, and valid wins.
Which Rule, and What Ran It¶
A rule is a definition, applied again and again: in PROV's terms a plan (prov:Plan), not an activity, which happens once and takes time. What generates a derivation is a derivation activity — the rule applied to its premises, named from the same rule and premises as the derivation — whose association (prov:qualifiedAssociation) gives the rule as its plan (prov:hadPlan). The rule behind a derivation is one path away, prov:wasGeneratedBy/prov:qualifiedAssociation/prov:hadPlan, as the query above follows it.
The rules record what they know: the rule, the premises, the certainty. Running them is an activity of its own, a run, and what ran them — la-gram, a GitLab or GitHub pipeline, the platform, any other application or process — records it once the rules have finished: a prov:Activity with its agent (prov:agent on its association, a prov:SoftwareAgent), when it ran (prov:startedAtTime, prov:endedAtTime) and the rules it ran (prov:used, their version IRI). Each derivation activity it produced is part of it (dcterms:isPartOf). A run that makes 133 derivations is 133 derivation activities, which the rules generate, and one run, which what ran them records — DD-27 records the decision.
The rules cannot record the run: a SHACL rule reads only the data graph, and a run in a derivation's key would give the same derivation a new IRI on every run. So the rules run as published wherever they run, and give a derivation the same IRI in la-gram, in a pipeline and on the platform.
A rule run is not a converter run: a converter lifts what its source says and derives nothing. In a pipeline the rules run as a job of their own — after a conversion, over the model it produced, or apart from any conversion, over any model, on a schedule or when it changes. The job:
- loads the model with what the rules need —
core-onto.ttl,archimate4-onto.ttlandarchimate4-relationship-tables.ttl, which the rules file names (dcterms:requires) — and the derivations already there, if it keeps them; - runs the rules as published, with an engine that runs
sh:SPARQLRulewith SPARQL 1.2 and repeats until nothing new is derived, since rules derive from each other's derivations; - records its run, with one update, filling in what it knows: its job URL, when it started and ended. The run's IRI is minted as a converter mints its run's, from the job URL — the derivation job's own, so a pipeline that converts and then derives has two runs (DD-29).
INSERT DATA {
<https://model.example.com/provenance/run/5b1d7a30> a prov:Activity ;
dcterms:identifier "https://gitlab.example.com/nordfreight/architecture/-/jobs/4711" ;
prov:startedAtTime "2026-11-01T09:29:12Z"^^xsd:dateTime ;
prov:endedAtTime "2026-11-01T09:30:00Z"^^xsd:dateTime ;
prov:used <https://meta.linked.archi/archimate4/derivation/4.0#> ;
prov:qualifiedAssociation [ a prov:Association ; prov:agent :shaclRuleEngine ] .
:shaclRuleEngine a prov:SoftwareAgent ;
skos:prefLabel "derivation job, architecture pipeline"@en .
} ;
INSERT { ?activity dcterms:isPartOf <https://model.example.com/provenance/run/5b1d7a30> }
WHERE {
?derivation am4deriv:derivationCertainty ?certainty ;
prov:wasGeneratedBy ?activity .
FILTER NOT EXISTS { ?activity dcterms:isPartOf ?run } # not claimed by an earlier run
}
PDR6's derivation above is then part of the run:
:derivation-activity-7e7be46403ce16127c960718460388e0816c9f71 dcterms:isPartOf <https://model.example.com/provenance/run/5b1d7a30> .
and everything the run derived, by which rule, is one query:
SELECT ?derivation ?rule WHERE {
?derivation prov:wasGeneratedBy ?activity .
?activity dcterms:isPartOf <https://model.example.com/provenance/run/5b1d7a30> ;
prov:qualifiedAssociation/prov:hadPlan ?rule .
}
An editor that derives records a run the same way, each time it derives, naming itself as the agent.
What a run claims depends on where it starts. A run that starts with no derivations — the derived graph cleared (Where Derivations Are Kept) — produces every derivation there is, and claims them all. A run that keeps the derivations already there produces only those not there yet, since a rule derives only what is not there yet, and claims only those; the rest stay part of the runs that produced them.
The agent and the times are said once, on the run. PROV does not carry them over dcterms:isPartOf; where a consumer needs the agent on a derivation activity itself, what ran the rules may add it to that activity's association as well (prov:agent).
Checking a Derivation¶
The rules apply Appendix B.4 as they derive. A derivation another tool recorded may not have, so the rules file also carries a validation shape, am4deriv:DerivationRestrictions, for any derivation in the same form — a qualified relationship with an am4deriv:derivationCertainty and its premises — whatever derived it. It reports one that a restriction of B.4 rules out, and which:
# A composition between two business objects, derived by some other tool.
:passiveComposition a am4:Composition ; arch:source :contract ; arch:target :term ;
am4deriv:derivationCertainty am4deriv:Valid ;
prov:wasGeneratedBy [ a prov:Activity ; prov:qualifiedAssociation [ a prov:Association ; prov:hadPlan am4deriv:DR2 ] ] ;
prov:wasDerivedFrom :contractClause , :clauseTerm .
Appendix B.4 does not allow this derivation: between passive structure, only realization or association.
A derived relationship is a qualified relationship like an asserted one, so the relationship shapes check it against the relationship tables as they check any other.
The rules and the shape read B.4 the same way in two places where it is silent or, read literally, too strict:
- A junction is in no domain. B.4 sorts elements into Motivation, Strategy, Core and Implementation and Migration; a junction is a connector, in none of them. A derivation through one is judged by its two ends: a requirement that realizes an And junction that realizes a goal realizes the goal.
- B.4 is not applied to specialization. Its restriction between passive structure elements — only realization or association — would otherwise stop DR1: an invoice that specializes a bill that specializes a document would not specialize the document. The relationship tables permit specialization between passive structure elements, and DR1 derives it.
Before and After¶
The red edge (Portal realizes Capability) is derived from the chain: Portal assigned to Function, Function realizes Capability.
View source model · Try it out ▶
The rule derives the red edge as a statement — its triple, its qualified predicate and its resource — and the derivation activity that generated it, with DR2 as its plan:
:portal am4:realizes :cap-tracking .
:portal am4:qualifiedRealization :derivation-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 .
:derivation-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 a am4:Realization ;
arch:source :portal ; arch:target :cap-tracking ;
rdf:reifies <<( :portal am4:realizes :cap-tracking )>> ;
am4deriv:derivationCertainty am4deriv:Valid ;
prov:wasDerivedFrom :qr-portal-assignedTo-fn-tracking , :qr-fn-tracking-realizes-cap-tracking ;
prov:wasGeneratedBy :derivation-activity-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 .
:derivation-activity-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 a prov:Activity ;
prov:qualifiedAssociation :derivation-activity-11fbc7f19f5dde599bb4af7c59942ea8eeb82883-association .
:derivation-activity-11fbc7f19f5dde599bb4af7c59942ea8eeb82883-association a prov:Association ;
prov:hadPlan am4deriv:DR2 .
# The premises, asserted: each its triple, qualified predicate and resource.
:portal am4:assignedTo :fn-tracking .
:portal am4:qualifiedAssignment :qr-portal-assignedTo-fn-tracking .
:qr-portal-assignedTo-fn-tracking a am4:Assignment ;
arch:source :portal ; arch:target :fn-tracking ;
rdf:reifies <<( :portal am4:assignedTo :fn-tracking )>> .
:fn-tracking am4:realizes :cap-tracking .
:fn-tracking am4:qualifiedRealization :qr-fn-tracking-realizes-cap-tracking .
:qr-fn-tracking-realizes-cap-tracking a am4:Realization ;
arch:source :fn-tracking ; arch:target :cap-tracking ;
rdf:reifies <<( :fn-tracking am4:realizes :cap-tracking )>> .
SPARQL Queries for Impact Analysis¶
A short SPARQL warm-up on the model:
# 1. List every Application Component
PREFIX am4: <https://meta.linked.archi/archimate4/onto#>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
SELECT ?c ?label WHERE {
?c a am4:ApplicationComponent ; skos:prefLabel ?label .
}
# 2. Capabilities with no realizing behaviour (a gap-finder)
SELECT ?cap WHERE {
?cap a am4:Capability .
FILTER NOT EXISTS { ?x am4:realizes ?cap }
}
# 3. Impact analysis — which capabilities ride on a given technology node?
# Needs no derivations: the property path follows the asserted chain — AzureCloud serves K8s
# serves TMS assignedTo BookingFunction realizes BookingService ... traversed transitively.
PREFIX am4: <https://meta.linked.archi/archimate4/onto#>
SELECT DISTINCT ?capability WHERE {
:AzureCloud (am4:serves|am4:assignedTo|am4:composedOf|am4:realizes|am4:triggers)+ ?capability .
?capability a am4:Capability .
}
Query 3 is the home-page promise made literal: "what breaks if we retire this node?" becomes a property-path query rather than a week of manual tracing.
The derivation rules support two materialization strategies: eager (run all rules at load time) or lazy (derive on query, using SPARQL property paths). Eager gives fast reads but requires re-materialization on every model change; lazy has zero maintenance cost but slower queries on large graphs. Each derivation's am4deriv:derivationCertainty (Valid for a certain derivation, Potential for a possible one) ensures consumers can always distinguish inferred from authored facts regardless of strategy.
The published ArchiMate questions take the lazy way where they ask what serves, realises, is assigned to or triggers what. Each follows the chains the valid rules follow — structural relationships in line (DR 2); a dependency or a flow after them, and opposing structural relationships after it (DR 3 to DR 6); triggering through structural relationships and further triggering (DR 5, DR 7, DR 8) — anchored on the relationship it asks about:
# What realises each capability: directly, or as DR 2 derives it
?from am4:realizes ?to .
?realizer (am4:composedOf|am4:aggregates|am4:assignedTo|am4:realizes)* ?from .
?to (am4:composedOf|am4:aggregates|am4:assignedTo|am4:realizes)* ?capability .
A question then answers the same with the derivations loaded, each one hop, as without them, and never with a potential derivation, which asserts no triple. A path does not apply the restrictions between domains of Appendix B.4, which the rules do: a question whose ends could cross one restricts them itself, as Who is responsible for what? asks only of active structure.
Four questions do not walk, as on a large model the walk is too slow to answer in a modelling tool: Which applications depend on which?, Which application components run on no technology?, How does each requirement trace to goals and to the elements that realise it? and Which capabilities does nothing realise? follow a few fixed steps, and a longer chain only once the derivations are loaded, each derivation then one hop.
What the potential rules propose has questions of its own, which answer when the derivations are loaded: Where could the model be more concrete? lists the potential derivations no modeller has confirmed, with the rule that proposed each, and Which relationships give rise to the most potential derivations? ranks the stated relationships they rest on — often one drawn to a whole where a part is meant, the place to model more precisely.
Where Derivations Are Kept¶
What a rule derives stays apart from what the modeller stated. A triple cannot say who stated it, so something else has to: where there are named graphs, the graph; in a file, the derivation's resource. DD-28 records the decision.
- In a store — the platform, a pipeline that publishes to a triple store: in a graph of their own,
{base}{notation}/{modelId}/graph/derived, beside the model's graphs. Recommended wherever there are named graphs. The model graphs are what was stated, to export, commit or open in an editor as they are; the union is what holds; a count or a diff chooses withFROM; deriving again starts withDROP GRAPH; and the model graphs stay the size of the model, which derivations outnumber — NordFreight's 35 relationships give 133 derivations, 88 of them potential. - In a file or an editor — a model's Turtle, an editor's model, a flattened export: beside the model, as in Before and After. A query by triple finds what holds, and telling what was stated takes a filter on the resource.
Before and After's derivation, in a store:
<https://model.example.com/archimate/derivation-example/graph/model> {
# the elements, and the premises: each its triple, qualified predicate and resource
:portal am4:assignedTo :fn-tracking .
:fn-tracking am4:realizes :cap-tracking .
}
<https://model.example.com/archimate/derivation-example/graph/derived> {
# the derivation, its derivation activity and that activity's association, as above
:portal am4:realizes :cap-tracking .
:portal am4:qualifiedRealization :derivation-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 .
:derivation-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 a am4:Realization ;
rdf:reifies <<( :portal am4:realizes :cap-tracking )>> ;
prov:wasGeneratedBy :derivation-activity-11fbc7f19f5dde599bb4af7c59942ea8eeb82883 .
}
| In a store | In a file | |
|---|---|---|
What holds: :portal am4:realizes ?x |
:cap-tracking, over the union |
:cap-tracking |
| What was stated | the two premises: FROM <…/graph/model> |
the two premises: the query below |
| Removing the derivations, to derive again | DROP GRAPH <…/graph/derived> |
the two updates below |
In a file, what was stated is a relationship whose triple is asserted that is not a valid derivation, nor a potential one the modeller has not confirmed:
SELECT ?relationship WHERE {
?relationship rdf:reifies <<( ?source ?predicate ?target )>> .
FILTER EXISTS { ?source ?predicate ?target }
FILTER NOT EXISTS {
?relationship am4deriv:derivationCertainty ?certainty .
FILTER(?certainty = am4deriv:Valid || NOT EXISTS { ?source ?leads ?relationship })
}
}
and removing the derivations takes two updates: a valid derivation's triple stays if the modeller also stated it, and a confirmed derivation stays altogether.
DELETE { ?source ?predicate ?target }
WHERE {
?derivation am4deriv:derivationCertainty am4deriv:Valid ;
rdf:reifies <<( ?source ?predicate ?target )>> .
FILTER NOT EXISTS {
?stated rdf:reifies <<( ?source ?predicate ?target )>> .
FILTER NOT EXISTS { ?stated am4deriv:derivationCertainty ?certainty }
}
} ;
DELETE { ?source ?qualified ?derivation . ?derivation ?p1 ?o1 . ?activity ?p2 ?o2 . ?association ?p3 ?o3 }
WHERE {
?derivation am4deriv:derivationCertainty ?certainty ;
arch:source ?source ;
prov:wasGeneratedBy ?activity .
?activity prov:qualifiedAssociation ?association .
FILTER(?certainty = am4deriv:Valid || NOT EXISTS { ?source ?leads ?derivation })
OPTIONAL { ?source ?qualified ?derivation }
?derivation ?p1 ?o1 . ?activity ?p2 ?o2 . ?association ?p3 ?o3 .
}
Confirming a potential derivation in a store moves its resource, with its derivation activity and that activity's association, into the model graph, beside the triple and qualified predicate the confirmation asserts; dropping the derived graph then leaves it. Deriving again after a relationship was removed starts from no derivations, as what rested on it stays until then.
A practice may also derive across models: a run of its own, over the models it chooses. What it derives belongs to none of them, so it is kept in the dataset's {base}graph/derived, its resources in urn:linked-archi:. The rules join on one element's IRI: they derive across models that share it, and nothing across a skos:exactMatch, for which a practice writes rules of its own — DD-28 sets out the cases.
Part 5 — Viewpoints and Generating Presentations¶
A model is one source of truth; stakeholders need many tailored views of it. Linked.Archi separates viewpoints (the specification of a kind of view), presentation contexts (how a view is styled and filtered for an audience), and deliverable templates (SPARQL-driven documents) — all generated from the single model.
Viewpoints as First-Class Resources¶
A viewpoint is an arch:Viewpoint individual that names the element types it admits, the stakeholders it targets, and the concerns it frames:
am4vp:OrganizationViewpoint a arch:Viewpoint ;
skos:prefLabel "Organization Viewpoint"@en ;
arch:includesConcept am4:BusinessActor , am4:Role , am4:Collaboration , am4:Location ,
am4:BusinessInterface ,
am4:Grouping , am4:AndJunction , am4:OrJunction ; # usable in every viewpoint
arch:targetsStakeholder am4vp:EnterpriseArchitect , am4vp:ProcessArchitect , am4vp:DomainArchitect ,
am4vp:Manager , am4vp:Employee , am4vp:Shareholder ;
arch:viewpointFramesConcern am4vp:CompetenciesAuthorityResponsibilities ;
arch:viewpointHasPurpose am4vp:Designing , am4vp:Deciding , am4vp:Informing ;
skos:broader am4vp:CompositionViewpoints , am4vp:SingleDomainSingleAspect . # category and scope
The catalogue holds all 25 example viewpoints of the specification's Appendix C, grouped twice with SKOS, as the ArchiMate taxonomy groups elements by domain and by aspect: by the specification's categories — the basic viewpoints by Composition, Support, Cooperation and Realization, then the Motivation, Strategy and Implementation and Migration viewpoints — and by the scope its tables state, such as Single domain, single aspect. Grouping and the two junctions are admitted in every viewpoint, as the specification allows; "core element", which some tables list, stands for every element of the Common, Business, Application and Technology domains.
A arch:View declares conformance to one viewpoint — and that conformance is exactly what the viewpoint-shapes from Part 3.4 check:
:NordFreightLayeredView a arch:View ;
skos:prefLabel "NordFreight Cross-Domain View"@en ;
arch:viewConformsToViewpoint am4vp:LayeredViewpoint .
Selected viewpoints (the full catalogue is the SKOS ViewpointCatalog):
| Viewpoint | Focus |
|---|---|
| Organization | Business actors, roles, collaborations |
| Application Structure | Application components, interfaces, data objects |
| Technology | Nodes, devices, system software, networks, equipment, facilities |
| Information Structure | Business objects, data objects, and their relationships |
| Process Cooperation | Processes, triggering, information exchange, supporting services |
| Service Realization | How services are realized by processes and active structure |
| Stakeholder | Stakeholders, drivers, assessments, goals, principles |
| Goal Realization | Goals refined into sub-goals and realized by requirements |
| Requirements Realization | Requirements realized by processes, components, services |
| Motivation | Full motivation structure (stakeholders through values) |
| Strategy | Resources, capabilities, value streams, courses of action |
| Capability Map | Capability hierarchy and composition |
| Outcome Realization | Outcomes realized by capabilities and core elements |
| Resource Map | Resources assigned to capabilities |
| Implementation and Deployment | Artifacts deployed on technology infrastructure |
| Migration | Baseline-to-target transition via plateaus and work packages |
| Cross-Domain (Layered) | Cross-domain traceability across all domains |
Presentation Contexts — One Model, Many Renderings¶
A presentation context is a "theme" — it selects appropriate visual notations, templates, and abstraction levels for a given stakeholder audience. Rather than creating separate models, you query the same knowledge graph through different lenses. Presentation contexts are a SKOS concept scheme; each concept names the audience and describes what they need:
am4pc:ExecutiveContext
a skos:Concept ; skos:topConceptOf am4pc:ArchiMatePresentationContexts ;
skos:prefLabel "Executive / C-Level"@en ;
skos:definition "High-level overview with minimal technical detail. Focus on business capabilities, strategic alignment, cost, and risk."@en ;
arch:usesNotationSet am4not:ArchiMate40StandardNotation ;
skos:inScheme am4pc:ArchiMatePresentationContexts .
am4pc:OperationsContext
a skos:Concept ; skos:topConceptOf am4pc:ArchiMatePresentationContexts ;
skos:prefLabel "Operations / Infrastructure"@en ;
skos:definition "Focus on technology domain and deployment. Nodes, devices, networks, environments."@en ;
arch:usesNotationSet am4not:ArchiMate40StandardNotation ;
skos:inScheme am4pc:ArchiMatePresentationContexts .
Both use the standard notation set out of the box. Organizations that want a simplified visual treatment for executives can define their own notation set (e.g. flat boxes without ArchiMate icons) and reference it via arch:usesNotationSet. The skos:definition text on each context drives tooling decisions about which viewpoints to apply and what level of detail to include.
Same NordFreight model, two audiences — executives see capabilities and goals, tech-ops sees nodes and deployment.
Deliverable Templates — Model to Document¶
A deliverable template is a document whose sections answer stakeholder concerns by asking model questions. The manifest ships four: the Architecture Definition Document, the Architecture Requirements Specification, the Architecture Principles Document, and a Change Impact Assessment produced for one element under change:
am4dt:ArchitectureDefinitionDocument a arch:DeliverableTemplate ;
skos:prefLabel "Architecture Definition Document"@en ;
arch:templateParameter am4dt:ModelParameter ;
arch:templateHasSection am4dt:ADD-S1 , am4dt:ADD-S2 , … .
am4dt:ADD-S4 a arch:TemplateSection ;
arch:sectionOrder 4 ;
skos:prefLabel "4. Technology Domain"@en ;
arch:sectionViewpoint am4vp:TechnologyViewpoint ;
arch:sectionAddressesConcern am4vp:InfrastructureQuality , am4vp:ApplicationPlatforms ;
arch:sectionAsks ( am4q:viewpoint-scope am4q:applications-without-technology ) ;
arch:sectionResultKey "technologyDomain" .
The section asks what belongs in a view of its viewpoint and which applications run on no technology. Generated from the ArchiMate 4.0 questions example model, the second answer reads:
### Which application components run on no technology?
**3 found** (Warning) — Stability, security, dependencies and costs of infrastructure, Structure of application platforms and the technology supporting them.
| Application |
| --- |
| Claims Portal |
| Policy Administration |
| crm |
A finding with no answers reads "None found" for its concerns, and a question the generator cannot ask — a parameter not given, a metamodel not loaded — is reported with the reason. See Deliverable Templates.
The generator itself lives in the toolbox repository; see the Deliverable Generator Spec.
Part 6 — Tailoring and Extending the Language¶
The semantic assets are raw material, not a sealed package. Tailoring means adding resources the manifest already knows how to aggregate — never forking the language.
Add a Custom Element Type¶
Suppose NordFreight wants to single out regulatory integration points. Define :RegulatoryGateway as a subclass of am4:ApplicationComponent, register it for navigation, and constrain it — touching several assets coherently:
# onto — the class
:RegulatoryGateway a owl:Class ;
rdfs:subClassOf am4:ApplicationComponent ;
skos:prefLabel "Regulatory Gateway"@en ;
skos:definition "An application component that integrates with an external regulatory authority."@en .
# tax — so palettes and filters pick it up, on both axes, as the published concepts list their classes
am4tax:ApplicationDomain skos:narrower :RegulatoryGateway .
am4tax:InternalActiveStructure skos:narrower :RegulatoryGateway .
# shapes — a tailored governance rule
:RegulatoryGatewayShape a sh:NodeShape ;
sh:targetClass :RegulatoryGateway ;
sh:property [
sh:path am4:realizes ;
sh:qualifiedValueShape [ sh:class am4:Requirement ] ;
sh:qualifiedMinCount 1 ;
sh:message "A Regulatory Gateway must realize at least one Requirement."@en ;
] .
Now reclassify the Customs Gateway:
Because of rdfs:subClassOf, everything already written for am4:ApplicationComponent still applies — the owner principle (Part 3.3), the serving derivation (Part 4), the queries (Part 4), and the Application Structure viewpoint all continue to see :CustomsGateway, with no changes. That is the payoff of monotonic subsumption.
Compose with Extensions¶
Cross-cutting extensions import the core ontology (arch:), so they attach to ArchiMate elements with no integration code. Record why the Customs Gateway pattern was chosen, and how the legacy TMS scores in portfolio terms:
@prefix ad: <https://meta.linked.archi/arch-decision#> .
@prefix timefw: <https://meta.linked.archi/time-framework/onto#> .
:UseDedicatedCustomsGateway a ad:Decision ;
skos:prefLabel "Use a dedicated Customs Gateway"@en ;
ad:addresses :EUCustomsCompliance ;
ad:affects :CustomsGateway ;
ad:status "accepted" .
:TMSFitAssessment a timefw:FitAssessment ;
timefw:assesses :TMS ;
timefw:functionalFit "low" ;
timefw:technicalFit "low" ;
timefw:classifiedAs timefw:Migrate . # → flagged for migration
Custom viewpoints, custom relationships (full three-declaration), and organization-specific notation follow the same patterns shown above — subclass existing types, register in the taxonomy, and constrain with SHACL. See Build Your Own Metamodel for the full workflow.
Part 7 — Linking with Other Notations and Frameworks¶
Because every Linked.Archi language imports the core ontology (arch:), an ArchiMate ApplicationComponent, a C4 Container, and a Backstage Component are all arch:Element instances. They coexist in one graph, share SHACL shapes, and answer the same SPARQL queries.
All languages import the core ontology (
arch:), enabling cross-notation linking in one graph.
A Concrete Link: ArchiMate ↔ Backstage¶
NordFreight's running estate is catalogued in Backstage, which knows ownership and lifecycle that the ArchiMate model does not. Link the two representations of the same system:
@prefix bs: <https://meta.linked.archi/backstage/onto#> .
@prefix cat: <https://backstage.example.com/catalog/> .
# The Backstage catalog entry, with the owner ArchiMate lacked
cat:tracking-portal a bs:Component ;
bs:name "tracking-portal" ;
skos:prefLabel "tracking-portal"@en ;
bs:lifecycleState bs:Production ;
bs:ownedBy cat:team-shipment-tracking .
cat:team-shipment-tracking a bs:Group ;
skos:prefLabel "Shipment Tracking"@en .
# Establish that these two nodes describe the same real-world system.
# skos:exactMatch, not owl:sameAs — the two models describe this system at
# different granularities, so the substitutability test fails. See DD-11.
:TrackingPortal skos:exactMatch cat:tracking-portal .
Now ask a question no single tool could answer — and re-run the owner principle from Part 3.3:
# Which ArchiMate Application Components lack an owner, even after consulting Backstage?
PREFIX am4: <https://meta.linked.archi/archimate4/onto#>
PREFIX arch: <https://meta.linked.archi/core#>
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX bs: <https://meta.linked.archi/backstage/onto#>
SELECT ?c WHERE {
?c a am4:ApplicationComponent .
FILTER NOT EXISTS { ?c bs:ownedBy ?own }
FILTER NOT EXISTS {
?c (skos:exactMatch|^skos:exactMatch) ?corresponding .
?corresponding bs:ownedBy ?ownerViaCorrespondence .
}
}
:TrackingPortal no longer appears: it carries no bs:ownedBy of its own, but the
correspondence reaches one. The governance gap was closed by linking, not by re-modelling.
(:TMS and :CustomsGateway remain flagged until they too are catalogued.)
That second FILTER NOT EXISTS is the cost of correspondence over merge, and it is worth
understanding rather than working around. skos:exactMatch carries no OWL entailment, so
nothing is inherited — the query crosses the link itself, one hop, written explicitly, with no
reasoner in the everyday path. owl:sameAs would let a reasoner pool both nodes' properties
and the shorter two-line query would pass unchanged; it also asserts the two IRIs denote one
individual, which silently corrupts every downstream query if that turns out to be wrong.
Choose with the substitutability test: if a reasoner could safely replace one IRI with the
other everywhere, forever, the nodes are one entity → owl:sameAs. Otherwise →
skos:exactMatch. A Backstage component and an ArchiMate component describe the same system
at different granularities and for different concerns, so this pairing is a correspondence,
not an identity. See DD-11
for the full rationale and for where reviewed identity links are recorded.
Why the property path runs both ways
skos:exactMatch is symmetric by definition, but symmetry is an entailment — without a
reasoner, only the direction actually written is present in the data. (skos:exactMatch|^skos:exactMatch)
is how a reasoner-free query stays correct whichever way the link was authored.
Other Pairings, in Brief¶
- ArchiMate ↔ C4 — map an
am4:ApplicationComponentto a C4Containerfor developer-facing zoom-in. See Application Layer vs C4 Containers. - ArchiMate ↔ BPMN — drill a single
am4:Processdown into an executable BPMN flow when order, gateways, and exceptions matter. - ArchiMate ↔ TOGAF — cross-map elements to the TOGAF content metamodel so a NordFreight element participates in an ADM deliverable. See the TOGAF Modelling Guide.
Cross-mapping happens at two levels, and they use different mechanisms:
| Level | What it relates | Mechanism | Where it is authored |
|---|---|---|---|
| Instance | this ArchiMate component ↔ that Backstage component | skos:exactMatch by default; owl:sameAs for the documented subset where identity is confirmed and a property merge is wanted |
reviewed by hand, recorded in the reconciliation graph |
| Type | am4:ApplicationComponent ↔ togaf:LogicalApplicationComponent |
skos:closeMatch, skos:relatedMatch, skos:broadMatch, skos:narrowMatch — skos:exactMatch only where the two genuinely coincide in scope |
a metamodel's cross-language mapping document |
Neither is produced by a converter: mappings are editorial judgements, not derivations. Instance
links are authored and reviewed per
DD-11; type-level
mappings live in a *-crossmappings.ttl registered on the metamodel via arch:crossLanguageMappings
— see Authoring cross-language mappings. Cross-boundary SPARQL
queries traverse the link explicitly, regardless of which notation originated each element.
Where to Go Next¶
You have now exercised every capability of ArchiMate 4.0 in Linked.Archi, each once: you read the language, authored a model, validated it three ways, derived new facts with provenance, rendered it for two audiences and a document, tailored it with a custom type and two extensions, and linked it to another notation. Re-reading the manifest map, every node is now lit.
Two things worth remembering. First, you never have to write SPARQL by hand: the Linked.Archi MCP server exposes this whole graph to AI agents, so a natural-language question ("what breaks if we retire Azure North Europe?") is translated to the query in Part 4 and answered against your real model. Second, every topic introduced here has a dedicated deep-dive article — the Relationship Modelling Guide, the Validation Guide, and the Design Decisions expand on the patterns shown above.
Further Reading¶
- ArchiMate 3.2 Modelling Guide — detailed analysis of the 3.2 ontology
- ArchiMate 3.2 vs 4.0 — migration guide between versions
- ArchiMate Design Decisions — rationale for ontology design choices
- Modelling Languages Guide — how ArchiMate relates to other languages
- Relationship Modelling Guide — the three-declaration pattern in depth
- Build Your Own Modelling Tool — how tools consume these assets
- Validation Guide — SHACL validation pipeline
- Deliverable Generator Spec — how templates become documents
- ArchiMate 4.0 Metamodel Manifest — the live index of every asset used here
- Architecture & Approach — the core thesis and the OWL / SHACL / SKOS division of labour
- Domain & Range Guide — why
domainIncludes/rangeIncludes, notrdfs:domain/rdfs:range - ArchiMate 4.0 Specification — the official spec by The Open Group
- The Open Group ArchiMate Forum — community and certification
Disclaimer: This is a community semantic representation of ArchiMate for interoperability purposes. It is not produced by, endorsed by, or affiliated with The Open Group. "ArchiMate" is a registered trademark of The Open Group.