Acyclic Recursion with Polymorphic Types and Underpeciﬁcation

Roussanka Loukanova

Department of Mathematics, Stockholm University, Stockholm, Sweden

Keywords:

Semantics, Algorithms, Intension, Denotation, Recursion, Types, Underspeciﬁcation, Subtypes, Polymor-

phism.

Abstract:

The paper extends Moschovakis higher-order type theory of acyclic recursion by adding type polymorphism.

We extend the type system of the theory to model parametric information that pertains to underspeciﬁed types.

Different kinds of type polymorphism are presented via type variables and recursion constructs for alternative,

disjunctive type assignments. Based on the new type system, we extend the reduction calculus of the theory

of acyclic recursion. We motivate the type polymorphism with examples from English language.

1 INTRODUCTION

A sequence of papers (Moschovakis, 1989;

Moschovakis, 1994; Moschovakis, 1997) intro-

duced a new approach to the notion of algorithm, by

the mathematical concept of recursion. The approach

uses a formal language of recursion and ﬁne semantic

distinctions between denotations and algorithms

computing the denotations. That work was on

untyped theory of algorithms and was the basis of

(Moschovakis, 2006), which introduced typed theory

of acyclic recursion, as formalization of the

concepts of algorithmic meaning in typed models.

was introduced for primary application to algo-

rithmic semantics of human language, by considering

semantics of programming languages, where a given

denotation can be computed by different algorithms.

Work on extending the expressive power of L

was initiated in (Loukanova, 2016; Loukanova,

2013a; Loukanova, 2011b). The class of formal lan-

guages and theories of typed acyclic recursion, col-

lectively, is a formal system, which we call the typed

theory of acyclic recursion (TTofAR).

TTofAR has potentials for applications to algo-

rithmic semantics of formal and natural languages.

What makes the work highly demanding is one of the

distinctive features of human languages — semantic

ambiguities and underspeciﬁcation. Ambiguous lan-

guage expressions are interpreted depending on con-

text information, and often, even in context, speciﬁc

interpretations can be parametric. Thus, intelligent

language processing requires computational integra-

tion of syntax with semantics that allows underspec-

iﬁed representations. Availability of computational

models of context are essential for speciﬁc interpreta-

tions and disambiguation. However, it is important to

provide representations in underspeciﬁed forms, be-

fore context information can select speciﬁc interpre-

tations. Thus, it is important to develop computa-

tional theory that represents parametric information

as such. Furthermore, parametric components can be

about unknown types of objects, not only underspec-

iﬁed objects of fully known types. This paper is on

development of a theory for computational semantics

that maintains parametric types.

Among the formal languages, we consider appli-

cations of TTofAR to semantics of programming lan-

guages, languages used in database systems and vari-

ous areas of Artiﬁcial Intelligence (AI). There is real-

ization in contemporary developments and technolo-

gies, related to language processing, that they are

more successful by using language constructs with

parametric or otherwise underspeciﬁed types. In pro-

gramming languages and formal languages of type

theory, this is provided by techniques classiﬁed as

polymorphism. See, e.g., the classic work (Cardelli

and Wegner, 1985). In large-scale computational

grammars of human language, underspeciﬁcation has

become important subject, see e.g., (Copestake et al.,

2005), work which, while not fully formalized, has

been used in implementations. For providing such

applications, our paper extends L

by adding poly-

morphism to its type system.

Semantic ambiguities are among the core, open

problems in language processing. While a broad

spectrum of semantic theories have been seeking so-

392

Loukanova, R.

Acyclic Recursion with Polymorphic Types and Underpeciﬁcation.

DOI: 10.5220/0005749003920399

In Proceedings of the 8th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2016) - Volume 2, pages 392-399

ISBN: 978-989-758-172-4

lutions, here we only mention theories that, accord-

ing to us, have underlain research and applications in

the areas related to processing of human language that

includes computational semantics. Montague’s Inten-

sional Logic (IL), see (Thomason, 1974), introduced

the ﬁrst signiﬁcant approach to computational seman-

tics, which also included representation of semantical

ambiguities. IL was extended by (Gallin, 1975) to

handle hidden quantiﬁcation over possible wolds and

times, which was the basis of extended, Montague

style grammars, e.g., (Muskens, 1995), and more re-

cently (Villadsen, 2010) . On the side of comprehen-

sive, logical approaches to information and semantics,

(Barwise, 1981) was the ﬁrst to introduce a computa-

tional approach to the concepts of partiality, seman-

tic parameters, and restricted parameters in logic ap-

proaches to information. While TTofAR, including

introduced here, extend (Gallin, 1975), and by that

Montague IL, TTofAR delimit Situation Theory to

functional systems. This is done by representing set-

theoretic relations with their characteristic functions,

via standard Curry encodings (when possible and rea-

sonable), and to acyclic recursion, i.e., to computa-

tions that close-off, via mutual recursion that ends af-

ter certain number of steps. TTofAR essentially ex-

tend Gallin logic, and logic systems based on it, by

adding expressiveness for algorithmic semantics and

semantic denotations, i.e., denotational and algorith-

mic semantics. By L

, we extend the expressiveness

of L

for handling underspeciﬁed information by type

polymorphism, which is also acyclic with respect to

computations. The system L

offers unique formal-

ization of underspeciﬁcation in information and se-

mantics, via integration of polymorphism with com-

putations that close-off. This makes it valuable the-

ory, as a mathematical model of algorithms that can

be underspeciﬁed, and for applications.

The untyped theory of recursion (Moschovakis,

1997; Moschovakis, 1989) is applied in (Hurkens

et al., 1998) to model reasoning. The potentials of

, with typed recursion, have been used in vari-

ous applications. Application of L

to logic pro-

gramming in linguistics and cognitive science is given

in (Van Lambalgen and Hamm, 2004). A sequence

of papers (Loukanova, 2016; Loukanova, 2013c;

Loukanova, 2013b; Loukanova, 2013a; Loukanova,

2012a; Loukanova, 2012b; Loukanova, 2011b;

Loukanova, 2011c; Loukanova, 2011d; Loukanova,

2011e; Loukanova, 2011a) and (Loukanova and

Jim

enez-L

opez, 2012) along extending the original

, applied TTofAR to computational semantics and

computational syntax-semantics interface of human

language. By adding polymorphism, L

offers po-

tentials for varieties of applications.

The following sections are concise introduction to

the theory of L

. We give motivation from compu-

tational semantics of human language, because L

has direct potentials for applications to computer-

ized processing of human language, including large-

scale, computational grammars of human language

and NLP for AI.

2 MOTIVATION FOR

UNDERSPECIFIED TYPES

In this section, we present some motivation for intro-

ducing parametric types in a type system, i.e., in this

paper, by extending L

. The general idea is that para-

metric types can be left underspeciﬁed when there is

not enough information to designate fully speciﬁed

types. Further speciﬁcation (which still can be para-

metric) of a parametric type can be reﬁned depending

on environment. In order to reach readers from vary-

ing research areas, including AI, we present the use-

fulness of parametric types by examples from human

language, with the special case of English. The mo-

tivation holds for other natural and formal languages,

and applications, e.g., in databases and other informa-

tion sciences, when there is underspeciﬁed data de-

pendent on possibilities for further instantiations.

Human language is abundant of different kinds of

ambiguities, e.g., see (Loukanova, 2010) for a clas-

siﬁcation along with representative examples. Some

semantic ambiguities can be associated with cor-

responding syntactic categories and parsings, while

there are purely semantic ambiguities that can not

be distinguished syntactically. In any case, seman-

tic interpretations need formal representations by ex-

pressions, i.e., terms of a formal theory that provides

mathematical medium for semantic interpretations.

In formal and computational grammars of hu-

man language, the grammatical function of a modi-

ﬁer in syntax is associated with varieties of syntac-

tic categories. Notoriously, a modiﬁer can contribute

to semantic ambiguities, some of which can corre-

spond to syntactic ambiguities, e.g., as for the sen-

tence (1a) in (1b)–(1d). The semantic difference be-

tween the two parsings (1b) (1c) is explicit. To rep-

resent the semantics of (1b), one needs a term, in

which [in Pittsburgh]

is rendered to a subterm of

type (

e →

e), which is appropriate for both nomi-

nal expressions (i.e., common nouns and more com-

plex NOMs) and verb phrases. Depending on seman-

tic theory and available information, one may assume

that the semantics of (1c) and (1d) are approximately

the same or, alternatively, that (1d) has no reasonable

meaning. So, with this limitation, there is no need

Acyclic Recursion with Polymorphic Types and Underpeciﬁcation

393

of parametric type to represent the semantics of the

sentence (1a), which can be rendered by using under-

speciﬁed terms of L

, but without involving paramet-

ric types.

John bought the car. (1a)

[John [[bought]

[the [car [in Pittsburgh]

]

NOM

]

(1b)

[John [[[bought]

[the [car]

NOM

]

[in Pittsburgh]

]

(1c)

[[John [[bought]

[the [car]

NOM

]

[in Pittsburgh]

]

(1d)

Similarly to prepositional phrases (PPs), adverbs syn-

tactically can be either verbal or sentence modiﬁers.

E.g., the adverb “amusedly ” in a sentence like “The

comedian was presenting his new joke amusedly.” can

contribute to different parsings with corresponding,

different semantic interpretations. The entire class

of grammatical modiﬁers, across syntactic categories,

would beneﬁt from polymorphic type assignment to

modiﬁers. In this paper, we present motivation for

type polymorphism with the shorter sentence (2a),

which does not involve tense, aspects, and transitive

verbs in the VP, while shares a common pattern of

grammatical modiﬁcation. The adverb “disturbingly”

in (2a) can be either a verbal modiﬁer, e.g., as in the

parsing (2b), or a sentence modiﬁer, as in (2c).

Jerry barks disturbingly. (2a)

[[Jerry]

[[barks]

disturbingly]

]

(2b)

[[Jerry [barks]

]

disturbingly]

(2c)

Semantically, with the parsing (2b), the sentence can

be used to describe a situation where the action of

barking itself is explicitly disturbing as a physical ac-

tion, e.g., Jerry himself may be disturbed and sound

that way. In such cases, we can render the adverb

“disturbingly” into a constant of type appropriate for

modiﬁers of VP, i.e., ((

e →

t) → (

e →

t)), as in (10),

and the sentence into a formal term of L

, as in (11b)–

(11f).

In other contexts, a parsing corresponding to (2c),

with the adverb “disturbingly” as a sentence modiﬁer,

requires a different type (

t →

t), as in (12), which is

appropriate for semantics of sentences, represented by

(13a)–(13f). E.g., this is needed when the sentence is

used to describe a situation that is disturbing, not nec-

essarily because the barking action is disturbing per

se, but in other aspects. E.g., Jerry himself may not be

disturbed, and his action of barking may not be physi-

cally disturbing by itself at all, while the situation de-

scribed by the component sentence [Jerry [barks]

]

is disturbing for other participants, i.e., agents, in the

described environment.

For these examples and their representation in L

see (Loukanova, 2012a), which initiated representa-

tion om grammatical modiﬁers by underspeciﬁed re-

cursion. Here we need to stress that the technique

for using underspeciﬁed L

-terms, where the under-

speciﬁcation covers only the presence of free, i.e., un-

derspeciﬁed, recursion variables of L

, as presented

in (Loukanova, 2012a), requires extending the theory

by adding parametric types and extending the en-

tire reduction system of L

. This is the topic of this

paper.

We introduce the extended formal system in the

following sections. Then, in Section 7, we demon-

strate the superiority of the extended theory L

. At

ﬁrst, we give alternative formal representations of the

semantics of (2b)–(2b) by using the original L

, with-

out parametric types. Then, we present the semantic

ambiguity of (2a) as semantic underspeciﬁcation, by

terms of the extended L

In this paper, we show that the use of the technique

of underspeciﬁcation, extended by adding parametric,

underspeciﬁed types, is representative for handling

semantic ambiguity. In particular, we apply it for rep-

resenting underspeciﬁed ambiguities of the grammat-

ical function of modiﬁcation in human language. In-

stead of rendering a sentence into alternative formal

terms, for all possible interpretations, when it is not

known which one may be appropriate in different con-

texts, and with respect to different agents, it is better

to render all of them into a single underspeciﬁed term

with underspeciﬁed recursion variables and paramet-

ric types. Then, the parameters can be instantiated

suitably depending on contexts and agents having ad-

ditional information.

We shall provide renderings of this sentence in

Section 7, after we present the necessary deﬁnitions

of the extended, polymorphic, formal system L

3 TYPES

We extend the type system of L

, by adding a formal

sub-language Types

(abbreviated as Types).

Basic Type Constants: BTypes = { e, t, s },

where e is for entities (individuals); t for truth values;

s for states, i.e., context information

Type Variables: TV = {ζ

| i = 0, 1, . . . }

Types Types

: deﬁned recursively (in BNF)

≡ e | t | s | σ | (τ → σ) | (3a)

where {ϑ

type

= T

, . . . , ϑ

type

= T

} (3b)

where τ, σ, τ

∈ Types; ϑ

∈ TV; T

are nonempty,

ﬁnite sets of types ( j = 0, . . . , m), such that { ϑ

type

ICAART 2016 - 8th International Conference on Agents and Artiﬁcial Intelligence

394

, . . . , ϑ

type

= T

} satisﬁes the Acyclicity Constraint

AC 1.

Acyclicity Constraint AC 1. For any pairwise dif-

ferent ϑ

∈ TV and nonempty, ﬁnite sets T

of types

( j = 0, . . . , m), {ϑ

type

= T

, . . . , ϑ

type

= T

} is acyclic

iff there is rank: {ϑ

, . . . , ϑ

} −→ N, such that

• if ϑ

occurs freely in T

then rank(ϑ

) < rank(ϑ

We call the type terms that have free occurrences

of type variables underspeciﬁed types. Some useful

notations:

e → t, the type of characteristic functions (4a)

of sets of individuals

e ≡ (s → e), the type of state dependent (4b)

entities, i.e., entity “concepts”

t ≡ (s → t), the type of state dependent truth,

i.e., of state dependent propositions

τ ≡ (s → τ), for τ ∈ TV (4c)

The type (5) is for curryed functions from objects of

type τ

, . . . , τ

to objects of type σ; (5) has type vari-

ables as components, i.e. it is underspeciﬁed.

(τ

→ ·· · → (τ

→ σ)) σ, τ

∈ TV, n ≥ 0 (5)

The type variables, e.g., τ ∈ TV, which we use as a

specialized kind of recursion variables, introduced in

the following section, represent “unknown” or “partly

known” types, for which no, or only some, informa-

tion is available. E.g.:

≡ (τ

→ τ

) where {τ

type

= e, τ

type

= t} (6a)

≡ τ where {τ

type

= (τ

→ τ

type

= e, τ

type

= t}

(6b)

4 SYNTAX

has typed vocabulary, i.e., for each τ ∈ Types:

Constants K: K

= {c

, . . . , c

, . . . },

Pure variables PV: PV

= {v

, v

, . . .},

Recursion variables RV: RV

= {r

, r

, . . .},

Pure and recursion variables can be of underspec-

iﬁed types, by type variables and alternative options

via sets of types assigned to type variables, in (3b).

The terms Terms

(Terms): Recursively, in BNF:

≡ c

| x

| (7a)



(σ→τ)

)



| (7b)



λv

)



(σ→τ)

| (7c)



where {ϑ

type

= T

, . . . , ϑ

type

= T

}

{ p

= A

, . . . ,

= A

}



(7d)

where for n, m ≥ 0, c

∈ K

; x

∈ PV

∪RV

; v

∈

; A, B, A

∈ Terms (i = 0, . . . , n); p

∈ RV

(i =

1, . . . , n); ϑ

∈ TV; T

⊂ Types are nonempty, ﬁnite

sets of types ( j = 1, . . . , m); such that the sequences:

{ϑ

type

= T

, . . . , ϑ

type

= T

} and

{ p

= A

, . . . , p

= A

} satisfy the Acyclicity

Constraint AC 2.

Acyclicity Constraint AC 2. the sequences

{ϑ

type

= T

, . . . , ϑ

type

= T

} and

{ p

= A

, . . . , p

= A

} are (jointly) acyclic iff

for a function rank: { ϑ

, . . . , ϑ

, p

, . . . , p

} −→ N,

1. if p

occurs freely in A

, then rank(p

) < rank(p

)

2. if ϑ

occurs freely in T

, then rank(ϑ

) < rank(ϑ

)

3. for p

= A

, if ϑ

occurs freely in σ

, then

rank(ϑ

) < rank(p

)

Informally, { p

= A

, . . . , p

= A

} deﬁnes

recursive step-wise computations of the values of A

(i.e., of their denotations), which are saved in p

. The

requirement rank(p

) < rank(p

), allows the value of

saved in p

to depend on the value of A

saved

in p

, which occurs freely in A

, and on the values of

, ϑ

with rank lower than rank(p

). By the acyclic-

ity AC 2, the computations deﬁned by the recur-

sion assignments { p

= A

, . . . , p

= A

}, along

with the type constraints {ϑ

type

= T

, . . . , ϑ

type

= T

terminate after a ﬁnite number of steps.

A type τ can be underspeciﬁed in two ways. (1)

τ can have free occurrences of type variables in it.

An underspeciﬁed type τ

can be speciﬁed by adding

speciﬁcations of some of its free variables, in the form

of type constraints via type assignments: (2) Each

type assignment ϑ

type

= T

binds the type variable ϑ

disjunctively, so it can still carry disjunctively under-

speciﬁed information, when T

has more than one el-

ement in it.

The terms (7d) of L

are essential for encoding

two-fold semantic information: denotational values

and algorithmic steps for computation of the deno-

tational values. We leave the precise deﬁnitions of

denotational and algorithmic semantics outside of the

scope of this paper. Informally, the denotation of a

term of the form (7d), is computed from the parts

, by mutual recursion following the rank, saving

the values on the way in p

Acyclic Recursion with Polymorphic Types and Underpeciﬁcation

395

5 REDUCTION CALCULUS

This section introduces the reduction system of L

which extends L

Informally, congruence between terms (types) is

the smallest relation ≡

(

≡

) between terms (types)

that is reﬂexive, symmetric, transitive, and closed un-

der: term formation, renaming bound variables, re-

ordering of assignments, congruence of types. A type

τ ∈ Types is proper iff it is not a type variable, i.e.,

τ 6∈ TV, otherwise it is immediate.

Reduction Rules for Types:

Congruence (t-cong)

If τ ≡

σ, then τ ⇒

Transitivity (t-trans)

If τ ⇒

σ and σ ⇒

θ then τ ⇒

Compositionality

If τ

⇒

and σ

⇒

, then (t-rep12)

(τ

→ σ

) ⇒

(τ

→ σ

)

If τ

⇒

, for i = 0, . . . , n, then (t-rep3)

where {ϑ

type

= τ

, . . . , ϑ

type

= τ

}

⇒

where {ϑ

type

= σ

, . . . , ϑ

type

= σ

}

The Head Rule for Types (t-head)



where {

−→

type

−→

τ }



where {

−→

type

−→

σ }

⇒

where {

−→

type

−→

τ ,

−→

type

−→

σ }

given that no ϑ

occurs free in any σ

for i = 1, . . . , n, j = 1, . . . , m

The Beki

c-Scott Rule for Types (t-B-S)

where {ϑ

type



where {

−→

type

−→

σ }



−→

type

−→

τ }

⇒

where {ϑ

type

= σ

−→

type

−→

σ ,

−→

type

−→

τ }

given that no θ

occurs freely in any τ

for i = 1, . . . , n, j = 1, . . . , m

S-subtype Rule (S-subt)

For any type variables t

, . . . , t

∈ TV and any

proper types τ

, . . . , τ

, . . . , t

, τ

, . . . , τ

}

⇒

, . . . , t

, ϑ

, . . . , ϑ

} where {ϑ

type

= τ,

. . . , ϑ

type

= τ}

Reduction Rules for Terms: The set of the re-

duction rules for Terms

extends the L

-reduction

(Moschovakis, 2006), by adding one more rule (type-

r) deﬁned here, to the L

rules (cong), (trans), (rep1),

(rep3), (rep3), (head), (B-S), (recap), (ap), (λ).

The Type Rule (type-r)

If τ ⇒

σ, then A

⇒ A

6 KEY THEORETICAL

FEATURES OF L

We give some of the major results (with proofs in an

extended paper) that are essential for the algorithmic

semantics of the language L

. We say that a type

τ ∈ Types is irreducible iff

for all σ ∈ Types, if τ ⇒ σ, then τ

≡

σ (8)

We say that a term A ∈ Terms is irreducible iff

for all B ∈ Terms, if A ⇒ B, then A ≡

B (9)

Theorem 1 (Canonical Form Theorem for Types).

For each type term τ ∈ Types, there is a unique, up

to congruence, irreducible type term cf(τ), such that:

1. (a) cf(τ) ≡ τ or

(b) cf(τ) ≡ τ

where {ϑ

type

= τ

, . . . , ϑ

type

= τ

}

2. τ ⇒

cf(τ)

3. if τ ⇒

σ and σ is irreducible, then σ

≡

cf(τ), i.e.,

cf(τ) is the unique up to congruence irreducible

type to which τ can be reduced.

Theorem 2 (Canonical Form Theorem). For each

term A

, there are a unique, up to congruence, irre-

ducible type cf(τ) and a unique, up to congruence,

irreducible term cf(A

), such that:

1. (a) cf(A

) ≡ A

cf(τ

) or

(b) cf(A

) ≡ A

where {p

= A

, . . . , p

= A

where cf(τ) ≡

≡

cf(τ

) and

≡

cf(τ

), for i = 1, . . . , n.

2. A

⇒ cf(A

)

3. if A

⇒ B

and B

is irreducible, then B

≡

cf(A

), i.e., cf(A

) is the unique up to congruence

irreducible term of irreducible type to which A

can be reduced.

The proofs of the above theorems use induction

by the deﬁnitions of Types

, Terms

, and the re-

duction rules. They are too long to be included in this

paper, and will be provided in an extended work. See

(Moschovakis, 2006) for the proof of the Canonical

Form Theorem in L

(without polymorphism), corre-

sponding to Theorem 2.

The canonical forms have a distinguished feature

that is part of their algorithmic role: they provide

algorithmic patterns for computations of the denota-

tions of all basic components, i.e., algorithms for se-

mantic computations. The more general terms pro-

vide algorithmic patterns represented by sub-terms

for the fundamental computational operators — func-

tional application, λ-abstraction, component values

that are saved in recursion variables upon the recur-

sive computations. The assignments of values to the

ICAART 2016 - 8th International Conference on Agents and Artiﬁcial Intelligence

396

recursion variables of lower ranks provide the speciﬁc

basic data that feeds-up the successive computational

steps.

The more general terms and sub-terms classify

language expressions with respect to their semantics

and determine the algorithms for computing their de-

notations. The canonical forms represent the decom-

position of the algorithmic steps to the most basic

ones.

Informally, two terms A, B ∈ Terms are algorith-

mically equivalent, i.e., algorithmically synonymous,

A ≈ B, iff (a) when A and B have algorithmic senses

(i.e., A and B are proper), then their denotations

(which are equal) are computed by the same algo-

rithm; (b) otherwise (i.e., A and B are immediate), A

and B have the same denotations.

7 FORMAL PRESENTATION OF

MOTIVATION

Now, we shall supplement the above formal deﬁni-

tions with examples and further motivation. The for-

mal system allows ﬂexible choices depending on ap-

plication needs. For example, we can render the ad-

verb “disturbingly” into a constant disturbingly

as in

(10), where the type is speciﬁc without any parame-

ters.

disturbingly

render

−−−→

disturbingly

: ((

e →

t) → (

e →

t))

(10)

Then, with the rendering (10), we can render the sen-

tence parsing (11a) into the terms in (11b)–(11f):

[[Jerry]

[barks disturbingly]

]

render

−−−→ (11a)

[disturbingly

(bark)](jerry) (11b)

⇒ [disturbingly

(b) where

= bark}](jerry) (ap, rep1)

(11c)

⇒ disturbingly

(b)(jerry) where

= bark} (recap)

(11d)

⇒ [disturbingly

(b)( j) where { j

= jerry}]

where {b

= bark} (ap, rep3)

(11e)

⇒

disturbingly

(b)( j)

where { j

= jerry, b

= bark} (head)

(11f)

Typically, in the existing systems of computational

semantics and computational grammars that incorpo-

rate semantic representations, in order to represent

alternative syntactic categories, type assignments, or

meanings of a lexeme (word), that lexeme is repre-

sented in the system by a set of different lexical items,

e.g., by marking a common lexeme sequence with

some label or index, correspondingly. Similarly, we

can render the adverb “disturbingly” into a second

-constant disturbingly

as in (12), which is needed

for the same sentence with the alternative parsing in

(13a) and its corresponding interpretation represented

by (13b)–(13f). As in (10) and (11b)–(11f), the types

of the constant disturbingly

in (12) and the terms in

(13b)–(13f) are speciﬁc, without any parameters.

disturbingly

render

−−−→ disturbingly

: (

t →

t) (12)

The type of the rendering (12) is suitable for rendering

of the sentence as in (13a)–(13f):

[[Jerry [barks]

]

disturbingly]

render

−−−→ (13a)

disturbingly



bark(jerry)



(ap) (13b)

⇒ disturbingly

(b) where

= bark(jerry)} (ap, rep3)

(13c)

⇒ disturbingly

(b) where

= [bark( j) where

{ j

= jerry}]} (B-S)

(13d)

⇒

disturbingly

(b) where

= bark( j), j

= jerry}

(13e)

≈ disturbingly

(b) where

{ j

= jerry, b

= bark( j)}

(13f)

While, the above alternative renderings can be appro-

priate in speciﬁc environments, with respect to spe-

ciﬁc agents, such speciﬁc information may not be

available. In such cases it is more adequate to ren-

der the sentence into a formal term that is underspec-

iﬁed and open to be instantiated when suitable infor-

mation is available. We can not render the verb “dis-

turbingly” into a parameter that could be instantiated

either as disturbingly

or disturbingly

in the standard

since every parameter and every constant have

to be of speciﬁc types as in (10) and (12). Our ex-

tended formal system TTofAR, with parametric types,

formalizes such possibilities, e.g., to render the verb

“disturbingly” to a constant disturbingly of paramet-

ric type, as in (14). The variable ζ is a type variable,

which can be instantiated when there is suitable infor-

mation available.

disturbingly

render

−−−→ disturbingly : (

ζ →

ζ) (14)

Note that, instead of assigning a simple type variable

to the constant disturbingly, we have used the under-

speciﬁed (i.e., parametric) type term (

ζ →

ζ), since

we “know” some information about the parametric

type, which we can represent by parametric type ex-

pression. The type (

ζ →

ζ) is functional and requires

Acyclic Recursion with Polymorphic Types and Underpeciﬁcation

397

that the term to be modiﬁed and the resulted, modi-

ﬁed, term to be of the same “unknown” type

ζ. This

is characteristic for any modiﬁer expressions in artiﬁ-

cial and natural languages. In addition,

ζ ≡ (s → ζ) is

state dependent. One could just use simple, paramet-

ric modiﬁer type ζ → ζ).

Then, the sentence can be rendered to an under-

speciﬁed term as in (15b), where the type of the con-

stant disturbingly is parametric and underspeciﬁed.

[Jerry barks disturbingly]

render

−−−→ (15a)

A where { j

= jerry, B

= bark,

= disturbingly}

(15b)

When sufﬁcient information is available, the type

variable ζ can be instantiate suitable, either as (

e →

t),

as in (16), or as

t. Thus, the already speciﬁed term

(16) corresponds to the denotation of the terms in

(11a)–(11f).

A where {ζ

type

= (

e →

t)}{ j

= jerry,

= bark,

= disturbingly}

(16)

We have presented an example from human lan-

guage, as a pattern of handling language ambiguities.

Semantic ambiguities are abundant in human lan-

guages, and make language processing, understand-

ing, and communications, via computerized system,

one of the difﬁcult areas in theories and applications.

Representing semantic information is particularly dif-

ﬁcult, because resolving multiple interpretations is

highly context dependent, and not only inefﬁcient,

but also unpredictable without sufﬁcient context in-

formation. In this section, we have presented these

problems with a pattern example, and demonstrated

formalization of ambiguous, multiple interpretations,

computationally, with the type polymorphism of L

Speciﬁc interpretations can be obtained from the for-

mal terms, via context and agents providing instanti-

ations.

8 CONCLUSIONS AND FUTURE

WORK

The notion of referencial intension, which we also

call algorithmic intension, in the languages of recur-

sion, including L

covers the computational aspect of

the concept of meaning — the algorithmic steps by

which denotations are computed. The algorithmic in-

tension, Int(A), of a meaningful term A is the tuple of

functions (a recursor) that is determined by its canoni-

cal form cf(A) ≡ A

where {p

= A

, . . . , p

= A

Thus, the languages of recursion offer a formalisa-

tion of semantic layers: denotations and algorithmic

steps for computation of denotations. When spe-

ciﬁc denotations depend on context information that

is unknown, the algorithms can be represented by L

terms in canonical forms with free type and recursion

variable.

=⇒ Type Speciﬁcation =⇒ Intensions (Algorithms) =⇒ Denotations

| {z }

Algorithmic Semantics

By L

, we have extended, the concept of algo-

rithm to a generalized notion of underspeciﬁed al-

gorithm, with respect to polymorphism, and in addi-

tion, for acyclic computations, i.e., polymorphic algo-

rithms that potentially close-off, which we consider

unique among theoretic formalizations of semantic

concepts.

We plan to extend the formal system presented in

this paper in two directions. On the theoretical side,

we work on extending the system with other reduction

rules and calculi. Such work broadens the range of

applications of L

to computational semantics of hu-

man languages, as well as to various areas of AI. E.g.,

we consider that it is important to add constraints over

underspeciﬁed types, along other kinds of constraints

over possible instantiations of free recursion variable,

e.g., in the line of (Loukanova, 2013a).

On the application side, we target applications

to computational syntax-semantics interface in nat-

ural language processing, e.g., along the lines of

(Loukanova, 2011d; Loukanova, 2011e; Loukanova,

2011a; Loukanova, 2012b) and (Loukanova and

Jim

enez-L

opez, 2012). Ambiguities and under-

speciﬁcation are characteristic for human languages.

(Loukanova, 2012a) presented ambiguity among

some human language modiﬁers. A vast range of am-

biguous modiﬁers require to be rendered with terms

of varying semantic types. The type system in this

paper provides formalization of such underspeciﬁca-

tion. We work on extending furthermore the expres-

sive power of the formal system L

introduced in this

paper, for covering other classes of ambiguities.

REFERENCES

Barwise, J. (1981). Scenes and other situations. The Journal

of Philosophy, 78:369–397.

Cardelli, L. and Wegner, P. (1985). On understanding types,

data abstraction, and polymorphism. ACM Computing

Surveys (CSUR), 17(4):471–523.

Copestake, A., Flickinger, D., Pollard, C., and Sag, I.

(2005). Minimal recursion semantics: an introduction.

Research on Language and Computation, 3:281–332.

ICAART 2016 - 8th International Conference on Agents and Artiﬁcial Intelligence

398

Gallin, D. (1975). Intensional and Higher-Order Modal

Logic. North-Holland.

Hurkens, A. J. C., McArthur, M., Moschovakis, Y. N.,

Moss, L. S., and Whitney, G. T. (1998). The logic of

recursive equations. The Journal of Symbolic Logic,

63(2):451–478.

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. (2011a). From Montague’s Rules of Quan-

tiﬁcation to Minimal Recursion Semantics and the

Language of Acyclic Recursion. In Bel-Enguix, G.,

Dahl, V., and Jim

enez-L

opez, M. D., editors, Biology,

Computation and Linguistics — New Interdisciplinary

Paradigms, volume 228 of Frontiers in Artiﬁcial Intel-

ligence and Applications, pages 200–214. IOS Press,

Amsterdam; Berlin; Tokyo; Washington, DC.

Loukanova, R. (2011b). Modeling Context Information

for Computational Semantics with the Language of

Acyclic Recursion. In P

erez, J. B., Corchado, J. M.,

Moreno, M., Juli

an, V., Mathieu, P., Canada-Bago,

J., Ortega, A., and Fern

andez-Caballero, A., editors,

Highlights in Practical Applications of Agents and

Multiagent Systems, volume 89 of Advances in Intel-

ligent and Soft Computing. Springer, pages 265–274.

Springer.

Loukanova, R. (2011c). Reference, Co-reference and

Antecedent-anaphora in the Type Theory of Acyclic

Recursion. In Bel-Enguix, G. and Jim

enez-L

opez,

M. D., editors, Bio-Inspired Models for Natural and

Formal Languages, pages 81–102. Cambridge Schol-

ars Publishing.

Loukanova, R. (2011d). Semantics with the Language of

Acyclic Recursion in Constraint-Based Grammar. In

Bel-Enguix, G. and Jim

enez-L

opez, M. D., editors,

Bio-Inspired Models for Natural and Formal Lan-

guages, pages 103–134. Cambridge Scholars Publish-

ing.

Loukanova, R. (2011e). Syntax-Semantics Interface for

Lexical Inﬂection with the Language of Acyclic Re-

cursion. In Bel-Enguix, G., Dahl, V., and Jim

enez-

opez, M. D., editors, Biology, Computation and Lin-

guistics — New Interdisciplinary Paradigms, volume

228 of Frontiers in Artiﬁcial Intelligence and Applica-

tions, pages 215–236. IOS Press, Amsterdam; Berlin;

Tokyo; Washington, DC.

Loukanova, R. (2012a). Algorithmic Semantics of Am-

biguous Modiﬁers by the Type Theory of Acyclic Re-

cursion. IEEE/WIC/ACM International Conference

on Web Intelligence and Intelligent Agent Technology,

3:117–121.

Loukanova, R. (2012b). Semantic Information with Type

Theory of Acyclic Recursion. In Huang, R., Ghorbani,

A. A., Pasi, G., Yamaguchi, T., Yen, N. Y., and Jin, B.,

editors, Active Media Technology - 8th International

Conference, AMT 2012, Macau, China, December 4-

7, 2012. Proceedings, volume 7669 of Lecture Notes

in Computer Science, pages 387–398. Springer.

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). A Predicative Operator and Un-

derspeciﬁcation by the Type Theory of Acyclic Re-

cursion. In Duchier, D. and Parmentier, Y., editors,

Constraint Solving and Language Processing, volume

8114 of Lecture Notes in Computer Science, pages

108–132. Springer Berlin Heidelberg.

Loukanova, R. (2016). Speciﬁcation of underspeciﬁed

quantiﬁers via question-answering by the theory of

acyclic recursion. In Andreasen, T., Christiansen, H.,

Kacprzyk, J., Larsen, H., Pasi, G., Pivert, O., De Tr

G., Vila, M. A., Yazici, A., and Zadro

zny, S., editors,

Flexible Query Answering Systems 2015, volume 400

of Advances in Intelligent Systems and Computing,

pages 57–69. Springer International Publishing.

Loukanova, R. and Jim

enez-L

opez, M. D. (2012). On

the Syntax-Semantics Interface of Argument Mark-

ing Prepositional Phrases. In P

erez, J. B., S

anchez,

M. A., Mathieu, P., Rodr

ıguez, J. M. C., Adam, E.,

Ortega, A., Moreno, M. N., Navarro, E., Hirsch, B.,

Lopes-Cardoso, H., and Juli

an, V., editors, Highlights

on Practical Applications of Agents and Multi-Agent

Systems, volume 156 of Advances in Intelligent and

Soft Computing, pages 53–60. Springer Berlin / Hei-

delberg.

Moschovakis, Y. N. (1989). The formal language of recur-

sion. The Journal of Symbolic Logic, 54(04):1216–

1252.

Moschovakis, Y. N. (1994). Sense and denotation as algo-

rithm and value. In Oikkonen, J. and Vaananen, J.,

editors, Lecture Notes in Logic, number 2 in Lecture

Notes in Logic, pages 210–249. Springer.

Moschovakis, Y. N. (1997). The logic of functional recur-

sion. In Logic and Scientiﬁc Methods, pages 179–207.

Kluwer Academic Publishers. Springer.

Moschovakis, Y. N. (2006). A logical calculus of meaning

and synonymy. Linguistics and Philosophy, 29:27–89.

Muskens, R. (1995). Meaning and Partiality. Studies in

Logic, Language and Information. CSLI Publications,

Stanford, California.

Thomason, R. H., editor (1974). Formal Philosophy: Se-

lected Papers of Richard Montague. Yale University

Press, New Haven, Connecticut.

Van Lambalgen, M. and Hamm, F. (2004). The Proper

Treatment Of Events. Explorations in Semantics.

Wiley-Blackwell, Oxford.

Villadsen, J. (2010). Nabla: A Linguistic System based

on Type Theory, volume 3 of Foundations of Com-

munication and Cognition (New Series). LIT Verlag

unster-Hamburg-Berlin-Wien-London.

Acyclic Recursion with Polymorphic Types and Underpeciﬁcation

399