/* This function counts states and
* precomputes the post/pre sets
* for each state
* Therefore it simply traverses the tree
* and expands the new found nodes
* The counter "count" counts the outgoing transitions
* of the current state to determine
* if it is a terminal state
* If it was we set terminal_encountered to true
*/
private void compute_pre_post_list()
{
Queue <T> to_be_expanded = new Queue <T>();
T initialState;
transition_system.GetInitialState(out initialState);
to_be_expanded.Enqueue(initialState);
array.addToStates(initialState);
int size = to_be_expanded.Count;
while (size > 0)
{
int count = 0;
var state = to_be_expanded.Dequeue();
T successor;
foreach (var transition in transition_system.GetTransitions(ref state))
{
count++;
transition_system.GetTargetState(ref state, transition, out successor);
if (array.addToStates(successor))
{
to_be_expanded.Enqueue(successor);
}
int suc_ind = array.getIndex(successor);
int state_ind = array.getIndex(state);
array.addToPost(state, successor);
array.addToPre(successor, state);
}
if (count == 0)
{
terminal_encountered = true;
}
int ind = array.getIndex(state);
size = to_be_expanded.Count;
}
}
/*
* Uses the factory which we created at the very beginning to
* do the actual modelchecking
* For each state formula it gets the satisfaction set
* by using the state forumla class' method
* Then it checks whether the initial state is in that set or not
*/
public void ModelChecker <T>(TransitionSystem <T> transition_system, LinkedList <T> states, StateFormula state_formula, out bool isSatiesfied, ref Pre_Compute_Factory <T> factory)
where T : struct, Modest.Exploration.IState <T>
{
HashSet <T> sat;
state_formula.isSatiesfied <T>(transition_system, states, out sat, ref factory);
T initialState;
transition_system.GetInitialState(out initialState);
if (sat.Contains(initialState))
{
isSatiesfied = true;
}
else
{
isSatiesfied = false;
}
}
public void AnalyzeTransitionSystem <T>(TransitionSystem <T> transitionSystem, ModelProperty[] properties) // called from Program.cs
where T : struct, Modest.Exploration.IState <T>
{ /*
* // Implement your transition system analysis procedures here
* // For illustration, let's count the immediate successors of the initial state:
* var successors = new HashSet<T>(); // the state types implement proper .GetHashCode and .Equals methods based on structural equality
* T initialState, successorState;
* transitionSystem.GetInitialState(out initialState);
* foreach(var transition in transitionSystem.GetTransitions(ref initialState))
* {
* transitionSystem.GetTargetState(ref initialState, transition, out successorState);
* successors.Add(successorState);
* // We could evaluate properties using transitionSystem.HasAtomicProposition(ref successorState, ...) here;
* // also see the class diagram for properties (file Properties-Classes.png).
* }
* Console.WriteLine("The initial state has " + successors.Count.ToString(CI.InvariantCulture) + " distinct immediate successor state" + (successors.Count == 1 ? string.Empty : "s") + ".");
*/
// Write Tests into Files
//var testAnalyzer = new TestAnalyzer();
//testAnalyzer.writeTestFiles<T>(transitionSystem, properties);
T initialState;
transitionSystem.GetInitialState(out initialState);
var newStates = new Queue <T>();
newStates.Enqueue(initialState);
/*
* Use this factory to pre_compute everything
* See class implementation for more information
*/
Pre_Compute_Factory <T> factory = new Pre_Compute_Factory <T>(transitionSystem);
HashSet <T> states = factory.getStates();
Console.WriteLine("States: " + factory.number_states + "\n");
if (factory.terminal_encountered)
{
Console.WriteLine("Error: deadlocks detected\n");
return;
}
// Transform properties in State_Formulas;
var state_formulas = new Dictionary <String, StateFormula>();
foreach (var model_property in properties)
{
Property property = model_property.Property;
String name = model_property.Name;
StateFormula complete_formula = new SError();
bool is_ctl = true;
parseStateFormula(property, out complete_formula, ref is_ctl);
if (!is_ctl)
{
Console.WriteLine(name + ": not supported \n");
}
else
{
state_formulas.Add(name, complete_formula);
}
}
//Transform into ENF
var state_ENF = new Dictionary <String, StateFormula>();
foreach (var key_formula in state_formulas)
{
String name = key_formula.Key;
StateFormula enf_formula = key_formula.Value.existentialNormalForm();
state_ENF.Add(key_formula.Key, enf_formula);
}
// Now do the model checking
foreach (var entry in state_ENF)
{
String name = entry.Key;
StateFormula state_formula = entry.Value;
bool isSatisfied;
LinkedList <T> linked_states = new LinkedList <T>();
foreach (var entry_state in states)
{
linked_states.AddLast(entry_state);
}
ModelChecker <T>(transitionSystem, linked_states, state_formula, out isSatisfied, ref factory);
if (isSatisfied)
{
Console.WriteLine(name + ": true \n");
}
else
{
Console.WriteLine(name + ": false \n");
}
}
Environment.Exit(0);
}