Behavior
Generated from the sysml-rs language pack — see the Language Reference index for provenance, licensing, and the raw JSON. 51 cards.
Behavior
KerML — kerml.behavior.behavior
A behavior is a classifier of things that happen over time — a specification of how a system acts. It is the KerML base of SysML action definitions and its steps order the occurrences it coordinates.
package P { behavior B; }
Normative clauses: KerML §7.4.7
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Function
KerML — kerml.behavior.function
A function is a behavior that produces a result by evaluating an expression over its parameters. It is the KerML base of SysML calculation definitions; a return parameter carries its result.
package P { function F; }
Normative clauses: KerML §7.4.8
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Interaction
KerML — kerml.behavior.interaction
An interaction is both a behavior and an association: a behavior that coordinates the things it connects, describing how they interact over time. It is the KerML base of item flows between participants.
package P { interaction I; }
Normative clauses: KerML §7.4.10
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Invariant
KerML — kerml.behavior.invariant
An invariant asserts that a boolean expression must always hold, written inv { expr } inside a constraint. It lowers to a distinct Invariant carrying the asserted boolean condition.
constraint def C { inv { 1 > 0 } }
Normative clauses: KerML §8.3.4.7.5
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Predicate
KerML — kerml.behavior.predicate
A predicate is a function whose result is a boolean — a named condition that evaluates to true or false. It is the KerML base of SysML constraint definitions.
package P { predicate Pr { true } }
Normative clauses: KerML §8.2.5.7.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Calc Result Is Expression Value
KerML — kerml.validation.calc-result-is-expression-value
A calculation returns, in its result parameter, the value of evaluating its result expression.
Normative clauses: KerML §7.4.8.3
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Clock Timeflow Constraint
KerML — kerml.validation.clock-timeflow-constraint
The currentTime of a Clock snapshot equals the TimeOf that snapshot relative to the clock: snapshots->forAll{TimeOf(s, thisClock) == s.currentTime}.
Normative clauses: KerML §9.2.12.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Durationof End Minus Start
KerML — kerml.validation.durationof-end-minus-start
DurationOf = TimeOf(endShot) − TimeOf(startShot).
Normative clauses: KerML §9.2.12.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Happens Just Before No Intervening
KerML — kerml.validation.happens-just-before-no-intervening
HappensJustBefore: no occurrence can exist in the gap between earlier and later.
Normative clauses: KerML §9.2.4.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Invocation Binds Arguments To Input Params
KerML — kerml.validation.invocation-binds-arguments-to-input-params
Input parameters bind to their corresponding argument values.
Normative clauses: KerML §7.4.9.1
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Local Clock Defaults To Universal Clock
KerML — kerml.validation.local-clock-defaults-to-universal-clock
An occurrence’s localClock defaults to Clocks::universalClock; suboccurrences inherit it.
Normative clauses: KerML §9.2.4.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Occurrence Has Lifetime Extent
KerML — kerml.validation.occurrence-has-lifetime-extent
An occurrence has an extent in time (lifetime) from start to end.
Normative clauses: KerML §9.2.4
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Timeof Continuity Constraint
KerML — kerml.validation.timeof-continuity-constraint
If A HappensJustBefore B, TimeOf(A.endShot) == TimeOf(B).
Normative clauses: KerML §9.2.12.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Timeof Ordering Constraint
KerML — kerml.validation.timeof-ordering-constraint
If A HappensBefore B, TimeOf(A.endShot) ≤ TimeOf(B).
Normative clauses: KerML §9.2.12.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Accept Action
SysML — sysml.behavior.accept-node
An accept action waits for an incoming event or message and binds its payload, so the action’s flow continues only once a matching occurrence is received. It is written with the accept keyword inside an action body.
package P { action def A { accept sig; } }
Normative clauses: SysML §7.17.8
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Action Definition
SysML — sysml.behavior.action-definition
An action definition defines a reusable kind of behavior that transforms inputs into outputs over time. Action usages instantiate it as steps within a larger behavior.
package P { action def Move; }
Normative clauses: SysML §8.3.17.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Action Usage
SysML — sysml.behavior.action-usage
An action usage is an occurrence of behavior that transforms inputs into outputs. It is typed by an action definition and can hold parameters and nested actions.
package P { action def Move; action m : Move; }
Normative clauses: SysML §8.3.17.4
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Assignment Action
SysML — sysml.behavior.assignment-node
An assignment action sets a feature to the value of an expression, mutating model state as the action flow proceeds. It is written with the assign keyword and the := operator.
package P { action def A { attribute x; assign x := 1; } }
Normative clauses: SysML §7.17.9
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Calculation Definition
SysML — sysml.behavior.calculation-definition
A calculation definition defines a reusable computation that maps inputs to a returned result. It is a behavior whose body is an expression; usages invoke it to compute values.
package P { calc def Sum { in a; in b; return a + b; } }
Normative clauses: SysML §8.3.19.2
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Calculation Usage
SysML — sysml.behavior.calculation-usage
A calculation usage is a typed occurrence of a calculation within a model. It is typed by a calculation definition and binds its inputs to produce a result.
package P { calc def Sum { in a; in b; return a + b; } calc s : Sum; }
Normative clauses: SysML §8.3.19.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Decision Node
SysML — sysml.behavior.decision-node
A decision node is a control node that routes flow down exactly one outgoing branch, chosen by guards on its successions. It is written with the decide keyword inside an action body.
package P { action def A { decide d; } }
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Exhibit State Usage
SysML — sysml.behavior.exhibit-state
An exhibit state usage lets a part or other structure display a state machine defined elsewhere as its own behavior, without redefining it. It is written with the exhibit state keywords and references the state whose behavior is exhibited.
package P { state def SD; part def M { exhibit state st : SD; } }
Normative clauses: SysML §8.3.18.2
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
For Loop Action
SysML — sysml.behavior.for-loop-node
A for loop action iterates a body action over the elements of a sequence, binding a loop variable to each element in turn. It is written with the for keyword, a variable, and an in sequence.
package P { action def A { attribute nums; for i in nums { action b; } } }
Normative clauses: SysML §7.17.12
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Fork Node
SysML — sysml.behavior.fork-node
A fork node is a control node that splits action flow into concurrent branches, activating every outgoing succession at once. It is written with the fork keyword inside an action body.
package P { action def A { fork f; } }
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Join Node
SysML — sysml.behavior.join-node
A join node is a control node that synchronizes concurrent branches, resuming flow only once every incoming succession has completed. It is written with the join keyword inside an action body.
package P { action def A { join j; } }
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Merge Node
SysML — sysml.behavior.merge-node
A merge node is a control node that combines alternative branches back into a single flow, continuing when any one incoming succession arrives. It is written with the merge keyword inside an action body.
package P { action def A { merge m; } }
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Message
SysML — sysml.behavior.message
A message (message ... from ... to ...) models a transfer between a source and target end without specifying how the payload is obtained or delivered. The spec models a message as a flow usage (the grammar rule Message returns FlowUsage), so it lowers to a FlowUsage — there is no distinct Message metaclass.
package P { part a; part b; message m from a to b; }
Normative clauses: SysML §7.16.1
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Message Event
SysML — sysml.behavior.message-event
A message event is one end of a message (message m from a to b; — each of a and b). The grammar rule MessageEvent returns EventOccurrenceUsage: each end lowers to an unnamed EventOccurrenceUsage owned by the message through a ParameterMembership, referencing the end feature via an owned ReferenceSubsetting — there is no distinct MessageEvent metaclass.
package P { part def C { part a; part b; message m from a to b; } }
Normative clauses: SysML §8.2.2.16
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Perform Action
SysML — sysml.behavior.perform-action
A perform action invokes an action defined elsewhere as a step in the current behavior, reusing that action’s definition. It is written with the perform keyword inside an action body.
package P { action def A { perform action pa; } }
Normative clauses: SysML §7.17.6
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
Send Action
SysML — sysml.behavior.send-node
A send action dispatches a payload to a target so it can be accepted elsewhere. It is written with the send keyword and a to target inside an action body.
package P { action def A { action tgt; send sig to tgt; } }
Normative clauses: SysML §7.17.7
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
State Action Usage
SysML — sysml.behavior.state-action-usage
A state subaction (an entry, do, or exit action of a state) is modeled as an ActionUsage owned by the state through a StateSubactionMembership that carries the subaction kind (the grammar rule StateActionUsage returns ActionUsage). It lowers to an ActionUsage owned via a StateSubactionMembership — there is no distinct StateActionUsage metaclass.
package P { state def S { entry action e; do action d; exit action x; } }
Normative clauses: SysML §8.3.18.4
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
State Definition
SysML — sysml.behavior.state-definition
A state definition defines a reusable kind of state machine — a set of states and transitions the modelled system moves through. State usages instantiate it.
package P { state def SM { state s1; state s2; } }
Normative clauses: SysML §8.3.18.5
Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown
State Usage
SysML — sysml.behavior.state-usage
A state usage is an occurrence of a state in a state machine, optionally with entry, do, and exit behaviors. It is a stage the modelled system can occupy.
package P { state def SM { state s1; state s2; } }
Normative clauses: SysML §8.3.18.6
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Succession
SysML — sysml.behavior.succession
A succession orders behavior, requiring one action or step to complete before its successor begins. It connects a source occurrence to a target occurrence.
package P { action def A { action a1; action a2; first a1 then a2; } }
Normative clauses: SysML §8.3.13.6
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Succession Flow Usage
SysML — sysml.behavior.succession-flow-usage
A succession flow, written succession flow … from … to …, is a flow that also imposes a temporal succession between its ends. It lowers to a distinct SuccessionFlowUsage.
part def P { in item a; out item b; succession flow sf from a to b; }
Normative clauses: SysML §8.3.16.4
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Terminate Node
SysML — sysml.behavior.terminate-node
A terminate node (terminate) ends an occurrence during an action’s performance. It lowers to a distinct TerminateActionUsage — an ActionUsage specializing the Systems Library TerminateAction — whose terminatedOccurrence defaults to the performing occurrence.
package P { action def A { terminate; } }
Normative clauses: SysML §8.3.17.16
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Transition Usage
SysML — sysml.behavior.transition-usage
A transition usage specifies a change from a source state to a target state, optionally guarded by a condition and carrying trigger and effect behaviors. It is written with the transition keyword and a then target.
package P { state def TrafficLight { state red; state green; transition first red then green; } }
Normative clauses: SysML §8.3.18.9
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
While Loop Action
SysML — sysml.behavior.while-loop-node
A while loop action repeats a body action while a boolean condition holds, re-evaluating the condition before each iteration. It is written with the while keyword and a condition inside an action body.
package P { action def A { while true { action w; } } }
Normative clauses: SysML §7.17.12
Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown
Calc Always Has Result Parameter
SysML — sysml.validation.calc-always-has-result-parameter
A calculation always has a result parameter (inherited if not owned); evaluation always yields a result.
Normative clauses: SysML §7.19.2
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Decision Node Exactly One Outgoing
SysML — sysml.validation.decision-node-exactly-one-outgoing
A decision routes to exactly one outgoing branch per performance.
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
For Loop Iterates Over Sequence
SysML — sysml.validation.for-loop-iterates-over-sequence
A ForLoopAction assigns each successive value from seq to its var loop variable and performs body for each; internally implemented via a nested WhileLoopAction.
Normative clauses: SysML §8.4.13.10
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Fork Node Concurrent Fanout
SysML — sysml.validation.fork-node-concurrent-fanout
A fork orders itself before ALL outgoing targets (every branch activates).
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
If Action Evaluates Test Then Branch
SysML — sysml.validation.if-action-evaluates-test-then-branch
An IfThenAction evaluates its ifTest; if true, performs thenClause; an IfThenElseAction additionally performs elseClause when ifTest is false.
Normative clauses: SysML §8.4.13.9
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Interpolate Returns Null Out Of Bounds
SysML — sysml.validation.interpolate-returns-null-out-of-bounds
Interpolate returns null (no extrapolation) for an out-of-bounds input.
Normative clauses: SysML §9.4.3.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Join Node Synchronize All Incoming
SysML — sysml.validation.join-node-synchronize-all-incoming
A join is ordered after ALL incoming sources complete.
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Merge Node Any One Incoming
SysML — sysml.validation.merge-node-any-one-incoming
A merge fires once per exactly-one incoming control.
Normative clauses: SysML §7.17.3
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Mref Dimension Must Match Attribute
SysML — sysml.validation.mref-dimension-must-match-attribute
A supplied mRef must have the same quantity dimension as the attribute being bound/assigned/compared.
Normative clauses: SysML §9.8.9.1
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Quantity Arithmetic Dimension Rules
SysML — sysml.validation.quantity-arithmetic-dimension-rules
+/− require equal dimension; × multiplies dimensions; relational ops require same quantity type.
Normative clauses: SysML §9.8.9.1
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Sampled Function Must Be Monotonic
SysML — sysml.validation.sampled-function-must-be-monotonic
A SampledFunction’s domain values must be strictly increasing or decreasing.
Normative clauses: SysML §9.4.3.2 (nearest heading)
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
Send Action Initiates Message Transfer
SysML — sysml.validation.send-action-initiates-message-transfer
A send initiates a MessageTransfer carrying the payload from the sender.
Normative clauses: SysML §8.4.13.5
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown
While Loop Iterates While Test
SysML — sysml.validation.while-loop-iterates-while-test
A WhileLoopAction performs its body while whileTest evaluates to true and untilTest evaluates to false; terminates when whileTest is false or untilTest is true.
Normative clauses: SysML §8.4.13.10
Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown