Covered topics:

  from dynamical systems to 
     static, deterministic, completely observable dynamical systems
 
   The latter allow offline and open-loop planning.

  Once we model the state of the DS and the actions, the planner has
  everything it needs to generate plans.

     -- here the action models are essentially provding us the
        information about the "environment transition function" (since
        environment transitions only through actions, describing
        actions and their effects will provide the complete
        specification of the environment).

  Representation of the world and actions:

   -- Generally we can use the state-variable representation.

      Suppose there are n state variables each taking m values.

      A state of the world is specified completely by giving hte
      values of all the state variables (since the world is
      observable, all the variable values must be known). 

      Thus, there are m^n different states.

      Typically we restrict our attention to binary state variables
      without loss of generality

         -- if there are n binary state variables, there are 2^n
            distinct states.

        The interest in binary state variables is because we can
        consider the values "true" and "false", and use the logical
        notation to describe the state.

       for example, [v1=true, v2=false,...vn=false]

        can be written out in logic as 
              
                v1 & !v2 & ... & !vn

       Since the states are known to be completely specified, we can
       do another simplification --- just name the variables that have
       values true (the others are false). 
  
       This idea of only naming what are known to be true makes sense
       only because the initial state is assumed to be completely
       known.  Otherwise, we will be in trouble since a variable may
       be unknown and we have given it a value False.  This assumption
       is traditionally called the "Closed World Assumption".


  -- The goal of a problem is represented by a partial state variable
     specification. The idea is that any state of the world which
     gives the specified values to the specified variables is a goal
     state (no matter what it does to the variables not named in the
     goal state).

     Thus, unlike initial state which is a complete state
     specification, the goal sate is generally a _Partial_ state
     specification.

  -- Actions are represented by pre and post- conditions

     preconditions and postconditions can be seen as the partial
     assignments to state variables. 

     If the precondition partial assignment of an action is
     _consistent_ with the state (i.e. for the variables the
     preconditions and state talk about commonly, they give them the
     same values), then the action is applicable in the state

     The new state resulting from the execution of the action is
     defined as 

      the partial assignment of the postconditions of the action +
         the values for other state variables not mentioned in the
         postconditions taken from the previous state 


    -- Traditionally, the post condition formula has been split into 
       ADD and DELETE lists 

       with the ADD naming the state variables that are assigned
       "True" value by the postconditions, and the DELETE
       naming the state variables that are assigned "False" value by
       the postconditions.

       This separation into ADD and Delete lists is not necessary, and
       is actually quite confusing 

       (it assumes that the "True" valued variables are some how more
       important than the "False" valued variables-- But, this is not
       necessarily true-- goals of a problem my involve false values
       -- e.g. Make sure that the light is turned off!).


  -- example action:

     Puton(A,B,C) ;; put x from y to z
   
    Precond: On(A,B), Clear(C), Clear(A)

    Postcond: On(A,C), !On(A,B), !Clear(C), Clear(B)

   (On(A,B) can be see as a state variable name-- ON-A-B, which takes
   values True and False. In the precond formule it is taking value
   true, and in the post cond formula it is taking value false


  -- Action schemas--

     Rather than represent actions specifically interms of state
     variables, sometimes it is useful to talk in terms of action
     schemas--

     For example: Puton(X,Y,Z)

     Precond: On(X,Y), Clear(Z), Clear(A)

     Postcond: On(X,Z), !On(X,Y), !Clear(Z), Clear(Y)

   The action schema can be instatiated by giving different values for
   X, Y, and Z--which then essentially decides what are the actual
   state variables that are affected by teh precond and post-cond
   formulas.