Requirements
Generated from the sysml-rs language pack — see the Language Reference index for provenance, licensing, and the raw JSON. 18 cards.
Actor
SysML — sysml.requirements.actor
An actor is an external party — a person, system, or role — that interacts with the subject of a requirement or case. It is written with the actor keyword and lowers to an actor membership carrying the actor part.
package P { part def Driver; requirement def R { actor a : Driver; } }
Normative clauses: SysML §8.3.21.2
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Assert Constraint
SysML — sysml.requirements.assert-constraint
An asserted constraint states a boolean condition that is claimed to hold for the enclosing element — it is taken as true rather than required or assumed. It is written with the assert keyword and lowers to a distinct assert-constraint usage.
package P { requirement def R { assert constraint ac { true } } }
Normative clauses: SysML §8.3.20.2
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Concern Definition
SysML — sysml.requirements.concern-definition
A concern definition defines a matter of interest to stakeholders that a system must address — a specialized requirement definition. Viewpoints frame concerns; views address them.
package P { concern def Safety { subject s; } }
Normative clauses: SysML §8.3.21.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Concern Usage
SysML — sysml.requirements.concern-usage
A concern usage is a typed occurrence of a concern, typed by a concern definition. It raises the concern where it applies, for a viewpoint to frame.
package P { concern def Safety { subject s; } concern cn : Safety; }
Normative clauses: SysML §8.3.21.4
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Constraint Definition
SysML — sysml.requirements.constraint-definition
A constraint definition defines a reusable boolean condition over parameters. Constraint usages assert it must hold, backing requirements and checks.
package P { constraint def Positive { in x; x > 0 } }
Normative clauses: SysML §8.3.20.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Related: Constraint Check
Constraint Usage
SysML — sysml.requirements.constraint-usage
A constraint usage asserts that a boolean condition holds for a model. It is typed by a constraint definition and evaluates to true or false.
package P { constraint def Positive { in x; x > 0 } constraint c : Positive; }
Normative clauses: SysML §8.3.20.4
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Framed Concern
SysML — sysml.requirements.framed-concern
A framed concern brings a concern into a requirement as something the requirement addresses — it frames the concern within the requirement’s scope. It is written with the frame keyword and lowers to a framed-concern membership carrying the concern usage.
package P { concern def Cn; requirement def R { frame concern fc : Cn; } }
Normative clauses: SysML §8.3.21.5
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Requirement Constraint (assume / require)
SysML — sysml.requirements.requirement-constraint
A requirement constraint is a boolean condition that a requirement either assumes as a precondition or requires as an obligation. It is written with the assume or require keyword and lowers to a requirement-constraint membership recording which role it plays.
package P { requirement def R { assume constraint ac { true } require constraint rc { true } } }
Normative clauses: SysML §8.3.21.7
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Requirement Definition
SysML — sysml.requirements.requirement-definition
A requirement definition states a condition a system must meet, over a subject and optional constraints. A requirement has at most one subject.
package P { requirement def R { subject s; } }
Normative clauses: SysML §8.3.21.8
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Related: Requirement Check
Requirement Usage
SysML — sysml.requirements.requirement-usage
A requirement usage is a typed occurrence of a requirement within a model, typed by a requirement definition. It states a condition an element must satisfy, nested where it applies.
package P { requirement def Rq { subject s; } requirement rq : Rq; }
Normative clauses: SysML §8.3.21.9
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Requirement Satisfaction
SysML — sysml.requirements.satisfaction
A satisfy relationship asserts that a subject element meets a requirement. It links the satisfying element to the requirement it fulfils.
package P { requirement def R { subject s; } part def Sys; part sys : Sys; satisfy R by sys; }
Normative clauses: SysML §8.3.21.10
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Stakeholder
SysML — sysml.requirements.stakeholder
A stakeholder is a party with an interest in a requirement’s satisfaction or a concern being addressed. It is written with the stakeholder keyword and lowers to a stakeholder membership carrying the stakeholder part.
package P { part def Owner; requirement def R { stakeholder sh : Owner; } }
Normative clauses: SysML §8.3.21.12
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Subject
SysML — sysml.requirements.subject
A subject binds a requirement, case, or concern to the thing it is about — the system or element under consideration. It is written with the subject keyword and lowers to a subject membership carrying the subject parameter.
package P { part def Car; requirement def R { subject s : Car; } }
Normative clauses: SysML §8.3.21.11
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Negated Satisfy Requires Not Satisfied
SysML — sysml.validation.negated-satisfy-requires-not-satisfied
A negated satisfy usage asserts the requirement evaluates to false; verdict inverts.
Normative clauses: SysML §7.21.4
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Requirement Check Result Is Boolean
SysML — sysml.validation.requirement-check-result-is-boolean
Every RequirementCheck result is Boolean.
Normative clauses: SysML §8.4.17.1
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Requirement Is Constraint Satisfied Iff True
SysML — sysml.validation.requirement-is-constraint-satisfied-iff-true
A requirement is a kind of constraint, satisfied iff it evaluates to true.
Normative clauses: SysML §7.21.1
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Requirement Result Is Assumption Implies Required
SysML — sysml.validation.requirement-result-is-assumption-implies-required
Effective result = allTrue(assumptions) implies allTrue(constraints); required constraints checked only when assumptions hold.
Normative clauses: SysML §7.21.2
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Requirement Subject Must Be First Parameter
SysML — sysml.validation.requirement-subject-must-be-first-parameter
The subject parameter must be the requirement’s first input.
Normative clauses: SysML §8.3.21
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown