/// <summary>
/// Check if the term represented by goal is reachable in the given model program.
/// Empty string as goal results in traversing the whole state space.
/// </summary>
/// <param name="mp">The model program to be checked.</param>
/// <param name="goal">The goal term involving the model program name as outer function symbol.</param>
/// <param name="excludeIsomorphicStates">Whether to use the symmetry reduction. Default is false.</param>
public static ReachabilityResult Check(ModelProgram mp, string goal, bool excludeIsomorphicStates = false)
{
Reachability reach = new Reachability();
reach.ModelProgram = mp;
reach.excludeIsomorphicStates = excludeIsomorphicStates;
return reach.CheckReachability(goal);
}
public MDPStrategy(ModelProgram modelProgram)
: base(modelProgram)
{
cov = new Dictionary<IState, double>();
v = new Dictionary<IState, double>();
cps = new Dictionary<int, Set<int>>();
}
/// <summary>
/// Construct a strategy with random action selection from the given model program.
/// </summary>
/// <param name="modelProgram">model program</param>
public Strategy(ModelProgram modelProgram)
{
if (modelProgram == null)
throw new ArgumentNullException("modelProgram");
this.modelProgram = modelProgram;
this.currState = modelProgram.InitialState;
this.initialState = modelProgram.InitialState;
}
/// <summary>
/// Инициализация модели.
/// </summary>
/// <param name = "program">Модель программы.</param>
/// <exception cref = "ArgumentNullException"><paramref name = "program" /> является <c>null</c>.</exception>
/// <remarks>
/// При инициализации модели совершается полный обход пространства
/// состояний. Состояния должны иметь тип <see cref = "SimpleState" />.
/// Списком атомарных высказываний назначается список всевозможных
/// существующих пар <c>x=y</c>, где <c>x</c> - имя переменной,
/// <c>y</c> - её значение.
/// </remarks>
public Model (ModelProgram program) {
if (program == null)
throw new ArgumentNullException ("program");
this.states = new Dictionary <int, List <string>> ();
this.transitions = new Dictionary <int, List <int>> ();
this.Prepare (program);
}
internal ComposedSignature(ModelProgram m1, ModelProgram m2)
{
Set <Symbol> allActionSymbols = m1.ActionSymbols().Union(m2.ActionSymbols());
this.actionSymbols = allActionSymbols;
this.m1ActionSymbols = allActionSymbols.Difference(m2.ActionSymbols());
this.m2ActionSymbols = allActionSymbols.Difference(m1.ActionSymbols());
this.sharedActionSymbols = m1.ActionSymbols().Intersect(m2.ActionSymbols());
}
public MDPNewStrategy(ModelProgram modelProgram)
: base(modelProgram)
{
cov = new Dictionary<int, double>();
v = new Dictionary<int, double>();
cps = new Dictionary<int, Set<int>>();
activeEdges = new Dictionary<int, Set<int>>();
passiveEdges = new Dictionary<int, Bag<int>>();
v[this.currState.GetHashCode()] = 1.0;
cov[this.currState.GetHashCode()] = 0.0;
}
private void Prepare (ModelProgram program) {
var actionSymbols = program.ActionSymbols ();
var _states = new Dictionary <SimpleState, int> ();
var _trans = new Dictionary <SimpleState, List <SimpleState>> ();
var frontier = new LinkedList <IState> (new [] { program.InitialState });
var stateIndex = 0;
while (frontier.Count > 0) {
var state = (SimpleState) frontier.First.Value;
frontier.RemoveFirst ();
if (! _states.ContainsKey (state))
_states.Add (state, stateIndex ++);
foreach (var action in actionSymbols.
Where (symbol => program.IsPotentiallyEnabled (state, symbol)).
SelectMany (symbol => program.GetActions (state, symbol))) {
TransitionProperties properties;
var target =
(SimpleState) program.GetTargetState (state, action, Set <string>.EmptySet, out properties);
if (! _trans.ContainsKey (state))
_trans.Add (state, new List <SimpleState> ());
_trans [state].Add (target);
if (! (_states.ContainsKey (target) || frontier.Contains (target)))
frontier.AddFirst (target);
}
}
foreach (var state in _states) {
var list = new List <string> ();
for (var i = 0; i < state.Key.LocationValuesCount; ++ i)
list.Add (string.Format ("{0}={1}", state.Key.GetLocationName (i), state.Key.GetLocationValue (i)));
this.states.Add (state.Value, list);
}
foreach (var transition in _trans) {
this.transitions.Add (_states [transition.Key],
transition.Value.Select (state => _states [state]).ToList ());
}
for (var i = 0; i < stateIndex; ++ i) {
if (! this.transitions.ContainsKey (i))
this.transitions.Add (i, new List <int> ());
}
}
/// <summary>
/// Constructs a model stepper for a given test suite and a given model program,
/// using the product of the test suite and the model program.
/// </summary>
/// <param name="startTest">name of start action of a test case</param>
/// <param name="testsuite">given test suite as a nonempty sequence of test cases</param>
/// <param name="mp">given model program</param>
public TestSuiteStepper(string startTest, Sequence<Sequence<CompoundTerm>> testsuite, ModelProgram mp)
: base(CreateModelProgram(startTest, testsuite, mp))
{
if (testsuite == null ||
testsuite.IsEmpty ||
testsuite.Exists(delegate(Sequence<CompoundTerm> testcase)
{
return (testcase == null || testcase.IsEmpty);
}))
throw new ConformanceTesterException("Invalid test suite, the test suite must be a nonempty sequence of nonempty action sequences.");
this.currentTest = testsuite.Head.AddFirst((CompoundTerm)Term.Parse(startTest + "(" + 0 + ")"));
this.testsuite = testsuite.Tail;
this.currentTestInProgress = false;
this.testnr = 1;
this.startTest = startTest;
}
internal ComposedSignature(ModelProgram m1, ModelProgram m2)
{
Set<Symbol> allActionSymbols = m1.ActionSymbols().Union(m2.ActionSymbols());
this.actionSymbols = allActionSymbols;
this.m1ActionSymbols = allActionSymbols.Difference(m2.ActionSymbols());
this.m2ActionSymbols = allActionSymbols.Difference(m1.ActionSymbols());
this.sharedActionSymbols = m1.ActionSymbols().Intersect(m2.ActionSymbols());
}
/// <summary>
/// Used internally by the derived viewer that may also set the modelprogram
/// </summary>
internal void SetStateMachine(FSM fa, StateProvider stateProvider, ModelProgram mp1, Set<Transition> groupingTransitions)
{
// Clear the node and transition tables and the cache
this.mp = mp1;
// nodes.Clear(); // not needed for mp2dot, I believe
// transitions.Clear(); // ditto
//reductCache.Clear();
//this.faInfo = new FAInfo(this.stateViewer1.DefaultModelName, fa, stateProvider, mp1);
this.faInfo = new FAInfo("Fsm", fa, stateProvider, mp1); // defined in StateView.cs
this.finiteAutomatonContext = new FAContext(fa, stateProvider, faInfo.ReductNames.Last, mp1);
this.finiteAutomatonContext.groupingTransitions = groupingTransitions;
//this.reductCache[this.faInfo.ReductNames.Last] = this.finiteAutomatonContext;
// removed code here
}
static ModelProgram CreateModelProgram(string startTest, Sequence<Sequence<CompoundTerm>> testsuite, ModelProgram mp)
{
Set<Symbol> symbs = Set<Symbol>.EmptySet;
foreach (Sequence<CompoundTerm> testcase in testsuite)
foreach (CompoundTerm action in testcase)
symbs = symbs.Add(action.Symbol);
FSM fa = FsmTraversals.GenerateTestSequenceAutomaton(startTest, testsuite, symbs);
FsmModelProgram fsmmp = new FsmModelProgram(fa, "TestSuite");
if (mp == null)
return fsmmp;
else
return new ProductModelProgram(fsmmp, mp);
}
FAName GetModelName(ModelProgram mp1)
{
IName nameProvider = mp1 as IName;
if (nameProvider != null)
return new FAName(Disambiguate(nameProvider.Name));
return new FAName(Disambiguate(this.defaultModelName));
}
//do postorder traversal
private Sequence<ReductName> GetSubFANames(Sequence<FSMBuilder.Branch> treePosition, ModelProgram mp1)
{
ProductModelProgram pmp = mp1 as ProductModelProgram;
if (pmp != null)
{
Sequence<ReductName> leftChildren =
GetSubFANames(treePosition.AddLast(FSMBuilder.Branch.Left),
pmp.M1);
Sequence<ReductName> rightChildren =
GetSubFANames(treePosition.AddLast(FSMBuilder.Branch.Right),
pmp.M2);
ReductName name = new ReductName(treePosition,
new FAName(leftChildren.Last.name,rightChildren.Last.name));
return leftChildren.Concatentate(rightChildren).AddLast(name);
}
else
{
return new Sequence<ReductName>(new ReductName(treePosition, GetModelName(mp1)));
}
}
/// <summary>
/// Builder that can create a finite automaton by exploring the possible steps of a model program.
/// </summary>
/// <param name="m">Model program to be explored</param>
public FSMBuilder(ModelProgram m) : this(m, null)
{
}
internal FAInfo(string defaultModelName,
FSM fa, StateProvider stateProvider, ModelProgram mp)
{
this.fa = fa;
this.stateProvider = stateProvider;
this.defaultModelName = defaultModelName;
this.nameDisambiguator = new Dictionary<string, int>();
this.mp = mp;
}
/// <summary>
/// Builder that can create a finite automaton by exploring the possible steps of a model program.
/// </summary>
/// <param name="m">Model program to be explored</param>
/// <param name="transitionPredicate">User defined predicate that returns true if a
/// transition is to be included in the gererated finite automaton</param>
public FSMBuilder(ModelProgram m, TransitionPredicate transitionPredicate)
{
this.modelProgram = m;
this.transitionPredicate = transitionPredicate;
}
internal ExploredTransitions(ModelProgram modelProgram, int initTransitions, int maxTransitions)
{
this.modelProgram = modelProgram;
this.transitions = Set<Transition>.EmptySet;
this.groupingTransitions = Set<Transition>.EmptySet;
Node initNode = new Literal(0);
this.initialNode = initNode;
this.nodes = new Set<Node>(initNode);
this.acceptingNodes = (modelProgram.IsAccepting(modelProgram.InitialState) ?
new Set<Node>(initNode) :
Set<Node>.EmptySet);
//this.errorNodes = (!modelProgram.SatisfiesStateInvariant(modelProgram.InitialState) ?
// new Set<Node>(initNode) :
// Set<Node>.EmptySet);
Dictionary<Node, IState> initialStateMap =
new Dictionary<Node, IState>();
initialStateMap[initNode] = modelProgram.InitialState;
this.stateMap = initialStateMap;
actionsExploredFromNode = new Dictionary<Node, Dictionary<CompoundTerm,Node>>();
Dictionary<IState, Node> initialNodeMap =
new Dictionary<IState, Node>();
initialNodeMap[modelProgram.InitialState] = initNode;
this.nodeMap = initialNodeMap;
this.hiddenTransitions = Set<Transition>.EmptySet;
this.maxTransitions = maxTransitions;
this.initTransitions = initTransitions;
}
/// <summary>
/// Construct a model stepper that records coverage points.
/// </summary>
/// <param name="modelProgram">model program</param>
/// <param name="policy">reward policy</param>
/// <param name="coveragePointProvider">(optional) coverage point provider</param>
public StrategyWithCoverage(ModelProgram modelProgram, RewardPolicy policy, CoveragePointDelegate coveragePointProvider)
: base(modelProgram)
{
this.policy = policy;
this.coveragePointProvider = coveragePointProvider;
}
/// <summary>
/// Process the goal in the format "ModelProgramName1(stateName1(value1)),ModelProgramName2(stateName2(value2)" to a compound term of the corresponding model program.
/// In the case of FSMs the format is "ModelProgramName(stateNumber)".
/// </summary>
/// <param name="mp">model program</param>
/// <param name="goalString">goal as string</param>
/// <returns>A set of compound terms corresponding to the goal string.</returns>
internal Set<CompoundTerm> processGoal(ModelProgram mp, string goalString)
{
Set<CompoundTerm> processedGoals = Set<CompoundTerm>.EmptySet;
if (goalString == "") return processedGoals;
string[] subgoals = goalString.Split(',');
Set<CompoundTerm> goals = Set<CompoundTerm>.EmptySet;
try
{
foreach (string g in subgoals)
{
CompoundTerm ct = CompoundTerm.Parse(g);
goals = goals.Add(ct);
}
}
catch (Exception e)
{
Console.Error.WriteLine("The goal '" + goalString + "' seems not to be a term. " +
"Goal should be in the form ModelProgramName(state) " +
"(or several such terms separated by commas).");
Console.Error.WriteLine("The error message: ", e.Message);
return processedGoals;
}
return processGoal(mp, goals);
}
/// <summary>
/// Construct a model stepper that records coverage points.
/// Coverage points of interest are provided by <paramref name="transitionPropertyNames"/>
/// </summary>
/// <param name="modelProgram">model program</param>
/// <param name="policy">reward policy</param>
/// <param name="transitionPropertyNames">(optional) coverage points of interest</param>
public StrategyWithCoverage(ModelProgram modelProgram, RewardPolicy policy, Set<string> transitionPropertyNames)
: base(modelProgram)
{
this.policy = policy;
this.coveragePointProvider = new CoveragePointProvider(modelProgram, transitionPropertyNames).GetCoveragePoints;
}
ComposedSignature signature; // cache: equals m1.ActionSymbols union m2.ActionSymbols
#endregion Fields
#region Constructors
/// <summary>
/// Constructs m1 * m2
/// </summary>
public ProductModelProgram(ModelProgram m1, ModelProgram m2)
{
this.signature = new ComposedSignature(m1, m2);
this.m1 = m1;
this.m2 = m2;
}
public MDPNewAbstractStrategy(ModelProgram modelProgram):
base(modelProgram)
{
requirementProperties = Sequence<string>.EmptySequence;
requireEnabledStateMap = Map<string, Set<int>>.EmptyMap;
activeEdges = new Dictionary<int, Set<int>>();
passiveEdges = new Dictionary<int, Bag<int>>();
bdt = new BinaryDecisionTree("root", null, null,1,1, new Set<int>(currState.GetHashCode()));
}
private static IStrategy CreateModelStepper(List<Assembly> libs, ModelProgram mp,
string/*?*/ msName, string[]/*?*/ coverage, Set<Symbol> obs)
{
//if no model stepper name is provided, use the default one and ignore coverage
if (msName == null)
return new Strategy(mp);
//check if one of the supported model steppers is used
if (msName.Equals(typeof(StrategyWithCoverage).FullName + ".CreateWithMaximumReward"))
return StrategyWithCoverage.CreateWithMaximumReward(mp, coverage);
//check if one of the supported model steppers is used
if (msName.Equals(typeof(StrategyWithCoverage).FullName + ".CreateWithProbableReward"))
return StrategyWithCoverage.CreateWithProbableReward(mp, coverage);
string msMethodName;
string msClassName;
ReflectionHelper.SplitFullMethodName(msName, out msClassName, out msMethodName);
Type msType = ReflectionHelper.FindType(libs, msClassName);
MethodInfo msMethod = ReflectionHelper.FindMethod(msType, msMethodName, new Type[] { typeof(ModelProgram), typeof(string[]) } , typeof(IStrategy));
IStrategy ms = null;
try
{
ms = (IStrategy)msMethod.Invoke(null, new object[] { mp, coverage });
ms.ObservableActionSymbols = obs;
}
catch (Exception e)
{
throw new ModelProgramUserException("Invocation of '" + msName + "' failed: " + e.ToString());
}
return ms;
}
/// <summary>
/// Used internally by the derived viewer that may also set the modelprogram
/// </summary>
internal void SetStateMachine(FSM fa, StateProvider stateProvider, ModelProgram mp1, Set<Transition> groupingTransitions)
{
// Clear the node and transition tables and the cache
this.mp = mp1;
nodes.Clear();
transitions.Clear();
//reductCache.Clear();
this.faInfo = new FAInfo(this.stateViewer1.DefaultModelName, fa, stateProvider, mp1);
this.finiteAutomatonContext = new FAContext(fa, stateProvider, faInfo.ReductNames.Last, mp1);
this.finiteAutomatonContext.groupingTransitions = groupingTransitions;
//this.reductCache[this.faInfo.ReductNames.Last] = this.finiteAutomatonContext;
this.projectionButton.Text = " " + faInfo.ReductNames.Last.name.ToString();
this.projectionButton.ToolTipText = faInfo.ReductNames.Last.name.ToString();
if (faInfo.IsProduct)
{
this.projectionButton.Enabled = true;
EnableProjection();
}
else
{
this.projectionButton.Enabled = false;
}
graphChanged = true;
PerformLayout();
}
/// <summary>
/// Creates a model stepper that uses coverage points (when != null) to direct the selection of actions.
/// If coverage == null, uses default coverage points that are (state.GetHashCode(), action.GetHashCode()) pairs.
/// Uses RewardPolicy.ProbableReward for action selection.
/// </summary>
/// <param name="modelProgram">given model program</param>
/// <param name="coverage">given coverage point names (may be null)</param>
public static StrategyWithCoverage CreateWithProbableReward(ModelProgram modelProgram, string[]/*?*/ coverage)
{
if (coverage == null)
return new StrategyWithCoverage(modelProgram, RewardPolicy.ProbableReward);
else
return new StrategyWithCoverage(modelProgram, RewardPolicy.ProbableReward, new Set<string>(coverage));
}
/// <summary>
/// Builder that can create a finite automaton by exploring the possible steps of a model program.
/// </summary>
/// <param name="m">Model program to be explored</param>
public FSMBuilder(ModelProgram m)
: this(m,null)
{
}
/// <summary>
/// Construct a model stepper that records coverage points.
/// Defines the coverage point for a given action a and state s
/// as the bag containig the pair (s.GetHashCode(),a.GetHashCode())
/// </summary>
/// <param name="modelProgram">model program</param>
/// <param name="policy">reward policy</param>
public StrategyWithCoverage(ModelProgram modelProgram, RewardPolicy policy)
: base(modelProgram)
{
this.policy = policy;
this.coveragePointProvider = DefaultCoveragePointProvider;
}
/// <summary>
/// Builder that can create a finite automaton by exploring the possible steps of a model program.
/// </summary>
/// <param name="m">Model program to be explored</param>
/// <param name="transitionPredicate">User defined predicate that returns true if a
/// transition is to be included in the gererated finite automaton</param>
public FSMBuilder(ModelProgram m, TransitionPredicate transitionPredicate)
{
this.modelProgram = m;
this.transitionPredicate = transitionPredicate;
}
internal Set<CompoundTerm> processGoal(ModelProgram mp, Set<CompoundTerm> goals)
{
Set<CompoundTerm> processedGoals = Set<CompoundTerm>.EmptySet;
if (typeof(LibraryModelProgram) == mp.GetType())
{
//we ignore it for the moment
Console.Error.WriteLine("Goals involving LibraryModelPrograms currently not supported. ");
Console.Error.WriteLine("Currently searching for a match for '" + goals.ToString() + "'. ");
}
else if (typeof(FsmModelProgram) == mp.GetType()) {
FsmModelProgram fsm = (FsmModelProgram)mp;
foreach (CompoundTerm ct in goals)
{
Console.WriteLine("Checking FSM: " + ct.ToString() + "; " + fsm.Name);
if (ct.FunctionSymbol.ToString() == fsm.Name) {
processedGoals = processedGoals.Add(CompoundTerm.Parse("FsmState(Set(" + ct.Arguments[0].ToString() + "))"));
goals = goals.Remove(ct);
}
Console.WriteLine("Current processedGoals: " + processedGoals.ToString());
}
}
else if (typeof(ProductModelProgram) == mp.GetType())
{
ProductModelProgram pmp = (ProductModelProgram)mp;
processedGoals = processedGoals.Union(processGoal(pmp.M1,goals));
processedGoals = processedGoals.Union(processGoal(pmp.M2,goals));
}
return processedGoals;
}
/// <summary>
/// Creates a model stepper that uses coverage points (when != null) to direct the selection of actions.
/// If coverage == null, uses default coverage points that are (state.GetHashCode(), action.GetHashCode()) pairs.
/// Uses RewardPolicy.MaximumReward for action selection.
/// </summary>
/// <param name="modelProgram">given model program</param>
/// <param name="coverage">given coverage point names (may be null)</param>
public static MDPStrategy CreateMDPStrategy(ModelProgram modelProgram, string[]/*?*/ coverage)
{
//return new MDPStrategy(modelProgram,new Set<string>(coverage));
return new MDPStrategy(modelProgram);
}
/// <summary>
/// Create a coverage point provider for a model program and a given set of property names
/// </summary>
/// <param name="mp">given model program</param>
/// <param name="transitionPropertyNames">property names of interest</param>
public CoveragePointProvider(ModelProgram mp, Set<string> transitionPropertyNames)
{
this.mp = mp;
this.transitionPropertyNames = transitionPropertyNames;
}
internal FAContext(FSM fa, StateProvider stateProvider, ReductName reductName, ModelProgram mp)
{
this.fa = fa;
this.stateProvider = stateProvider;
this.reductName = reductName;
this.mp = mp;
this.deadNodes = FsmTraversals.GetDeadStates(fa);
this.unsafeNodes = Set<Node>.EmptySet;
this.groupingTransitions = Set<Transition>.EmptySet;
}
/// <summary>
/// Sets the initial state of the view
/// </summary>
/// <param name="modelProgram">given model program to be viewed</param>
public void SetModelProgram(ModelProgram modelProgram1)
{
this.modelProgram = modelProgram1;
this.exploredTransitions = new ExploredTransitions(modelProgram1, this.initialTransitions, this.maxTransitions);
this.exploredTransitions.excludeIsomorphicStates = this.ExcludeIsomorphicStates;
this.exploredTransitions.collapseExcludedIsomorphicStates = this.collapseExcludedIsomorphicStates;
this.exploredTransitions.ShowReachable(this.exploredTransitions.initialNode);
this.InitializeViewer();
}
ComposedSignature signature; // cache: equals m1.ActionSymbols union m2.ActionSymbols
/// <summary>
/// Constructs m1 * m2
/// </summary>
public ProductModelProgram(ModelProgram m1, ModelProgram m2)
{
this.signature = new ComposedSignature(m1, m2);
this.m1 = m1;
this.m2 = m2;
}