B13. EVENT STRUCTURE
1. Events and Subevents
An event is an eventuality that involves a change of state. We wil
cash out the word "involves" by taking it to be the subevent or
equality relation. That is, an event is a change of state or an
eventuality that has a change of state as a subevent. But this means
that we must, counterintuitively, first explicate "subevent", or at
least explicate them in tandem. We will start off with a couple of
general properites of the "subevent" relation, and then enrich the
concept as we define "event" and various event structures.
The "subevent" relation is antisymmetric.
(forall (e1 e2) (if (subevent e1 e2) (not (subevent e2 e1)))) (1)
It is thus also antireflexive.
The "subevent" relation is transitive.
(forall (e1 e2 e3) (2)
(if (and (subevent e1 e2)(subevent e2 e3))
(subevent e1 e3)))
We now define "event":
(forall (e) (3)
(iff (event e)
(or (exists (e1 e2)
(and (nequal e1 e2)(change' e e1 e2)))
(exists (e1)
(subevent e1 e)))))
We have specified that the change must be from a state e1 to a
distinct state e2. This rules out circular changes at the base of an
event. But a circular change can be decomposed into a change from an
initial state to a distinct state and then back to the initial state.
We do mean to rule out "changes" where nothing happens.
As we explicate the predicate "subevent", we will do so in a way that
respects the constraint that an event is an eventuality. In the base
case, where the event is itself a change of state, this holds because
e in the above axiom is the first argument of a primed predicate.
(forall (e) (if (event e)(eventuality e))) (4)
Now we can say that the arguments of "subevent" are events.
(forall (e1 e2) (5)
(if (subevent e1 e2) (and (event e1)(event e2))))
We can build up events that are not directly changes of states, but
somewhere in chains of subevents of subevents of subevents, we must
bottom out in changes of state.
In the next two sections we will detail some of the ways one event can
be a subevent of another. The internal structure of events can be
analyzed in terms familiar from control structures in programming
languages, but applied not just to intentional actions, but to events
in general. In a sense, we view the world as a computer executing its
own history.
There can be sequences of events, conditionals, and interations, among
other structures. In the rest of this chapter, we axiomatize some of
these possibilities.
2. Event Sequences and Conditionals
The aggregate, or conjunction, of two events is an event. Moreover,
if even one of the conjuncts is an event, the aggregate is an event.
Thus, the sentence "The day was warm and Pat jogged down the beach"
describes an event.
(forall (e e1 e2) (6)
(if (and (and' e e1 e2)(event e1))
(and (subevent e1 e)(event e))))
Since "and'" is essentially commutative, we can also say
(forall (e e1 e2) (7)
(if (and (and' e e1 e2)(event e2))
(and (subevent e2 e)(event e))))
The "and'" events, when applied to programming languages, cover the
loosest case of parallel processes, where no temporal overlap between
the processes is required.
Two events are in sequence if one is before the other, and the
aggregate of the two events is just their reified conjunction.
(forall (e e1 e2) (8)
(iff (eventSequence e e1 e2)
(and (event e1)(event e2)
(and' e e1 e2)(beforeOrMeets e1 e2))))
From (6) and (7) we see that the components of an event sequence are
subevents and that the event sequence is itself an event.
(forall (e e1 e2) (9)
(if (eventSequence e e1 e2)
(and (event e)(subevent e1 e)(subevent e2 e))))
The definition of "eventSequence" can be extended to event sequences
of arbitrary length by letting e1 and/or e2 be an event sequence. We
could but won't relate "eventSequence" to "sequence".
One of the most basic control structures in programming languages is
the conditional, so we would like to consider conditional events, such
as "If something is denser than water, it sinks." One way to deal
with conditional events is to factor out the implication. We would
not say that there was a conditional event. Rather we would say that
if the condition holds, there is an event, the consequent of the
conditional. This decision would propagate to more complex events,
however. Rather than being able to talk about two sequential events
--
The object rolls into the water; if it is denser than water, it
sinks.
-- we would have to talk about two possible events or event sequences
--
If the object is denser than water, it rolls into the water and it
sinks.
If the object is not denser than water, it rolls into the water.
This expansion would be vastly exacerbated in cases of conditionals
embedded in iterations and other conditionals. A programming language
designed along these lines would be a nightmare to work in. All
possible combinations of potentially relevant conditions would have to
be stated up front, each with a different sequence of steps of the
corresponding execution following it. As is usually the case, the
best strategy is to allow our ontological garden to flourish and
simply accept conditional events as events.
We will take a conditional event to be the implicational relation
between some eventuality -- a state or an event -- and an event, with
a further relation that the first eventuality must obtain at the
beginning of the second.
(forall (e e1 e2) (10)
(iff (cond e e1 e2)
(and (imply' e e1 e2)(event e2)
(forall (t)
(if (begins t e2)(atTime e1 t))))))
The conditions on the real existence of e follow from the conditions
on the real existence of implication relations stated in Axiom (B4.8).
The event e2 is a subevent of e and hence e is also an event.
(forall (e e1 e2) (11)
(if (cond e e1 e2)(and (subevent e2 e)(event e))))
More complex conditionals can be constructed by having event sequences
of conditionals and by having the consequent itself be a conditional.
3. Iterations
Some processes in nature seem to us to be pure iterations, with no
termination condition and no set of entities the interation is over.
The sun rising and setting is like this. Everyday we see a new
instance of that event type.
We can define "iteration" recursively.
(forall (e e1) (12)
(iff (iteration e e1)
(exists (e2 e3)
(and (eventSequence' e e2 e3)(instanceOf e2 e1)
(iteration e3 e1)))))
Here e1 is an event type, the e2's instantiate e1, and e is the event
that consists of the succession of e2's. That e2 is a subevent of e
and that e and the e2's are events follow from the properties of
"eventSequence".
Some iterative processes have a termination condition. In an
hourglass the grains of sand fall from the upper chamber to the lower
chamber until the upper chamber is empty. We define a predicate
"whileDo" that says one event type e2 is instantiated by successive
instances as long as eventuality e1 happens or holds.
(forall (e e1 e2) (13)
(iff (whileDo e e1 e2)
(exists (e3 e4 e5)
(and (cond e e1 e3)(eventSequence' e3 e4 e5)
(instanceOf e4 e2)(whileDo e5 e1 e2)))))
That is, the "whileDo" event is a conditional whose condition is e1
and when the condition holds, the consequent occurs, where the
consequent is a sequence e3 of the events e4 and e5. Event e4 is an
instance of e2, and e5 is another "whileDo" event with e1 as its
condition and the event type e2 as its consequent.
It again follows from the properties of "eventSequence" and "cond"
that the e4's are subevents of e and that e and the e4's are events.
A "repeatUntil" event can be defined similarly.
(forall (e e1 e2) (14)
(iff (repeatUntil e e1 e2)
(exists (e3 e4 e5)
(and (eventSequence' e e3 e4)(instanceOf e3 e1)
(cond e4 e2 e5)(repeatUntil e5 e1 e2)))
The only difference between this and a "whileDo" event is that an
instance e3 of the body e1 occurs before the condition e2 is checked.
The e3's are subevents of e, and e and the e3's are events.
Sometimes we want to talk about the same event type happening to all
the elements in a sequence in turn. That is, there is a parameter x
in the event type e1, and for every member y of the set s, an instance
e2 of e1 occurs, in which y plays the role of x. If s is a sequence
of one element, the "forAllOfSeq" event is just the instance for that
element. If the sequence s is longer, the "forAllOfSeq" event e is
the event sequence. The first event in the event sequence is an
instance e2 of e1, where the first element y of the sequence s plays
the same role in e2 that x plays in e1. The second event in the event
sequence is another "forAllOfSeq" event, where the sequence s1 is the
rest of the sequence s after its first element has been removed.
(forall (e s e1) (15)
(iff (forAllOfSeq e s x e1)
(exists (y e2 l e3 s1)
(or (and (length 1 s)(first y s)(subst y e2 x e1)
(equal e e2))
(and (length l s)(gt l 1)(first y s)
(subst y e2 x e1)(eventSequence e e2 e3)
(forAllOfSeq e3 s1 x e1)(rest s1 s))))))
Again, the instances e2 are subevents of e, and e and the e2's are
events.
We can obviously do an iteration over the first n integers by letting
the sequence s be the sequence <1, ..., n>.
A complex event is a composite entity whose components are its
subevents, among whose properties are the "event" propreties, and
among whose relations are the "subevent" relations.
(forall (e1 e) (16)
(if (subevent e1 e)
(exists (s1 s2 s3)
(and (compositeEntity e)
(componentsOf s1 e)(propertiesOf s2 e)
(relationsOf s3 e)
(forall (e2)(iff (member e2 s1)(subevent e2 e)))
(forall (e2)
(if (member e2 s1)
(exists (e3)
(and (event' e3 e2)(member e3 s2)))))
(forall (e2)
(if (member e2 s1)
(exists (e3)
(and (subevent' e3 e2 e)
(member e3 s2)))))))))
The antecedent in line 2 is "(subevent e1 e)" because this is a
necessary and sufficient condition for e to be a complex event. Lines
5-6 label the components, properties and relations. Line 7 says the
components are the subevents. Liness 8-11 say that the "event"
properties are among the composite entity's properties. Lines 12-16
say that the "subevent" relations are among its relations.
Predicates Introduced in this Chapter
(event e): e is an event.
(subevent e1 e2): Event e1 is a subevent of event e2.
(eventSequence e e1 e2): Event e is a sequence consisting of event e1
followed by event e2.
(cond e e1 e2): e is the conditional event of event e2
occurring if eventuality e happens or
holds.
(iteration e e1): e is the event consisting of iterations of
event type e1.
(whileDo e e1 e2): e is the event consisting of iterations of
event e2 as long as eventuality e1
happens or holds.
(repeatUntil e e1 e2): e is the event consisting of iterations of
event type e1 happening until e2 happens
or holds.
(forAllOfSeq e s x e1): e is the event consisting of iterations of
event type e1 where in successive
iterations the role of x is played by the
successive members of sequence s.