Logic: Lecture 23, 17 November 2015
-----------------------------------
 
(Reference: Applied Automata Theory by Wolfgang Thomas, Chapter 1.4)

View a finite word as encoding a sequence of states rather than a
sequence of actions.

Can we characterize the first order theory of this class of structures?

Star-free expressions
----------------------

- emptyset, emptystring
- a in Sigma
- concatenation, union, intersection
- complementation

Star-free => FO
----------------

Star-free expression e defines a language L(e)

For each expression e, inductively construct a formula phi_e(i,j)
that says the string from position i to position j belongs to
L(e)

FO=>Star-free is more difficult.  Go via automata theory
(aperiodic automata).

LTL => FO
----------

Recall semantics of LTL

  System    : (S,sin,->,v)
    sigma = s0 s1 ... sn is a run of the sytem

    sigma,i |= phi,  i is a position in {0,2,...,n}

  FO translation over the structure ({0,1,..,n}, succ, <, {Q_p})

  - In FO, < is not definable in terms of succ, so need both
  - Q_p is predicate describing positions where p holds
      Q_p = {i | p in v(si)}
  - Assume min, max etc

  Define alpha_{phi}(x) in FO, by induction on phi
  - x is a position
  - alpha_phi(i) is true in FO iff sigma,i |= phi

  alpha_{p}(x) = Q_p(x)
  alpha_{~phi}(x) = ~alpha_{phi}(x)
  alpha_{phi or psi}(x) = alpha_{phi}(x) or alpha_{psi}(x)
  alpha_{X phi}(x) = Ey y = succ(x) and alpha_{phi}(y)
  alpha_{phi U pxi}(x) = Ey [ x <= y and alpha_{psi}(y) and
                              (Az x <= z < y -> alpha_{phi}(z))]

We can, of course, directly translate F and G also in FO.

  alpha_{F phi}(x) = Ey [x <= y and alpha_{phi}(y)]
  alpha_{G phi}(x) = Ay [x <= y -> alpha_{phi}(y)]

Again, reverse translation (FO to LTL) is not easy.

----------------------------------------------------------------------

Theorem [Kamp, McNaughton]
  LTL = FO = star-free

----------------------------------------------------------------------

Model checking:

Does a system satisfy a property?

- System is (S,sin,->,v)
- Property is written in LTL

System is said to satisfy LTL property phi if *every* run
satisfies phi at initial position

Model checking: algorithmically decide if a system satisfies a
property

Using MSO->automata, we can construct an automaton for

  L(phi) = { sigma = s0 s1 ... sn | sigma,0 |= phi }

(Need to modify the construction slightly because now we have
atomic propositions labelling states rather than actions
labelling edges).

Model checking:

- Automata theoretically: Is L(System) subset of L(phi)?

- Equivalenty: Is L(System) intersect complement(L(phi)) empty?

  - Note that complement(L(phi)) = L(~phi), so we can check if
    L(System) intersect L(~phi) is empty?

- In principle, this is effective using our MSO to automata
  translation

  - Recall that this translation involves a tower of exponentials
    blowup in general

- [Vardi, Wolper 1986] A more effective direct translation is
  possible from LTL to automata with a single exponential blowup:
  formula of size n generates automaton of size 2^n

----------------------------------------------------------------------

From linear time to branching time

- Language theoretic view of a system: behaviour is a collection
  of separate runs/words/...

- Branching time view: consider the (unique) computation tree

  - root is the initial state

  - to each node, add as children extensions of the current run
    by one more transition

- At a state, we can make assertions about runs originating from
  that state

  - Use LTL formula phi to specify a property of a given run

  - Use path quantifiers E phi, A phi to assert that phi holds for
    some run starting at this state, or  phi holds for all runs
    starting at this state


  e.g.
     s |= E( X phi)   - for some succcessor state s', s' |= phi
     s |= A( F phi)   - along every run sigma from s, sigma,0 |= F phi

- Restrict expressivity to make model checking more efficient

  - Pair up a path quantifier with a single temporal modality

    - EX phi, AX phi, E (phi U psi), A (phi U psi)
      - Hence also, EF phi, AF phi, AF phi, AG phi

    - Disallow A( FG phi), E (X phi or psi_1 until psi_2), ...

- This restricted logic is called Computation Tree Logic (CTL)

- Model checking CTL

  - Treat system as a directed graph and label each state s
    (vertex) by a formula phi if s |= phi

    - Build up the labelling inductively, by structure of phi

    - Subformulas of phi is the set of building blocks that make
      up phi

    - Label psi can be assigned if labels for all subformulas of
      psi are already available


======================================================================