16 model questions: questions the model answers, each with the SPARQL that answers it, bound to the concerns it informs. A finding question's rows are problems against those concerns: none means they are met.

Orientation

What does the model contain? core/inventory

The model's elements, relationships and views, counted by type.

A row: One row per type: its kind (element, relationship, view) and how many of the model's concepts are of it.

Does not prove: That the model is complete. The counts describe what was modelled, not what exists in the enterprise.

Reads: Model data

?model (optional) — The model to count. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT ?kind ?type (COUNT(DISTINCT ?concept) AS ?count)
WHERE {
  ?concept arch:inModel ?model ;
           rdf:type ?type .
  # The most specific type: neither a core class nor an abstract one.
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  # A view by its own kind, not also as arch:View.
  FILTER(?type != arch:View || NOT EXISTS { ?concept rdf:type ?viewKind . FILTER(?viewKind IN (arch:Diagram, arch:Catalog, arch:Matrix)) })
  BIND(IF(EXISTS { ?concept arch:source ?anySource }, "relationship",
       IF(EXISTS { ?concept rdf:type ?anyViewType . FILTER(?anyViewType IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix)) },
          "view", "element")) AS ?kind)
}
GROUP BY ?kind ?type
ORDER BY ?kind DESC(?count) ?type

Resolution

What is recorded about this element? core/element-detail

Every statement about one concept, with the name of each value that has one.

A row: One row per property and value of the concept.

Does not prove: That an unrecorded property is false. The model records what was said, nothing about what was not.

Reads: Model data

?focus — The concept the question is about. A modelling tool binds the selected element.

SPARQL

SELECT DISTINCT ?property ?value ?valueLabel
WHERE {
  ?focus ?property ?value .
  # Its own type: not the core or abstract classes it is also an instance of.
  FILTER(?property != rdf:type || ?value NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS {
    SELECT DISTINCT ?property ?value
    WHERE {
      BIND(rdf:type AS ?property)
      { ?value arch:isAbstractClass true } UNION { GRAPH ?abstractClassGraph { ?value arch:isAbstractClass true } }
    }
  }
  # A value's name: a concept's from the model, a type's from its metamodel.
  OPTIONAL {
    { ?value skos:prefLabel ?valueLabel } UNION { GRAPH ?labelGraph { ?value skos:prefLabel ?valueLabel } }
    FILTER(lang(?valueLabel) = "" || langMatches(lang(?valueLabel), "en"))
  }
}
ORDER BY ?property

Which elements are of this type? core/elements-by-type

The elements of one type (of every type when none is given), with their names and definitions.

A row: One row per element, with its most specific type.

Does not prove: That no other element plays the part: an element of a specialisation is listed only where it is also typed with the type asked for.

Reads: Model data

?conceptType (optional) — An element type, such as an application component.
?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT DISTINCT ?element ?label ?type ?definition
WHERE {
  ?element arch:inModel ?model ;
           rdf:type ?conceptType ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  # Elements only: not relationships, views or folders.
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  FILTER NOT EXISTS { ?element rdf:type ?notElement . FILTER(?notElement IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix, arch:Folder)) }
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
  OPTIONAL { ?element skos:definition ?definition . FILTER(lang(?definition) = "" || langMatches(lang(?definition), "en")) }
}
ORDER BY ?type ?label

Analysis

What is this element directly related to? core/neighbours-qualified

Every relationship that starts or ends at the element, read from the qualified relationships.

A row: One row per relationship: its direction seen from the element, its type and the concept at its other end.

Does not prove: A runtime dependency. A modelled relationship is a statement someone made, not an observed call.

Concerns: DependencyConcern

Reads: Model data

?focus — The element the question is about. A modelling tool binds the selected element.

SPARQL

SELECT DISTINCT ?direction ?relationship ?relationshipType ?other ?otherLabel
WHERE {
  {
    ?relationship arch:source ?focus ;
                  arch:target ?other .
    BIND("outgoing" AS ?direction)
  }
  UNION
  {
    ?relationship arch:target ?focus ;
                  arch:source ?other .
    BIND("incoming" AS ?direction)
  }
  ?relationship rdf:type ?relationshipType .
  FILTER(?relationshipType NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?relationshipType WHERE { { ?relationshipType arch:isAbstractClass true }
                                                    UNION { GRAPH ?abstractClassGraph { ?relationshipType arch:isAbstractClass true } } } }
  OPTIONAL { ?other skos:prefLabel ?otherLabel . FILTER(lang(?otherLabel) = "" || langMatches(lang(?otherLabel), "en")) }
}
ORDER BY ?direction ?relationshipType ?otherLabel

What reaches this element within two hops? core/dependents-qualified

Concepts from which a path of one or two relationships ends at the element, with the relationship types along the way.

A row: One row per path: its length, the concept it starts from, the concept between, and the relationship types.

Does not prove: Impact. Reachability is not dependency: an assignment followed by an association does not make the last concept depend on the first. Read the types, and use a language's impact question where there is one.

Concerns: DependencyConcern

Reads: Model data

?focus — The element the question is about. A modelling tool binds the selected element.

SPARQL

SELECT DISTINCT ?hops ?dependent ?dependentLabel ?firstType ?via ?secondType
WHERE {
  {
    ?first arch:source ?dependent ;
           arch:target ?focus ;
           rdf:type ?firstType .
    BIND(1 AS ?hops)
  }
  UNION
  {
    ?first arch:source ?via ;
           arch:target ?focus ;
           rdf:type ?firstType .
    ?second arch:source ?dependent ;
            arch:target ?via ;
            rdf:type ?secondType .
    FILTER(?dependent != ?focus)
    FILTER(?secondType NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
    BIND(2 AS ?hops)
  }
  FILTER(?firstType NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?firstType WHERE { { ?firstType arch:isAbstractClass true }
                                             UNION { GRAPH ?abstractClassGraph { ?firstType arch:isAbstractClass true } } } }
  MINUS { SELECT DISTINCT ?secondType WHERE { { ?secondType arch:isAbstractClass true }
                                              UNION { GRAPH ?abstractClassGraph { ?secondType arch:isAbstractClass true } } } }
  OPTIONAL { ?dependent skos:prefLabel ?dependentLabel . FILTER(lang(?dependentLabel) = "" || langMatches(lang(?dependentLabel), "en")) }
}
ORDER BY ?hops ?dependentLabel

Enrichment

What is baseline, target or still awaiting approval? core/lifecycle

Concepts with an architecture state (baseline, target, transitional) or an approval state (proposed, approved).

A row: One row per concept with either state recorded.

Does not prove: That a concept without a state is current. An unstated state is unknown.

Concerns: EvolutionConcern GovernanceConcern

Reads: Model data

?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT ?element ?label ?type ?state ?approval
WHERE {
  ?element arch:inModel ?model ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  OPTIONAL { ?element arch:architectureState ?state }
  OPTIONAL { ?element arch:approvalState ?approval }
  FILTER(BOUND(?state) || BOUND(?approval))
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?approval ?state ?type ?label

Quality

Which elements appear in no view? finding · Info core/unpresented

Elements of the model that no diagram, catalogue or matrix presents.

A row: One row per element without arch:inView.

Does not prove: That the element is irrelevant. Much of a model is only ever queried; this matters where a deliverable is read as complete.

Concerns: QualityConcern

Reads: Model data Each finding is about: ?element

?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT ?element ?label ?type
WHERE {
  ?element arch:inModel ?model ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  FILTER NOT EXISTS { ?element rdf:type ?notElement . FILTER(?notElement IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix, arch:Folder)) }
  FILTER NOT EXISTS { ?element arch:inView ?anyView }
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?type ?label

Which elements have no definition? finding · Info core/coverage-gaps

Elements, of one type or of any, with no skos:definition.

A row: One row per element without a definition.

Does not prove: That the element is unclear to its readers. A self-explanatory name may need no definition.

Concerns: QualityConcern

Reads: Model data Each finding is about: ?element

?conceptType (optional) — An element type, such as an application component.
?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT DISTINCT ?element ?label ?type
WHERE {
  ?element arch:inModel ?model ;
           rdf:type ?conceptType ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  FILTER NOT EXISTS { ?element rdf:type ?notElement . FILTER(?notElement IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix, arch:Folder)) }
  FILTER NOT EXISTS { ?element skos:definition ?anyDefinition }
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?type ?label

Which elements share a name with another of the same type? finding · Warning core/label-collisions

Elements whose name, compared without regard to case, another element of the same most specific type also has, in any loaded model.

A row: One row per element in a collision, with how many elements share the name.

Does not prove: That they are the same thing. A shared name makes two elements candidates for a person to compare, never a merge.

Concerns: QualityConcern

Reads: Model data Each finding is about: ?element

?model (optional) — The model whose elements are reported. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT DISTINCT ?element ?label ?type ?sharedBy
WHERE {
  {
    SELECT ?type ?key (COUNT(DISTINCT ?candidate) AS ?sharedBy)
    WHERE {
      ?candidate arch:inModel ?anyModel ;
                 rdf:type ?type ;
                 skos:prefLabel ?candidateLabel .
      FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
      MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                            UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
      FILTER NOT EXISTS { ?candidate arch:source ?anySource }
      FILTER NOT EXISTS { ?candidate rdf:type ?notElement . FILTER(?notElement IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix, arch:Folder)) }
      BIND(LCASE(STR(?candidateLabel)) AS ?key)
    }
    GROUP BY ?type ?key
    HAVING (COUNT(DISTINCT ?candidate) > 1)
  }
  ?element arch:inModel ?model ;
           rdf:type ?type ;
           skos:prefLabel ?label .
  FILTER(LCASE(STR(?label)) = ?key)
}
ORDER BY ?key ?type

Which elements take part in no relationship? finding · Info core/orphans

Elements that are neither the source nor the target of any relationship.

A row: One row per unconnected element.

Does not prove: That the element is unused or safe to delete. It may be context drawn on a diagram, or its relationships may be in a model that is not loaded.

Concerns: QualityConcern

Reads: Model data Each finding is about: ?element

?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT ?element ?label ?type
WHERE {
  ?element arch:inModel ?model ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  FILTER NOT EXISTS { ?element rdf:type ?notElement . FILTER(?notElement IN (arch:View, arch:Diagram, arch:Catalog, arch:Matrix, arch:Folder)) }
  FILTER NOT EXISTS { ?incoming arch:target ?element }
  FILTER NOT EXISTS { ?outgoing arch:source ?element }
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?type ?label

Which relationships are out of step with their direct triple? finding · Violation core/reifies-audit

Qualified relationships whose type has an unqualified form (arch:unqualifiedForm) but whose rdf:reifies triple term is missing or names other ends, or whose direct triple is not asserted. Needs RDF 1.2 triple terms.

A row: One row per relationship in error, with what is wrong.

Does not prove: That a query over the direct triples is wrong everywhere: it misses or misreports exactly these relationships.

Concerns: QualityConcern

Reads: Model and metamodel Each finding is about: ?relationship

SPARQL

SELECT DISTINCT ?relationship ?type ?source ?target ?problem
WHERE {
  ?relationship arch:source ?source ;
                arch:target ?target ;
                rdf:type ?type .
  # Only types with an unqualified form carry the direct triple.
  { ?type arch:unqualifiedForm ?predicate }
  UNION
  { GRAPH ?mappingGraph { ?type arch:unqualifiedForm ?predicate } }
  FILTER NOT EXISTS {
    ?relationship rdf:reifies <<( ?source ?predicate ?target )>> .
    ?source ?predicate ?target .
  }
  BIND(IF(NOT EXISTS { ?relationship rdf:reifies ?anyTerm }, "no rdf:reifies",
       IF(NOT EXISTS { ?source ?predicate ?target }, "direct triple not asserted",
          "rdf:reifies names a different triple")) AS ?problem)
}
ORDER BY ?problem ?type

Views

What does this view present? core/view-contents-semantic

The elements and relationships a view presents.

A row: One row per presented concept, with its most specific type.

Does not prove: Layout or grouping: nesting on a diagram is geometry, not a relationship.

Reads: Model data

?view — A view. A modelling tool binds the open view.

SPARQL

SELECT ?concept ?label ?type ?kind
WHERE {
  ?concept arch:inView ?view ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  BIND(IF(EXISTS { ?concept arch:source ?anySource }, "relationship", "element") AS ?kind)
  OPTIONAL { ?concept skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?kind ?type ?label

What in the model belongs in a view of this viewpoint? core/viewpoint-scope

Elements whose type the viewpoint admits — a type it names or a specialisation of one — each with its outgoing relationships summarised. The viewpoint is the one statement of what a view or a deliverable section covers.

A row: One row per element: name, type, definition and a "relationship → target" summary of what it points to.

Does not prove: That the elements belong in one diagram. A viewpoint says what may appear, not what should be drawn together.

Reads: Model and metamodel

?viewpoint — A viewpoint. A modelling tool binds the open view's viewpoint; a deliverable, the section's.
?model (optional) — The model to look in. A modelling tool binds the open model; a deliverable, the model it is produced from.

SPARQL

SELECT ?element (SAMPLE(?anyLabel) AS ?label) ?type (SAMPLE(?anyDefinition) AS ?definition)
       (GROUP_CONCAT(DISTINCT ?link; separator = "; ") AS ?outgoing)
WHERE {
  # What each viewpoint admits: the types it names and their specialisations.
  {
    SELECT DISTINCT ?viewpoint ?type
    WHERE {
      { ?viewpoint arch:includesConcept ?admitted }
      UNION
      { GRAPH ?admittingGraph { ?viewpoint arch:includesConcept ?admitted } }
      { ?type rdfs:subClassOf* ?admitted }
      UNION
      { GRAPH ?hierarchyGraph { ?type rdfs:subClassOf* ?admitted } }
    }
  }
  ?element rdf:type ?type ;
           arch:inModel ?model .
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  OPTIONAL { ?element skos:prefLabel ?anyLabel . FILTER(lang(?anyLabel) = "" || langMatches(lang(?anyLabel), "en")) }
  OPTIONAL { ?element skos:definition ?anyDefinition . FILTER(lang(?anyDefinition) = "" || langMatches(lang(?anyDefinition), "en")) }
  OPTIONAL {
    ?relationship arch:source ?element ;
                  arch:target ?other ;
                  rdf:type ?relationshipType .
    FILTER(?relationshipType NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
    MINUS { SELECT DISTINCT ?relationshipType WHERE { { ?relationshipType arch:isAbstractClass true }
                                                      UNION { GRAPH ?abstractClassGraph { ?relationshipType arch:isAbstractClass true } } } }
    OPTIONAL { ?other skos:prefLabel ?otherLabel . FILTER(lang(?otherLabel) = "" || langMatches(lang(?otherLabel), "en")) }
    BIND(CONCAT(REPLACE(STR(?relationshipType), "^.*[#/]", ""), " → ",
                COALESCE(STR(?otherLabel), STR(?other))) AS ?link)
  }
}
GROUP BY ?element ?type
ORDER BY ?type ?label

Which elements does their view's viewpoint not admit? finding · Warning core/viewpoint-conformance

Elements presented in a view whose viewpoint states the concepts it admits (arch:includesConcept), and whose type is neither one of them nor a specialisation of one. Views whose viewpoint the loaded metamodels do not define are the subject of "Which views follow a viewpoint the loaded metamodels do not define?".

A row: One row per element out of place: the view, its viewpoint, the element and its type.

Does not prove: That the view is wrong. A viewpoint is a convention; the finding is that the view departs from it, which may be deliberate.

Concerns: GovernanceConcern QualityConcern

Reads: Model and metamodel Each finding is about: ?element

?view (optional) — A view to check; every view when none is given. A modelling tool binds the open view.

SPARQL

SELECT DISTINCT ?view ?viewpoint ?element ?label ?type
WHERE {
  ?element arch:inView ?view ;
           rdf:type ?type .
  FILTER(?type NOT IN (arch:ModelConcept, arch:Element, arch:QualifiedRelationship))
  MINUS { SELECT DISTINCT ?type WHERE { { ?type arch:isAbstractClass true }
                                        UNION { GRAPH ?abstractClassGraph { ?type arch:isAbstractClass true } } } }
  FILTER NOT EXISTS { ?element arch:source ?anySource }
  ?view arch:viewConformsToViewpoint ?viewpoint .
  # Only viewpoints that state what they admit are judged.
  { SELECT DISTINCT ?viewpoint WHERE { { ?viewpoint arch:includesConcept ?anyConcept }
                                       UNION { GRAPH ?declaringGraph { ?viewpoint arch:includesConcept ?anyConcept } } } }
  # What each admits: the types it names and their specialisations.
  MINUS {
    SELECT DISTINCT ?viewpoint ?type
    WHERE {
      { ?viewpoint arch:includesConcept ?admitted }
      UNION
      { GRAPH ?admittingGraph { ?viewpoint arch:includesConcept ?admitted } }
      { ?type rdfs:subClassOf* ?admitted }
      UNION
      { GRAPH ?hierarchyGraph { ?type rdfs:subClassOf* ?admitted } }
    }
  }
  OPTIONAL { ?element skos:prefLabel ?label . FILTER(lang(?label) = "" || langMatches(lang(?label), "en")) }
}
ORDER BY ?view ?type ?label

Which views follow a viewpoint the loaded metamodels do not define? finding · Warning core/unknown-viewpoints

Views whose arch:viewConformsToViewpoint names a resource nothing loaded defines — a misspelt or outdated viewpoint IRI, or a metamodel that is not loaded. Their conformance cannot be judged.

A row: One row per view, with the viewpoint it names.

Does not prove: That the viewpoint does not exist: it may be defined in a metamodel that is not loaded.

Concerns: GovernanceConcern QualityConcern

Reads: Model and metamodel Each finding is about: ?view

SPARQL

SELECT ?view ?viewLabel ?viewpoint
WHERE {
  ?view arch:viewConformsToViewpoint ?viewpoint .
  FILTER NOT EXISTS {
    { ?viewpoint rdf:type ?anyType }
    UNION
    { GRAPH ?definingGraph { ?viewpoint rdf:type ?anyType } }
  }
  OPTIONAL { ?view skos:prefLabel ?viewLabel . FILTER(lang(?viewLabel) = "" || langMatches(lang(?viewLabel), "en")) }
}
ORDER BY ?viewLabel

Which views show this element? core/view-usage-semantic

The views that present the element, with their viewpoints.

A row: One row per view presenting the element.

Does not prove: That a view not listed leaves it out on purpose: a view drawn without arch:inView may still place it.

Reads: Model data

?focus — The element the question is about. A modelling tool binds the selected element.

SPARQL

SELECT ?view ?viewLabel ?viewpoint
WHERE {
  ?focus arch:inView ?view .
  OPTIONAL { ?view skos:prefLabel ?viewLabel . FILTER(lang(?viewLabel) = "" || langMatches(lang(?viewLabel), "en")) }
  OPTIONAL { ?view arch:viewConformsToViewpoint ?viewpoint }
}
ORDER BY ?viewLabel

Linked.Archi Core Questions

Orientation

Resolution

Analysis

Enrichment

Quality

Views

TTL Source

JSON-LD