You cannot step in the same river twice

This document is called: [BEFORE-AFTER]
Under development

One question we need to address is how identity is preserved over time is one which still interests philosophers today.

Heraclitus of Ephesus, also known as the Weeping Philosopher and Heraclitus
the Obscure, has left us only a few philosophical sentences. Due to this lack
of original writing, Heraclitus philosophy remains hard to characterize. His
belief seems to have been that the universe is in a constant state of flux,
as this famous quote indicates. By the time that you attempt to step into the
river a second time, the waters of the river will have moved on and so, the
river will not be the same one you stepped into the first time. The sentence
also has a second meaning; you cannot step into the same river again because
you are no longer the same as the person who took the first step. The question
is: how can identity presists over time.

Consider

  (1) (implies A B)

i.e., A implies B, and which is sometimes read as "if A then B". In
logic the semantics of (1) does not include any temporal component.

In computer languages we have the construct

  (2) (if A then B)
  (3) (DO A)
      (DO B)

In its usual semantics we don't even consider B until we have decided A.

Because FOL [context]s are data structures that can be updated
(see [MUTABLE])
we can represent both of these interpretations.

To be more explicit let's write

  (3) A ==> B  

to express the idea of either if-then (temporal) or implies (logic)
 
  (forall (c [context] ((Consist c) ==> (Consist (r c ...)))  

The first obversation is that this 'implication' in our view cannot be made
outside a [context] so we need to always specify which context is our focus [FOCUS].  

Let's call our focus Meta because clearly Meta mentions [context]s. Thus in
Meta we write

  (Consist C) ==> (Consist (R C))

where 'C' is an individual constant symbol of Meta of type [context] and 'R'
is a function that maps [context]s onto [context]s.
  
  (Step 1) R deduces a wff from the facts of C and makes a new fact, f=<w,j>
           where w is wff and j (a justification) records the information that
           wff was concluded from C by applying the rule R.

  (idea 1) we can use a [REFLECTION] principle

           for each fact f in the facts of C
              we can conclude (from Meta)
           (in-facts C f)
 
           This is similiar to the contexts of Guha and the worlds of
           polyscheme.

  (idea 2) we can attach to C the data structure Cm, which is the model C
           in Meta.

           (plan 1) R destructively 'updates' Cm to include f in its facts
                    In META we have (in-facts C f) (by inspection)
                    This is like belief revision

           (plan 2) R adds a new individual constant, C1, to Meta  AND 
                    R makes a new context C1m = (add-fact Cm f)  AND 
                    R attaches C1 to C1m in Meta  
                    In Meta the consequence
                      (AND (NOT (in-facts C f)) (= C1 (r C)) (in-facts C1 f)  
                    This is like situation caculus and polyscheme

           (plan 3) R adds a new individual constant C1 to Meta  AND 
                    R makes a new context C1m = (addfact Cm f)  AND 
                    R attach C1 to C1m in Meta  
                    R adds a timestamp to C and C1 (time C t0) (time C1 t1)
                    In META we have the consequences
                       (NOT (IN-FACTS C f))
                       (= C1 (R C))
                       (IN-FACTS C1 f)  
                              
Now there are many possibilities

           captures the semantics of before and after, ie,
             before C had N facts
             after C had n+1 facts one of which is f!!!!
           This is like belief revision.


           R creates a new context which is 
             like C except that the facts of the new context
             contain both the facts of C and the new fact f.
           This is represents the semantics of implies.
           This is like traditional logic,
              
  (case 2) 'C' is an individual constant symbol of Meta of type [context] and it
           it is attached to a data structure which we will call Cm, which is the 
           model C in META.  Noe we could have an r which makes a new fact, as in
           (case 1) and 'updates' Cm to Cm' where f is now a fact of Cm'.  This 
           captures the semantics of before and after, ie, before C had N facts
           after C had n+1 facts one of which was f!!!!
           This is like belief revision.


Once one sees this there ar many additional intermediate things r might do.