SysML v2 Deep Dive 4 min read

Lesson 4: The Universal Pattern in SysML v2

Radical Regularity

If you learned SysML v1, you probably remember this feeling: structural modeling made sense, behavior modeling made sense, and requirements modeling made sense. But they never felt like the same language.

Blocks, Activities, and Requirements, though all technically "Classes" in the metamodel, had distinct notations and diagram types. It often felt like learning three different languages.

SysML v2 unifies them using Radical Regularity. Not by adding more constructs, but by removing the differences between them.

The One Universal Pattern: Definition, Usage, and Decomposition

SysML v2 applies one universal pattern across the entire language. Instead of switching mental modes between structure, behavior, and requirements, you follow the same rhythm everywhere:

Definition → Usage → Decomposition

Define what something is, describe where it appears in your system, then open it up and show what is inside it. When you want to build hierarchies, you nest usages inside definitions using curly brackets { }. Once you understand this pattern, you can apply it everywhere: to physical structure, to requirements, and to behavior.

Applying the Pattern in Practice

Example 1: A Simple Parts Hierarchy

part def Engine;

This defines the idea of an engine: a reusable component type, like a blueprint. It does not place an engine anywhere yet.

part def Car {
    part myEngine : Engine;
}

Example 1
.

Engine is a type, Car is another type, and myEngine is a usage of the Engine definition inside the Car definition. In plain language: a car contains an engine.

In SysML v1, this would span a Block Definition Diagram and an Internal Block Diagram. In SysML v2, it is one consistent pattern; and the same modeling logic applies to both requirements and behavior.

Example 2: The Requirements Tree

requirement def SafetyLimit {
    doc /* The vehicle must achieve an acceptable crash safety level. */
}

This defines the requirement concept but does not apply it yet.

requirement def VehicleSpecs {
    subject car : Car;
    requirement crashTest : SafetyLimit;
}

Example 2

SafetyLimit defines the requirement type, and crashTest is a usage of that requirement inside VehicleSpecs. Requirements are now first-class modeling elements with structure, parameters, inheritance, and constraints, rather than just text strings. Notice that crashTest automatically applies to the car subject defined in VehicleSpecs because it is nested inside of it.

Example 3: The Action Hierarchy

action def Ignite;

This defines the idea of an ignition action.

action def StartUpSequence {
    action fireSpark : Ignite;
}

Example 3

Ignite defines the action concept, and fireSpark is its usage inside the startup sequence. The same definition-and-usage pattern applies to behavior. No new modeling rules to learn.

SysML v2 Is Fractal

Across all three examples, the pattern is identical:

  • A part definition contains parts.
  • A requirement definition contains requirements.
  • An action definition contains actions.

Different domains, same structural logic. This is what it means to say SysML v2 is fractal: the same modeling pattern repeats everywhere, and once you learn it, you reuse it across the entire language.

Why Radical Regularity Matters

It makes the language easier to learn and use. Once you understand the definition-and-usage pattern, you apply it uniformly across structure, behavior, and requirements. No more switching modeling styles.

It makes requirements formal. Because requirements are structured like other model elements, they can own attributes, bind to specific system elements, and express measurable constraints. That allows tools to evaluate them, rather than just storing text.

Together, these changes make SysML v2 models more consistent, more analyzable, and far easier to scale.

To Sum Up

What used to be separate modeling concepts in SysML v1 are now unified under definitions and usages in SysML v2. Behavior calls become action usages, requirement containment becomes structural nesting, and requirement text becomes both documentation and formal constraints. The ideas are familiar: the language is just more consistent.

Here is a quick mapping from SysML v1 to SysML v2:

V1V2
Block / Activity / Requirement (Different concepts)part def / action def / requirement def (Unified concepts).
Call Behavior Actionaction (Usage).
Requirement ContainmentNested requirement usages inside the { }.
Requirement Textdoc /* text */ for narrative description and formal constraint expressions (e.g., require constraint { ... }) for verifiable content.

In the next lesson, we explore the visual-textual hybrid in SysML v2 and see how writing models in text does not mean losing diagrams: it means connecting them more tightly to the model itself.

SysML v2

SysModeler Team

Engineering & Product