Underspecified Relations with a Formal Language of Situation Theory
Roussanka Loukanova
Department of Mathematics, Stockholm University, Stockholm, Sweden
Keywords:
Formal Language, Situation Theory, Information, Parametric Information, Partiality, Situations, Restrictions,
Memory Variables.
Abstract:
The paper is an introduction to a formal language of Situation Theory. The language provides algorithmic pro-
cessing of situated information. We introduce specialized, restricted variables that are recursively constrained
to satisfy type-theoretic conditions by restrictions and algorithmic assignments. The restricted variables des-
ignate recursively connected networks of memory locations for ‘saving’ parametric information that depends
on situations and restrictions over objects. The formal definitions introduce richly informative typed language
for classification and representation of underspecified, parametric, and partial information that is dependent
on situations.
1 INTRODUCTION
Extensive work on Computational Semantics, e.g.,
by Barwise (Barwise, 1981), has shown that the ex-
isting approaches to computational semantics often
concentrate on specific tasks, by leaving other im-
portant problems in semantics outside their scope.
Situation Theory was originally introduced by Bar-
wise (Barwise, 1981) to fill up such gaps by address-
ing a broad range of semantic phenomena that under-
lie crucial criteria for an adequate theory of meaning
(Loukanova, 2010). As a result of these efforts, Bar-
wise and Perry (Barwise and Perry, 1983) adopted a
strategy of developing Situation Theory as a general
model theory of information and its the fundamen-
tals, in particular, by modelling relational and partial
information, and its dependence on situations. They
introduced Situation Semantics as one of the applica-
tions of Situation Theory, which provides models of
semantic information as a special case of more gen-
eral kinds of information. For an informal introduc-
tion to Situation Theory and Situation Semantics, see
(Devlin, 2008). These fundamental ideas of situated
information can be modeled by precise mathematics
of Situation Theory (Loukanova, 2014) that provides
mathematical structures of information as semantic
domains of the formal language introduced in this pa-
per. Such mathematical models of information have
broad potentials for applications, e.g., to semantics
of human languages (Loukanova, 2013c). The key
contributions of such approach to Situation Theory is
mathematical modelling of information that is situ-
ation dependent, partial, enhanced with intrinsic se-
mantic parameters, and structured by types that carry
information and information restrictions. This paper
complements such mathematical models of Situation
Theory with a formal language toward practical ap-
plications in advanced technologies.
A detailed review and analyses of existing work
on Situation Theory and its applications is in forth-
coming work (Loukanova, 2015). Here, we men-
tion some of the key works. E.g., Seligman and
Moss (Seligman and Moss, 2011) is a mathemati-
cal model theory of Situation Theory, in the spirit of
(Loukanova, 2014). On the side of specialized lan-
guages for Satiation Theory, there have been devel-
opments of languages for programming and medium
specifications of versions of Situation Theory, e.g.,
PROSIT, ASTL, and BABY-SIT (Tin and Akman,
1994; Tin et al., 1995; Tin and Akman, 1996). Lim-
ited versions of powerful theories, especially, when
targeting specialized domains have been useful ap-
proach to applications in many areas, including in
human language processing. Specialized languages
for Situation Theory have been extensively used in
Head-driven Phrase Structure Grammar (HPSG), for
semantic representations including semantic under-
specification. Current HPSG systems have been using
semantic representations with the specification lan-
guage Minimal Recursion Semantics (MRS), which
is situation-theoretical in its nature (Copestake et al.,
2005). Situation Semantics inspired other work in lin-
guistics, e.g., for semantics of questions (Ginzburg
and Sag, 2000), (Loukanova, 2013b), and for seman-
298
Loukanova R..
Underspecified Relations with a Formal Language of Situation Theory.
DOI: 10.5220/0005353402980309
In Proceedings of the International Conference on Agents and Artificial Intelligence (PUaNLP-2015), pages 298-309
ISBN: 978-989-758-073-4
Copyright
c
2015 SCITEPRESS (Science and Technology Publications, Lda.)
tics of tense and aspect from cognitive perspective
(Van Lambalgen and Hamm, 2004).
This paper is inspired by Moschovakis recur-
sion (Moschovakis, 2006) and our work on its ap-
plications to computational semantics and compu-
tational syntax-semantics interface for human lan-
guage (Loukanova, 2011), and its theoretical devel-
opment (Loukanova, 2013a). Moschovakis recursion
(Moschovakis, 2006) is a mathematical theory of a
functional, formal language of recursion, which while
having a two-sorted type system, is highly elegant
from computational perspective. On the other side,
our work in this paper is based on relational mod-
els of information, i.e., Situation Theory, which is
a higher-order model-theory of partial, typed infor-
mation. The type systems of Situation Theory and
its formal language, which is introduced in this pa-
per, are rich and finely-grained with informational
content. Situation-theoretic types can have compo-
nents consisting of partial situations, restricted pa-
rameters, and other kinds of typed objects. Higher-
order mathematical models of such Situation Theory
have been introduced in more precise details recently
(Loukanova, 2014). Situation Theory in such lines
has already proved useful for applications to compu-
tational semantics of human language (Loukanova,
2001; Loukanova, 2002a; Loukanova, 2002b) and
more recently in (Loukanova, 2013c).
Situation Theory is model-theory of information,
i.e., mathematical structures of mathematical objects.
It deserves emphasizing that restricted parameters in
such a typed Situation Theory, are not variables —
they are specific objects in informational domains,
that are organized according to the types of objects
in them. situation-theoretical objects are mathemati-
cal, set-theoretic objects, some of which can be proper
classes, or non-well-founded sets (Aczel, 1988; Rath-
jen, 2004). In application systems, typically these
objects are sets. The important is that these sets, or
classes, are not exhaustively given in their fullness.
Rather, they are represented by finite number of fi-
nite rules for potential generation. Non-well founded
phenomena that is inspired by Situation Theory has
been studied by (Barwise and Etchemendy, 1995) and
(Barwise and Moss, 1996). In this paper, we present
a formal language for designating such situation-
theoretical objects and the corresponding rules. In
model-theoretic Situation Theory,restricted situation-
theoretical parameters model either “undeveloped”
or “partially known” objects. Such parametric ob-
jects are build up recursively from other situation-
theoretical objects, including parameters. They are
restricted parameters by satisfying various restrictions
over their “unknown” (“undeveloped”) components.
By the language L
ST
ap
introduced in this paper, we
provide formal expressions, i.e., L
ST
ap
-terms, includ-
ing restricted variables, for denoting parametric ob-
jects. The L
ST
ap
-terms provide algorithmic patterns for
computing the situational objects they denote, which
can represent complex and partial information about
objects that may include parametric restrictions. Re-
stricted parameters can be specified when more infor-
mation is added depending on context.
We would like to stress that while Situation The-
ory and its applications emerged in 80’s, mathemat-
ics of situation-theoretical models of finely-grained
information and their corresponding formal and com-
putational syntax are largely open topics, with newly
emerging theoretical developments and applications.
Both sides of development, on the one hand, Situation
Theory, as a higher-ordermodel theory of typed infor-
mation, and on the other hand, a formal language with
dependent types for it, are new directions of work. In
particular, we are targeting a development of a formal
language with dependent types for Situation Theory,
as a system of Martin-L¨of Dependent-Type Theory
(MLDT), see (Martin-L¨of, 1984; Univalent Founda-
tions Program, 2013). Among the distinctive applica-
tions are computational semantics and neuroscience
of language. The paper is based on work on several
new directions, in particular: (1) type-theory of re-
cursion (a functional approach), (2) relational type-
theory of situated, partial, and parametric information
(a relational approach), (3) applications of these the-
ories to computational syntax-semantics interfaces in
natural and formal languages.
The paper is an introduction to a formal lan-
guage L
ST
ap
, which has terms that designate objects
of Situation Theory. (The subscript in L
ST
ap
indicates
that the language uses recursive assignments of spe-
cialized variables, representing semantic parameters,
with acyclicity.) In particular, we take Situation The-
ory that is specialized with recursively restricted pa-
rameters, as full-standing objects in domains of infor-
mation. The intended semantic domains of L
ST
ap
are
domains of mathematical, situation-theoretical struc-
tures of typed objects and information. Objects and
information can be partial and parametric. Recur-
sively restricted variables of the formal language L
ST
ap
designate semantic, complex parameters of Situation
Theory. We define recursion L
ST
ap
-terms that deter-
mine both restrictions over and assignments to the
variables. Recursion L
ST
ap
-terms, i.e., terms with re-
stricted variables and recursive assignments, desig-
nate networks of allocated slots, which are denoted
by the restricted variables, in which abstract, paramet-
ric information is saved during computational steps
represented by the systems of assignments. The re-
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
299
strictions over the variables represent what type of in-
formation can be saved in the corresponding memory
slots.
In Section 2, we give the formal definitions of
the vocabulary and the L
ST
ap
-terms. In Section 3,
we demonstrate applications of the formal language
L
ST
ap
by expressions with restricted recursion variables.
Specialized recursion terms of L
ST
ap
can be used to rep-
resent computational patterns. Technically, L
ST
ap
-terms
designate parametric objects and algorithms for com-
puting and storing parametric information with re-
strictions. In this settings, algorithms consist of com-
putational steps that handle situated and parametric
information. Assignments of sub-terms to some of the
restricted L
ST
ap
-variables provide computational steps
for information processing, by saving the outcomes
in the memory slots designated by these variables.
Assignments of sub-terms to some other restricted
variables provide specific instantiations of parametric
components. In general, the terms of the language L
ST
ap
designate algorithms for handling relational informa-
tion. In addition to L
ST
ap
-terms denoting primitive and
complex relations, some L
ST
ap
-terms denote functions
for designating operations over situated and paramet-
ric objects.
The terms of the formal language L
ST
ap
are demon-
strated with examples. We give intuitions about the
denotational and algorithmic semantics of L
ST
ap
. The
denotational semantics provides the objects denoted
by L
ST
ap
-terms, while the algorithmic semantics of L
ST
ap
-
terms provides the computational patterns (or steps)
for processing and saving information in memory net-
works.
2 BASIC SYNTAX OF L
ST
ap
2.1 Types of L
ST
ap
The class Types of L
ST
ap
is defined recursively, by start-
ing with a (relatively small) set of basic types. Note
that some of the expressions of the formal language
L
ST
ap
, defined later, will be complex types. Types can
be a set or a proper class, e.g., a non-well-founded
set, depending of further expanding of the definitions
of the L
ST
ap
-terms for relevant applications.
Basic (Primitive) Types. The set BTypes can be
chosen depending on a specific choice of L
ST
ap
for prac-
tical applications. E.g., as a standard for Situation
Theory (Loukanova, 2013c; Loukanova, 2014), we
take a set BTypes of basic (primitive) types:
BTypes = {IND, LOC, REL, FUN, POL, ARGR,
INFON, SIT, PROP, PARAM, TYPE, |=}
(1)
where IND is the type for individuals; LOC, for space-
time locations; REL, for relations, primitive and com-
plex; FUN, for functions, primitive and complex;
TYPE, for primitive and complex types; PARAM, for
basic and complex parameters; POL, for two polarity
objects, e.g., presented by the natural numbers 0 and
1; ARGR, for abstract argument roles, basic and com-
plex; INFON, for situation-theoretical objects that are
basic or complex informationunits; PROP, for abstract
objects that are propositions; SIT, for situations; |= is
a designated type called “supports” (explained later).
Complex Types. More complex L
ST
ap
-types will be
formally defined in the following sections since they
will be constructed recursively from other kinds of
L
ST
ap
-expressions. I.e., we will define the expressions
of L
ST
ap
and among them complex types. For any given
expression A and a type T, we use the notation A :T iff
A is assigned to the type T, in which case we say “A is
of type T”. As in MLDT (Univalent Foundations Pro-
gram, 2013), the construction of new, complex L
ST
ap
-
types can be left open-ended, for adding new types
depending on needs, by following the L
ST
ap
-rules for
complex types, which we will give in the following
sections, instead of accumulating all possible types in
a class Types. E.g., by following the L
ST
ap
-rules, we
can construct the types at stages:
Types
0
, Types
1
, . .. , Types
n
, . . . (2)
so that Types
i
⊆ Types
i+1
, for all i ≥ 0. The process
can be left “open”, for adding new expressions to the
existing levels and new levels. “Closing” the process,
by accumulating all Types
i
, at once, into a collection
Types can lead to a large collection Types, which may
be a proper class that is not a set. In what follows, we
shall use the notation Types to be either a collection,
which can be a proper class, or the set of types Types
i
for some stage i. E.g., we will often write τ ∈ Types
by considering that Types is the collection of types
available at some stage of constructed expressions:
τ ∈ Types ⇐⇒ τ ∈ Types
i
, for some i ≥ 0 (3a)
τ : TYPE ⇐⇒ τ ∈ Types
i
, for some i ≥ 0 (3b)
We will use the usual set-theoretical notations for
union of collections, which can be union of proper
classes rather than of sets. Technical details of such
distinctions and stages involve considerable work by
using methods of set theory and are beyond the sub-
ject of this paper.
ICAART2015-InternationalConferenceonAgentsandArtificialIntelligence
300
2.2 Vocabulary
The vocabulary of L
ST
ap
consists of pairwise disjoint
classes (sets) of objects.
Constants. For each τ ∈ Types, L
ST
ap
has a finite
(or denumerable, depending on applications) set of
constants: K
τ
= { c
τ
0
, c
τ
1
, . . . , c
τ
k
τ
}. Depending on spe-
cific applications, the sets of constants can be finite.
We allow some of the sets K
τ
to be empty. In par-
ticular, we take non-empty sets of constants: K
IND
–
for primitive individuals, K
LOC
– for space-time loca-
tions, K
REL
– for primitive relations, K
FUN
– for prim-
itive functions, K
POL
= {0, 1} – for polarity values.
K =
[
τ∈Types
K
τ
(4)
When the type of the constants is understood, we use
K instead of K
τ
.
Pure Variables. L
ST
ap
has a set (or a class) of typed
pure variables,
PureVars =
[
τ∈Types
PureVars
τ
, (5)
where, for each τ ∈ Types, PureVars
τ
= {v
τ
0
, v
τ
1
, . . . }.
Restricted Memory Variables. The formal lan-
guage L
ST
ap
has a set, which can be a proper class, of
typed, restricted recursion variables, which we also
call restricted variables or (restricted) memory vari-
ables,
RestrRecVars =
[
τ∈Types
RestrRecVars
τ
, (6)
where, RestrRecVars
τ
= { p
τ
0
, p
τ
1
, . . . }, for each τ ∈
Types, i.e., τ : TYPE. In particular, for each of the
basic types, we take a set of basic restricted memory
variables, which can be used for saving information
and other objects of the associated type:
P
IND
= {a, b, c, . . . }, P
LOC
= {l, l
0
, l
1
, . . . }, (7a)
P
REL
= {r
0
, r
1
, . . . }, P
FUN
= {f
0
, f
1
, . . . }, (7b)
P
POL
= {p
0
, p
1
, . . . }, P
INFON
= {i
0
, i
1
, . . . } (7c)
P
SIT
= {s
0
, s
1
, . . . }. (7d)
The sets of the variables of L
ST
ap
are typed, respec-
tively, for each τ ∈ Types:
Vars
τ
= PureVars
τ
∪RestrRecVars
τ
, (8a)
Vars = PureVars∪RestrRecVars (8b)
We use notations without types: Vars, PureVars,
RestrRecVars, when the type of the variables is un-
derstood. See the discussion on page 3 about (3a)–
(3b). Furthermore, we use the following notations,
for every τ : TYPE and v ∈ Vars:
v
τ
∈ Vars ⇐⇒ v ∈ Vars
τ
⇐⇒ v : τ (9)
For semantic reasons, we distinguish between re-
stricted variables, which are syntactic objects, and
semantic parameters as semantic objects. Restricted
variables are variables in the formal language L
ST
ap
. In
addition, they are restricted with types, which can be
simple or complex, to insure that the variables can
be instantiated only with objects satisfying the re-
strictions. We should have such distinctions in mind,
while their technical details are not in the subject of
this paper. Sometimes, when the context makes it
clear, the restricted variables are called parameters.
Now, we provide an example to demonstrate the ideas
behind restricted variables and the distinctions be-
tween variables and semantic parameters. The formal
definitions of the syntax of such terms is given in the
subsequent sections.
Example 2.1. In the following term, (10) the λ-
abstractions bind pure variables. The situated term
(10) is the type of situations x
SIT
s
and locations x
LOC
l
,
where an individual denoted by a restricted variable
a
IND
walks. The restrictions over these variables con-
strain them to be in the respectively typed classes of
variables. E.g., the restriction over a requires that
a ∈ RestrRecVars
IND
.
λx
SIT
s
, x
LOC
l
(x
SIT
s
|=≪ walk,walker : a
IND
, (10)
Loc : x
LOC
l
;Pol : 1 ≫)
The restricted memory variable a
IND
, which occurs
freely in the term (10), can denote only an individ-
ual in a given semantics domain, not a location or a
situation. The individual denoted by a
IND
can be spe-
cific and known to the interpreter. In addition, Situ-
ation Theory (Loukanova, 2013c; Loukanova, 2014)
provides genuine semantic parameters that represent
unknown or underdeveloped objects. E.g., an inter-
preter of the term (10) can assign a semantic param-
eter to the variable a
IND
, without knowing what that
individual is.
Typically, unless otherwise specified either explicitly
or by the syntax of the expressions, we shall use let-
ters x, y, z, with or without subscripts, to vary over
pure variables of any types, and letters p, q, r, with or
without subscripts, to vary over memory variables of
any type.
2.3 Argument Roles
In symbolic approaches, the arguments to function
and predicate expressions (or their respective deno-
tations) typically are taken as linearly ordered. E.g.,
A can be a function (or predicate) expression used
to denote a function (respectively, a predicate) with
n arguments. An instantiation of these arguments
by some objects denoted by a
1
, ..., a
n
can be ex-
pressed by A(a
1
, . . . , a
n
). In fact, strictly speaking,
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
301
this means that A has n argument “slots” that are filled
up by a
1
, ..., a
n
. The linear order makes it clear
which slots are filled up by what expressions (or el-
ements). The word “argument” is often overloaded
to mean either the argument slots, e.g., the ones re-
sulted in by λ-abstractions in a term like λx, y, z A, or
the objects to which the term applies, e.g., a, b, c in
(λx, y, z A)(a, b, c). The context makes clear which of
these interpretations is the case. In Situation Theory
(Loukanova, 2013c; Loukanova, 2014), this context
dependent distinction (in fact, ambiguity) is made ex-
plicit by the notion of an argument role, which corre-
sponds to “an argument slot”. The argument roles rep-
resent saturation requirements over functions, predi-
cated, and types. Along this, the introduction of ar-
gument roles makes it possible to express complex
appropriateness conditions over what objects can fill
up these argument roles. Furthermore, using sets of
explicit argument roles associated with functions and
predicates makes it possible to take away the linear
order over them. This corresponds to the relations be-
tween objects in nature, which take place in three di-
mensional space. Usually, the natural relations are not
associated with order and do not impose order over
the objects related, which can be located in various
arrangements and distances in space and time. Mathe-
matics and Computer Science have techniques for un-
ambiguous encoding and distinguishing the argument
roles and their respective fillers, by liner orders over
them. These techniques meet the needs of express-
ing relations, functions, and operations, by the means
of available writing systems (traditionally on paper)
and computer programming. By the new advances of
technologies, we have ways of modeling and depict-
ing information in its natural ways — relations be-
tween objects taking place in space and time, not al-
ways associated with linear orders. Situation Theory
reflects on this natural aspect of the structure of rela-
tions and operations (processes) that occur in nature
and in information transferred in nature. Thus, it dis-
tinguishes between arguments roles of relations and
operations and the objects filling up these roles. The
formal language for Situation Theory,which we intro-
duce here, reflects on this correspondingly. This does
not preclude using traditional liner orders to express
argument roles, and “suppress” their explicit appear-
ance.
Definition 1 (Argument Roles). 1. We assume a set
of basic argument roles, which can be associated
with the expressions for relations, functions, and
types:
BA
ARGR
= {ρ
1
, . . . , ρ
m
, . . . }, for m ≥ 0 (11)
2. A finite set of argument roles is assigned to each
of the primitive relations and each of the primitive
types, by a function Args, such that Dom(Args) =
A
REL
∪B
TYPE
and Range(Args) ⊆ P
finite
(BA
ARGR
),
where P
finite
(BA
ARGR
) is the set of finite subsets
of BA
ARGR
.
3. A
ARGR
, is a set (or class) of basic and complex
argument roles,
BA
ARGR
∪ { [ξ] | ξ ∈P
IND
∪ P
LOC
∪ P
SIT
∪
P
REL
∪ P
FUN
∪ P
POL
} (12)
⊆ A
ARGR
Note that the elements of the class A
ARGR
are
specialized expressions, i.e., specialized L
ST
ap
-terms,
which can vary depending on specific applications of
L
ST
ap
.
Example 2.2. Let smile, read, and give be relation
constants. We can associate sets of argument roles
with these constants, in a simple way, without any
constraints over the arguments, as follows:
SArgs(smile) ≡ {arg
1
} (13a)
SArgs(read) ≡ {arg
1
, arg
2
} (13b)
SArgs(give) ≡ {arg
1
, arg
2
, arg
3
} (13c)
SArgs(γ) ≡ {arg
1
, . . . , arg
n
}, (13d)
for any relation γ with n arguments (n ∈ N).
Appropriateness Constraints. Typically, the basic
relations, functions, and types are associated with ar-
gument roles that have to satisfy constraints for their
appropriate filling. We represent such constraints
with types.
Definition 2 (Basic Argument Roles with Appropri-
ateness Constraints). A set of argument roles is as-
signed to each of the primitive relations, and to each
of the primitive types, by a function Args such that
Dom(Args) = (A
REL
∪ A
FUN
∪ B
TYPE
) (14a)
Range(Args) ⊆ P (A
ARG
× P (T
TYPE
)) (14b)
I.e., for every primitive relation, function, and type γ,
γ ∈ A
REL
∪ A
FUN
∪ B
TYPE
, Args(γ) is a set of ordered
pairs:
Args(γ) = {harg
1
, T
1
i, . . . , harg
n
, T
n
i} (15)
where n ≥ 0, arg
1
, . . . , arg
n
∈ A
ARG
and T
1
, . . . , T
n
are
sets of types (basic or complex).
Definition 3 (Argument roles with appropriateness
constraints).
1. Every relation constant, relation variable, and ba-
sic type γ, γ∈ A
REL
∪Vars
REL
∪B
TYPE
, is associated
with a set Args(γ), called the set of argument roles
of γ, so that:
Args(γ) ≡ {T
1
: arg
1
, . . . , T
n
: arg
n
} (16)
ICAART2015-InternationalConferenceonAgentsandArtificialIntelligence
302
where n ≥ 0, arg
1
, . . . , arg
n
∈ A
ARG
, and T
1
, . . . , T
n
are sets of types (basic or complex).
The expressions arg
1
, . . . , arg
n
are called the argu-
ment roles (or the argument slots) of γ. The sets
of types T
1
, . . . , T
n
are specific for the argument
roles of γ and are called the basic appropriateness
constraints of the argument roles of γ.
2. Every function constant and every function vari-
able γ, γ ∈ A
FUN
∪Vars
FUN
, is associated with two
sets, Args(γ), called the set of argument roles of
γ, and Value(γ), called the (singleton set of the)
value role of γ, so that:
Args(γ) ≡ {T
1
: arg
1
, . . . , T
n
: arg
n
} (17a)
Value(γ) ≡ {T
n+1
: arg
n+1
} (17b)
where n ≥ 0, arg
1
, . . . , arg
n+1
∈ A
ARG
, and T
1
, ...,
T
n+1
are sets of types (basic or complex).
The expressions arg
1
, . . . , arg
n
are called the ar-
gument roles (or the argument slots) of γ. The ex-
pression arg
n+1
is called the value role of γ. The
sets of types T
1
, . . . , T
n+1
are specific for the argu-
ment roles of γ and are called, respectively, the ba-
sic appropriateness constraints of the arguments
and of the value of γ.
2.4 Terms of L
ST
ap
Terms(K) =
[
τ∈Types
Terms
τ
(18)
where the sets Terms
τ
are defined recursively as fol-
lows.
The typed classes of L
ST
ap
-terms, Terms
τ
, for τ ∈
Types, are defined recursively as follows.
Constants. If c ∈ K
τ
, then c ∈ Terms
τ
, (i.e., every
constant of type τ is also a term of type τ) denoted
c : τ. There are no free and no bound occurrences of
variables in the term c:
FreeVars(c) = ∅ and BoundVars(c) = ∅ (19)
Variables. If x ∈ Vars
τ
, then x : τ, i.e., every variable
of type τ is also a term of type τ. The only occurrence
of the variable x in the term x is free; there are no
bound occurrences of variables in x, i.e.:
FreeVars(x) = { x} and BoundVars(x) = ∅ (20)
Infon Terms. For every relation term (basic or com-
plex) ρ ∈ Terms
REL
, associated with argument roles
Args(ρ) = { T
1
: arg
1
, . . . , T
n
: arg
n
}, and every se-
quence of terms ξ
1
, ..., ξ
n
such that ξ
1
∈ Terms
T
1
,
... , ξ
n
∈ Terms
T
n
, (i.e., terms ξ
1
, ..., ξ
n
that sat-
isfy the corresponding appropriateness constraints of
the argument roles of ρ), ξ
1
: T
1
, ..., ξ
n
: T
n
, every
space-time location term τ ∈ Terms
LOC
, (i.e., τ : LOC),
and every polarity term t ∈ Terms
POL
, (t : POL, i.e.,
t ∈ {0, 1} ∪ P
POL
), the expression in (21) is an infon
term:
≪ ρ, T
1
: arg
1
: ξ
1
, . . . ,
T
n
: arg
n
: ξ
n
,
LOC : Loc : τ,
POL : Pol : t ≫ ∈ Terms
INFON
(21)
The expression in (22) is the full infon term, which
includes its type association. It is used when the type
labeling is relevant.
≪ ρ, T
1
: arg
1
: ξ
1
, . . . ,
T
n
: arg
n
: ξ
n
,
LOC : Loc : τ, POL : Pol : t ≫ : INFON
(22)
All free (bound) occurrences of variables in ρ, ξ
1
, ...,
ξ
n
, τ are also free (bound) in the infon term.
Notation 1. Often, in this paper, we shall use the no-
tation (23a) when the type constraints over the argu-
ment roles are irrelevant, or (23b), when in addition,
there is an understood order of the arguments.
≪ ρ, arg
1
: ξ
1
, . . . , arg
n
: ξ
n
, Loc : τ;t ≫ (23a)
≪ ρ, ξ
1
, . . . , ξ
n
, τ;t ≫ (23b)
Proposition Terms. The expression in (24) is a ba-
sic proposition term
(γ, T
1
: arg
1
: ξ
1
, . . . , T
n
: arg
n
: ξ
n
,
LOC : Loc : τ, POL : Pol : t) : PROP
(24)
for every type term γ ∈ Terms
TYPE
, associated with
argument roles Args(γ) ≡ {T
1
: arg
1
, . . . , T
n
: arg
n
},
every sequence of terms ξ
1
, ..., ξ
n
such that ξ
1
∈
Terms
T
1
, .. ., ξ
n
∈ Terms
T
n
(i.e., terms ξ
1
, .. ., ξ
n
that
satisfy the corresponding appropriateness constraints
of the argument roles of γ, ξ
1
: T
1
, ..., ξ
n
: T
n
), ev-
ery space-time location expression τ : LOC, and every
polarity expression t : POL.
Notation 2. The components for a space-time loca-
tion LOC : Loc : τ and for a polarity POL : Pol : t can
be omitted, as in the expression in (25a), when they
are irrelevant or understood. In such cases, the polar-
ity t is understood to be positive, i.e., t = 1. In addi-
tion, expressions like that in (25b), omitting their type
association to PROP, are used when the type labeling
PROP is not relevant.
(γ, T
1
: arg
1
: ξ
1
, . . . , T
n
: arg
n
: ξ
n
, ) : PROP (25a)
(γ, T
1
: arg
1
: ξ
1
, . . . , T
n
: arg
n
: ξ
n
) (25b)
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
303
All the free (bound) occurrences of variables in
γ, ξ
1
, ..., ξ
n
are also free (bound) in the proposition
term.
Notation 3. Often, in this paper, we shall use the no-
tational abbreviation (26a) when the type constraints
over the argument roles are irrelevant, or (26b) when
there is an understood order and type constraints of
the arguments.
(γ, arg
1
: ξ
1
, . . . , arg
n
: ξ
n
) (26a)
(γ, ξ
1
, . . . , ξ
n
) (26b)
Complex proposition terms are formed from sim-
pler ones by the logic operations ∧, ∨, →, and quan-
tification.
Application Terms. For every function term, ba-
sic or complex, γ ∈ Terms
FUN
, which comes associ-
ated with argument roles Args(γ) ≡ {T
1
: arg
1
, . . . , T
n
:
arg
n
} and with a value role Value(γ) ≡ { T
n+1
: val},
and for every sequence of terms ξ
1
∈ Terms
T
1
, ...,
ξ
n
, ξ
n+1
∈ Terms
T
n+1
, i.e., terms ξ
1
, ..., ξ
n
, ξ
n+1
that
satisfy the corresponding appropriateness constraints
of the argument and value roles of γ, ξ
1
: T
1
, ...,
ξ
n+1
: T
n+1
, the expression in (27) is an application
term:
γ{T
1
: arg
1
: ξ
1
, . . . ,
T
n
: arg
n
: ξ
n
} ∈ Terms
T
n+1
(27)
Informally said, the term (27) represents application
of the function term γ to the argument terms ξ
1
, .. .,
ξ
n
that fill up the corresponding argument roles arg
1
,
... , arg
n
of γ. In addition, the term (27) expresses that
arg
1
, . .., arg
n
satisfy the corresponding appropriate-
ness conditions T
1
, .. ., T
n
, otherwise (27) is not well-
formed. The full expression in (28), which includes
the type association, is used when the type labeling is
relevant.
γ{T
1
: arg
1
: ξ
1
, . . . , T
n
: arg
n
: ξ
n
} : T
n+1
(28)
The expression (29) represents the proposition that
the value of the function γ for the given argument
“fillers” ξ
1
, .. ., ξ
n
has to be ξ
n+1
.
γ{T
1
: arg
1
: ξ
1
, . . . ,
T
n
: arg
n
: ξ
n
} = ξ
n+1
∈ Terms
PROP
(29)
All free (bound) occurrences of variables in γ, ξ
1
, .. .,
ξ
n
, ξ
n+1
are also free (bound) in the application term
in (27), respectively, in (28) and (29).
λ-abstraction Terms. Case 1: Complex Relations
with Complex Arguments. For every infon term I ∈
Terms
INFON
(basic or complex) and all pure variables
ξ
1
, . . . , ξ
n
∈ PureVars (which may occur freely in I),
the expression λ{ξ
1
, . . . , ξ
n
}I is a complex-relation
term, i.e.:
λ{ξ
1
, . . . , ξ
n
}I ∈ Terms
REL
(30a)
λ{ξ
1
, . . . , ξ
n
}I : REL (30b)
The argument roles of λ{ ξ
1
, . . . , ξ
n
}I, which we de-
note by [ξ
1
], . . . , [ξ
n
], are associated with correspond-
ing appropriateness constraints as follows:
Args(λ{ξ
1
, . . . , ξ
n
}I)
≡ {T
1
: [ξ
1
], . . . , T
n
: [ξ
n
]}
(31)
where, for each i ∈ {1, . . . , n}, T
i
is the union of all
types that are the appropriateness constraints of all the
argument roles that occur in I, and such that ξ
i
fills up
them without being bound. (Note that ξ
i
may fill more
than one argument role in I.)
Case 2: Complex Types with Complex Argu-
ments. For every proposition term θ ∈ Terms
PROP
(basic or complex) and all pure variables ξ
1
, . . . , ξ
n
∈
PureVars (which may occur freely in θ, in the in-
teresting cases), the expression λ{ξ
1
, . . . , ξ
n
}θ is a
complex-type term, i.e.:
λ{ξ
1
, . . . , ξ
n
}θ ∈ Terms
TYPE
(32a)
λ{ξ
1
, . . . , ξ
n
}θ : TYPE (32b)
The argument roles of λ{ξ
1
, . . . , ξ
n
}θ, which we de-
note by [ξ
1
], ..., [ξ
n
], are associated with correspond-
ing appropriateness constraints to be of the types T
1
,
... , T
n
, respectively, i.e., {T
1
: [ξ
1
], . .., T
n
: [ξ
n
]}, as
follows:
Args(λ{ξ
1
, . . . , ξ
n
}θ)
≡ {T
1
: [ξ
1
], . . . , T
n
: [ξ
n
]}
(33)
where, for each i ∈ {1, . . . , n}, T
i
is the union of all
types that are the appropriateness constraints of all the
argument roles that occur in θ and such that ξ
i
fills
up them, without being bound. (Note that ξ
i
may fill
more than one argument role in θ.)
Case 3: Complex Functions (Operations) with
Complex Arguments. For every term ϕ ∈ Terms
τ
(basic or complex), where τ ∈ Types, τ 6≡ INFON,
and τ 6≡ PROP, and for all pure variables ξ
1
, . . . , ξ
n
∈
PureVars (which may occur freely in ϕ), the expres-
sion λ{ξ
1
, . . . , ξ
n
}ϕ is a complex-function term:
λ{ξ
1
, . . . , ξ
n
}ϕ ∈ Terms
FUN
(34a)
λ{ξ
1
, . . . , ξ
n
}ϕ : FUN (34b)
The function term λ{ ξ
1
, . . . , ξ
n
}ϕ has a value role,
ValueRole(ϕ) ≡ {τ : val }, and argument roles, de-
noted by [ξ
1
], . . . , [ξ
n
], which are associated with cor-
responding appropriateness constraints as follows:
Args(λ{ξ
1
, . . . , ξ
n
}ϕ)
= {T
1
: [ξ
1
], . . . , T
n
: [ξ
n
]}
(35)
ICAART2015-InternationalConferenceonAgentsandArtificialIntelligence
304
where, for each i ∈ {1, . . . , n}, T
i
is the union of all
types that are the appropriatenessconstraints of all the
argument roles that occur in ϕ, and such that ξ
i
fills
up them, without being bound. (Note that ξ
i
may fill
more than one argument role in ϕ.)
In the above Cases 1, 2, 3, the newly constructed
terms have a common form λ{ ξ
1
, . . . , ξ
n
}φ, for a sub-
term φ of the respective type, i.e., infon, type, or nei-
ther of these. All the free occurrences of ξ
1
, . . . , ξ
n
in φ are bound in the new term λ{ ξ
1
, . . . , ξ
n
}φ. All
other free (bound) occurrences of variables in φ are
free (bound) in the term λ{ ξ
1
, . . . , ξ
n
}φ.
FreeVars
λ{ξ
1
, . . . , ξ
n
}φ
= FreeVars(φ) − {ξ
1
, . . . , ξ
n
}
(36)
BoundVars
λ{ξ
1
, . . . , ξ
n
}φ
= BoundVars(φ)∪ {ξ
1
, . . . , ξ
n
}
(37)
Notation 4. The terms λ{ ξ
1
, . . . , ξ
n
}χ, from the
above Cases 1, 2, 3, are alternatively denoted by
[ξ
1
, . . . , ξ
n
| χ] (38a)
[T
1
: ξ
1
, . . . , T
n
: ξ
n
| χ]. (38b)
The notation (38b) is used when the type restrictions
over the new, complex argument roles [ξ
1
], ... , [ξ
n
]
are understood from the context, or are irrelevant.
Restricted Recursion Terms. For any given
• L
ST
ap
-terms for unary types C
k
∈ Terms
TYPE
(i.e.,
C
k
: TYPE), with Args(C
k
) ≡ {T
k
: arg
k
} (i.e.,
C
k
has a single argument role arg
k
that is re-
stricted to be filled up by expressions of type
T
k
) and all pairwise different, restricted variables
q
k
∈ RestrRecVars
T
k
, for k = 1, . . . , m (m ≥ 0),
such that
{(q
1
: C
1
), . . . , (q
m
: C
m
)}
is a sequence of type restrictions that satisfies the
acyclicity constraint given in Definition 4, and
• L
ST
ap
-terms A
i
∈ Terms
σ
i
(i.e., A
i
: σ
i
), for i =
0, . . . , n, and pairwise different, restricted vari-
ables p
i
∈ RestrRecVars
σ
i
, for i = 1, . . . , n (n ≥ 0),
such that
{p
1
:
= A
1
, . . . , p
n
:
= A
n
}
is a sequence of assignments that satisfies the
acyclicity constraint given in Definition 5, the fol-
lowing expression is a restricted recursion term of
type σ
0
:
A
0
where {(q
1
: C
1
), . . . , (q
m
: C
m
)}
{(p
1
:
= A
1
), . . . , (p
n
:
= A
n
)}
: σ
0
(39)
All free occurrences of p
1
, . . . , p
n
in A
0
, ..., A
n
are
bound in the term [A
0
where {p
1
:
= A
1
, . . . , p
n
:
=
A
n
}]. All other free (bound) occurrences of variables
in A
1
, . . . , A
n
are free (bound) in the term [A
0
where
{p
1
:
= A
1
, . . . , p
n
:
= A
n
}].
FreeVars
A
0
where {p
1
:
= A
1
, . . . , p
n
:
= A
n
}
=
[
p
n
i=0
(FreeVars(A
i
)) − { p
1
, . . . , p
n
} (40)
BoundVars
A
0
where {p
1
:
= A
1
, . . . , p
n
:
= A
n
}
=
[
p
n
i=0
(BoundVars(A
i
)) ∪ {p
1
, . . . , p
n
} (41)
Sometimes we enclose the recursion terms in extra
brackets to separate them from the surrounding text,
for example as in:
[A
0
where {p
1
:
= A
1
, . . . , p
n
:
= A
n
} : σ
0
]
In the cases when m = 0 or n = 0, the respective se-
quences of restrictions and assignments are empty and
can be denoted explicitly by {}.
Definition 4 (Acyclicity Constraint for Type Restric-
tions). For any unary types C
k
: TYPE and q
k
∈
RestrRecVars (where q
k
is of the type of the argument
role of C
k
), k = 0, . . . , m (m ≥ 0), the sequence of type
restrictions
{(q
1
: C
1
), . . . , (q
m
: C
m
)}
is acyclic if and only if there is a ranking func-
tion rank : {q
1
, . . . , q
m
} −→ N such that, for all
q
i
, q
j
∈ { q
1
, . . . , q
m
}, if q
j
occurs freely in C
i
, then
rank(q
j
) < rank(q
i
). Note that the acyclicity con-
straint is a proper part of the recursive definition of
the L
ST
ap
-terms.
Definition 5 (Acyclicity Constraint for Assignments).
A sequence of assignments
{p
1
:
= A
1
, . . . , p
n
:
= A
n
}
is acyclic if and only if there is a ranking function
rank : {p
1
, . . . , p
n
} −→ N such that, for all memory
variables p
i
, p
j
∈ { p
1
, . . . , p
n
}, if p
j
occurs freely in
A
i
, then rank(p
j
) < rank(p
i
). Note that the acyclicity
constraint is a proper part of the recursive definition
of the L
ST
ap
-terms.
2.5 Underspecified Terms for Situated
Propositions
Space-time Relations. We assume, that the collec-
tion K
REL
includes relation constants for time prece-
dence ≺, time overlapping ◦, space overlapping ⋄ ,
and time, space, and space-time inclusions between
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
305
locations, respectively denoted by ⊆
t
, ⊆
s
, ⊆. With
these relations, we can form specialized infons, e.g.:
≪ ◦, l
1
, l
2
;1 ≫, denoted by l
1
◦ l
2
(42a)
≪ ⋄, l
1
, l
2
;1 ≫, denoted by l
1
⋄ l
2
(42b)
≪≺, l
1
, l
2
;1 ≫, denoted by l
1
≺ l
2
(42c)
≪⊆
t
, l
1
, l
2
;1 ≫, denoted by l
1
⊆
t
l
2
(42d)
≪⊆
s
, l
1
, l
2
;1 ≫, denoted by l
1
⊆
s
l
2
(42e)
≪⊆, l
1
, l
2
;1 ≫ denoted by l
1
⊆ l
2
(42f)
These infons are usually given by their abbreviated
infix notations, e.g., l
1
◦ l
2
, l
1
≺ l
2
l
1
⊆
t
l
2
, l
1
⊆
s
l
2
,
l
1
⊆ l
2
.
2.6 Situated Proposition Terms
An expression like (43), in order to be well-formed
expression of the language L
ST
ap
, i.e., a proposition
L
ST
ap
-term, has to be composed of component sub-
expressions (T
1
, ..., T
n
, ξ
1
, .. ., ξ
n
, etc.) that are of
the corresponding types in the syntax of L
ST
ap
.
(γ, T
1
: arg
1
: ξ
1
, . . . , T
n
: arg
n
: ξ
n
,
LOC : Loc : τ, POL : Pol : t) : PROP
(43)
Intuitively, a proposition term (43) (correspondingly,
(24), (25a)–(25b), (26a)–(26b)) expresses the propo-
sition that the objects denoted by ξ
1
, ..., ξ
n
, are (or
are not) of the type denoted by γ, in case the polarity
t = 1 (t = 0). Both propositions, with t = 1 or t = 0,
exist, i.e., are defined either positively for t = 1, or
negatively for t = 0, iff ξ
1
, . . . , ξ
n
denote objects of
the respectivetypes denoted by T
1
, . .., T
n
. These type
constraints over the argument roles of γ are intrinsic
components of the propositions denoted by the ex-
pression (43). I.e., the “component” sub-expressions,
in the argument structure of (43), constrain the argu-
ment roles of den(γ), designated by arg
1
, .. ., arg
n
, to
be filled by objects den(ξ
1
), . . . , den(ξ
n
), for which
the corresponding propositions (den(ξ
1
) : den(T
1
)),
... , (den(ξ
n
) : den(T
n
)) hold, i.e., these propositions
have to be true. In case any one of these “component”
propositions does not hold, either by being false or
by being nonsense error, the proposition term (43) (in
each case t = 1 or t = 0) does not denote anything, or
denotes an error, assuming that the semantic structure
of L
ST
ap
includes such an element error.
We distinguish between the term expressions for
propositions and the propositions they denote. We say
“the term denoting the proposition that ξ
1
, . . . , ξ
n
de-
note objects of the type denoted by γ”, or simply, “the
term denoting the proposition that ξ
1
, . . . , ξ
n
are of the
type γ”, when there is no ambiguity between expres-
sions and what they denote.
An important class of propositions consists of the
following situated propositions, which use the desig-
nated “support” type |=. The type |= is associated
with two argument roles, one for objects of the type
SIT of situations, and the other for objects of the type
INF of inforns. I.e.:
Args(|=) ≡ { SIT : arg
sit
, INFON : arg
infon
} (44)
Definition 6 (Terms for Situated Propositions). Any
proposition term of the form (45)
(|=, SIT : arg
sit
: s, INFON : arg
infon
: σ) (45)
where s ∈ P
SIT
and σ ∈ Terms
INFON
, is called a term
for situated propositions. The expression (46) is an
abbreviation of the term (45).
(s |= σ) (46)
Usually, we pronounce terms of the forms (45) and
(46) as “the term denoting the proposition that σ holds
in the situation s” or “the term denoting the proposi-
tion that the situation s supports the infon σ”. We
distinguish between the term expressions for proposi-
tions and the propositions they denote. When the con-
text does not cause ambiguity with respect to this dif-
ference, we simply say “the proposition that σ holds
in the situation s” or “the proposition that the situation
s supports the infon σ”.
Example 2.3. Assume that book and read are con-
stants with the associated argument roles given in
the corresponding infon sub-terms of the proposition
term (47a)–(47b). The term (47a)–(47b) has a sin-
gle, but complex, conjunctive informational unit with
basic infons as parts. The entire term (47a)–(47b) de-
notes a proposition that in situation s an individual de-
noted by the pure variable x reads the object denoted
by the parameter variable b, in the location denoted
by the parameter variable l, and in the same situation
s the object b has the property of being a book in a
broader location denoted by l
1
: l ⊆
t
l
1
(l is time in-
cluded in l
1
), l ⊆
s
l
1
(l is space included in l
1
).
(s |=≪ book, arg : b, Loc : l
1
;1 ≫ (47a)
∧ ≪ read, reader : x,readed : b, Loc : l;1 ≫ (47b)
∧ l ⊆
t
l
1
∧ l ⊆
s
l
1
) (47c)
3 APPLICATIONS
This section demonstrates applications of the syntax
of the formal language L
ST
ap
for computational rep-
resentation of relations that include situated and un-
derspecified information. The underspecification can
be given via parameters that are partly specified with
minimal restrictions depending on specific cases of
use.
ICAART2015-InternationalConferenceonAgentsandArtificialIntelligence
306
3.1 Typed Restrictions
In general, underspecified information is represented
by typed variables. Usually, information represented
by both kinds of variables, pure and memory vari-
ables, is partly specified by their type. Their type re-
striction, which is represented by a type term R, over
a variable v, is included as a component (v : R) of the
term in which the variable occurs. Sometimes, the
type restriction, or a part of the restriction, is given as
a superscript over the variable: v
R
. A major way to
represent underspecified information is to use terms
with components that are memory variables (loca-
tions) restricted by complex type terms. In addition, a
term A can be assigned to a memory variable p
:
= A,
which can be also restricted (p : R). The term A can
itself be underspecified, by having components with
restricted memory variables. In the following terms,
the λ-abstractions bind pure variables. Assume that
I is the following infon term underspecified for the
memory locations b, l, while x is pure variable.
I ≡ ≪ book, arg : b, Loc : l;Pol : 1 ≫ ∧ (48a)
≪ read, reader : x, readed : b, (48b)
Loc : l;Pol : 1 ≫
The type term (49) is the type of individuals that read
a particular book b ∈ RestrRecVars
IND
, in a particular
situation s ∈ RestrRecVars
SIT
, in a particular location
l ∈ RestrRecVars
LOC
. Note that s is a memory location
(variable) for a situation that is only partly specified
by the parametric infons in the term (49).
λx (s |= I) (49)
The type term (50) is the type of relations between a
situation, a location and an individual, where the in-
dividual reads a particular book b ∈ RestrRecVars
IND
.
λx
SIT
s
, l, x (x
SIT
s
|= I) (50)
The sub-term (51b)–(51e) denotes an abstract rela-
tion, consisting of informational units, which can be
used in proposition terms, e.g., as in (51b)–(51e).
The relation denoted by (51b)–(51e) has new, its own
argument-roles, denoted by [x], [y], and [z], which are
filled up by the objects respectively denoted by a, b,
and c.
s |= (51a)
≪λx, y, z
≪ read-to, reader : x, (51b)
readed : y,
addressee : z, Loc : l;1 ≫ ∧
≪ book, arg : y, Loc : l
1
;1 ≫ ∧ (51c)
≪ listen, arg : z,Loc : l
2
;1 ≫ ∧ (51d)
l ⊆ l
1
∧ l
2
⊆
t
l
, (51e)
[x] : a, [y] : b, [z] : c, Loc : l; 1 ≫
(51f)
The proposition term (51a)–(51f) denotes the propo-
sition that in the situation s the individual denoted by
a reads the object denoted by b, to the addressee de-
noted by c, in the location l. The addressee denoted
by c listens in the location l
2
that is shorter than l. The
object denoted by b is the book in the broader location
l
1
. The symbols a, b, c can be constants or variables.
3.2 Underspecified Recursion Terms
The sub-term (51b)–(51e) denotes an abstract rela-
tion, consisting of informational units, which have
an underlying informational structure. We can ex-
tract the abstract “pattern” of that structure, by “pa-
rameterizing” the specific instances of the relations
read-to, book, listen, and their specific arguments.
The resulted abstract informational pattern is given by
(52b)–(52f) and represents a wide class of relations,
among which some are used by human language.
In the following examples, we subsequently give
complex terms with different structures, which have
sub-terms that have shared components. To save
space and avoid repetitions, we introduce auxiliary
notations, i.e., abbreviations, for the sub-terms, by us-
ing the sign ≡. Note that we take the sign ≡ as a meta-
symbol, which is not in the vocabulary of L
ST
ap
, to des-
ignate syntactic equality, i.e., orthographical equiva-
lence, between L
ST
ap
-expressions. E.g., the symbol P
introduced in (52a)–(52f) is treated as orthographi-
cally equal to the entire term in (52b)–(52f), which
is a single, complex term. Thus, in (53a)–(53g), the
symbol P has to be replaced with the term (52b)–
(52f), which is a sub-term of the entire recursion term
(53a)–(53g).
P ≡ (52a)
s |=≪ λx, y, z
h
(52b)
≪ r
1
, [x
′
] : x,[y
′
] : y, [z
′
] : z;1 ≫ ∧ (52c)
≪ r
2
, [y
′
] : y;1 ≫ ∧ (52d)
≪ r
3
, [z
′
] : z;1 ≫ ∧ i
4
∧ i
5
i
, (52e)
[x] : a, [y] : b, [z] : c, Loc : l; 1 ≫
(52f)
The abstract informational pattern (52b)–(52f) can be
specified, i.e., instantiated, with more specific infor-
mation, by maintaining the informational pattern in
it, by adding where-scope to it and assignment in the
where-scope, (53a)–(53g). Note that the entire ex-
pression (53a)–(53g) is a single term, i.e., a recursion
term with assignments, which, in this case, has no ad-
ditional restrictions.
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
307
P where { (53a)
r
1
:
= λx
′
, y
′
, z
′
≪ read-to, reader : x
′
, (53b)
readed : y
′
, addressee : z
′
, (53c)
Loc : l;1 ≫, (53d)
r
2
:
= λy
′
≪ book, arg : y
′
, Loc : l
1
;1 ≫, (53e)
r
3
:
= λz
′
≪ listen, arg : z
′
, Loc : l
2
;1 ≫, (53f)
i
4
:
= l ⊆ l
1
, i
5
:
= l
2
⊆
t
l} (53g)
As with the symbol P above, we use the same auxil-
iary notation for the term designated by T in (54a)–
(54e), and (55a)–(55h). Note that the term T, in
(54a)–(54e), represents a more general, informational
pattern than P, in (52b)–(52f), since the memory vari-
ables r
2
, r
3
in (54a)–(54e) are given the possibility to
depend on x, y, z, as for r
1
.
T ≡
s |=≪ λx, y, z
h
(54a)
≪ r
1
, [x
′
] : x,[y
′
] : y, [z
′
] : z;1 ≫ ∧ (54b)
≪ r
2
, [x
′
] : x,[y
′
] : y, [z
′
] : z;1 ≫ ∧ (54c)
≪ r
3
, [x
′
] : x,[y
′
] : y, [z
′
] : z;1 ≫ ∧ i
4
∧ i
5
i
, (54d)
[x] : a, [y] : b, [z] : c, Loc : l; 1 ≫
(54e)
The term in (55a)–(55h) has specifying information
in its where-scope, with restrictions and assignments.
The objects denoted by l, l
1
, l
2
have to be of the type
LOC, and the objects denoted by a and c of the type
of persons in the situation s (according to recursion).
The situation denoted by the free parameter variable
s is the reading situation by the recursively embedded
information in the infons in (55c)–(55e). Note that we
treat the parameter variables as memory locations.
T where
{(l : LOC), (l
1
: LOC), (l
2
: LOC), (55a)
(a : T), (c : T)} (55b)
{r
1
:
= λx
′
, y
′
, z
′
≪ read-to, (55c)
reader : x
′
, readed : y
′
,
addressee : z
′
, Loc : l;1 ≫,
r
2
:
= λx
′
, y
′
, z
′
≪ book, (55d)
arg : y
′
, Loc : l
1
;1 ≫,
r
3
:
= λx
′
, y
′
, z
′
≪ listen, (55e)
arg : z
′
, Loc : l
2
;1 ≫, (55f)
i
4
:
= l ⊆ l
1
, i
5
:
= l
2
⊆
t
l, (55g)
T
:
= λu(s |=≪ person, u, l, 1 ≫)} (55h)
In particular, they can be memory variables for mem-
orizing more complex information about correspond-
ing objects.
4 CONCLUSIONS AND FUTURE
WORK
The above examples show that different terms, such
as infon terms, relation terms, and proposition terms
carry different pieces of information, that have com-
ponents that can be related by complex information
structures. The components of the more complex
terms carry structured information about typical rela-
tions between objects, in space-time locations that can
be related. The components also carry information
about what objects are appropriate for filling basic
and complex argument structures. In realistic, prac-
tical systems, these components can be “related” by
rich and fine-grained informational structures.
The examples provide arguments for the infor-
mational richness and fine-granularity of the formal
language L
ST
ap
, that is designed to provide syntax-
semantic interface to mathematical structures of Sit-
uation Theory (Loukanova, 2001; Loukanova, 2002a;
Loukanova, 2002b).
The paper introduces the definitions of the syntax
of the formal language L
ST
ap
. The definitions are sup-
plemented with intuitions about its model-theory pre-
sented in (Loukanova, 2013c; Loukanova, 2014). In
particular, we provide intuitions about its denotational
semantics, and what the terms can denote. Section 3.2
provides arguments for information “patterns” with
fine-granularity, which are the basis for algorithmic
semantics, i.e., for semantics that provides structural
information about how the denotations of the terms
can be computed.
The formal introduction of the denotational and
algorithmic semantics of L
ST
ap
in Situation Theoretical
models is not in the scope of this paper. That is more
extensive work that is in our plans. Another closely
related line of work is development of formal logi-
cal calculi and theory of L
ST
ap
. This is an open area of
research with potentials for applications in various ar-
eas, especially where fine-granular, relational, partial,
and parametric information is essential. We foresee
its applications in many sub-areas of neuroscience in
general, and in particular in neuroscience of language.
The target is applications to advancedtechnologies in-
volving intelligent systems, including in the areas of
Artificial Intelligence.
REFERENCES
Aczel, P. (1988). Non-well-founded Sets. Number 14
in CSLI Lecture Notes. CSLI Publications, Stanford,
California.
ICAART2015-InternationalConferenceonAgentsandArtificialIntelligence
308
Barwise, J. (1981). Scenes and other situations. Journal of
Philosophy, 78:369–397.
Barwise, J. and Etchemendy, J. (1995). The Liar: An Essay
on Truth and Circularity. Oxford University Press.
Barwise, J. and Moss, L. (1996). Vicious Circles. CSLI
Publications, Stanford, California.
Barwise, J. and Perry, J. (1983). Situations and Attitudes.
Cambridge, MA:MIT press. Republished as (Barwise
and Perry, 1999).
Barwise, J. and Perry, J. (1999). Situations and Attitudes.
The Hume Series. CSLI Publications, Stanford, Cali-
fornia.
Copestake, A., Flickinger, D., Pollard, C., and Sag, I.
(2005). Minimal recursion semantics: an introduction.
Research on Language and Computation, 3:281–332.
Devlin, K. (2008). Situation theory and situation semantics.
In Gabbay, D. and Woods, J., editors, Handbook of the
History of Logic, volume 7, pages 601–664. Elsevier.
Ginzburg, J. and Sag, I. A. (2000). Interrogative Investiga-
tions: The Form, Meaning, and Use of English Inter-
rogatives. CSLI Publications, Stanford, California.
Loukanova, R. (2001). Russellian and Strawsonian Definite
Descriptions in Situation Semantics. In Gelbukh, A.,
editor, Computational Linguistics and Intelligent Text
Processing, volume 2004 of Lecture Notes in Com-
puter Science, pages 69–79. Springer Berlin / Heidel-
berg.
Loukanova, R. (2002a). Generalized Quantification in Sit-
uation Semantics. In Gelbukh, A., editor, Compu-
tational Linguistics and Intelligent Text Processing,
volume 2276 of Lecture Notes in Computer Science,
pages 46–57. Springer Berlin / Heidelberg.
Loukanova, R. (2002b). Quantification and Intensionality
in Situation Semantics. In Gelbukh, A., editor, Com-
putational Linguistics and Intelligent Text Processing,
volume 2276 of Lecture Notes in Computer Science,
pages 32–45. Springer Berlin / Heidelberg.
Loukanova, R. (2010). Computational Syntax-Semantics
Interface. In Bel-Enguix, G. and Jim´enez-L´opez,
M. D., editors, Language as a Complex System: Inter-
disciplinary Approaches, pages 111–150. Cambridge
Scholars Publishing.
Loukanova, R. (2011). Syntax-Semantics Interface for Lex-
ical Inflection with the Language of Acyclic Recur-
sion. In Bel-Enguix, G., Dahl, V., and Jim´enez-
L´opez, M. D., editors, Biology, Computation and Lin-
guistics — New Interdisciplinary Paradigms, volume
228 of Frontiers in Artificial Intelligence and Applica-
tions, pages 215–236. IOS Press, Amsterdam; Berlin;
Tokyo; Washington, DC.
Loukanova, R. (2013a). Algorithmic Granularity with
Constraints. In Imamura, K., Usui, S., Shirao, T.,
Kasamatsu, T., Schwabe, L., and Zhong, N., edi-
tors, Brain and Health Informatics, volume 8211 of
Lecture Notes in Computer Science, pages 399–408.
Springer International Publishing.
Loukanova, R. (2013b). Algorithmic Semantics for Pro-
cessing Pronominal Verbal Phrases. In Larsen, H. L.,
Martin-Bautista, M. J., Vila, M. A., Andreasen, T., and
Christiansen, H., editors, Flexible Query Answering
Systems, volume 8132 of Lecture Notes in Computer
Science, pages 164–175. Springer Berlin Heidelberg.
Loukanova, R. (2013c). Situated Agents in Linguistic Con-
texts. In Filipe, J. and Fred, A., editors, Proceed-
ings of the 5th International Conference on Agents
and Artificial Intelligence, volume 1, pages 494–503,
Barcelona, Spain. SciTePress — Science and Technol-
ogy Publications.
Loukanova, R. (2014). Situation Theory, Situated Informa-
tion, and Situated Agents. Transactions on Compu-
tational Collective Intelligence (TCCI) Journal, TCCI
XVII 2014, LNCS 8790.
Loukanova, R. (2015). Higher-order Theory of Recursion
and Situation Theory — present and future potentials.
Forthcoming.
Martin-L¨of, P. (1984). Intuitionistic Type Theory. Bibliopo-
lis, Napoli.
Moschovakis, Y. N. (2006). A logical calculus of meaning
and synonymy. Linguistics and Philosophy, 29:27–89.
Rathjen, M. (2004). Predicativity, circularity, and anti-
foundation. In Link, G., editor, One hundred years
of Russelll’s paradox (De Gruyter Series in Logic and
Its Applications), volume 6, pages 191–219. Walter de
Gruyter, Berlin, New York.
Seligman, J. and Moss, L. S. (2011). Situation Theory. In
van Benthem, J. and ter Meulen, A., editors, Hand-
book of Logic and Language, pages 253–329. Else-
vier, Amsterdam.
Tin, E. and Akman, V. (1994). BABY-SIT: Towards a situa-
tion-theoretic computational environment. Current Is-
sues in Mathematical Linguistics, North-Holland Lin-
guistic Series, 56:299–308.
Tin, E. and Akman, V. (1996). Information-oriented com-
putation with BABY-SIT. In Seligman, J. and West-
erst˚ahl, D., editors, Logic, Language and Computa-
tion, Volume 1, number 58 in CSLI Lecture Notes,
pages 19–34. CSLI Publications, Stanford.
Tin, E., Akman, V., and Ersan, M. (1995). Towards
Situation-oriented Programming Languages. SIG-
PLAN Notices, 30(1):27–36.
Univalent Foundations Program, T. (2013). Homotopy
Type Theory: Univalent Foundations of Mathematics.
http://homotopytypetheory.org/book, Institute for Ad-
vanced Study.
Van Lambalgen, M. and Hamm, F. (2004). The Proper
Treatment Of Events. Explorations in Semantics.
Wiley-Blackwell, Oxford.
UnderspecifiedRelationswithaFormalLanguageofSituationTheory
309
