Skip to content

ArchiMate 4.0 Primer & Modelling Guide — Enterprise Architecture with Linked.Archi

Tailor · Model · Validate · Derive · Present · Link

ArchiMate 4 Hexagonion — as a linked-data ontology for enterprise architecture modelling

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.

ArchiMate 4 Metamodel Manifest Map 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)

ArchiMate 4 Elements by Aspect The aspect hierarchy — see the full ArchiMate 4 Taxonomy for all elements under each aspect.

ArchiMate 4 Aspect Dimensions The six aspect dimensions of ArchiMate 4.

By Domain (where it belongs)

ArchiMate 4 Elements by Domain 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 Process Internal Behaviour am4:Process
Function Function Internal Behaviour am4:Function
Event Event Event am4:Event
Service Service External Behaviour am4:Service
Role Role Internal Active Structure am4:Role
Collaboration Collaboration Internal Active Structure am4:Collaboration
Path Path Active Structure am4:Path
Grouping Grouping Composite am4:Grouping
Location 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, and am4:Service are 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 Business Actor Internal Active Structure am4:BusinessActor
Business Interface Business Interface External Active Structure am4:BusinessInterface
Business Object Business Object Passive Structure am4:BusinessObject
Product 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 Application Component Internal Active Structure am4:ApplicationComponent
Application Interface Application Interface External Active Structure am4:ApplicationInterface
Data Object 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 Node Internal Active Structure am4:Node
Device Device Internal Active Structure am4:Device
System Software System Software Internal Active Structure am4:SystemSoftware
Technology Interface Technology Interface External Active Structure am4:TechnologyInterface
Communication Network Communication Network Active Structure am4:CommunicationNetwork
Distribution Network Distribution Network Active Structure am4:DistributionNetwork
Equipment Equipment Internal Active Structure am4:Equipment
Facility Facility Internal Active Structure am4:Facility
Artifact Artifact Passive Structure am4:Artifact
Material 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 Capability Strategy Behaviour am4:Capability
Resource Resource Structure am4:Resource
Value Stream Value Stream Strategy Behaviour am4:ValueStream
Course of Action 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 Stakeholder Motivation am4:Stakeholder
Driver Driver Motivation am4:Driver
Assessment Assessment Motivation am4:Assessment
Goal Goal Motivation am4:Goal
Outcome Outcome Motivation am4:Outcome
Principle Principle Motivation am4:Principle
Requirement Requirement Motivation am4:Requirement
Meaning Meaning Motivation am4:Meaning
Value 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 Work Package Behaviour am4:WorkPackage
Deliverable Deliverable Passive Structure am4:Deliverable
Plateau 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)

ArchiMate 4 Relationship 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:

NordFreight Customs Gateway Fragment 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

NordFreight Layered 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

NordFreight 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:or lists. 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, not am4rt: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:

  1. loads the model with what the rules need — core-onto.ttl, archimate4-onto.ttl and archimate4-relationship-tables.ttl, which the rules file names (dcterms:requires) — and the derivations already there, if it keeps them;
  2. runs the rules as published, with an engine that runs sh:SPARQLRule with SPARQL 1.2 and repeats until nothing new is derived, since rules derive from each other's derivations;
  3. 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

NordFreight — Derivation Example 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 with FROM; deriving again starts with DROP 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.

Presentation Contexts 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:

:CustomsGateway a :RegulatoryGateway ; skos:prefLabel "Customs Gateway"@en .

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.

Cross-Notation Linking via the core ontology All languages import the core ontology (arch:), enabling cross-notation linking in one graph.

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:ApplicationComponent to a C4 Container for developer-facing zoom-in. See Application Layer vs C4 Containers.
  • ArchiMate ↔ BPMN — drill a single am4:Process down 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


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.