Balisage Paper: Markup Meaning and Mereology

Introduction

XML documents consist of marked elements, which may in turn contain sequences of marked elements, etc. This hierarchy of elements is conveniently represented as a tree in which each node stands for an element, in which each arc between elements stand for a parent-child relationship, and in which the children of each node are ordered sequentially in accordance with their document order.

While it is commonly the case that the generic identifier of an element is understood to ascribe a property to the element's content, that elements represented by nodes dominated by that element's node in the document tree are also understood to be contained by it, and that these nodes are understood to inherit the properties ascribed to their ancestor elements, none of this is always or necessarily the case.

As we have pointed out elsewhere [Sperberg-McQueen and Huitfeldt 2008], the parent-child relationship may be taken to indicate either a containment relationship, or a dominance relationship. Frequently these relationships coincide, and no harm is caused by not distinguishing them. When they do not coincide, however, the result may easily be confusing.

One view of the structure of XML documents emphasizing the part-whole relationship is this: A document contains elements, i.e., parts. Some of these parts contain further elements, i.e., have parts of their own. The generic identifiers of elements ascribe properties to their own content and/or to the content of elements related to them by part-whole relationships.

Mereology is precisely the theory of part-whole relationships. Even so, mereology does not seem to have found much application in markup theory until now. It may therefore be interesting to investigate whether the application of mereology may give insights relevant to the understanding of interpretation and processing of marked-up documents.

It is sometimes said that XML provides a formal syntax for document representation, but no formal semantics for the interpretation or processing of this syntax. If mereology can be brought to bear on the ascription and propagation of properties and relations between parts of marked-up documents, it may help in providing a general approach to markup semantics. For example, the work presented here may turn out to be of direct relevance for the work on formal tag set descriptions and intertextual semantics specifications presented in [Marcoux et al. 2009] and [Sperberg-McQueen et al. 2009a].

Before we proceed, some words on the limitations of this paper are in place. First, although our focus is on XML, and although we mention other markup languages in passing, we believe that mereology deserves to be studied in relation to markup languages in general (such as XML, SGML, TexMecs, LMNL, and others) rather than XML only. We think so partly because application of mereology may be equally or more profitable when it comes to some non-XML markup systems, and partly because such broader studies might inspire modifications of — or alternatives to — any or all of these. We hope to come back to applications of mereology to markup more generally in future work.

Second, the concept XML document as used in this paper refers almost exclusively to XML in its serialized form. We do not explicitly attempt to apply mereology to XML documents considered as graphs of xPath nodes, Infoset items, or the like.

Finally, we limit ourselves to an attempt to apply the so-called Calculus of Individuals, a mereological system worked out by Nelson Goodman [Goodman 1977] (initially in cooperation with Henry S. Leonard [Leonard and Goodman 1940]). As a further simplification, and in order to ensure focus, we will ignore XML attributes, entities, declarations, comments, processing instructions, and marked sections; in short, we will regard XML documents as consisting of elements and their content only .

The Calculus of Individuals

The origins of mereology go back to ancient Greece, but it was taken up as a formal study and developed mathematically only early in the 20th century. Today, it is a well developed formal discipline, and there are a number of different mereological systems. The term mereology is sometimes used to refer to these formal calculi in particular, sometimes to formal as well as non-formalized theories of part-whole relationships in general [Libardi 1994, pp. 13–15].

Early developments of formal mereology were largely motivated by scepticism towards set theory and the calculus of classes, and a desire to translate or reduce all talk of abstract classes and their members to talk of concrete individuals and their parts. Mereology therefore came to be associated with a particular ontological stance, nominalism, and to be shunned by most adherents of other ontological views.^[1]

Such ontological considerations may or may not motivate, but do not in any way need to concern, our attempt to apply mereology to markup languages, however: later work in the field is generally taken to demonstrate that mereology and set theory may live merrily together, that in fact the one may be seen as an extension of the other, and that the adoption of mereology does not by itself commit one to any particular ontological stance.^[2]

The part-whole relationships that mereology studies are relationships between entities that are, in Goodman's terminology, called individuals. Generally speaking an individual may be any thing in a very wide sense of the word — a concrete, an abstract, a universal or a particular — i.e., any object or entity of which something can be predicated. This is admittedly still pretty general, and more specific talk may be in order: As examples of individuals we may take stones, tables, chairs, animals and other medium-sized everyday objects; but if we like we may also populate our world with individuals such as molecules, atoms, electrons, quarks; or planets, stars and galaxies; or for that matter persons, visual after-images, mental images or sense data. If we believe in abstract objects we may include numbers, geometrical objects, concepts, etc., and according to some applications of mereology there may also be temporal individuals such as processes, events, and snippets of time.

Individuals need not be contiguous, neither in space nor in time. This is one of the principles of the Calculus of Individuals which has provoked some discussion. In its defence one may point to the fact that we actually do employ the notion of at least some such disconnected wholes in everyday language. Thus, to treat the land mass of Japan (or any geographic entity which includes two or more islands) as an individual may seem unobjectionable. However, according to another principle, the sum of any two individuals is always also an individual. This seems to force us to accept as individuals, i.e., wholes, sums of randomly scattered parts such as Caesar's nose and the state of Utah [Goodman 1972, p. 37].^[3] Goodman bites that bullet, while much of the ensuing debate has been concerned with attempts to find ways of distinguishing such scattered and arbitrary sums from more cohesive or integral individuals as wholes consisting of parts in a more intuitively satisfactory sense.

A formal mereological theory takes conventional first-order predicate logic as its basis. We will use conventional modern logical notation for quantifiers, operators, predicates, variables and constants. More specifically, we will use (x) for universal and (∃x) for existential quantification over x; ¬ for negation, → for implication, ∨ for inclusive disjunction, ∧ for conjunction, ⇔ for equivalence, and = for identity. We use the small roman letters a, b, c... for constants, x, y, z... for variables, and upper roman letters A, B, C... for predicates. We will occasionally use the conventional abbreviation iff for if and only if.

The extension which mereology makes to this basis is very modest: In fact the extension consists in adding only one single primitive relation to the first-order system. This specifically mereological, primitive relation may be chosen from among the relations part of, proper part of, discrete from or overlapping with. As each of these relations may be defined in terms of any of the others, it does not matter much which one we chose as our undefined primitive.^[4] With a hopefully obvious appeal to markup theorists, we will follow [Goodman 1977] in choosing overlap for our primitive relation.^[5]

Variables are taken to range over individuals only, and predicates are taken to ascribe properties of or relations between individuals.

From a mereological point of view, two individuals overlap iff they have some content in common. One consequence of this definition may briefly confuse markup specialists: since in an XML document a child element and its parent element have some content in common (everything contained by the child is also contained by the parent), it follows that in the sense introduced here the child and the parent overlap. That is, the term overlap, as used in the calculus of individuals, includes proper nesting or normal part/whole relations.

Thus, if we think of XML elements as individuals consisting of stretches of consecutive character occurrences, and if we consider the following four cases (strictly speaking, the first line is not well formed XML and is included only for purposes of illustration):

            <s>  <q>   </s> </q>
            <s>  <q>   </q> </s>
            <q>  <s>   </s> </q>
            <s>  </s>  <q>  </q>

The overlap operator is written ∘. The following condition on ∘ captures the intuitive notion of “having some content in common,” and we thus take it as an axiom:^[6]

2.41  x ∘ y  ⇔ (∃z)(w)((w ∘ z) → ((w ∘ x) ∧ (w ∘ y)))

We now state further relation and operator definitions, theorems and axioms. Note that not all of them belong to all variants of mereological systems; they do, however, belong to ours.

As already mentioned, the relations part of, proper part, and discrete may all be defined in terms of the overlap relation.

Iff x is a part of y, then everything that overlaps x also overlaps y:

D2.042 x < y =df (z)((z ∘ x) → (z ∘ y))

Iff x is a proper part of y, then x is a part of y but y is not a part of x:

D2.043 x ≪ y =df (x < y) ∧ ¬(y < x)

Iff x and y are discrete, then they have no part in common, i.e., they do not overlap^[7]:

D2.041 x ʅ y =df ¬(x o y) 

It is worth noting that identity can be defined in terms of the primitive relation:

D2.044 x = y =df  (z)((z o x) ⇔ (z o y))

The product of x and y is the individual which exactly contains their common part:

D2.045 x · y =df (℩z)(w)((w < z) ⇔ ((w < x) ∧ (w < y)))

The sum of x and y is the individual which contains exactly and exhaustively both of them, or, in other words, the individual which overlaps all and only those individuals which overlap any of them:

D2.047 x + y =df (℩z)(w)((w ∘ z) ⇔ ((w ∘ x) ∨ (w ∘ y)))

The negate of an individual includes everything which does not overlap with that individual (i.e., what is often called its complement, or the rest of the world):

D2.046 –x =df (℩z)(y)((y ʅ x) ⇔ (y < z))

The difference between x and y is what remains of x after we eliminate the parts it has in common with y:

x – y =df (x · –y)

There is considerable controversy in the literature over the nil individual. The nil individual is the mereological analogue of the empty class. If accepted, it is part of any individual. Most mereological systems reject its existence, and we will do the same in this paper.^[8]

There is less controversy over the existence of the universal individual, i.e., the one individual of which every other is a part — the world or the universe as an individual. In our case, we are not applying the Calculus of Individuals as a Grand Theory of Everything, but limit its application to domains consisting of a single document, to collections (not to say sets or classes) of documents, or perhaps to documents and whatever else we may need to take into consideration to make sense of what these documents say. So we, too, will endorse the existence of a universal individual, customarily denoted by the letter W:

W =df (℩x)(y)(y < x)

Note that, because there is no nil individual:

However, the following statements hold, either as axioms or theorems, depending on how one elaborates the system:

Do all individuals have parts, or are there some individuals which are not further divisible into parts? Whether we take the one or the other position may have wide-reaching consequences for other properties of a mereological system, and the literature abounds with discussion on the subject. Given our domain of application, however, we believe that any system will have to be atomistic — on none of our analyses will documents have parts below character-level, or at least we foresee no need to talk about parts of characters. So we may simply add the axiom of atomicity to our system right away:

(x)(∃y)((y < x) ∧ ¬(∃z)(z ≪ y)) 

The Calculus applied to XML

What might it mean to apply the Calculus of Individuals to XML documents (or, for short, to XML) and what purpose might such an application of the calculus serve? A preliminary answer to the first question is that an application of the Calculus of Individuals to XML would require us to decide which entities to count as individuals, to decide which of these are to count as atomic individuals, as well as which properties they can have and which relations hold between them. Given the Calculus of Individual's rules of composition, different decisions on these issues will bring us to recognize the existence of individuals which may or may not coincide with established ways of viewing the structure of XML documents. Identifying rules which replicate such conventional views is, if possible, in itself of interest. Identifying rules which provide alternative views of XML documents may be of even greater interest, at least if they also suggest alternate and useful ways of analysing the parts of a document, of addressing them, and of how to ascribe properties of and relations between parts of a document.

A preliminary answer to the second question has thus already been suggested: We suspect that an application of the Calculus of Individuals to XML might suggest ways of identifying and addressing parts of a document which in some cases, or for some purposes, would be more convenient or more powerful than existing methods such as SAX, DOM or xPath. We also suspect that some application of the Calculus of Individuals to XML might suggest ways of dealing with what is sometimes called the semantics of XML, i.e., how to understand XML documents in terms of properties ascribed to and relations indicated between the various parts of them indicated by the markup.

In what follows we have nothing but tentative answers to the general questions just posed. Trying to answer the first question, we will present different ways of applying the Calculus of Individuals to XML. We will also explore some of their implications for answers to the second question. The explorative nature of our work should be emphasized: We do not want to suggest that these are the only, or the best, ways of applying the Calculus of Individuals to XML, nor do we suggest that we have identified all or even the most important implications of the approaches that we consider.

Therefore, each of the following sections begins by suggesting a different answer to the question Which are the individuals of a marked-up document? First, we consider the possibility that the individuals simply are XML elements. Next, we go down one step in level of granularity and identify tags and character strings as individuals. Finally, we proceed to a still finer level of granularity in order to see what happens if we recognize individual characters as atomic individuals, and distinguish between different kinds of individuals built from these atoms.

(1) <para>A <quote>rose</quote> is <emph>a</emph> rose.</para>

(2) <quote>rose</quote>
(3) <emph>a</emph>

<para>
A 
<quote>
rose 
</quote>
 is 
<emph>
a
</emph>
 rose.
</para>

<para>
<para>A 
<para>A <quote>
<para>A <quote>rose 
A rose
A  rose.
rose a
<para>A <quote>
A <quote>rose </quote> is <emph>
rose </quote>  rose.</para>

The character-atom approach

The approach

Finally, and moving one further step down in the level of granularity, we take character occurrences as the atomic individuals in our application of the calculus. For the sake of conciseness, we will use character as a synonym for character occurrence, except where confusion might arise.

The type of a character occurrence is represented in our system by a property of that character occurrence. So any atom (i.e., character occurrence) has the property of being an a, or a b, or a c, etc., thus populating our vocabulary with one predicate for each of the characters of the writing system at hand.^[13]

We define a total order relation on atoms, based on document order, represented by the predicate PA(x, y), true iff x precedes y in document order (“P” stands for “precedes” and “A” indicates it is a predicate on atoms). The transitive reduction of PA is represented by the predicate NA(x, y), true iff x immediately precedes y in document order (“N” stands for “next” and “A” indicates it is a predicate on atoms).

Since characters are atomic individuals, all individuals which can be composed on the basis of the characters of a document are also individuals, i.e., composite individuals. Composite individuals of special interest for our purposes are strings. We define strings as individuals which are either atoms, or the sum of atoms consecutive in NA order. A string that consists of only one character is (also) an atom. There is no such thing as an empty string (which would have to be the nil individual). Note that strings constitute a tiny fraction of all existing individuals.

Some strings are of particular interest to us. We define a molecular string (or molecule) as a string that is delimited on both sides (in the serialization underlying document order) by a tag, with no other tag intervening in between. A total ordering of molecular strings, represented by the predicate P(x, y), is trivially derived from the ordering of atoms (itself based on document order). The transitive reduction of P is represented by the predicate N(x, y). (“P” stands for “precedes” and “N” for “next”.)

We define an elemental string as a string delimited by the matching tags of an XML element (there may be intervening tags). We do not rely on any ordering of elemental strings.

For any given string x, we define (for convenience only) the label of x as the sequence of the types of the atoms composing x, in NA order. That is, for example, a string is labelled rose (or has the label rose) iff it is the sum of atoms of types r, o, s, and e, and those atoms are NA-ordered so that the one of type r comes first, the one of type o comes second, etc.

While it might have been plausible to treat tags as a special kind of strings, and build elements and nodes with their ordering and parent-child relationship in a way similar to that suggested in the tags and PCDATA approach above, instead, we shall regard tags simply as delimiting certain string individuals, and ascribing properties to (or relations between) those individuals.

We can now read (1) as follows:

• There are 17 atomic individuals. Their ordered sequence of types is: A,  , r, o, s, e,  , i, s,  , a,  , r, o, s, e, and ..

• There are five molecular string individuals. Their ordered sequence of labels is: A , rose,  is , a, and  rose..

• There are three elemental string individuals, labelled A rose is a rose., rose and a.

• The elemental string labelled A rose is a rose. has the property indicated by the generic identifier <para>.

  • Note that this does not imply that any of its parts, such as the molecular strings labelled A , rose, etc., has this property.

• The elemental string labelled rose has the property indicated by the generic identifier <quote>.

• The elemental string labelled a has the property indicated by the generic identifier <emph>.

  • Here we have an example of an atom which is also a molecule and an elemental string.

We introduce the following predicates:

Table I

Predicate	Meaning	Range of x and y
NA(x,y)	next after x is y (or, x immediately precedes y)	atoms
PA(x,y)	x precedes y	atoms
N(x,y)	next after x is y (or, x immediately precedes y)	molecules
P(x,y)	x precedes y	molecules
A(x)	x is atomic	any
M(x)	x is molecular	any
E(x)	x is elemental	any
ccc(x)	x has the property assigned by ccc (where ccc is an XML generic identifier)	any
T("c",x)	x is of type c (where c is a character type)	atoms
L("ccc",x)	x is labelled ccc (where ccc is a sequence of character types)	any

The last two predicates (T and L) are to be regarded as notational convenience features.^[14] We are ignoring potential problems of name conflicts in this presentation (which would arise e.g. in the case of a document containing XML generic identifiers A, M or E).

Examples

We assign the identifiers i01, i02, i03, etc. ^[15] to individuals of (1) and state some facts about them as follows:

Table II

T("A",i01)	A(i01)	NA(i01,i02)
T(" ",i02)	A(i02)	NA(i02,i03)
T("r",i03)	A(i03)	NA(i03,i04)
T("o",i04)	A(i04)	NA(i04,i05)
T("s",i05)	A(i05)	NA(i05,i06)
T("e",i06)	A(i06)	NA(i06,i07)
T(" ",i07)	A(i07)	NA(i07,i08)
T("i",i08)	A(i08)	NA(i08,i09)
T("s",i09)	A(i09)	NA(i09,i10)
T(" ",i10)	A(i10)	NA(i10,i11)
T("a",i11)	A(i11)	NA(i11,i12)
T(" ",i12)	A(i12)	NA(i12,i13)
T("r",i13)	A(i13)	NA(i13,i14)
T("o",i14)	A(i14)	NA(i14,i15)
T("s",i15)	A(i15)	NA(i15,i16)
T("e",i16)	A(i16)	NA(i16,i17)
T(".",i17)	A(i17)
i18=i01+i02	M(i18)	N(i18,i19)
i19=i03+i04+i05+i06	M(i19)	N(i19,i20)
i20=i07+i08+i09+i10	M(i20)	N(i20,i11)
	M(i11)	N(i11,i21)
i21=i12+i13+i14+i15+i16+i17	M(i21)
i22=i18+i19+i20+i11+i21
L("A ",i18)
L("rose",i19)	E(i19)	quote(i19)
L(" is ",i20)
T("a",i11)	E(i11)	emph(i11)
L("rose.",i21)
L("A rose is a rose.",i22)	E(i22)	para(i22)

The same information may be presented more conspicuously in the following table, listing for each individual its identifier, its type, its label, the kind of individual it is (A for atoms, M for molecular and E for elemental strings), its assigned properties (i.e., properties assigned by an XML generic identifier), its next atom or molecular string and its immediate proper parts. ^[16]

Table III

Id	Type	Label	Kind	Assigned property	Next atom	Next molecule	Immediate parts
i01	"A"		A		i02
i02	" "		A		i03
i03	"r"		A		i04
i04	"o"		A		i05
i05	"o"		A		i06
i06	"e"		A		i07
i07	" "		A		i08
i08	"i"		A		i09
i09	"s"		A		i10
i10	" "		A		i11
i11	"a"	"a"	A M E	emph	i12	i21
i12	" "		A		i13
i13	"r"		A		i14
i14	"o"		A		i15
i15	"s"		A		i16
i16	"e"		A		i17
i17	"."		A
i18		"A "	M			i19	i01, i02
i19		"rose"	M E	quote		i20	i03, i04, i05, i06
i20		" is "	M			i11	i07, i08, i09, i10
i21		"rose."	M				i12, i13, i14, i15, i16, i17
i22		"A rose is a rose."	E	para			i18, i19, i20, i11, i21

The elemental strings i22, i19 and i11 correspond to the XML elements (1)-(3) in a fairly straightforward way, and can now be identified for example as follows:

i22 = (℩x)(para(x) ∧ E(x))
i19 = (℩x)(quote(x) ∧ E(x))
i11 = (℩x)(emph(x) ∧ E(x))

The non-elemental molecules i18, i20 and i21 can be identified for example as follows:

i18 = (℩x)(∃y)(quote(y) ∧ N(x,y))
i20 = (℩x)(∃y)(emph(y) ∧ N(x,y))
i21 = (℩x)(M(x) ∧ ¬(∃y)N(x,y))

Although in this particular case the denoting expressions identifying individuals are fairly simple, identifying individuals by means of denoting expressions may in general become rather tedious. For example, in any document with more than one individual assigned the property quote, the denoting expression identifying individual i19 above would return the sum of all those individuals.

So although we have shown that all atoms, molecular and elemental strings of (1) can be identified by our relatively straightforward application of the Calculus, some of the above examples draw on the simplicity of the example and are rather ad hoc. Therefore, before we proceed to discuss how the Calculus can be used to make statements and make inferences about a document, we introduce a slightly more complicated (and also more realistic) example.

Consider the following XML document:

<?xml version="1.0" encoding="UTF-8"?>
<doc> 
    A rule:
    <list>
        <item>First:</item>
        <item>
            <list>
                <item>think,</item>
                <item>decide.</item>
            </list>
        </item>
        <item>Then:</item>
        <item>
            <list>
                <item>act,</item>
                <item>regret.</item>
            </list>
        </item>
    </list>
</doc>

Once again we provide identifiers for individuals of the document and present their properties and relations in tabular form, but this time we include only the molecular and elemental individuals: ^[17]

Table IV

Id	Label	Kind	Assigned property	Next molecule	Immediate parts
i01	A rule:	M		i02
i02	First:	M E	item	i03
i03	think,	M E	item	i04
i04	decide.	M E	item	i05
i05	Then:	M E	item	i06
i06	act,	M E	item	i07
i07	regret.	M E	item
i08		E	list, item		i03, i04
i09		E	list, item		i06, i07
i10		E	list		i02, i08, i05, i09
i11		E	doc		i01, i10

Note that the individuals i08 and i09 are each represented as one individual with two assigned properties, rather than as two individuals each with one property. The difference between this representation and the conventional XML representation can be illustrated by juxtaposing a conventional XML tree of the document (to the left) and what we might call a mereological graph (to the right):^[18]

Because of our decision not to count tags as part of the document, all coextensive XML elements will be represented as one elemental individual. The nesting order of these elements in the XML document will not be preserved in this representation. ^[19]

As before, we can use denoting expressions to refer to any part of the document, for example:

i01 = (℩x)¬(∃y)N(y,x)
i02 = (℩x)(item(x) ∧ ¬(∃y)(item(y) ∧ P(y,x)))
i03 = (℩x)(∃y)(∃z)(w)(v)
      ((x ≪ y) ∧ list(y) ∧ 
      (y ≪ z) ∧ list(z) ∧
      (N(w,x) → ¬(w ≪ y)) ∧ 
      (N(v,w) → ¬(v ≪ z))) 
i09 = (℩x)(∃y)(∃z)
      (list(x) ∧ (x ≪ y) ∧ list(y) ∧
       list(z) ∧ (z ≪ y) ∧ ¬(x = z) ∧ P(x,z))

Statements and inferences

We can also use the Calculus to make statements about the document — unquantified, such as (1)–(4), or quantified, such as (5)–(8):

(1) list(i09)
(2) item(i09)
(3) i07 ≪ i09
(4) i09 ≪ i10
(5) (x)(y)((list(x) ∧ item(x) ∧ (y ≪ x)) → item(y))
(6) (x)(y)((list(x) ∧ item(x) ∧ (x ≪ y)) → (list(y) ∨ doc(y)))
(7) (x)(item(x) → (∃y)((x ≪ y)  ∧ list(y)))
(8) (x)(item(x) → (∃y)(∃z)
   (item(y) ∧ list(z)  ∧ (x ≪ z) ∧ (y ≪ z)  ∧ ¬(x = y)))

In order to avoid unnecessary misunderstanding, it should be pointed out that (1)–(8) are descriptive statements about this particular document. (In other context, such as for example situations where we wanted to express general constraints on document structure, we might of course also want to state facts about document types, but that is not our issue here.)

From the statements we can make inferences, such as for example:

(9) item(i07)
     [From (1), (2), (3) and (5).]
(10) list(i10) ∨ doc(i10)
     [From (1), (2), (4) and (6).]
(11) (∃y)((i09 ≪ y) ∧ list(y))
     [From (2) and (7).]
(12) (∃y)(∃z)(item(y) ∧ list(z) ∧ (i07 ≪ z) ∧ (y ≪ z) ∧ ¬(i07 = y))
     [From (8) and (9).]

Conclusion

We have shown that strings composed of characters defined as atomic individuals can be identified and referenced by denoting expressions, that the Calculus can be used to describe the part-whole relationships and ordering relations between parts of the document as well as the properties ascribed by generic identifiers. We have also shown that this application of the Calculus can be used for making statements about documents and for drawing inferences from these statements.

The approach chosen here has at least two obvious problems, or shortcomings; one concerns the representation of coextensive elements, one relates to the representation of empty elements. Before we discuss these problems, however, we would like to assess one of its possible merits. In the next section, we will therefore sketch how this application of the Calculus can be used for the formulation of rules for propagation of properties among the parts of a document.

Property Propagation — a Sketch

We have assumed that the generic identifier of an element may be seen as assigning a property to the PCDATA content of that element, and not to any proper part of that PCDATA content. But sometimes, the meaning of the markup is such that that property is not assigned (or not only assigned) to the contents of the element itself, but also to all or some of its descendants, or to all or some of its ancestors, or to one or more of its siblings, or to only specific other elements. Furthermore, what is assigned to the element or elements in question may be not a monadic property, but a relation of them to other elements in the same document, or even to document elements or other entities outside that document. Thus, the propagation of properties ascribed by the generic identifier of an element may follow a large diversity of patterns.

Using examples from the TEI and HTML encoding schemes, we will show that some of these patterns can conveniently be described by means of our application of the Calculus. We will first address some of the general distribution patterns identified by Nelson Goodman, which seem to represent important aspects of the intended semantics of certain TEI or HTML element types. We will then proceed to more complicated examples.

F is dissective iff (x)(y)((F(x) ∧ (y < x)) → F(y))

<s>We
   <add>, as all 
      <del>purely <hi>human</hi> and</del> 
   finite beings,
   </add> 
are all fallible.</s>

(x)(y)((add(x) ∧ (y < x)) → add(y))
(x)(y)((del(x) ∧ (y < x)) → del(y))    
(x)(y)((hi(x) ∧ (y < x)) → hi(y))

(x)(y)(z)((F(x) ∧ (y < x) ∧ 
   ¬((z < x) ∧ (y < z) ∧ (G(z) ∨ H(z) ∨ ...))) 
   → F(y))

F is anti-dissective iff (x)(y)((F(x) ∧ (y ≪ x)) → ¬F(y))

(x)(y)((p(x) ∧ (y ≪ x)) → ¬p(y))

F is expansive iff (x)(y)((F(x) ∧ (x < y)) → F(y))

F is anti-expansive iff (x)(y)((F(x) ∧ (x ≪ y)) → ¬F(y))

F is collective iff (x)(y)((F(x) ∧ F(y)) → F(x + y))

F is anti-colletive iff (x)(y)((F(x) ∧ F(y) ∧ (x ʅ y)) → ¬F(x + y))

<!DOCTYPE html SYSTEM "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>Simple HTML</title>
    </head>
    <body>
        <p>First para</p>
        <p>Second para</p>
    </body>
    </html>

(x)(y)((title(x) ∧ (x < y) ∧ html(y)) → hasTitle(y,x))

<sp>
    <speaker>Peer</speaker> 
    Why 
    <stage>(hesitating)</stage> 
    swear?
</sp>

(x)(y)((speaker(x) ∧ (x < y) ∧ sp(y)) → 
          (z)(((z < y) ∧ ¬(speaker(z) ∨ stage(z))) → saidBy(z,x)))

(x)(y)((docTitle(x) ∧ (x < y) ∧ text(y)) → hasTitle(y,x))

(x)(y)(z)(w)((docDate(x) ∧ (x < y) ∧ text(y)) →
   (((z < y) ∧ ¬((z < w) ∧ (add(w) ∨ note(w)))) →
   (hasDate(y,x) ∧ hasDate(z,x))))

Problems

We have mentioned that there are at least two serious problems with our application of the Calculus. One problem, which has already been identified, relates to the representation of coextensive elements. The other problem, which relates to the representation of empty elements, has only been mentioned in passing. We believe this is the least serious of the two, and we will therefore discuss that first.

Conclusion and Future Work

We have considered some possible applications of the Calculus of Individuals to XML, whereof the so-called character-atom approach has seemed the most promising so far. Strings composed of characters defined as atomic individuals can be identified and referenced by denoting expressions. The part-whole relationships and ordering relations between parts of the document as well as the properties ascribed by generic identifiers can be described. Statements about the individuals of documents and their properties can be made, and inferences can be drawn from these statements.

We have shown, by means of examples from the TEI and HTML encoding schemes, how this application of the Calculus can be used for the formulation of rules describing the propagation of properties among the parts of a document.

We have identified problems or shortcomings concerning the representation of empty elements and coextensive elements, and suggested that these problems may be overcome partly by allowing a more generous set of atoms, and partly by replacing the Calculus of Individuals with some other formal mereological system.

In order to assess whether the application of formal mereology to markup semantics is worth while, we believe that continued work is required along several lines: The application to XML should be extended beyond the limitations of the approach presented here to include XML the full range of XML mechanisms, such as attributes, entities, declarations, comments, processing instructions, and marked sections. While the approach presented here is limited to the consideration of XML documents in serialized form, i.e. as character streams, attempts should be made at applying formal mereology to XML documents considered as graphs of xPath nodes, Infoset items, and the like.

Furthermore, and as already mentioned, mereological systems beyond the Calculus of Individuals should be considered in order to overcome some of the problems encountered in the approach presented her. Last, but not least: The application of formal mereological systems should be extended to other markup systems such as SGML, TexMecs, LMNL, Goddag and others.