See: Actor definition.

An Actor Model is the modelling of a computation using a network of actors sending messages to each others.

It means that target(e1) emitted a message message(e2) that has been received by target(e2) as a consequence of processing message(e1).

It means that: if one event must happen before another, we say that the first event causally precedes the second. For instance:

• If e2 cannot happen if e1 did not happen, then e1 causally precedes e2.
• e1 may happen and e2 may not happen.

As a set of events causally related.

As a set of events causally related. The graph of events is linear i.e. for any three events a, b, and c there is a path is the graph such that: a *→ b *→ c.

In other words, the set of events is totally ordered.

As a set of events causally related. The graph of events is not linear i.e. it is possible to find two events a and b such that no causal links exist between a and b.

In other words, the set of events is partially ordered.

1. A strict partial order on a set S is a predicate ≺ such that:
2. There is no x ∈ S such that x ≺ x.
3. If x ≺ y, then: y ≺ x is false.
4. If x ≺ y and y ≺ z, then: If x ≺ z.
5. There may be pairs (x,y) : (S,S) such that neither x ≺ y or y ≺ x is defined.

It means that: if an event E in ε causes a message to be sent, there exists an event E' in e in which that message was received; i.e. every event which was activated has occurred

It means that neither e1 → e2 nor e2 → e1 is defined.

It means that e1 → e2.

ε is built from a postulated single event that precedes all others: ⊥.

All other events are inductively built from ⊥.

We posit that for any two events e1 and ek, the number of events in between is finite.

We posit that the number of successors of any event is finite.

Given an actor computation, there is a monotonic injective map from (ε,→) to into (ℕ, <).

1. Every actor is either one of a finite number of initial actors or is created during the course of a computation.
2. Every created actor is created in a unique event called that actor's creation event.
3. Several actors may be created in a single event; the only restriction is that only a finite number may be created in any single event.
4. we require that an actor's creation event precede the first event in which it receives a message.

1. The precursor suborder is then the transitive closure of the precursor relation and is a suborder of "→".
2. The precursor suborder is a tree with ⊥ as its root.

1. The precedes order is precisely the transitive closure of the union of the activation and precursor suborders.
2. Thus, every actor computation is the transitive closure of the union of two finitary trees, and encodes the interplay of the two.

1. Actor induction is defined for all of the orders defined above, and when faced with proving some property of an actor computation, one chooses which one based on the complexity of the interactions on which the property depends.
2. Properties of programs without "side-effects" can usually be proved using only "activation" induction, while properties of isolated databases can usually be proved using only "arrival" induction. Complex programs with side-effects will require full-blown "precedes" induction.

It is possible to implement a fork-join behaviour using the actor model.

1. F, R, G1, G2 : Actor
2. F.compute("f(x)=h(g1(x),g2(x))", R)
   1. F computes the value f(x) which is equal to h(g1(x),g2(x)) and sends the result to R.
3. F creates the actor H.
4. F sends a message to G1 requesting to compute g1(x) and to send the result to H.
5. F sends a message to G2 requesting to compute g2(x) and to send the result to H.
6. H waits for g1(x) and g2(x).
7. After receiving the values, H computes the result and sends it to R.

1. My message passing only.
2. The most fundamental form of knowledge which is conveyed by a message in an actor computation is knowledge about the existence of another actor.
3. An actor cannot know an actor's name unless it was either created with that knowledge or acquired it as a result of receiving a message.

1. The arbiter gives a strict order to received messages.
2. This order — local to the actor — is the time at the actor.
3. Picture a clock quadrant: each message received makes the second hand to move forward a given amount of angle.
4. We call the second hand axis of rotation the local time axis at an actor.

1. Choose an event α along the local time axis of an actor.
2. List in order the addresses of all actors received up to α.
3. This list is called the vector of acquaintances of the actor at α.

1. e : Event
2. participant(e) is:
   1. target(e)
   2. ∨ an acquaintance of target(e)
   3. ∨ an actor mentioned in the message(e)
   4. ∨ an actor created in e

1. The biggest vector of acquaintances contains:
   1. its parents
   2. acquaintances of its parents
   3. its siblings

1. A request r is kind of Message
2. content :≡ content(r)
3. spec(content) is the request itself.
4. dest(content) is the address of the actor to receive the reply.

1. A reply r is a kind of Message.
2. content(r) should satisfy the associated request or explain why a satisfactory answer could not have been produced.

1. q : Request
2. r : Any reply to q
3. activity(q) :≡ the set of events which follow q in the partial order but precede r
4. Informally, activity(q) is the set of events that contribute to r