Defining diagram behaviour using state actions and transition labels

State actions and transition actions are instructions that you write inside a state or transition, respectively, to define the behaviour of the diagram during simulation.

Consider a model with a finite automaton that empirically tests one variant of the Collatz hypothesis. For a given numeric input $u$, the diagram computes the Collatz sequence $n_0=u,n_1,n_2,...$ by repeating the rule:

• If $n_i$ is even, then $n_{i+1}=n_i/2$
• If $n_i$ is odd, then $n_{i+1}=3n_i+1$

The Collatz hypothesis states that for every natural number, there is a sequence of numbers that eventually reduces to one.

The diagram consists of three states. At the beginning of the simulation, the Init state initialises the diagram data by setting:

• Local data n corresponds to the input value u.
• Local data n2 is converted to a remainder when n is divided by 2.
• Output data y is set to false

Depending on the parity of the input data, the diagram switches to either the Even or Odd state. As the state activity switches between Even and Odd states, the diagram calculates the numbers in the sequence. When the number-grid sequence reaches the value 1, the y output becomes true and the simulation stops.

Types of state actions

State actions define what the state diagram does while the state is active. The most common types of state actions are entry, during, and exit:

• entry - actions occur when a state becomes active.

• during - actions occur at a time step when the state is already active and the diagram does not transition out of that state.

• exit - actions occur when the diagram exits this state.

You can specify the state action type using the full keyword (entry, during, exit) or abbreviation (en, du, ex). You can also combine state action types by using commas. For example, an action with the combined type entry, during occurs at the time step when the state becomes active and at each subsequent time step as long as the state remains active.

The gradient diagram contains actions in states:

• Init - when this state becomes active at the start of the simulation, the entry action determines the parity of n and sets y to false. When the diagram leaves the Init state after one time step, the exit action determines whether n is equal to one.

• Even - When this state becomes active, and at each subsequent time step while the state is active, the combined entry, during action calculates the value and parity for the next number in the hail sequence, n/2.

• Odd - When this state becomes active, and at each subsequent time step while the state is active, the combined entry, during action checks if n is greater than one and, if so, calculates the value and parity for the next number in the sequence of hailstones, 3*n+1.

Types of transition labels

Transition labels define what the state diagram does when the active state changes. The most common types of transition labels are conditions and condition actions: [Condition]{Action}.

• A condition is a logical expression that specifies whether a transition occurs. If you do not specify a condition, the transition will occur one time step after the initial state becomes active.

• A condition action is an instruction that is executed when the condition that provides the transition is true. A condition action is executed after the condition, but before any exit or entry state actions.

A gradient diagram contains actions over transitions:

• Default transition in Init - at the beginning of the simulation, the condition action $n = u$ assigns the input value u to the local data n.

• Transition from Init to Even - the $n2 == 0$ condition specifies that the transition occurs when n is even. The number 1 in the source of this transition indicates that this transition is evaluated before the transition of Init to Odd.

• Transition from Odd to Even - the condition $n2 == 0$ specifies that the transition occurs when n is even.

• Transition from Even to Odd - the condition $n2 ~= 0$ determines that the transition occurs when n is odd. In this case, the action of the $y = isequal(n,1)$ condition determines whether n is equal to one.

Study the behaviour of the diagram

Let's run a simulation for a hailstone sequence starting with the value 9. To do this, use the command control to load and run the model collatz.engee.

modelName = "collatz";
model = modelName in [m.name for m in engee.get_all_models()] ? engee.open( modelName ) : engee.load( "$(@__DIR__)/$(modelName).engee");

results = engee.run( modelName )

SimulationResult(
    "n" => WorkspaceArray{Float64}("collatz/n")
,
    "y" => WorkspaceArray{Float64}("collatz/y")

)

Let's get the results and study the behaviour of the diagram.

res_n = results["n"].value;
res_t = results["n"].time;

bar(res_t, res_n) 

State diagram

• At the time $t = 0$, the default transition to the Init state occurs. The transition action sets the value of n to 9. The Init state becomes active. Actions in entry set Init value n2 to 1 and y to false.

• At the moment of time $t = 1$ the condition n2 == 0 is not fulfilled, so the diagram is preparing for transition to Odd. The exit action in Init sets y to false. The Init state becomes inactive and the Odd state becomes active. The entry action in Odd sets n to 28 and n2 to 0.

• At time $t = 2$ the condition n2 == 0 is true, so the diagram prepares to transition to Even. The Odd state becomes inactive and the Even state becomes active. The action of entering Even sets n to 14 and n2 to 0.

• At time $t = 3$ the condition n2 ~= 0 is not fulfilled, so the diagram does not transition to another state. The Even state remains active. The action in the during set Even sets n to 7 and n2 to 1.

• During $t = 4$ condition n2 ~= 0 is true, so the diagram prepares to transition to Odd. The transition action sets y to false. The Even state becomes inactive and the Odd state becomes active. The actions of entry to Odd set n to 22 and n2 to 0.

• The graph continues to calculate the hail sequence until it reaches the value $n = 1$ at time $t = 19$.

• While $t = 20$ is running, the graph prepares to transition from Even to Odd. The transition action sets y to true. The Even state becomes inactive and the Odd state becomes active. The entry actions in Odd do not change n or n2.

You can also run the model simulation from the modelling environment. To do this, open the model collatz.engee and run it. You can then look at the result of the simulation in the "Graphs" window or in the "Data Inspector" application.

1. On the "Applications" tab in the upper right corner, go to the "Data Inspector" section.

2. To see the hail sequence values, select the recorded signal n in the Data Inspector.

Conclusion

The "hail" sequence reaches the value of 1 after 19 iterations. You can also do the experiment with other numbers.

Blocks used in example

• Chart
• Constant
• Out1