FFDM Report

Version 0.6

December 22, 2020

Contents
1 Introduction 3

2 Project background 3

3 Our approach 3

4 Logical background - Structure of the paper 3

5 Stage theory: the formal language 3

5.1 Logical framework . . . . . . . . . . . . . . . . . . . . . . . . . . 3
5.2 Non-logical vocabulary . . . . . . . . . . . . . . . . . . . . . . . . 5
5.3 Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.4 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

6 Stage theory: the axioms 7

6.1 Plural logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.2 Stages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.3 Initial stage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.4 What exists at stages . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.5 What is and is not constructible . . . . . . . . . . . . . . . . . . 11
6.6 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.7 Set constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.8 Sum constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.9 Pair constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.10 Construction relations . . . . . . . . . . . . . . . . . . . . . . . . 14
6.11 Maximal extension of a stage . . . . . . . . . . . . . . . . . . . . 19
6.12 Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

7 Consistency of the stage theory 20

A Notions 21
A.1 List of (key) types and identity criteria . . . . . . . . . . . . . . . 21
A.2 Non-logical vocabulary . . . . . . . . . . . . . . . . . . . . . . . . 21

B Resources 21

C Design choices 21

D Set-theoretic model 21

E Future work 25

2
1 Introduction
[To be included in the full report.]

2 Project background
[To be included in the full report.]

3 Our approach
[To be included in the full report.]

4 Logical background - Structure of the paper

[To be included in the full report.]

5 Stage theory: the formal language

In the section, we introduce the formal language in which the axioms of the
stage theory will be formulated (for the axioms, see Section 6). The language is
given by the logical framework (plural logic) and some non-logical vocabulary.
The non-logical vocabulary includes expressions for the key constructional op-
erations and for auxiliary vocabulary needed to express the way in which the
constructional operations are deployed through the stages.

5.1 Logical framework

As a logical framework for the stage theory, we use plural logic, specifically
what is known in the philosophical literature as PFO+, which is short for plural
first-order logic plus plural predicates. This is the standard language for the for-
malization of plural logic, though there are some differences in notation among
authors that use this system. (REF) Our exposition of the system relies on
Florio and Linnebo (REF).
The language of PFO+ extends the language of first-order logic with the
following classes of expressions:

A. Plural terms: plural variables (vv, xx, yy, . . ., and variously indexed vari-
ants thereof) and plural constants (aa, bb, . . ., and variants thereof), roughly
corresponding to the natural language pronoun ‘they’ and to plural proper
names, respectively.
B. Universal and existential quantifiers that bind plural variables (e.g. ∀xx,
∃yy, . . . ). We may read ‘∀xx’ as ‘whenever there are some things xx, then
. . . ’, and we may read ‘∃yy’ as ‘there are some things yy such that. . . ’.

3
 C. The binary predicate ≺ for plural membership, corresponding to the natu-
ral language ‘is one of’ or ‘is among’. The predicate expresses the relation
between an object and some things: ‘x ≺ xx’ expresses that x is one of
xx (this may be pronounced “x is one of the xs”).
D. Plural predicates, that is, predicates with one or more argument places
reserved for plural terms. An example of a plural predicate is Sum(x, yy),
which represents that x is the (a) mereological sum of the yy. The pred-
icate’s arity can be represented by numerical superscripts, which may be
omitted for economy, as in the preceding example. The full predicate is
Sum2 (x, yy).

The non-logical vocabulary of the language, which includes first-order and plural
predicates (class D above), is discussed in the next section.
We define a well-formed formula in the language of PFO+ starting with
atomic formulas. These are formed by combining predicates with the appropri-
ate number of terms. As noted earlier, we need to ensure that argument places
reserved for terms of certain kind (singular or plural) are occupied by terms of
that kind. More complex formulas are obtained by means of sentential connec-
tives and variable binding using singular or plural quantifiers. (See Florio and
Linnebo REF for details.)
We should emphasize that plural predicates in this language are read col-
lectively. For example, Set(x, yy) means that x is the (a) set of the yy, where
yy are taken together. This contrasts with distributive readings of plural predi-
cates, for example when we say that xx are sets to mean that each of xx is a set.
This does not make PFO+ any less expressive, since the effect of distributive
predication can be obtained by paraphrase in the way just indicated. Using
the singular predicate IsSet(x), we can say that xx are sets by saying that
everything that is one of xx is a set:

∀x(x ≺ xx → IsSet(x))
To illustrate the use of PFO+, it might be helpful to provide some examples
of formulas together with informal glosses. For intuitiveness and simplicity, our
informal glosses will often render plural expressions in terms of “pluralities” and
their members.

• ∃xx∃xSum(x, xx)
(Some things have a mereological sum.)
• ∀x∀y∃zz∀z(z ≺ zz ↔ (z = x ∨ z = y))
(For any two objects, possibly identical, their plurality exists. That
is, there are some things such that anything is one of them if and
only if it is identical to one object or the other.)
• ∀xx∀yy∀x((Set(x, xx) ∧ Set(x, yy)) → ∀z(z ≺ xx ↔ z ≺ yy))
(If an object x is the set of both xx and yy, then xx and yy have
the same members.)

4
5.2 Non-logical vocabulary
We have designed the language of the stage theory so that its basic non-logical
vocabulary can express the constructional operations in scope, the structure of
the stages, and the way in which operations and stages interact to produce the
target ontology. This vocabulary is given by constants and by the first-order
predicates and plural predicates of kind D mentioned above.
The present version of the stage theory describes the operations of three
basic constructors yielding, respectively, sets, mereological sums, and ordered
pairs. These constructors are expressed by the following predicates.

Constructional operators
notation: intended reading:
Sum(z : xx) z is the (a) mereological sum of the xx
Set(z : xx) z is the (a) set of the xx
Pair(z : x, y) z is the (a) pair of x and y

The process of constructions involves the application of a constructor to objects.

The sum constructor, unlike other basic constructors, does not apply unrestrict-
edly. That is, not every object can be an input of the sum constructor. Objects
that can are said to be summable. This feature is indicated by a primitive pred-
icate.

Application of constructors
notation: intended reading:
Summable(x) x is a permissible input of the sum constructor

The target ontology involves construction relations that “log” the structure
of the construction process. The components of this structure are accessed by
the five projection predicates listed below. More details about the predicates
and their role is provided in Section 6.10. To indicate the types of construc-
tion and the types of construction relations, we use eight special constants, also
listed below.

Construction relation
notation:
ConstrProj1 (w, y)
ConstrProj2 (w, y)
ConstrProj3 (w, y)
ConstrProj4a (w, yy)
ConstrProj4b (w, y1 , y2 )
intended reading:
w is related to a construction of type y
the type of the construction relation w is y
w is related to a construction whose
output is y
w is related to a construction whose
inputs are yy
w is related to a construction whose
inputs are, in order, y1 and y2

5
 cset set construction type
csum sum construction type
cop ordered pair construction type
cunion union construction type
cSetMembers set–members relation type
cWholeParts whole–parts relation type
cTuplePlaces tuple–places relation type
cSuperSubSets superset-subsets relation type

Finally, we have some predicates pertaining to stages and their structure.

Stages
notation: intended reading:
Stage(x) x is a stage
E(s, t) s is before, or equal to, t
@(x, s) x exists at (stage) s

This completes the list of the primitive non-logical vocabulary of the language.

5.3 Conventions
To simplify the exposition of the stage theory, we rely on a number of usual
conventions. We highlight some key examples below.
Firstly, we adopt the following formatting conventions.
• When parentheses are omitted, the standard rules of precedence among
logical connectives should be applied to disambiguate.
• Different styles of parentheses are used to make groupings of formulas
easier to recognize.
• A leading block of universal quantifiers is sometimes omitted. So axioms
with free variables are short for their universal closure.
• To improve readability, we use infix notation for some predicates. For
example, we write ‘s E t’ rather than ‘E(s, t)’, and ‘x@t’ rather than
‘@(x, t).
Secondly, we adopt a convention related to restricted quantification.

• Quantification restricted to certain kinds of entities may be marked by the

use of particular variables. For example, we will often use s, s0 , t, etc. to
range over stages. So ∀sϕ(s) is short for ∀s(Stage(s) → ϕ(s)). Similarly,
we use ss, ss0 , tt for plural quantification over stages. So ∀ssϕ(ss) is short
for ∀ss(∀x(x ≺ ss → Stage(x)) → ϕ(ss)).

6
Finally, as we focus on a constructional approach, it makes sense to use the
following, less common formatting convention.

• For some predicates, we use a colon rather than a comma to emphasize

constructional links among argument places (e.g. Pair(x : y, z) rather
than Pair(x, y, z) to indicate that x is the pair constructed from y and
z).

5.4 Definitions
We make frequent use of definitions to introduce new non-logical expressions as
abbreviations. To illustrate this, we give some key examples here from plural
logic and stage theory. Other definitions will be given as they are required.
Two important relations in plural logic are introduced as abbreviations using
the language described above. One is the many-many relation of plural inclusion
(‘are among’) is symbolized as ‘4’ :

xx 4 yy ↔def ∀z(z ≺ xx → z ≺ yy)

So some things xx are among yy when everything that that is one of xx is one
of yy.
The other important relation is plural identity, which is symbolized as ‘≈’:

xx ≈ yy ↔def (xx 4 yy ∧ yy 4 xx)

That is, two pluralities are identical just in case they have the same members.
We now introduce some abbreviation for the stage theory. Some things exists
at a stage iff each of them exists at that stage. So we define ‘xx@s’ (“xx exist
at s”) as follows:
xx@s ↔def ∀x(x ≺ xx → x@s)
We let s C t abbreviate s E t ∧ s 6= t. We occasionally write t D s and t B s
to mean s E t and s C t, respectively. We say that t is a successor stage of s iff
s precedes t and there is no stage strictly in between s and t, that is:

Succ(s, t) ↔def s C t ∧ ¬∃u (s C u ∧ u C t)

Later we will introduce a related abbreviation, a predicate ‘Max(s, t)’ repre-

senting that t is a maximal extension of s, that is, that t contains the result of
carrying out every construction that is possible at s (Section 6.11).

6 Stage theory: the axioms

Our theory has several parts, which have their different concerns. The axioma-
tization aims to be perspicuous and user-friendly, not to be minimal.

7
6.1 Plural logic
The formal system PFO+ comes equipped with logical axioms and rules of in-
ference. The axioms and rules associated with the logical vocabulary of ordinary
first-order logic are the standard ones. For example, one could rely on intro-
duction and elimination rules for each logical expression. The plural quantifiers
are governed by axioms or rules analogous to those governing the first-order
quantifiers.
In addition, we have the following axioms or axioms schemes. First, every
plurality is non-empty:

(Non-empty) ∀xx∃y y ≺ xx
(Every plurality has at least one member.)

Then, there is an axiom scheme of indiscernibility:

(Indisc) ∀xx∀yy[xx ≈ yy → (ϕ(xx) ↔ ϕ(yy))]

(Coextensive pluralities satisfy the same formulas.)

This is a plural analogue of Leibniz’s law of the indiscernibility of identicals.

Finally, there is the unrestricted axiom scheme of plural comprehension, an
intuitive principle that provides information about what pluralities there are.
For any formula ϕ(x) containing x but not xx free, we have an axiom stating
that if ϕ(x) is satisfied by at least one thing, then there are the things each of
which satisfies ϕ(x):
(P-Comp) ∃xϕ(x) → ∃xx∀x(x ≺ xx ↔ ϕ(x))
(If something is ϕ, then there are some things that are all and
only the ϕs. That is, if something is ϕ, then the ϕs exist. )
We refer to an axiomatization of plural logic based on the principles just de-
scribed as full plural logic. The fullness of the logic has to with the fact that
plural comprehension applies to any formula ϕ(x)—provided that x but not xx
occur free.

6.2 Stages
The stages are partially ordered by the accessibility relation E:

(1) ∀s s E s
(E is reflexive.)

(2) ∀s∀t(s E t ∧ t E s → s = t)
(E is antisymmetric.)

(3) ∀s0 ∀s1 ∀s2 (s0 E s1 ∧ s1 E s2 → s0 E s2 )

(E is transitive.)

8
This partial order is convergent:

(4) s0 E s1 ∧ s0 E s2 → ∃t(s1 E t ∧ s2 E t)
(E is convergent.)

Stages are well-founded by E. Let x C y abbreviate s E y ∧ x 6= y. Then, we

have

(5) ∀ss∃s(s ≺ ss ∧ ¬∃t(t ≺ ss ∧ t C s))

(The stages are well-founded by E. That is, for any plurality ss of stages,
there is a member s that is first among ss with respect to the order E.)

Notice that the last axiom makes essential use of plural logic. Also, this axiom
enables us to do well-founded induction on E. (Assume that a property holds
at the initial stage and that, whenever the property holds at every s such that
s C t, then it also holds at t. Then the property holds at every stage.)
The accessibility relation is serial:
(6) ∀s∃t s C t
(For every stage, there is a strictly later stage.)
Remark. Axiom (6) and the well-foundedness of E entail that every stage has
a successor stage.
Remark. We will eventually see that the seriality of E can be proved from the
other axioms of our theory. (To anticipate: suppose we apply the set constructor
to “the Russell plurality” at a stage s. The resulting set can only be available
at stages later than s. But other axioms will entails the existence of that set, as
well as its availability at some stage.) We keep the axiom of seriality, however,
as we will sometimes be interested in working with less than the full theory.
There are infinitely many stages:
(Infinity) ∃t(∃s s C t ∧ ∀s(s C t → ∃u(s C u ∧ u C t)))
(There is a non-initial stage which isn’t immediately after any other
stage.)
We also assume the axiom scheme of Replacement. This is a powerful princi-
ple, which provides information about how many stages there are. Specifically,
the principle says there are so many stages that the objects available at any one
of them do not suffice to reach arbitrarily high in the hierarchy of stages. That
is, for any stage s, any objects xx at s, and any formula ψ(x, y) that represents
a function from xx to objects throughout the hierarchy, there is a stage at which
we find all the values that this function takes for arguments among xx.
(Replacement)

xx@s ∧ ∀x(x ≺ xx → ∃y(¬Stage(y) ∧ ∀z(ψ(x, z) ↔ y = z)) →

∃t(s E t ∧ ∀x(x ≺ xx → ∀y(ψ(x, y) → y@t))

9
 (Suppose that xx exist at s and that ψ(x, y) represents a function from
objects among xx to non-stages. Then there is a stage t such that what
exists at t includes the image of every member of xx under ψ.)

6.3 Initial stage

Let ‘Init(s)’ abbreviate the statement that s is initial:

Init(s) ↔def ∀t s E t

Remark. This definition of an initial stage could be weakened so as to permit

several alternative initial stages. We would do this by defining a stage t to be
initial just in case it is not preceded by any other stage: ¬∃s s C t.
We define an object to be a given iff it exists at some initial stage:

Given(x) ↔def ∃s(Init(s) ∧ x@s)

Then we assume the existence of some given:

(7) ∃x Given(s)
(There is some given.)

Remark. We can now prove that there is an initial stage:

∃s∀t s E t
(There is a stage that precedes every other stage.)
In our setting, we assume the existence of specific givens that will be used to
code information about construction relations (see Section 6.10). These givens
are assumed to be distinct. So we have the following strengthening of (7):

(8) The givens include eight distinct objects: cset , csum , cop cunion ,
cSetMembers , cWholeParts , cTuplePlaces , cSuperSubSets .

6.4 What exists at stages

First, we have an axiom that ties the objects in our ontology to stages, with the
exception of the stages themselves, which have an auxiliary role.
(9) ∀x(¬Stage(x) → ∃s x@s)
(Everything that isn’t a stage exists at some stage.)
Stages are “cumulative”:

(10) s E t ∧ x@s → x@t

(When one stage precedes another, then everything that exists at the
former also exists at the latter.)

10
 Define a stage t to be the least upper bound (LUB) of some stages ss in the
usual way:
LUB(t, ss) ↔def ∀s(s ≺ ss → s E t) ∧ ∀t0 (∀s(s ≺ ss → s E t0 ) → t E t0 )
Then we have an axiom ensuring that limit stages are “collection” stages:
(11) LUB(t, ss) → ∀x(x@t → ∃s(s ≺ ss ∧ x@s))
(Suppose t is the least upper bound of some stages ss. Then everything
that exists at t exists at some of ss.)
Remark. The cumulativity of the stages entails the other direction, which
means this conditional can be strengthened to a biconditional.
We define a predicate ConstrFrom(x, s) whose intuitive meaning is that
x is constructed from some objects that exist at stage s. To be precise:
ConstrFrom(x, s) ↔def ∃xx(xx@s ∧ Set(x : xx) ∨
Sum(x : xx)) ∨
∃u∃v(u@s ∧ v@s ∧ Pair(x : u, v))
Remark. We may later want to generalize and accept other constructors. Then
this definition will have to be modified accordingly. However, as we will see,
other axioms that utilize this predicate can remain unchanged, thus allowing a
pleasing modularity.
We have additional axioms:
(12) ∀x(x@s ↔ x@t) → s = t
(Stages with identical domains are identical.)
Using also notions related to construction relations (Section 6.10), we restrict
what can exist at a successor stage:
(13) Succ(s, t) ∧ x@t → x@s ∨ ConstrFrom(x, s) ∨ ConstrRel(x)
(Everything that exists at a successor stage either existed at the
predecessor stage, or is constructed from something at that stage, or is a
construction relation.)

6.5 What is and is not constructible

Any objects existing at a given stage are permissible inputs for the set construc-
tor. Similarly, any two objects existing at given stage are permissible inputs of
the pair constructor. By contrast, the application of the sum constructor is
restricted to summable objects. The next axiom states that summable objects
comprise givens and sums:
(14) Summable(x) ↔ (Given(x) ∨ ∃xx Sum(x : xx))
(Any object is summable if and only if it is either a given or a sum. )
Remark. The axioms of the stage theory entail that neither sets nor pairs are
summable.

11
6.6 Constructors
We need axioms that characterize the behavior of the three basic constructors
and fix the identity criteria of the outputs of the constructions. This is done in
the next three sections covering sets, sums, and pairs, in this order.

6.7 Set constructor

(15) ∀xx∀s(xx@s → ∃t∃x(s E t ∧ Set(x : xx) ∧ x@t))
(For every plurality xx of objects existing at s, there is a later stage t at
which the set of xx exists.)

(16) ∀x(x@t ∧ Set(x : xx) → ∃s(s C t ∧ xx@s)

(The elements of a set exist at an earlier stage than the set itself.)

(17) Set(x : xx) ∧ Set(y : yy) → (xx ≈ yy ↔ x = y)

(Extensionality: two sets are identical if and only if their elements are
the same.)

Remark. We can now derive the correct CLAP profile for sets, namely C
LAP.

6.8 Sum constructor

(18) ∀x(x ≺ xx → Summable(x) ∧ x@s) → ∃t∃x(s E t ∧ Sum(x : xx) ∧ x@t)
(For every plurality xx of summable objects existing at s, there is a later
stage t at which the sum of xx exists. )

Remark. In the case of sets, we required that the elements of any set exist at a
stage strictly before any stage at which the set itself exists. Should an analogous
requirement be made concerning sums? The answer is negative: sums are simply
different from sets in this regard. To see this, consider a given g and let gg be
the plurality whose sole member is g. Let i be the initial stage. Then (as we will
see shortly) Sum(g : gg). This provides a counterexample to the contemplated
requirement that every sum be the sum of some object that exist strictly before
the sum itself.
Next, we need to state a criterion of identity for sums. Before we do that,
however, it is useful to remind ourselves of the following constraints on their
individuation:

(ExtensionalitySum ) Sum(x : xx) ∧ Sum(y : yy) ∧ xx ≈ yy → x = y

(Sums constructed from the same pluralities are the same.)

(CollapseSum ) Sum(x : xx) ∧ ∀u(u ≺ xx ↔ u = y) → x = y

(The sum constructed from the singleton plurality of x is x.)

12
(LevelingSum )
Sum(x : xx) ∧ Sum(y : yy) ∧ ∃u ∃uu ∃vv Sum(u : uu) ∧
∀z(z ≺ xx ↔ z = u ∨ z ≺ vv) ∧


∀z(z ≺ yy ↔ z ≺ uu ∨ z ≺ vv) →
x=y

(Suppose x is a sum of xx and y is a sum of yy. If u is a sum of uu, xx is

the “union” plurality of u and vv, and yy is the union plurality of uu
and vv, then x is y. In other words, two pluralities, one obtained from
the other by replacing some objects with their sum, yield the same sum.)

Of course, ExtensionalitySum entails Absorption and Permutation. Thus, these

three principles lay down the entire CLAP profile of sums, namely full CLAP.
The three principles provide sufficient conditions for mereological sums to be
identical. But we do not yet have any necessary conditions. Let us explore
the possibility of adding a “terminal clause” to the effect that no two sums are
identical unless they are identified as a result of these three principles. The
three principles can then be regarded as a recursive definition of sum identity.
Our question, then, is how this terminal clause might be formulated.
In fact, it turns out there is a simple way to do so. We begin by adopting the
following definition:
x ≤ y ↔def ∃xx ∃yy (Sum(x : xx) ∧ Sum(y : yy) ∧ xx 4 yy)
Next, we require:
(19) The sums, ordered by ≤, form an atomistic classical extensional
mereology (ACEM) whose atoms are precisely the givens.
Remark. To see that (19) follows from the desired terminal clause, we claim
that the three principles never require us to regard anything as a proper part of
a given, which are therefore left as atomic. However, the three principles and
induction on C imply that the laws of ACEM hold.
Remark. (19) has some pleasing consequences. For one thing, it provides
a clear and simple criterion of identity for sums, namely that two sums are
identical if and only if they are sums of the very same pluralities of givens. For
another, it entails that the three constraints are satisfied. Thus, we have used
our three constraints and the associated terminal clause to derive a single axiom,
which provides more explicit information about the structure of the sums, and
which in turn implies the constraints and the terminal clause.
Remark. Various generalizations will eventually be needed. First, we will even-
tually want to allow the givens to come equipped with a mereological structure.
This will involve exchanging (19) for some other axiom(s). Second, we will
eventually want to add “decomposers”, which construct new parts of already
existing objects.

13
6.9 Pair constructor
(20) x@s ∧ y@s → ∃t∃z(s E t ∧ z@t ∧ Pair(z : x, y))
(For every objects x and y that exist at s, there is a later stage t at
which the pair of x and y exists.)

(21) Pair(z : x, y) ∧ z@t → ∃s(s C t ∧ x@s ∧ y@s)

(The coordinates of a pair exist at an earlier stage than the pair itself.)

Pairs are subject to the obvious criterion of identity:

(22) Pair(x : u, v) ∧ Pair(y : u0 , v 0 ) → (u = u0 ∧ v = v 0 ↔ x = y)
(Two pairs are identical if and only if their coordinates are identical.)

Remark. Although mathematically unproblematic, this approach is less than

ideal in our present context. A main attraction of our approach vis-à-vis a more
familiar, purely set-theoretic one is that it allows primitive sums and pairs.
Thus, it is not in the spirit of this approach to have to resort to coding to
represent tuples of length greater than 2. Relatedly, when tuples are coded in
the ordinary way, it is not meaningful to ask about their length. For example,
the object hha, bi, ci can be understood both as a pair of ha, bi and c and as the
triple ha, b, ci.
Remark. The previous remark raises the question of how our approach is best
extended to allow primitive tuples of arbitrary length. A straightforward but
rather clunky option is to supplement our pair constructor with a primitive
n-tuple constructor for each n between 2 and some chosen cutoff N . That
is, for each 1 < n ≤ N we add a predicate n-Tuple(y : x1 , ..., xn ), subject
to the obvious generalization of (22). A more elegant option—whose develop-
ment, however, would require some more work—is to develop a general theory of
sequences, perhaps based on one constructor for turning an object into the cor-
responding sequence of length one and another for concatenating two sequences.
We leave this for future work.

6.10 Construction relations

We also introduce axioms ensuring that, whenever certain construction relations
obtain, there are objects that encode this information. We call the relevant
objects construction relations in order to emphasize the kind of information
they carry. For example, if Set(x : xx), we have an object that can convey
the information that x has been constructed using the set constructor, which
generates a relation between a set and their members, and that the x is the
output of the construction while xx is the input.
The axioms rely on special predicates and special constants corresponding
to givens conventionally chosen to indicate types of the construction effected

14
(basic and derived) and types of the resulting construction relation (basic and
derived).
The constant for types of constructions are:
• cset , csum , cop (basic constructions);
• cunion (derived constructions).
The constants for types of construction relations are:
• basic: cSetMembers , cWholeParts , cTuplePlaces (basic relations);
• cSuperSubSets (derived relations).
Then we have projection predicates providing information about the construc-
tion “witnessed”:

• ConstrProj1 (w, y)
(w is related to a construction of type y, where the type is coded by one
of cset , csum , cop , and cunion )
• ConstrProj2 (w, y)
(the type of the construction relation w is y, where the type of is coded
by one of cSetMembers , cWholeParts , cTuplePlaces , and cSuperSubSets )
• ConstrProj3 (w, y)
(w is related to a construction whose output is y)
• ConstrProj4a (w, yy)
(w is related to a construction whose inputs are, in the case of sets and
sums, yy)
• ConstrProj4b (w, y1 , y2 )
(w is related to a construction whose inputs are, in the case of pairs, y1
and y2 )

To illustrate the idea, consider the case of sets: if x is set constructed at t

from objects existing at previous stages, then we also require at t the existence
of a (unique) construction relation carrying the appropriate information.
First, we have an axiom sanctioning the functional nature of the projection
predicates:
(23)

(ConstrProj1 (w, y) ∧ ConstrProj1 (w, y 0 ) → y = y 0 ) ∧

(ConstrProj2 (w, y) ∧ ConstrProj2 (w, y 0 ) → y = y 0 ) ∧
(ConstrProj3 (w, y) ∧ ConstrProj3 (w, y 0 ) → y = y 0 ) ∧
(ConstrProj4a (w, yy) ∧ ConstrProj4a (w, yy 0 ) → yy ≈ yy 0 ) ∧
(ConstrProj4b (w, y1 , y2 ) ∧ ConstrProj4b (w, z1 , z2 ) → y1 = z1 ∧ y2 = z2 )

15
 (Projection predicates are functional. For the first three, this means
that, if they relate w to an object, they relate w to nothing else. If the
predicate ConstrProj4a relates w to a plurality, it relates w to no
other plurality. Finally, if the predicate ConstrProj4b relates w to two
objects, it relates w to no other objects.)
In addition, we lay down the following axioms:
(24)
(Set(x : xx) ∧ x@t ∧ ∃s(ConstrFrom(x, s) ∧ s C t)) →
∃w w@t ∧ ConstrProj1 (w, cset ) ∧
ConstrProj2 (w, cSetMembers ) ∧
ConstrProj3 (w, x) ∧


ConstrProj4a (w, xx)

(If x is a set that exists at t and is constructed from objects xx existing

at some previous stage, then we also require at t the existence of w
whose projections are cset , cSetMembers , x, and xx.)
Remark. The condition

∃s(ConstrFrom(x, s) ∧ s C t))

in the antecedent of (24) is redundant in light of axiom (16).

(25)
(Sum(x : xx) ∧ x@t ∧ ∃s(ConstrFrom(x, s) ∧ s C t)) →
∃w w@t ∧ ConstrProj1 (w, csum ) ∧
ConstrProj2 (w, cWholeParts ) ∧
ConstrProj3 (w, x) ∧


ConstrProj4a (w, xx)

(If x is a sum that exists at t and is constructed from objects xx existing

at some previous stage, then we also require at t the existence of w
whose projections are csum , cWholeParts , x, and xx.)

Remark. In the case of sums, the condition

∃s(ConstrFrom(x, s) ∧ s C t))

in the antecedent is not redundant. An example might help illustrate the effect of
this conditions. Let us use ‘+’ to indicate the result of summing some objects.
And let us indicate the plurality of x1 , ..., xn as [x1 , ..., xn ]. So, for example,
Sum(a + b : [a, b]). Suppose stage 0 comprises three givens a, b, and c. At stage
1 we have the following summables: a, b, c, a + b, a + c, b + c, and a + b + c.
Consider Sum(a + b + c : [a + b, c]). While a + b and c exist at stage 1, no

16
relation for this construction is introduced at stage 1. This is because a + b does
not exist at the previous stage. The construction relation for Sum(a + b + c :
[a + b, c]) is introduced at stage 2. By contrast, the construction relation for
Sum(a + b + c : [a, b, c]) exists at stage 1, since a + b + c exists at that stage and
each member of [a, b, c] exists at the previous stage.

(26)
(Pair(x : u, v) ∧ x@t ∧ ∃s(ConstrFrom(x, s) ∧ s C t)) →
∃w w@t ∧ ConstrProj1 (w, cop ) ∧
ConstrProj2 (w, cTuplePlaces ) ∧
ConstrProj3 (w, x) ∧


ConstrProj4b (w, u, v)
(If x is an ordered pair that exists at t and is constructed from objects
xx existing at some previous stage, then we also require at t the
existence of w whose projections are cop , cTuplePlaces , x, and xx.)

Remark. In the case of pairs, as in the case of sets, the condition

∃s(ConstrFrom(x, s) ∧ s C t))

is redundant.
We introduce a similar axiom for set-theoretic union, conceived as a derived
constructor. Define a set x to be the union of the sets yy iff something is an
element of x just in case it is an element of some set in yy:

Union(x : yy) ↔def ∃xx (Set(x : xx) ∧

∀y(y ≺ yy → ∃zz Set(y : zz)) ∧
∀z(z ≺ xx ↔ ∃y∃zz(y ≺ yy ∧ Set(y : zz) ∧ z ≺ zz))

Remark. Whenever the set of sets yy exists at a stage, their union exists at
that stage.
Construction relations for union are introduced by the following axiom:
(27)
(Union(x : yy) ∧ x@t ∧ ∃s(yy@s ∧ s C t)) →
∃w w@t ∧ ConstrProj1 (w, cunion ) ∧
ConstrProj2 (w, cSuperSubSets ) ∧
ConstrProj3 (w, x) ∧


ConstrProj4a (w, yy)

(If x is the union of sets yy, x exists at t, and yy exist at some stage
before t, then we also require at t the existence of w whose projections
are cunion , cSuperSubSets , x, and yy.)

17
Remark. The case of union resembles that of sum in that the condition
∃s(ConstrFrom(x, s) ∧ s C t))
is not redundant.
We can use one of the projection predicates to define the predicate being a
construction relation:
ConstrRel(w) ↔def ∃x ConstrProj1 (w, x)
So an object is a construction relation if and only if it has a first projection.
Construction relations have extensional identity criteria. This is captured
by the next axiom. For reasons of economy, we express it through a precise but
not formalized statement:
(28) For any construction relations w and w0 , w = w0 if and only if their
projections are the same.
We want to ensure that the only construction relations existing at a stage
are those recording basic or derived constructions using objects from previous
stages:
(29)
ConstrRel(w) ∧ w@t →
∃x∃xx∃s Set(x : xx) ∧ x@t ∧ xx@s ∧ s C t∧
ConstrProj1 (w, cset ) ∧ ConstrProj2 (w, cSetMembers ) ∧


ConstrProj3 (w, x) ∧ ConstrProj4a (w, xx) ∨
∃x∃xx∃s Sum(x : xx) ∧ x@t ∧ xx@s ∧ s C t∧
ConstrProj1 (w, csum ) ∧ ConstrProj2 (w, cWholeParts ) ∧


ConstrProj3 (w, x) ∧ ConstrProj4a (w, xx) ∨
∃x∃y1 ∃y2 ∃s Pair(x : y1 , y2 ) ∧ x@t ∧ y1 @s ∧ y2 @s ∧ s C t∧
ConstrProj1 (w, cpair ) ∧ ConstrProj2 (w, cTuplePlaces ) ∧


ConstrProj3 (w, x) ∧ ConstrProj4b (w, y1 , y2 ) ∨
∃x∃xx∃s Union(x : xx) ∧ x@t ∧ xx@s ∧ s C t∧
ConstrProj1 (w, cunion ) ∧ ConstrProj2 (w, cSuperSubsets ) ∧


ConstrProj3 (w, x) ∧ ConstrProj4a (w, xx)

(If a construction relation w exists at a stage t, then it must

appropriately record one of the following four constructions: (1) a set
existing at t constructed from elements existing at some stage before t;
(2) a sum existing at t constructed from objects existing at some stage
before t; (3) a pair existing at t constructed from coordinates existing at
some stage before t; (4) a set existing at t that is the union of sets
existing at some stage before t.)

18
Remark. Axiom (29) implies that there are four kinds of construction relations,
corresponding to the three basic constructors and to the derived constructor of
union.

6.11 Maximal extension of a stage

A stage t is a maximal extension of s iff (1) t contains every object that can
be constructed on the basis of objects that exist at s and (2) every object at
t is either already at s or is constructed from objects at s or is a construction
relation recording such a construction, including the derived construction of
union. This leads to the following definition:

Max(s, t) ↔def s E t ∧ ∀x(ConstrFrom(x, s) → x@t) ∧

∀x x@t → ConstrFrom(x, s) ∨ (ConstrRel(x) ∧
(∃y(ConstrProj3 (x, y) ∧ ConstrFrom(y, s)) ∨


(ConstrProj1 (x, cunion ) ∧ ∃yy(yy@s ∧ ConstrProjc4a (y, yy)))

Remark. The axioms for construction relations ensure that the appropriate
construction relations exist at maximal stages.

(30) ∀s∃t Max(s, t)

(Every stage has a maximal extension.)

Remark. Using (12), one can show that the maximal extension is unique.
Remark. A maximal extension strictly succeeds the stage whose maximal ex-
tension it is: Max(s, t) → s C t.
Remark. Consider the statement that every successor stage is also a maximal
extension:
Succ(s, t) → Max(s, t) (*)
If we make this statement, it follows that every stage has a unique successor.
As we saw above, the LUB of some stages is also unique. Thus, by induction on
E, we prove that E is a linear order (and thus also a well-ordering). Thus, (*)
provides a kind of switch, which, if on, requires E to be a well-ordering, and if
off, allows E to be merely a well-ordered convergent partial order.

6.12 Classification
We want to classify the objects in our ontology. We make explicit the definitions
of the unary predicates of set and pair, which were implicit in our expositions:

IsSet(x) ↔def ∃xx Set(x : xx)

IsPair(x) ↔def ∃y1 ∃y2 Sum(x : y1 , y2 )

Our target principles are:

19
 (i) everything is either a summable, a set, a pair, a construction relation, or
a stage;
(ii) nothing has more than one of the mentioned properties.
The first principle can be obtained from the preceding axioms. This can be
seen as follows. By the axioms concerning what exists at a stage, we have that
anything that is not a stage exists at some stage. The only things that exist at
stages are givens, constructed objects, and construction relations. Givens are
summable, and constructed objects are sets, sums, or pairs.
The second is assumed as an axiom.

(31)

(IsSet(x) → ¬Summable(x) ∧ ¬IsPair(x) ∧ ¬ConstrRel(x) ∧ ¬Stage(x)) ∧

(Summable(x) → ¬IsSet(x) ∧ ¬IsPair(x) ∧ ¬ConstrRel(x) ∧ ¬Stage(x)) ∧
(IsPair(x) → ¬IsSet(x) ∧ ¬Summable(x) ∧ ¬ConstrRel(x) ∧ ¬Stage(x)) ∧
(ConstrRel(x) → ¬IsSet(x) ∧ ¬Summable(x) ∧ ¬IsPair(x) ∧ ¬Stage(x)) ∧
(Stage(x) → ¬IsSet(x) ∧ ¬Summable(x) ∧ ¬IsPair(x) ∧ ¬ConstrRel(x))

(Nothing has more than one of the relevant properties.)

7 Consistency of the stage theory

As a proof of concept, we can show that our stage theory is consistent. As is
often the case, this is done by constructing a set-theoretic model in which every
axioms of the theory is true. The actual model construction and consistency
proof can be found in Appendix D. Here we provide a brief overview.
To construct a set-theoretic model, we obviously need to rely on some set
theory in the metalanguage. Suppose this set theory is X. We will then have
proved that “the stage theory is consistent relative to X”, that is, if our set
theory X consistent, then so is the stage theory. This makes it important to
let X be some familiar set theory of whose consistency set theorists are highly
confident. One such theory is Zermelo Fraenkel set theory with the Axiom of
Choice (ZFC). Our options concerning the choice of the theory X are either
ZFC itself or some relatively minor variants.

• We can use a Morse-Kelley class theory (MK), which adds to ZFC a single
layer of classes on top of all of the sets.
• We can use ZFC + an extra axiom stating that there exists an “inaccessible
cardinal”. In the literature on strong axioms of infinity, this is considered
a very modest extension of ZFC. (It is, however, stronger than MK, but
has the advantage of talking only about sets, with no need to add a notion
of class.)

20
 • We can use ZFC as our metatheory and prove the consistency of a slight
weakening of our stage theory obtained by restricting the axiom of plural
comprehension. Instead of stating that any condition ϕ(x) that has in-
stances can be used to define a plurality of all ϕ’s, we state that there is
a plurality of all ϕ’s at stage s, for any given stage s.

• We can drop the axiom of replacement from the stage theory and use ZFC
to prove the consistency of the resulting theory.

In short, our stage theory can be proved to be consistent assuming some very
modest extensions of standard set theory ZFC, and even the need to consider
extensions can be avoided by weakening non-essential parts of the stage theory.
In Appendix D, we pursue the first option, namely we show that the stage
theory is consistent relative to MK.

A Notions
A.1 List of (key) types and identity criteria
A.2 Non-logical vocabulary

B Resources
C Design choices
D Set-theoretic model
We wish to construct a set-theoretic model for the axiomatic stage theory. For
convenience, we will work in set theory with urelements. Since our urelements
form a set, it is routine to translate this impure set theory into a corresponding
pure set theory. Our metatheory will mostly be ZFC, but at times it is also useful
to use Morse-Kelley set theory, which adds to ZFC a single layer of classes on
top of all the sets.
The model we construct validates the full stage theory, including the optional
additional principle (*) to the effect that every successor stage is a maximal ex-
tension. In future work, it would be interesting to consider alternative, or more
general, set-theoretic constructions which model other stage-theoretic axioms
and assumptions.
As a basis for the model, we assume two disjoint sorts of urelements:

• A set I of indexing objects that encode the type of the objects that are
modeled: m for (mereologically) summable, s for set, t for tuples, and c
for construction relations. We require that the index objects are not used
in any other way in the set theoretical model. That is, I = {m, s, t, c}.
• A set G of givens.

21
We also assume G has the following subset:
• A set W of the eight constants indicating types of construction relations.
So W = {cset , csum , cop , cunion , cSetMembers , cWholeParts , cTuplePlaces , cSuperSubSets }.
Other than the stages, which will be treated separately, we model each object
as a pair of an indexing object, which specifies what kind of object is being
represented, and a set, which specifies the particular objects of this kind that is
being represented. In characterizing the set theoretical model, we use the usual
notation for ordered pairs, ‘(. . . , . . . )’, as an abbreviation of the Kuratowski
pair, i.e., (a, b) =def {{a}, {a, b}}.
A remark about the role of the index objects: their function is to avoid
clashes between types, or more precisely, to prevent confusion over which type
of object is represented by a certain set, which (if they arose) would also lead to
unclarity about which object is represented by the set in question. An example:
without the index objects, the set {{a}, {a, b}} might be taken to represent
either itself, i.e. a set of rank 2, or the ordered pair of a and b.
Here is the idea:

• z represents the mereological sum of a set x of givens iff there is an x ⊆ G

such that z = (m, x).
• z represents a set x iff z = (s, x).
• z represents a pair hx, yi iff z = (t, x, y).

• z represents a construction relation iff z = (c, x1 , x2 , x3 , x4 ) and one of

the following is the case:
(i) x1 = cset , x2 = cSetMembers , x3 represents a set y, and x4 is the set of
the members of y;
(ii) x1 = csum , x2 = cWholeParts , x3 represents a mereological sum of a
set y of givens, and x4 = y;
(iii) x1 = cop , x2 = cTuplePlaces , x3 represents a pair hu, vi, and x4 =
(u, v);
(iv) x1 = cunion , x2 = cSuperSubSets , x3 represents a set y, and x4 is a set
whose members represent sets the union of which is y.

We now specify the model. We define a construction operation C such that

C(X) will model the result of undertaking all of our forms of construction on
the basis of (the objects) represented by elements of X. That is, given a set X,
we define C(X) as the set whose members are all and only the following objects:
• for any x ⊆ X, (s, x) ∈ C(X);

• for any x ⊆ X where each member of x represents something summable,

then (m, y) ∈ C(X), where y is the union of all of the sets that figure as
second coordinates of elements of x;

22
 • for any u, v ∈ X, then (t, u, v) ∈ C(X);
• construction relations as follows:
(i) for any x ⊆ X, (c, cset , cSetMembers , (s, x), x) ∈ C(X);
(ii) for any x ⊆ X such that each member of x represents something
summable, (c, csum , cWholeParts , (m, y), x) ∈ C(X), where y is the
union of all of the sets that figure as second coordinates of elements
of x;
(iii) for any u, v ∈ X, (c, cop , cTuplePlaces , (t, u, v), (u, v)) ∈ C(X);
(iv) for any x, y ⊆ X such that the members of y, represents sets whose
union is represented by x, x ⊆ X, (c, cunion , cSuperSubSets , (s, x), y) ∈
C(X).

Let G∗ be {hm, {g}i : g ∈ G}.

By set-theoretic recursion, we now define a sequence Mα such that

• Let M0 be defined as G∗ .
• Let Mα+1 = Mα ∪ C(Mα )
• Let Mλ = γ<λ Mγ
S

As usual (see Kunen, Set Theory: An Introduction to Independence Proofs,

REF), we can talk about M as the union of all of the Mα , exactly as we talk
about V as the union of all of the Vα . In fact, for the purposes of interpreting
traditional plural logic, it is convenient to use as our metatheory Morse-Kelley
rather than ZFC. Then M can be a proper class. Alternatively, if we use ZFC +
“there is an inaccessible cardinal”, we let M be Mκ for κ the first inaccessible.

Lemma 1. When (m, x) ∈ M , then x ⊆ G.

Proof. A straightforward induction on the construction of M .
We now want to interpret our stage theory in this model. Plural variables
are interpreted as ranging over non-empty subclasses of M (if we use Morse-
Kelley class theory) or non-empty subsets of M (if we use ZFC + “there is
an inaccessible cardinal”). Plural membership is interpreted as set- or class-
theoretic membership, i.e. ‘≺’ is true of a, b iff a ∈ b.

• ‘Set(x : xx)’ is true of a, b iff a = (s, b).

• ‘Sum(x : xx)’ is true of a, b iff a = (m, b).
• ‘Pair(x : u, v)’ is true of a, b, c iff a = (t, b, c).
• ‘Summable’ is true of a iff a = (m, x), for some x.

23
 • ‘ConstrProj1 (w, y)’ is true of a, b iff a = (c, b, x2 , x3 , x4 ), for some
x2 , x3 , x4 .
• ‘ConstrProj2 (w, y)’ is true of a, b iff a = (c, x1 , b, x3 , x4 ), for some
x1 , x3 , x4 .
• ‘ConstrProj3 (w, y)’ is true of a, b iff a = (c, x1 , x2 , b, x4 ), for some
x1 , x2 , x4 .
• ‘ConstrProj4a (w, y)’ is true of a, b iff a = (c, x1 , x2 , x3 , b) and x1 ∈
{cset , csum , cunion }, for some x2 , x3 .
• ‘ConstrProj4b (w, y)’ is true of a, b iff a = (c, x1 , x2 , x3 , b) and x1 = cop ,
for some x2 , x3 .
• ‘Stage’ is true of all and only the Mα ’s, where ‘E’ is true of Mα and Mβ
iff α ≤ β, and ‘x@s’ is true of a and Mα iff a ∈ Mα .

The language of the stage theory also contains eight special constants, which
have been included among the givens. So we let these constant interpret them-
selves.
Theorem 1. All of the axioms of our stage theory as satisfied in this model.
Proof sketch:
• The axioms of plural logic are satisfied because plural variables are inter-
preted as ranging over non-empty subcollections of M . (These subcollec-
tions will be either subclasses or subsets, depending on whether we use
MK or ZFC + “there is an inaccessible”.) (Notice that to validate com-
prehension axioms that give pluralities not bounded by a stage, we need
to go beyond ZFC. This is the only place where this is needed.)
• The axioms concerning stages are satisfied because these axioms are true of
the canonical ordering (α ≤ β) of the ordinals. (Notice that the proofs that
the axioms of infinity and replacement are satisfied uses the corresponding
axioms of set theory.)
• The axioms concerning the initial stage are satisfied because M0 has been
chosen so as to be non-empty and to contain the interpretations of the
eight special constants.
• The axioms concerning what exists at a stage are satisfied: every non-stage
exists at a stage; the stages are cumulative; limit stages just accumulate
the preceding stages; stages with identical domains are identical; and suc-
cessor stages contain only the domain of the preceding stage, objects that
can be constructed from this domain, and construction relations.
• There is one axiom concerning what is or is not constructible. The axiom
is true in our model, since summable objects are those representing sums,
which is done by sums and givens.

24
 • The axioms concerning the set constructor are satisfies. The definition of
the construction operator C implies that every plurality existing at stage
forms a set a the next. Moreover, since the stages are well-founded, the
elements of a set exist prior to the set. The extensionality of sets in the
metalanguage secures the extensionality of sets in the object language.

• The axioms concerning the sum constructor are satisfied because of the
definition of the construction operator C and of the fact that the sums are
isomorphic to the powerset algebra of the set of givens. Since the latter
validates the axioms of Atomistic Classical Extensional Mereology, so does
the former.

• The axioms concerning the pair constructor are satisfies. The definition of
the construction operator C implies that every two objects at stage forms
a set a the next. Since the stages are well-founded, the coordinates of
a pair exist prior to the pair. The representation of pairs in the model
ensures that the criterion of identity is satisfied.

• The axioms concerning the construction relations are satisfied because

the definition of the construction operator C ensures that all required
construction operations are generated. For each construction, C adds a
tuple recording the appropriate information about the construction.
• The model has been constructed so as to satisfy the axiom that every
successor stage is maximal. This is because the construction operation C
yields all of our forms of construction from the objects at a given stage,
and it generates all relevant construction relations.
• Finally, the classification axioms are satisfied by the way in which different
types of objects have been encoded in the model. This encoding represents
different types of objects by means of different indices.

E Future work

25