{ "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.4rc1" }, "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "code", "collapsed": false, "input": [ "import spot\n", "spot.setup(show_default='.ban')\n", "from IPython.display import display" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 1 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Stutter-invariant languages\n", "\n", "A language $L$ is said to be _stutter-invariant_ iff $\\ell_0\\ldots\\ell_{i-1}\\ell_i\\ell_{i+1}\\ldots\\in L \\iff \\ell_0\\ldots\\ell_{i-1}\\ell_i\\ell_i\\ell_{i+1}\\ldots\\in L$, i.e., if duplicating a letter in a word or removing a duplicated letter does not change the membership of that word to $L$. These languages are also called _stutter-insensitive_. We use the adjective _sutter-sensitive_ to describe a language that is not stutter-invariant. Of course we can extend this vocabulary to LTL formulas or automata that represent stutter-invariant languages.\n", "\n", "Stutter-invariant languages play an important role in model checking. When verifying a stutter-invariant specification against a system, we know that we have some freedom in how we discretize the time in the model: as long as we do not hide changes of model variables that are observed by the specification, we can merge multiple steps of the model. This, combined by careful analysis of actions of the model that are independent, is the basis for a set of techniques known as _partial-order reductions_ (POR) that postpone the visit of some successors in the model, because we know we can always visit them later." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Stutter-invariant formulas\n", "\n", "When the specification is expressed as an LTL formula, a well known way to ensure it is _stutter-invariant_ is to forbid the use of the `X` operator. Testing whether a formula is `X`-free can be done in constant time using the `is_syntactic_stutter_invariant()` method." ] }, { "cell_type": "code", "collapsed": false, "input": [ "f = spot.formula('a U b')\n", "print(f.is_syntactic_stutter_invariant())" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "True\n" ] } ], "prompt_number": 2 }, { "cell_type": "code", "collapsed": false, "input": [ "f = spot.formula('a U Xb')\n", "print(f.is_syntactic_stutter_invariant())" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "False\n" ] } ], "prompt_number": 3 }, { "cell_type": "markdown", "metadata": {}, "source": [ "However some formula are syntactic-invariant despite their use of `X`. Spot implements some [automaton-based check](https://www.lrde.epita.fr/~adl/dl/adl/michaud.15.spin.pdf) to detect stutter-invariance reliably and efficiently. This can be tested with the `is_stutter_invariant()` function." ] }, { "cell_type": "code", "collapsed": false, "input": [ "g = spot.formula('F(a & X(!a & Gb))')\n", "print(g.is_syntactic_stutter_invariant())\n", "print(spot.is_stutter_invariant(g))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "False\n", "True\n" ] } ], "prompt_number": 4 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Of course this `is_stutter_invariant()` function first checks whether the formula is `X`-free before wasting time building automata, so if you want to detect stutter-invariant formulas in your model checker, this is the only function to use. Also, if you hapen to already have an automaton `aut_g` for `g`, you should pass it as a second argument to avoid it being recomputed: `spot.is_stutter_invariant(g, aut_g)`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is also known that any stutter-invariant LTL formula can be converted to an `X`-free LTL formula. Several proofs of that exist. Spot implements the rewriting of [K. Etessami](http://homepages.inf.ed.ac.uk/kousha/note_on_stut_tl_lpi.ps) under the name `remove_x()`. Note that the output of this function is only equivalent to its input if the latter is stutter-invariant." ] }, { "cell_type": "code", "collapsed": false, "input": [ "spot.remove_x(g)" ], "language": "python", "metadata": {}, "outputs": [ { "latex": [ "$\\mathsf{F} (a \\land ((a \\land (a \\mathbin{\\mathsf{U}} (\\lnot a \\land \\mathsf{G} b)) \\land ((\\lnot b \\mathbin{\\mathsf{U}} \\lnot a) \\lor (b \\mathbin{\\mathsf{U}} \\lnot a))) \\lor (\\lnot a \\land (\\lnot a \\mathbin{\\mathsf{U}} (a \\land \\lnot a \\land \\mathsf{G} b)) \\land ((\\lnot b \\mathbin{\\mathsf{U}} a) \\lor (b \\mathbin{\\mathsf{U}} a))) \\lor (b \\land (b \\mathbin{\\mathsf{U}} (\\lnot a \\land \\lnot b \\land \\mathsf{G} b)) \\land ((\\lnot a \\mathbin{\\mathsf{U}} \\lnot b) \\lor (a \\mathbin{\\mathsf{U}} \\lnot b))) \\lor (\\lnot b \\land (\\lnot b \\mathbin{\\mathsf{U}} (\\lnot a \\land b \\land \\mathsf{G} b)) \\land ((\\lnot a \\mathbin{\\mathsf{U}} b) \\lor (a \\mathbin{\\mathsf{U}} b))) \\lor (\\lnot a \\land \\mathsf{G} b \\land (\\mathsf{G} \\lnot a \\lor \\mathsf{G} a) \\land (\\mathsf{G} b \\lor \\mathsf{G} \\lnot b))))$" ], "metadata": {}, "output_type": "pyout", "prompt_number": 5, "text": [ "F(a & ((a & (a U (!a & Gb)) & ((!b U !a) | (b U !a))) | (!a & (!a U (a & !a & Gb)) & ((!b U a) | (b U a))) | (b & (b U (!a & !b & Gb)) & ((!a U !b) | (a U !b))) | (!b & (!b U (!a & b & Gb)) & ((!a U b) | (a U b))) | (!a & Gb & (G!a | Ga) & (Gb | G!b))))" ] } ], "prompt_number": 5 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Stutter-invariant automata" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly to formulas, automata use a few bits to store some known properties about themselves, like whether they represent a stutter-invariant language. This property can be checked with the `prop_stutter_invariant()` method, but that returns a `trival` instance (i.e., yes, no, or maybe). Some algorithms will update that property whenever that is cheap or expliclitely asked for. For instance `spot.translate()` only sets the property if the translated formula is `X`-free." ] }, { "cell_type": "code", "collapsed": false, "input": [ "aut = spot.translate(g)\n", "print(aut.prop_stutter_invariant())" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "maybe\n" ] } ], "prompt_number": 6 }, { "cell_type": "markdown", "metadata": {}, "source": [ "As suggested above, we can call `is_stutter_invariant()` by passing a formula and its automaton, to save on one translation. A second translation is still needed to complement the automaton." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print(spot.is_stutter_invariant(g, aut))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "True\n" ] } ], "prompt_number": 7 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that `prop_stutter_invariant()` was updated as a side-effect so that any futher call to `is_stutter_invariant()` with this automaton will be instantaneous." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print(aut.prop_stutter_invariant())" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "yes\n" ] } ], "prompt_number": 8 }, { "cell_type": "markdown", "metadata": {}, "source": [ "You have to be aware of this property being set in your back because if while playing with `is_stutter_invariant()` you the incorrect formula for an automaton by mistake, the automaton will have its property set incorrectly, and running `is_stutter_inariant()` with the correct formula will simply return the cached property.\n", "\n", "In doubt, you can always reset the property as follows:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "aut.prop_stutter_invariant(spot.trival_maybe())\n", "print(aut.prop_stutter_invariant())" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "maybe\n" ] } ], "prompt_number": 9 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In case you have an automaton for which you do not have formula, you can also use `is_stutter_invariant()` by passing this automaton as the first argument. In that case a negated automaton will be constructed by determinization. If you do happen to have a negated automaton handy, you can pass it as a second argument to avoid that." ] }, { "cell_type": "code", "collapsed": false, "input": [ "a1 = spot.automaton('''HOA: v1 \n", "AP: 1 \"a\" \n", "States: 2 \n", "Start: 0 \n", "Acceptance: 0 t\n", "--BODY-- \n", "State: 0 [0] 1 \n", "State: 1 [t] 0 \n", "--END--''')\n", "display(a1)\n", "print(spot.is_stutter_invariant(a1))" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "t\n", "[all]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\n", "\n", "1->0\n", "\n", "\n", "1\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce55870> >" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "False\n" ] } ], "prompt_number": 10 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Explaining why a formula is not sutter-invariant" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As explained in our [Spin'15 paper](https://www.lrde.epita.fr/~adl/dl/adl/michaud.15.spin.pdf) the sutter-invariant checks are implemented using simple operators suchs as `spot.closure(aut)`, that augment the language of L by adding words that can be obtained by removing duplicated letters, and `spot.sl(aut)` or `spot.sl2(aut)` that both augment the language that L by adding words that can be obtained by duplicating letters. The default `is_stutter_invariant()` function is implemented as `spot.product(spot.closure(aut), spot.closure(neg_aut)).is_empty()`, but that is just one possible implementation selected because it was more efficient.\n", "\n", "Using these bricks, we can modify the original algorithm so it uses a counterexample to explain why a formula is stutter-sensitive." ] }, { "cell_type": "code", "collapsed": false, "input": [ "def explain_stut(f):\n", " f = spot.formula(f)\n", " pos = spot.translate(f)\n", " neg = spot.translate(spot.formula_Not(f))\n", " word = spot.product(spot.closure(pos), spot.closure(neg)).accepting_word()\n", " if word is None:\n", " print(f, \"is stutter invariant\")\n", " return\n", " word.simplify()\n", " waut = word.as_automaton()\n", " if waut.intersects(pos):\n", " acc, rej, aut = \"accepted\", \"rejected\", neg\n", " else:\n", " acc, rej, aut = \"rejected\", \"accepted\", pos\n", " word2 = spot.sl2(waut).intersecting_word(aut)\n", " word2.simplify()\n", " print(\"\"\"{} is {} by {}\n", " but if we stutter some of its letters, we get\n", "{} which is {} by {}\"\"\".format(word, acc, f, word2, rej, f))" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 11 }, { "cell_type": "code", "collapsed": false, "input": [ "explain_stut('GF(a & Xb)')" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "cycle{!a & !b; a & b} is rejected by GF(a & Xb)\n", " but if we stutter some of its letters, we get\n", "cycle{!a & !b; a & b; a & b} which is accepted by GF(a & Xb)\n" ] } ], "prompt_number": 12 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Detecting stutter-invariant states\n", "\n", "Even if the language of an automaton is not sutter invariant, some of its states may recognize a stutter-invariant language. (We assume the language of a state is the language the automaton would have when starting from this state.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### First example\n", "\n", "For instance let us build a disjunction of a stutter-invariant formula and a stutter-sensitive one:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "f1 = spot.formula('F(a & X!a & XF(b & X!b & Ga))')\n", "f2 = spot.formula('F(a & Xa & XXa & G!b)')\n", "f = spot.formula_Or([f1, f2])\n", "\n", "print(spot.is_stutter_invariant(f1))\n", "print(spot.is_stutter_invariant(f2))\n", "print(spot.is_stutter_invariant(f))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "True\n", "False\n", "False\n" ] } ], "prompt_number": 13 }, { "cell_type": "code", "collapsed": false, "input": [ "pos = spot.translate(f)\n", "display(pos)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Inf(\n", "\u24ff\n", ")\n", "[B\u00fcchi]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "0->0\n", "\n", "\n", "1\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "0->2\n", "\n", "\n", "a & !b\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "1->3\n", "\n", "\n", "!a\n", "\n", "\n", "5\n", "\n", "5\n", "\n", "\n", "2->5\n", "\n", "\n", "a & !b\n", "\n", "\n", "3->3\n", "\n", "\n", "1\n", "\n", "\n", "4\n", "\n", "4\n", "\n", "\n", "3->4\n", "\n", "\n", "a & b\n", "\n", "\n", "6\n", "\n", "6\n", "\n", "\n", "5->6\n", "\n", "\n", "a & !b\n", "\n", "\n", "7\n", "\n", "7\n", "\n", "\n", "4->7\n", "\n", "\n", "a & !b\n", "\n", "\n", "7->7\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "6->6\n", "\n", "\n", "!b\n", "\u24ff\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce2e900> >" ] } ], "prompt_number": 14 }, { "cell_type": "markdown", "metadata": {}, "source": [ "While the automaton as a whole is stutter-sensitive, we can see that eventually we will enter a sub-automaton that is stutter-invariant.\n", "\n", "The `stutter_invariant_states()` function returns a Boolean vector indiced by the state number. A state is marked as `True` if either its language is stutter-invariant, or if it can only be reached via a stutter-invariant state (see the second example later). As always, the second argument, `f`, can be omitted (pass `None`) if the formula is unknown, or it can be replaced by a negated automaton if it is known. " ] }, { "cell_type": "code", "collapsed": false, "input": [ "spot.stutter_invariant_states(pos, f)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 15, "text": [ "(False, True, False, True, True, True, True, True)" ] } ], "prompt_number": 15 }, { "cell_type": "markdown", "metadata": {}, "source": [ "For convenience, the `highligh_...()` version colors the stutter-invariant states of the automaton for display.\n", "(That 5 is the color number for red in Spot's hard-coded palette.)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "spot.highlight_stutter_invariant_states(pos, f, 5)\n", "display(pos)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Inf(\n", "\u24ff\n", ")\n", "[B\u00fcchi]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "0->0\n", "\n", "\n", "1\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "0->2\n", "\n", "\n", "a & !b\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "1->3\n", "\n", "\n", "!a\n", "\n", "\n", "5\n", "\n", "5\n", "\n", "\n", "2->5\n", "\n", "\n", "a & !b\n", "\n", "\n", "3->3\n", "\n", "\n", "1\n", "\n", "\n", "4\n", "\n", "4\n", "\n", "\n", "3->4\n", "\n", "\n", "a & b\n", "\n", "\n", "6\n", "\n", "6\n", "\n", "\n", "5->6\n", "\n", "\n", "a & !b\n", "\n", "\n", "7\n", "\n", "7\n", "\n", "\n", "4->7\n", "\n", "\n", "a & !b\n", "\n", "\n", "7->7\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "6->6\n", "\n", "\n", "!b\n", "\u24ff\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce2e900> >" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Such a procedure gives us map of where POR can be enabled when model checking using such an automaton." ] }, { "cell_type": "heading", "level": 3, "metadata": {}, "source": [ "Second example" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This second example illustrates the fact that a state can be marked if it it not sutter-invariant but appear below a stutter-invariant state. We build our example automaton as the disjuction of the following two stutter-sensitive formulas, whose union is equivalent to the sutter-invariant formula `GF!a`." ] }, { "cell_type": "code", "collapsed": false, "input": [ "g1 = spot.formula('GF(a & Xa) & GF!a')\n", "g2 = spot.formula('!GF(a & Xa) & GF!a')\n", "g = spot.formula_Or([g1, g2])" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 17 }, { "cell_type": "code", "collapsed": false, "input": [ "print(spot.is_stutter_invariant(g1))\n", "print(spot.is_stutter_invariant(g2))\n", "print(spot.is_stutter_invariant(g))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "False\n", "False\n", "True\n" ] } ], "prompt_number": 18 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are the automata for `g1` and `g2`, note that none of the states are stutter-invariant." ] }, { "cell_type": "code", "collapsed": false, "input": [ "aut1 = spot.translate(g1)\n", "aut1.set_name(str(g1))\n", "spot.highlight_stutter_invariant_states(aut1, g1, 5)\n", "display(aut1)\n", "\n", "aut2 = spot.translate(g2)\n", "aut2.set_name(str(g2))\n", "spot.highlight_stutter_invariant_states(aut2, g2, 5)\n", "display(aut2)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "G(F(a & Xa) & F!a)\n", "Inf(\n", "\u24ff\n", ")&Inf(\n", "\u2776\n", ")\n", "[gen. B\u00fcchi 2]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "0->0\n", "\n", "\n", "!a\n", "\u2776\n", "\n", "\n", "0->0\n", "\n", "\n", "a\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "1->0\n", "\n", "\n", "a\n", "\n", "\n", "1->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce2e8d0> >" ] }, { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "FG(!a | X!a)\n", "Inf(\n", "\u24ff\n", ")\n", "[B\u00fcchi]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "0->0\n", "\n", "\n", "1\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "!a\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "0->2\n", "\n", "\n", "a\n", "\n", "\n", "1->1\n", "\n", "\n", "!a\n", "\u24ff\n", "\n", "\n", "1->2\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "2->1\n", "\n", "\n", "!a\n", "\u24ff\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce61d50> >" ] } ], "prompt_number": 19 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we build the sum of these two automata. The stutter-invariance check detects that the initial state is stutter-invariant (i.e., the entire language is stutter-invariant) so all states below it are marked despite the fact that the language recognized from these individual states would not be stutter-invariant." ] }, { "cell_type": "code", "collapsed": false, "input": [ "aut = spot.sum(aut1, aut2)\n", "# At this point it is unknown if AUT is stutter-invariant\n", "assert(aut.prop_stutter_invariant().is_maybe())\n", "spot.highlight_stutter_invariant_states(aut, g, 5)\n", "display(aut)\n", "# The stutter_invariant property is set on AUT as a side effect\n", "# of calling sutter_invariant_states() or any variant of it.\n", "assert(aut.prop_stutter_invariant().is_true())\n", "\n", "print(aut.to_str())" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "(Inf(\n", "\u24ff\n", ")&Inf(\n", "\u2776\n", ")) | Inf(\n", "\u2777\n", ")\n", "[Fin-less 3]\n", "\n", "\n", "5\n", "\n", "5\n", "\n", "\n", "I->5\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "5->0\n", "\n", "\n", "1\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "5->1\n", "\n", "\n", "a\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "5->2\n", "\n", "\n", "1\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "5->3\n", "\n", "\n", "!a\n", "\n", "\n", "4\n", "\n", "4\n", "\n", "\n", "5->4\n", "\n", "\n", "a\n", "\n", "\n", "0->0\n", "\n", "\n", "!a\n", "\u2776\n", "\n", "\n", "0->0\n", "\n", "\n", "a\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "1->0\n", "\n", "\n", "a\n", "\n", "\n", "1->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "2->2\n", "\n", "\n", "1\n", "\n", "\n", "2->3\n", "\n", "\n", "!a\n", "\n", "\n", "2->4\n", "\n", "\n", "a\n", "\n", "\n", "3->3\n", "\n", "\n", "!a\n", "\u2777\n", "\n", "\n", "3->4\n", "\n", "\n", "a\n", "\u2777\n", "\n", "\n", "4->3\n", "\n", "\n", "!a\n", "\u2777\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce2ea50> >" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "HOA: v1\n", "States: 6\n", "Start: 5\n", "AP: 1 \"a\"\n", "Acceptance: 3 (Inf(0)&Inf(1)) | Inf(2)\n", "properties: trans-labels explicit-labels trans-acc stutter-invariant\n", "--BODY--\n", "State: 0\n", "[!0] 0 {1}\n", "[0] 0\n", "[0] 1 {0}\n", "State: 1\n", "[0] 0\n", "[0] 1 {0}\n", "State: 2\n", "[t] 2\n", "[!0] 3\n", "[0] 4\n", "State: 3\n", "[!0] 3 {2}\n", "[0] 4 {2}\n", "State: 4\n", "[!0] 3 {2}\n", "State: 5\n", "[!0] 3\n", "[0] 1\n", "[0] 4\n", "[t] 0\n", "[t] 2\n", "--END--\n" ] } ], "prompt_number": 20 }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Third example\n", "\n", "These procedures work regardless of the acceptance condition. Here is an example with co-B\u00fcchi acceptance.\n", "\n", "In this case we do not even have a formula to pass as second argument, so the check will perform a complementation by determinization." ] }, { "cell_type": "code", "collapsed": false, "input": [ "aut = spot.automaton('randaut --seed=30 -Q4 -A\"Fin(0)\" a |')\n", "spot.highlight_stutter_invariant_states(aut, None, 5)\n", "display(aut)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Fin(\n", "\u24ff\n", ")\n", "[co-B\u00fcchi]\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "I->0\n", "\n", "\n", "\n", "\n", "0->0\n", "\n", "\n", "a\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "0->2\n", "\n", "\n", "!a\n", "\n", "\n", "2->0\n", "\n", "\n", "!a\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "2->3\n", "\n", "\n", "!a\n", "\n", "\n", "1\n", "\n", "1\n", "\u24ff\n", "\n", "\n", "1->3\n", "\n", "\n", "a\n", "\n", "\n", "3->1\n", "\n", "\n", "!a\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce2e960> >" ] } ], "prompt_number": 21 }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the negated automaton is already known, it can be passed as second argument (instead of the positive formula) to avoid unnecessary work." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sutter-invariance at the letter level\n", "\n", "Instead of marking each state as stuttering or not, we can list the letters that we can stutter in each state.\n", "More precisely, a state $q$ is _stutter-invariant for letter $a$_ if the membership to $L(q)$ of any word starting with $a$ is preserved by the operations that duplicate letters or remove duplicates. \n", "\n", "$(\\ell_0\\ldots\\ell_{i-1}\\ell_i\\ell_{i+1}\\ldots\\in L(q) \\land \\ell_0=a) \\iff (\\ell_0\\ldots\\ell_{i-1}\\ell_i\\ell_i\\ell_{i+1}\\ldots\\in L(q)\\land \\ell_0=a)$\n", "\n", "Under this definition, we can also say that $q$ is _stutter-invariant_ iff it is _stutter-invariant for any letter_.\n", "\n", "For instance consider the following automaton, for which all words that start with $b$ are stutter invariant.\n", "The initial state may not be declared as stutter-invariant because of words that start with $\\lnot b$." ] }, { "cell_type": "code", "collapsed": false, "input": [ "f = spot.formula('(!b&Xa) | Gb')\n", "pos = spot.translate(f)\n", "spot.highlight_stutter_invariant_states(pos, f, 5)\n", "display(pos)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Inf(\n", "\u24ff\n", ")\n", "[B\u00fcchi]\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "I->3\n", "\n", "\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "3->0\n", "\n", "\n", "!b\n", "\n", "\n", "1\n", "\n", "1\n", "\u24ff\n", "\n", "\n", "3->1\n", "\n", "\n", "b\n", "\n", "\n", "2\n", "\n", "2\n", "\u24ff\n", "\n", "\n", "0->2\n", "\n", "\n", "a\n", "\n", "\n", "2->2\n", "\n", "\n", "1\n", "\n", "\n", "1->1\n", "\n", "\n", "b\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79ce55e10> >" ] } ], "prompt_number": 22 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `stutter_invariant_letters()` functions returns a vector of BDDs indexed by state numbers. The BDD at index $q$ specifies all letters $\\ell$ for which state $q$ would be stuttering. Note that if $q$ is stutter-invariant or reachable from a stutter-invariant state, the associated BDD will be `bddtrue` (printed as `1` below).\n", "\n", "This interface is a bit inconveniant to use interactively, due to the fact that we need a `spot.bdd_dict` object to print a BDD." ] }, { "cell_type": "code", "collapsed": false, "input": [ "sil_vec = spot.stutter_invariant_letters(pos, f)\n", "for q in range(pos.num_states()):\n", " print(\"sil_vec[{}] =\".format(q), spot.bdd_format_formula(pos.get_dict(), sil_vec[q]))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "sil_vec[0] = 1\n", "sil_vec[1] = 1\n", "sil_vec[2] = 1\n", "sil_vec[3] = b\n" ] } ], "prompt_number": 23 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The set of stutter-invariant states is not always forward closed\n", "\n", "Consider the following automaton, which is a variant of our second example above. \n", "\n", "The language accepted from state (2) is `!GF(a & Xa) & GF!a` (this can be simplified to `FG(!a | X!a)`), while the language accepted from state (0) is `GF(a & Xa) & GF!a`. Therefore. the language accepted from state (5) is `a & X(GF!a)`. Since this is equivalent to `a & GF(!a)` state (5) recognizes stutter-invariant language, but as we can see, it is not the case that all states below (5) are also marked. In fact, states (0) can also be reached via states (7) and (6), recognizing respectively `(a & X(a & GF!a)) | (!a & X(!a & GF(a & Xa) & GF!a))` and `!a & GF(a & Xa) & GF!a))`, i.e., two stutter-sentive languages." ] }, { "cell_type": "code", "collapsed": false, "input": [ "ex1 = spot.automaton(\"\"\"HOA: v1 \n", "States: 8 Start: 7 AP: 1 \"a\" Acceptance: 2 (Inf(0)&Inf(1))\n", "--BODY--\n", "State: 0 [!0] 0 {1} [0] 0 [0] 1 {0}\n", "State: 1 [0] 0 [0] 1 {0}\n", "State: 2 [t] 2 [!0] 3 [0] 4\n", "State: 3 [!0] 3 {0 1} [0] 4 {0 1}\n", "State: 4 [!0] 3 {0 1}\n", "State: 5 [0] 0 [0] 2\n", "State: 6 [!0] 0\n", "State: 7 [!0] 6 [0] 5\n", "--END--\"\"\")\n", "spot.highlight_stutter_invariant_states(ex1,None, 5)\n", "display(ex1)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Inf(\n", "\u24ff\n", ")&Inf(\n", "\u2776\n", ")\n", "[gen. B\u00fcchi 2]\n", "\n", "\n", "7\n", "\n", "7\n", "\n", "\n", "I->7\n", "\n", "\n", "\n", "\n", "5\n", "\n", "5\n", "\n", "\n", "7->5\n", "\n", "\n", "a\n", "\n", "\n", "6\n", "\n", "6\n", "\n", "\n", "7->6\n", "\n", "\n", "!a\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "0->0\n", "\n", "\n", "!a\n", "\u2776\n", "\n", "\n", "0->0\n", "\n", "\n", "a\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "1->0\n", "\n", "\n", "a\n", "\n", "\n", "1->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "2->2\n", "\n", "\n", "1\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "2->3\n", "\n", "\n", "!a\n", "\n", "\n", "4\n", "\n", "4\n", "\n", "\n", "2->4\n", "\n", "\n", "a\n", "\n", "\n", "3->3\n", "\n", "\n", "!a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "3->4\n", "\n", "\n", "a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "4->3\n", "\n", "\n", "!a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "5->0\n", "\n", "\n", "a\n", "\n", "\n", "5->2\n", "\n", "\n", "a\n", "\n", "\n", "6->0\n", "\n", "\n", "!a\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79cdf1ba0> >" ] } ], "prompt_number": 24 }, { "cell_type": "markdown", "metadata": {}, "source": [ "This situation can be tested with `spot.is_stutter_invariant_forward_closed()`. The function returns `-1` if the successor of any stutter-invariant state is it is also a stutter-invariant state, otherwise it return the number of one stutter-sensitive state that has a stutter-invariant state as predecessor." ] }, { "cell_type": "code", "collapsed": false, "input": [ "sistates = spot.stutter_invariant_states(ex1)\n", "spot.is_stutter_invariant_forward_closed(ex1, sistates)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 25, "text": [ "0" ] } ], "prompt_number": 25 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In cases where we prefer to have a forward-closed set of stutter-invariant states, it is always possible to duplicate\n", "the problematic states. The `make_stutter_invariant_foward_closed_inplace()` modifies the automaton in place, and also returns an updated copie of the vector of stutter-invariant states." ] }, { "cell_type": "code", "collapsed": false, "input": [ "sistates2 = spot.make_stutter_invariant_forward_closed_inplace(ex1, sistates)\n", "spot.highlight_stutter_invariant_states(ex1, None, 5)\n", "display(ex1)\n", "print(sistates2)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "svg": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "Inf(\n", "\u24ff\n", ")&Inf(\n", "\u2776\n", ")\n", "[gen. B\u00fcchi 2]\n", "\n", "\n", "7\n", "\n", "7\n", "\n", "\n", "I->7\n", "\n", "\n", "\n", "\n", "5\n", "\n", "5\n", "\n", "\n", "7->5\n", "\n", "\n", "a\n", "\n", "\n", "6\n", "\n", "6\n", "\n", "\n", "7->6\n", "\n", "\n", "!a\n", "\n", "\n", "0\n", "\n", "0\n", "\n", "\n", "0->0\n", "\n", "\n", "!a\n", "\u2776\n", "\n", "\n", "0->0\n", "\n", "\n", "a\n", "\n", "\n", "1\n", "\n", "1\n", "\n", "\n", "0->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "1->0\n", "\n", "\n", "a\n", "\n", "\n", "1->1\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "2\n", "\n", "2\n", "\n", "\n", "2->2\n", "\n", "\n", "1\n", "\n", "\n", "3\n", "\n", "3\n", "\n", "\n", "2->3\n", "\n", "\n", "!a\n", "\n", "\n", "4\n", "\n", "4\n", "\n", "\n", "2->4\n", "\n", "\n", "a\n", "\n", "\n", "3->3\n", "\n", "\n", "!a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "3->4\n", "\n", "\n", "a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "4->3\n", "\n", "\n", "!a\n", "\u24ff\n", "\u2776\n", "\n", "\n", "5->2\n", "\n", "\n", "a\n", "\n", "\n", "8\n", "\n", "8\n", "\n", "\n", "5->8\n", "\n", "\n", "a\n", "\n", "\n", "8->8\n", "\n", "\n", "!a\n", "\u2776\n", "\n", "\n", "8->8\n", "\n", "\n", "a\n", "\n", "\n", "9\n", "\n", "9\n", "\n", "\n", "8->9\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "6->0\n", "\n", "\n", "!a\n", "\n", "\n", "9->8\n", "\n", "\n", "a\n", "\n", "\n", "9->9\n", "\n", "\n", "a\n", "\u24ff\n", "\n", "\n", "\n" ], "text": [ " *' at 0x7fc79cdf1ba0> >" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "(False, False, True, True, True, True, False, False, True, True)\n" ] } ], "prompt_number": 26 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, state 0 is no longuer a problem." ] }, { "cell_type": "code", "collapsed": false, "input": [ "spot.is_stutter_invariant_forward_closed(ex1, sistates2)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 27, "text": [ "-1" ] } ], "prompt_number": 27 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's see how infrequently the set of stutter-invarant states is not closed." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import spot.gen as gen\n", "\n", "try:\n", " import pandas\n", "except ImportError:\n", " import sys; sys.exit(77) # Our test suite will skip the rest if Pandas is missing" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 28 }, { "cell_type": "code", "collapsed": false, "input": [ "# Let's consider the LTL formula from the following 5 sources,\n", "# and restrict ourselves to formulas that are not stutter-invariant.\n", "formulas = [ f for f in gen.ltl_patterns(gen.LTL_DAC_PATTERNS, \n", " gen.LTL_EH_PATTERNS, \n", " gen.LTL_HKRSS_PATTERNS, \n", " gen.LTL_P_PATTERNS, \n", " gen.LTL_SB_PATTERNS)\n", " if not f.is_syntactic_stutter_invariant() ]\n", "\n", "fmt_txt = []\n", "aut_size = []\n", "sistates_size = []\n", "fwd_closed = []\n", "\n", "for f in formulas:\n", " fmt_txt.append(f.to_str())\n", " aut = spot.translate(f)\n", " aut_size.append(aut.num_states())\n", " sistates = spot.stutter_invariant_states(aut, f)\n", " sistates_size.append(sum(sistates))\n", " fwd_closed.append(spot.is_stutter_invariant_forward_closed(aut, sistates) == -1)\n", " \n", "# Put everything in a data frame for display.\n", "df = pandas.DataFrame({'formula': fmt_txt, 'states': aut_size, 'SIstates': sistates_size, 'fwd_closed': fwd_closed},\n", " columns=['formula','states','SIstates','fwd_closed'])\n", "display(df)" ], "language": "python", "metadata": { "scrolled": false }, "outputs": [ { "html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
formulastatesSIstatesfwd_closed
0Fp0 -> (!p0 U (!p0 & p1 & X(!p0 U p2)))32True
1Fp0 -> (!p1 U (p0 | (!p1 & p2 & X(!p1 U p3))))43True
2G!p0 | (!p0 U ((p0 & Fp1) -> (!p1 U (!p1 & p2 ...42True
3G((p0 & Fp1) -> (!p2 U (p1 | (!p2 & p3 & X(!p2...41True
4G(p0 -> (Fp1 -> (!p1 U (p2 | (!p1 & p3 & X(!p1...30True
5F(p0 & XFp1) -> (!p0 U p2)32True
6Fp0 -> (!(!p0 & p1 & X(!p0 U (!p0 & p2))) U (p...43True
7G!p0 | (!p0 U (p0 & (F(p1 & XFp2) -> (!p1 U p3...42True
8G((p0 & Fp1) -> (!(!p1 & p2 & X(!p1 U (!p1 & p...41True
9G(p0 -> ((!(!p1 & p2 & X(!p1 U (!p1 & p3))) U ...30True
10G((p0 & XFp1) -> XF(p1 & Fp2))61True
11Fp0 -> (((p1 & X(!p0 U p2)) -> X(!p0 U (p2 & F...62True
12G(p0 -> G((p1 & XFp2) -> X(!p2 U (p2 & Fp3))))50True
13G((p0 & Fp1) -> (((p2 & X(!p1 U p3)) -> X(!p1 ...102True
14G(p0 -> (((p1 & X(!p2 U p3)) -> X(!p2 U (p3 & ...100True
15G(p0 -> F(p1 & XFp2))40True
16Fp0 -> ((p1 -> (!p0 U (!p0 & p2 & X(!p0 U p3))...41True
17G(p0 -> G(p1 -> (p2 & XFp3)))33True
18G((p0 & Fp1) -> ((p2 -> (!p1 U (!p1 & p3 & X(!...40True
19G(p0 -> ((p1 -> (!p2 U (!p2 & p3 & X(!p2 U p4)...62True
20G(p0 -> F(p1 & !p2 & X(!p2 U p3)))40True
21Fp0 -> ((p1 -> (!p0 U (!p0 & p2 & !p3 & X((!p0...41True
22G(p0 -> G(p1 -> (p2 & !p3 & X(!p3 U p4))))33True
23G((p0 & Fp1) -> ((p2 -> (!p1 U (!p1 & p3 & !p4...40True
24G(p0 -> ((p1 -> (!p2 U (!p2 & p3 & !p4 & X((!p...62True
25p0 U (p1 & X(p2 U p3))32True
26p0 U (p1 & X(p2 & F(p3 & XF(p4 & XF(p5 & XFp6)...72True
27F(p0 & XGp1)22True
28F(p0 & X(p1 & XFp2))42True
29F(p0 & X(p1 U p2))31True
...............
33G((p0 & p1 & !p2 & Xp2) -> X(p3 | X(!p1 | p3)))30True
34G((p0 & p1 & !p2 & Xp2) -> X(X!p1 | (p2 U (!p2...55True
35G(p0 & p1 & !p2 & Xp2) -> X(X!p1 | (p2 U (!p2 ...11True
36G((!p0 & p1) -> Xp2)20True
37G(p0 -> X(p0 | p1))22True
38G((!(p1 <-> Xp1) | !(p0 <-> Xp0) | !(p2 <-> Xp...3434True
39G((p0 & !p1 & Xp1 & Xp0) -> (p2 -> Xp3))22True
40G(p0 -> X(!p0 U p1))20True
41G((!p0 & Xp0) -> X((p0 U p1) | Gp0))33True
42G((!p0 & Xp0) -> X(p0 U (p0 & !p1 & X(p0 & p1))))44True
43G((!p0 & Xp0) -> X(p0 U (p0 & !p1 & X(p0 & p1 ...66True
44G((p0 & X!p0) -> X(!p0 U (!p0 & !p1 & X(!p0 & ...66True
45G((p0 & X!p0) -> X(!p0 U (!p0 & !p1 & X(!p0 & ...88True
46G((!p0 & Xp0) -> X(!(!p0 & Xp0) U (!p1 & Xp1)))66True
47G(!p0 | X(!p0 | X(!p0 | X(!p0 | X(!p0 | X(!p0 ...120True
48G((Xp0 -> p0) -> (p1 <-> Xp1))44True
49G((Xp0 -> p0) -> ((p1 -> Xp1) & (!p1 -> X!p1)))44True
50p0 & XG!p021True
51XG(p0 -> (G!p1 | (!Xp1 U p2)))41True
52XG((p0 & !p1) -> (G!p1 | (!p1 U p2)))32True
53XG((p0 & p1) -> (Gp1 | (p1 U p2)))32True
54Xp0 & G((!p0 & Xp0) -> XXp0)50True
55(Xp0 U Xp1) | !X(p0 U p1)11True
56(Xp0 U p1) | !X(p0 U (p0 & p1))11True
57((Xp0 U p1) | !X(p0 U (p0 & p1))) & G(p0 -> Fp1)22True
58((Xp0 U Xp1) | !X(p0 U p1)) & G(p0 -> Fp1)22True
59!G(p0 -> X(p1 R p2))31True
60(p0 & Xp1) R X(((p2 U p3) R p0) U (p2 R p0))53True
61G(p0 | XGp1) & G(p2 | XG!p1)32True
62G(p0 | (Xp1 & X!p1))11True
\n", "

63 rows \u00d7 4 columns

\n", "
" ], "metadata": {}, "output_type": "display_data", "text": [ " formula states SIstates \\\n", "0 Fp0 -> (!p0 U (!p0 & p1 & X(!p0 U p2))) 3 2 \n", "1 Fp0 -> (!p1 U (p0 | (!p1 & p2 & X(!p1 U p3)))) 4 3 \n", "2 G!p0 | (!p0 U ((p0 & Fp1) -> (!p1 U (!p1 & p2 ... 4 2 \n", "3 G((p0 & Fp1) -> (!p2 U (p1 | (!p2 & p3 & X(!p2... 4 1 \n", "4 G(p0 -> (Fp1 -> (!p1 U (p2 | (!p1 & p3 & X(!p1... 3 0 \n", "5 F(p0 & XFp1) -> (!p0 U p2) 3 2 \n", "6 Fp0 -> (!(!p0 & p1 & X(!p0 U (!p0 & p2))) U (p... 4 3 \n", "7 G!p0 | (!p0 U (p0 & (F(p1 & XFp2) -> (!p1 U p3... 4 2 \n", "8 G((p0 & Fp1) -> (!(!p1 & p2 & X(!p1 U (!p1 & p... 4 1 \n", "9 G(p0 -> ((!(!p1 & p2 & X(!p1 U (!p1 & p3))) U ... 3 0 \n", "10 G((p0 & XFp1) -> XF(p1 & Fp2)) 6 1 \n", "11 Fp0 -> (((p1 & X(!p0 U p2)) -> X(!p0 U (p2 & F... 6 2 \n", "12 G(p0 -> G((p1 & XFp2) -> X(!p2 U (p2 & Fp3)))) 5 0 \n", "13 G((p0 & Fp1) -> (((p2 & X(!p1 U p3)) -> X(!p1 ... 10 2 \n", "14 G(p0 -> (((p1 & X(!p2 U p3)) -> X(!p2 U (p3 & ... 10 0 \n", "15 G(p0 -> F(p1 & XFp2)) 4 0 \n", "16 Fp0 -> ((p1 -> (!p0 U (!p0 & p2 & X(!p0 U p3))... 4 1 \n", "17 G(p0 -> G(p1 -> (p2 & XFp3))) 3 3 \n", "18 G((p0 & Fp1) -> ((p2 -> (!p1 U (!p1 & p3 & X(!... 4 0 \n", "19 G(p0 -> ((p1 -> (!p2 U (!p2 & p3 & X(!p2 U p4)... 6 2 \n", "20 G(p0 -> F(p1 & !p2 & X(!p2 U p3))) 4 0 \n", "21 Fp0 -> ((p1 -> (!p0 U (!p0 & p2 & !p3 & X((!p0... 4 1 \n", "22 G(p0 -> G(p1 -> (p2 & !p3 & X(!p3 U p4)))) 3 3 \n", "23 G((p0 & Fp1) -> ((p2 -> (!p1 U (!p1 & p3 & !p4... 4 0 \n", "24 G(p0 -> ((p1 -> (!p2 U (!p2 & p3 & !p4 & X((!p... 6 2 \n", "25 p0 U (p1 & X(p2 U p3)) 3 2 \n", "26 p0 U (p1 & X(p2 & F(p3 & XF(p4 & XF(p5 & XFp6)... 7 2 \n", "27 F(p0 & XGp1) 2 2 \n", "28 F(p0 & X(p1 & XFp2)) 4 2 \n", "29 F(p0 & X(p1 U p2)) 3 1 \n", ".. ... ... ... \n", "33 G((p0 & p1 & !p2 & Xp2) -> X(p3 | X(!p1 | p3))) 3 0 \n", "34 G((p0 & p1 & !p2 & Xp2) -> X(X!p1 | (p2 U (!p2... 5 5 \n", "35 G(p0 & p1 & !p2 & Xp2) -> X(X!p1 | (p2 U (!p2 ... 1 1 \n", "36 G((!p0 & p1) -> Xp2) 2 0 \n", "37 G(p0 -> X(p0 | p1)) 2 2 \n", "38 G((!(p1 <-> Xp1) | !(p0 <-> Xp0) | !(p2 <-> Xp... 34 34 \n", "39 G((p0 & !p1 & Xp1 & Xp0) -> (p2 -> Xp3)) 2 2 \n", "40 G(p0 -> X(!p0 U p1)) 2 0 \n", "41 G((!p0 & Xp0) -> X((p0 U p1) | Gp0)) 3 3 \n", "42 G((!p0 & Xp0) -> X(p0 U (p0 & !p1 & X(p0 & p1)))) 4 4 \n", "43 G((!p0 & Xp0) -> X(p0 U (p0 & !p1 & X(p0 & p1 ... 6 6 \n", "44 G((p0 & X!p0) -> X(!p0 U (!p0 & !p1 & X(!p0 & ... 6 6 \n", "45 G((p0 & X!p0) -> X(!p0 U (!p0 & !p1 & X(!p0 & ... 8 8 \n", "46 G((!p0 & Xp0) -> X(!(!p0 & Xp0) U (!p1 & Xp1))) 6 6 \n", "47 G(!p0 | X(!p0 | X(!p0 | X(!p0 | X(!p0 | X(!p0 ... 12 0 \n", "48 G((Xp0 -> p0) -> (p1 <-> Xp1)) 4 4 \n", "49 G((Xp0 -> p0) -> ((p1 -> Xp1) & (!p1 -> X!p1))) 4 4 \n", "50 p0 & XG!p0 2 1 \n", "51 XG(p0 -> (G!p1 | (!Xp1 U p2))) 4 1 \n", "52 XG((p0 & !p1) -> (G!p1 | (!p1 U p2))) 3 2 \n", "53 XG((p0 & p1) -> (Gp1 | (p1 U p2))) 3 2 \n", "54 Xp0 & G((!p0 & Xp0) -> XXp0) 5 0 \n", "55 (Xp0 U Xp1) | !X(p0 U p1) 1 1 \n", "56 (Xp0 U p1) | !X(p0 U (p0 & p1)) 1 1 \n", "57 ((Xp0 U p1) | !X(p0 U (p0 & p1))) & G(p0 -> Fp1) 2 2 \n", "58 ((Xp0 U Xp1) | !X(p0 U p1)) & G(p0 -> Fp1) 2 2 \n", "59 !G(p0 -> X(p1 R p2)) 3 1 \n", "60 (p0 & Xp1) R X(((p2 U p3) R p0) U (p2 R p0)) 5 3 \n", "61 G(p0 | XGp1) & G(p2 | XG!p1) 3 2 \n", "62 G(p0 | (Xp1 & X!p1)) 1 1 \n", "\n", " fwd_closed \n", "0 True \n", "1 True \n", "2 True \n", "3 True \n", "4 True \n", "5 True \n", "6 True \n", "7 True \n", "8 True \n", "9 True \n", "10 True \n", "11 True \n", "12 True \n", "13 True \n", "14 True \n", "15 True \n", "16 True \n", "17 True \n", "18 True \n", "19 True \n", "20 True \n", "21 True \n", "22 True \n", "23 True \n", "24 True \n", "25 True \n", "26 True \n", "27 True \n", "28 True \n", "29 True \n", ".. ... \n", "33 True \n", "34 True \n", "35 True \n", "36 True \n", "37 True \n", "38 True \n", "39 True \n", "40 True \n", "41 True \n", "42 True \n", "43 True \n", "44 True \n", "45 True \n", "46 True \n", "47 True \n", "48 True \n", "49 True \n", "50 True \n", "51 True \n", "52 True \n", "53 True \n", "54 True \n", "55 True \n", "56 True \n", "57 True \n", "58 True \n", "59 True \n", "60 True \n", "61 True \n", "62 True \n", "\n", "[63 rows x 4 columns]" ] } ], "prompt_number": 29 }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is no instance of set of stutter-invariant states that is not closed in these example formulas." ] }, { "cell_type": "code", "collapsed": false, "input": [ "sum(fwd_closed), len(fwd_closed)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 30, "text": [ "(63, 63)" ] } ], "prompt_number": 30 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is the percentage of stutter-invarant states." ] }, { "cell_type": "code", "collapsed": false, "input": [ "100*sum(sistates_size)/sum(aut_size)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 31, "text": [ "55.90277777777778" ] } ], "prompt_number": 31 } ], "metadata": {} } ] }