Touchstone and the MB²SE foundation
Touchstone implements the MB²SE method, Model-Based Model-Based Systems Engineering, stated in
Dominique Ernadote's habilitation à diriger des recherches, MB²SE: A Theoretical Foundation for
Systems Engineering (Université Paris-Saclay, 2020). Every HDR citation below names a
section of that document.
The method models the modelling itself: the objectives that justify a model, the ontology that serves them, the mapping of that ontology onto a standard metamodel, and the activities that build the model. This page says how each construct of the method lands in the profile, and why the profile takes the shape it does where the method leaves a choice.
The method's information model, in the profile
| The method says | The profile carries | HDR |
|---|---|---|
| A modeling objective is approved, postponed or rejected, with a rationale, and prioritized | «Objective» with status, rationale, priority | 3.1.2, 3.1.4, Fig 3.2 |
| A project concept, in the stakeholders' words, and a hierarchy of concepts | «Concept», specializing «Concept» | 3.1.4, 4.3.2 |
| An ontology is (C, R): concepts and directed relations, plus properties of concepts | «Relation» for R, «Attribute» for the properties | 4.3.2, 3.1.4 |
| A concept is relevant for an objective, and a concept serving no objective is out of scope | «JustifiedBy» from Concept, Attribute or Relation to Objective | Fig 3.4 |
| The ontology maps onto a standard metamodel through a functor, refined by predicates on stereotype, ownership and attribute values | «ConceptMapping» with metaclasses, stereotype, scope, filter | 4.3.4, Table 4.2 |
| A concept's extension is its own mapping's set; a relation's targets are those among the target concept's individuals | Ontology.individuals, relationTargets | 4.3.4, 4.3.6 |
| A relation maps onto a path in the metamodel | «RelationMapping», and «AttributeMapping» for values | 4.3.6 |
| The tool implementation is a requirement traced to the concept | «Implements», with a rationale | Fig 3.1, 5.3.3 |
| Modelling activities build the model | «Step», «StepAction», «ProcessPackage» | 3.2, Fig 3.11 |
| An enabler formalizes a modeling approach, reusable across projects, its mapping set when a project starts | «Enabler» | 6.1 |
| A model's quality is assessed while it is being built | «ModelingRule», «EngineeringRule» and the derived properties that score them | 8.1.2 |
| Fixing actions add and never remove | the plugin's rules add a stereotype and never remove one | 5.3.1 |
The method's modeling indicator has no element of its own. It is computed: a rule's score rolls up to its Concept and from there to the Objectives that justify the Concept, which is the indicator the method asks for, derived rather than declared.
Why the property is the relation
The ontology's relation could be carried by the association line or by the property at its end. The profile carries it on the property, owned by the source Concept and typed by the target Concept, for four reasons that come from the method.
A relation of the method is directed. Its instantiation is a function from the individuals of its source concept to sets of individuals of its target concept (HDR 4.3.3). A Property owned by Concept A and typed by Concept B is that function, with a name, a multiplicity and an ordering. A UML Association is symmetric until navigability says otherwise, so an association navigable both ways is two relations of the method, one per direction.
The method's own figures draw relations as end names. One line between System Component and Function carries two role names, Is allocated to and Performs (HDR Fig 6.1).
The expression language of maturity rules navigates a Relation by its name: a rule on Customer
Need reaches the cost of the applications it selected through selectedPackage.applications.cost
(HDR 7.2.1, 7.4), each name a hyperlink to a Relation. Only a property gives a relation a name
reachable from the Concept.
The mapping side is a property too. A «RelationMapping» resolves to a property, a tag or a derived property of the source metaclass, each of them a navigation from the source.
Two consequences follow. An association between two Concepts with no owned end yields no Relation, because the modeller has not said which way the relation goes. A relation that needs attributes of its own is reified as a Concept with two Relations (HDR 4.3.3), rather than as an AssociationClass.
Why a mapping is a conjunction
A «ConceptMapping» is one conjunction: the elements of the metaclass, carrying the stereotype, within the scope, accepted by the filter. The method's extension of a concept is exactly that, I_C(c) = { x ∈ I_C(f(c)) ∧ p(x) } (HDR 4.3.4), where f(c) is the metaclass and p the predicate.
The filter is a predicate and returns no set of its own. A behavior that returned the set would
have to re-implement the declarative tags, could not be combined with another mapping, and would
defeat the externalized creation of individuals the method describes (HDR 4.3.5, Algorithm 1), which
reads the AND components of a definition to create an element: apply this stereotype, put it in this
package, set this value.
OR lives one level up, as the method recommends (HDR 4.3.5): several mappings implementing one Concept, whose individuals are the union, or several specializing Concepts each with one mapping. The second form is preferred when rules or objectives differ between the kinds, and it keeps externalized creation possible because each sub-concept remains a conjunction.
Why a general Concept is not the union of its specializations
A mapped Concept's individuals are the elements its own mappings select, I_C(c) = { x ∈ I_C(f(c)) ∧ p(x) } (HDR 4.3.4), and nothing else. The taxonomy is a constraint on the implementation, (c0, c1) ∈ H^C induces I(c0) ⊂ I(c1) (4.3.3), and the runtime does not enforce it by copying a
specialization's individuals upward. A Concept mapped to Class whose specialization is mapped to
«Block» contains every Block on its own merit, because a Block is a Class. A Concept mapped to
Class whose specialization is mapped to Activity is a non-compliant implementation, and the
runtime reports what the mappings say rather than what the taxonomy wishes; a validation rule that
reports the disagreement is held in reserve.
A Concept with no mapping and with specializations is the merge case of 4.3.5: its individuals are the union of theirs. That is how the method expresses a disjunction while keeping each mapped Concept creatable from outside the tool.
Why filter and query differ
ConceptMapping.filter is a predicate over candidates the declarative tags already selected: one
Element in, a Boolean out. The query of an «AttributeMapping» or «RelationMapping» produces the
value or the targets when no single property, tag or derived property does, the path with
intermediate filters of HDR 4.3.6. A predicate cannot express a multi-hop relation, so the two tags
carry different names. The runtime evaluates either through the tool's expression evaluator and
never reads the body's language.
A Relation's targets are intersected with its type's individuals, I_R(r)(a) = { x ∈ I_R(g(r))(a) ∧ x ∈ I_C(tgt(r)) } (4.3.6). Every raw value the tool returns is first normalised to a collection,
because the tool answers a single element from some accessors and a collection from others, and a
caller that branches on the difference inherits every undocumented case.
How maturity is assessed
A maturity rule is a predicate per individual of its context Concept. Two kinds exist because they are treated differently everywhere.
A «ModelingRule» measures completeness. A mature model satisfies every modeling rule for every individual, and the rules aggregate: a Concept's completeness is the mean over its modeling rules, including those on its Attributes and Relations; an Objective's completeness is the mean over the Concepts, Attributes and Relations it justifies. Rejected and Postponed objectives count in no model-level figure.
An «EngineeringRule» measures the system. A capability coverage of 78 % is a finding that triggers a decision, and averaging it with another engineering rule produces a number that means nothing. So engineering rules are listed, each with its own score, and never fold into a completeness figure. The method's Uncovered Functions deliverable, completed with a rationale for each uncovered function, is an engineering rule's result (HDR 6.1).
Two rules govern the arithmetic. A rule's score is the passing individuals over all individuals of the context Concept, and it is absent when there are none. A vacuous pass reported as 100 % is the most common way a maturity dashboard lies, so an empty concept shows no score. And a rule is a predicate per individual: an indicator that is not per individual, such as a total mass, has no carrier in the profile.
Results are never stored in the model. They exist in two forms computed from the same definitions:
live derived properties on the rules, Concepts and Objectives, which a modeller reads in the
specification window while working, and the maturity report, a dated HTML page for people outside
the tool, generated from an Enabler's context menu. individuals, passing, failing, score and
completeness are computed each time a specification window shows them and each time a report is
generated; the report adds a finding count and an Enabler completeness, both means or sums over those
properties, and nothing else. The Touchstone Maturity validation suite flags a malformed rule where
the modeller edits it, before the rule produces a score.
The report opens on the engineering rules because those are the rules engineers decide on; the modeling completeness beside them says how far the model can be trusted while they decide. The report states scores, counts and names and carries no verdict: whether a finding calls for a design decision or for more modeling is the engineer's call, and a page saying so would pre-empt it.
A rule is written over the ontology, never over the tool. Its references are hyperlinks to Concepts, Attributes, Relations, literals and other rules, so one rule holds for every Enabler that implements its Concepts and survives a change of implementation. A condition the language cannot state is a tool validation rule behind a «MaturityRuleImplementation», and the scoring reads it like any other rule.
What the profile leaves out
The method describes constructs the profile carries no element for, each with a reason.
| Construct | HDR | Why absent |
|---|---|---|
| Deliverable and standard deliverable, and the ranking of framework views | Fig 3.1, 3.1.6 | serves ontology-based document generation, which the resource does not yet do |
| Modeling actor | Fig 3.11 | a plain UML Actor in the process package serves |
| Constraints between two ontologies over the same elements, and the fixing actions derived from them | ch. 5 | needed only when two frameworks are formalized over one model |
| Dynamic mapping, the overload stack | 6.4 | its consumer is the document generator; filter covers the computed functor of 6.5 |
| Graduation of maturity through the process | 3.2 | «MaturityRule» as a Step's postcondition is the solution held in reserve |
| Functor, the contextual selection of an implementation | 6.1, 6.2 | the union of every reachable mapping serves the first consumers; a «Functor» selecting implementation packages and «Implements» links, with a scope, is the design held in reserve |
| Numeric comparison between Attribute values | 7.2.1 | every value is a set, so a comparison between two chains needs scalars, a numeric type and a reading for sets of several values; no objective yet needs one |
| A rule over the extent rather than the individual | a maturity rule is a predicate per individual, so an indicator such as "no two Functions share a name" has no carrier |
The design record under docs/superpowers/ states each of these decisions as it was taken.