The Underdetermination of Typings

Jan Westerhoff
Trinity College
Cambridge CB2 1TQ
United Kingdom

jcw26@cam.ac.uk
0044 (0)1223 52 52 04




Abstract

It is often assumed that the distinction between individuals and
properties is a purely structural one, i.e. that they differ in the
way in which they go together to form states of affairs (monadic
properties take one individual, dyadic properties take two,
higher-order properties take properties of lower orders and so
on). And in fact, as Ramsey has argued in his essay `Universals', if
any way of telling apart individuals and properties works it is a
structural one. But in fact there is no structural distinction between
individuals and properties. Below I will describe a set of
transformations which show that if your structural theory calls
something an individual and something else a property there is a
transformation of that assignment which calls the first thing a
property and the second an individual which is equally in accord with
the structural data. Therefore, what is an individual and what a
property is not determined by the structural data. We do not say
anything essential about an object if we classify it as either, in
fact we do not even say something important about the object at all.









1. Motivation and Key Notions

Introduction

We think that objects belong to certain types, for example that they are
individuals, properties, relations and so on. We also think that if we
say what type some objects belongs to, we have described an essential
feature of the object, or at least said something important about
it. In fact this is not the case.

Let us look at an uncontroversial example of objects belonging to
different types. I take it that it is as uncontroversial as anything
can be in ontology that we consider a particular like the Tower of
London as belonging to the type of individuals, something like
`being red' as a first order (monadic) property of individuals
and something like `being a colour' as a second order (monadic)
property of first order monadic properties. We do this because of the
way these three objects can occur in states of affairs. The individual
and the first order property can go together to make up a state of
affairs (the one picked out by the sentence `The Tower is red') as can
the first order property and the second order property (`Red is a
colour'). However, the individual and the second order property cannot
go together to form a state of affairs. We assume that these facts are
encoded in our typing the three objects in the way we do.

But this is not the only way in which we can type the objects. Suppose
we consider `being red' as an individual (let us call it `Red' for
that purpose) and both `being the Tower' and `being a colour' as
first order properties (let us call them `to tower' and `to
colour'). In this case the objects fit together to produce the very
same states of affairs as those above. The state of affairs
corresponding to the one denoted by `The Tower is red' (and which is
now denoted by `Red towers') consists still of an individual and a
first order (monadic) property, although their roles are
reversed. There is also an equivalent to the state of affairs denoted
by `Red is a colour' (now `Red colours'), but now this has exactly
the same form as the previous one, rather than being made up of a
first order and a second order property. Equally there couldn't be a state
of affairs consisting of `to tower' and `to colour' since things
forming a state of affairs cannot be at the same level (this was
achieved in the first typing by the fact that they were not located at
neighbouring levels).

There are still further ways of typing the above objects. For example
we can consider both `being the Tower' and `being a colour' as
individuals (and call them `Tower' and `Colour') and have `being red'
again as a first order property. Or we could `lift' the two last
examples of typings by moving everything to the next higher type;
individuals would become first order properties, first order
properties second order properties. Finally we could reverse our
initial typing which made use of three levels such that now `being a
colour' is a individual (`Colour'), `being red' a first order property
and `being the Tower' a second order property. As the reader is
invited to check all these typings allow the same states of
affairs to occur and are thus equally acceptable.





Data and Conventions

Perhaps we should pause a bit at this place and be somewhat more
explicit about how we can be so sure that the above typings really all
are alternatives in that they make the same states of affairs possible.

First of all let us note that there are such a things as ontological
data. These are information about what can form states of affairs with
what; a particular example of such a datum is e.g. that `red' and
`Tower' go together in a state of affairs which is denoted by the
sentence `The Tower is red'. To be a bit more concise let us write T,
R and C for `Tower', `being red' and `being a colour' independent of
the ontological type assigned to them in a particular typing. We will
call the collection B of these the basis of our data. Let us denote
the fact that some of these go together to form a state of affairs by
prefixing the multisets containing them with a +, else with a
-. (Multisets (enclosed in square brackets) are just like ordinary
sets apart from the fact that they allow for repetitions. Thus while
{a, b } = { a, a, b }, not [a, b] = [a, a, b]. They are distinguished
from ordered sets in that the order of elements does not matter,
i.e. while not <a, a, b> = <a, b, a>, [a, a, b] = [a, b, a]. We assume
that each multiset of cardinality one is automatically prefixed with a
-.)  Thus the ontological data D we have about T, R and C is that +[T,
R], +[C, R] and -[T, C], -[T, T], -[R, R], -[C, C]. These data act as
a constraint on the typing we want to construct. They are that what
the typing is to be a theory of.

There is also another kind of constraint involved which I will call
the type-form conventions. The conventions which were in play
in the above typings said that types are indexed by an ascending,
uninterrupted sequence of ordinal numbers beginning with zero and that
members of these types can only go together in states of affairs if
they are all located at two directly neighbouring types. This is just
the picture of types found in the Russellian simple theory of types. 

The task of constructing a typing for a particular set of objects
means finding a way of remaining faithful to the ontological data
within the type-form conventions in play. Of course it can happen that
a certain set of ontological data cannot be typed at all given a set
of type-form conventions. For example if your data are +[A, B], +[B,
C] and +[C, A] there is clearly no way of typing this in the
stratified way just suggested. 

This was not the case with the examples discussed above. There it is
straightforward to check that all of the above typings were in
accordance with the ontological data. But we have also seen that
there can be more than one way of achieving such accordance. For
example if our data demand that two objects cannot go together in a
state of affairs (as e.g. for S and C above) we have different
ways of accounting for this. We can put them `types apart' or, to
achieve the same effect, put them in the same type. The important
point is that this can even happen if we have agreed on one system of
type-form conventions. It is clear that such a system is purely
conventional (hence the name). We could have said that elements from
the same type can go together, or that only members of types with the
same parity can go together, or any other such convention. But even
settling for a framework in which to give an account of our
ontological data radically underdetermines the form of the resulting
typing. Above we have given five substantially different alternative
typings for a set of data on the basis of one set of type-form
conventions. In some there are three levels of types, in others only
two, in some there are individuals, in others there aren't, and in
particular each element could turn up at any level, it could be an
individual, a first order property or a second order property.

Of course the data restrict the number of possible typings relative to
some type-form conventions to some extent. For examples, typings were
S was an individual, C a first order property and R a second
order property or where S and R are individuals and C a first
order property cannot faithfully represent the data since on the above
type-form conventions they would entail that +[S,C] and -[R,
S]. However, the restriction isn't restrictive enough to guarantee
uniqueness.







2. Main results and further developments

In the remainder of this paper we are going to outline how the typing of
some ontological data can be represented in graph-theoretic form. We
then show that there are a number of transformations of such a graph
which preserve the adequacy of the typing. Such transformations were in
play when we considered the different typings of the data presented at
the beginning of our paper. These transformations change the typing,
but do not affect its adequacy as a typing of some particular
ontological data.

We then prove two main results:

an applicability result which says that if some data can by typed in a
stratified way according to the above conventions at all, all our
transformations preserve accordance with the data.

a flexibility result which shows that any typing of some data
according to the above conventions in which some object is at level 0
and where some object S is at level n can by a successive applications
of the three transformations be made into another typing which is also
in accordance with the data but where S is located at level m, for any
m.

The flexibility result is particularly important. It shows that
contrary to a common assumption in ontology objects do not belong
essentially to their type (i.e. nothing is essentially an individual
or a property). By making some changes in other parts of our typing,
everything can be moved to any type we like.  Clearly that doesn't mean
that this can be done for all objects and that thus all typings
are adequate. Rather, if you put some object in some type first,
faithfulness to the data will imply that you are restricted in where
to put the other objects. Nevertheless, for each particular object we
can put it into whatever type we like.

We then consider two arguments which try to get around this
conclusion. The first is to consider not just monadic properties, as
we have done, but also dyadic and generally polyadic
properties. Unfortunately this does not make any major
difference. Both the applicability and the flexibility result remain
provable.

Secondly we look at attempts to tighten the type-form conventions in
such as way as rule out the transformations leading to different
typings. The idea is to restrict the conventions in a manner which
results in only a single typing dropping out as adequate in the
end. But we soon see that such a procedure is necessarily far too
restrictive. If we tighten the type-form convention in any way which
makes them essentially stronger than the ones we have given above, we
will lose the ability to type many of the data which we want to be
able to type.

Given that none of these two arguments works,the underdetermination
remains. We spend the remainder of the essay elaborating the
philosophical implications of this underdetermination of typings. We
see that if we say that an object belongs to a certain type we have
certainly not mentioned any essential property of the object. It is
even doubtful whether we have said anything important about the object
at all, since by making amendments elsewhere, everything could be in
any type. The only important information will be contained in the
typing as a whole (since this will reflect the initial ontological
data), but not in whether a particular object is assigned to this or
that type. Therefore these initial ontological data do not allow us to
draw the ontological distinctions we would like to think we could
draw.