Reduction and Elimination in Philosophy and the Sciences

The Calculus of Inductive Constructions as a Foundation for
Semantics
Piotr Wilkin, Warsaw, Poland
Since Frege started his work on formalizing natural
language semantics, the framework for those semantics
has been set-based. First, most theories have been based
on type theory, later replaced by Zermelo-Fraenkel’s set
theory. Today, this paradigm is rarely questioned and even
if some attempts are made to circumvent ZFC, for example
to eliminate some paradoxes in quantified modal logic
(Oksanen 1999), most of the development is done within
that framework. This raises two major problems: set theory
is structuralistic and extensional in nature. The latter needs
no explanation, the former can be explained this way: in
set theory, one expresses structures, not functionality. This
is well seen in the definition of the ordered pair – in ZFC,
one defines as {{a},{a,b}} and only later proves that
this construct satisfies the properties we require of the
ordered pair – namely, to be able to construct an ordered
pair from two elements and to retrieve, respectively, the
first or second element.
What I propose here is to switch to a certain
intuitionistic setting to express semantics, namely, the
Calculus of Inductive Constructions. I am aware that the
term “intuitionistic” will make some people, and especially
philosophers, wary of the idea, since this instantly
suggests a connection with Brouwer’s philosophical
concept of intuitionism as a philosophy of mathematics.
However, I believe that while intuitionism might be
questionable as a framework for mathematics, it is wellsuited
as a framework for natural-language semantics.
This is because the subjects of both disciplines are
fundamentally different. With natural-language semantics,
we want to describe not an idealized area such as
mathematics, but a very real one – how people use the
language. While in mathematics it is often advisable to
abstract away from the specific means of obtaining some
result (namely, the calculation), it is hardly plausible to
suggest that we can do the same with language
expressions, as there are clearly some cases (as in the
case of intensional contexts or, more specifically,
propositional attitudes) where we cannot abstract from the
way a specific human being reconstructs a language
expression.
From Frege’s times, the accepted and widespread
form of a logical assertion has been C � ϕ, where C stands
for the context and ϕ represents the expression to be
asserted (in the given context). This is true for provability,
as well as for logical consequence in a model (obviously,
the two relations differ in nature, but a common
characteristic is shared – they are both binary relations
between a context and an evaluated expression, whether
the context be a model or a theory). However, a
counterproposal to this form can be submitted: C � ϕ : t,
which reads: in context C, the expression ϕ is of type t.
This is called a typing judgement. The concept of types
dates back to the theory of types from Principia
Mathematica, but this specific idea owes its roots to
Church’s theory of simple types (Church 1940), which was
based on the lambda calculus and proposed as an
alternative.
Once we enter the area of semantics, one can see
the usefulness of the typing assertion over the traditional
logical one. In semantics, we are often interested not only
in information about true sentences, we also want to know
whether a given expression is a properly constructed
sentence or whether some expression is actually a definite
description. Indeed, various solutions like the Montague
grammar (Montague 1974) exploit this concept with the
use of semantic categories, which is a concept parallel to
the one by Church but designed specifically for natural
language analysis in the early XX century by Polish
logicians Stanislaw Lesniewski and Kazimierz Ajdukiewicz
(Ajdukiewicz 1935). However, the interesting modification
here lies not only in the adding of the type, but also in
modifying the way we read the expression. This was first
noticed by the logician Haskell Curry (Curry 1934), who
recognized that in case of simply typed combinators (an
analogon to Church’s simple type system), if we only
assign types to basic lambda terms, the proper types
correspond exactly to tautologies of a minimal (consisting
only of the implication, without the other connectives)
intuitionistic propositional calculus. Thus, for example, the
K combinator (λxλy.x) becomes a proof of the known
tautology α → (β → α). How so? According to the functional
interpretation (known as the Brouwer-Heyting-Kolmogorov
interpretation (Sorensen and Urzyczyn 2006)), a proof of
implication is a function transforming a proof of the LHS to
a proof of the RHS. So in this case, we want the function in
question to take an argument being a proof of α, then
return us an argument which itself is a function from β to α.
The K combinator is exactly that – it takes an x (of type α),
then returns us λy.x, which is itself a function – that takes
an y (of type β) and returns the previously taken x (of type α).
This approach, while generally interesting, is hardly
revolutionary. However, this has to be coupled with a
different idea – Church designed his simple type system
not with this intuitionistic reading in mind, but to avoid a
form of Russell’s Paradox for his untyped lambda calculus,
which is represented by the Omega term: (λx.xx)(λx.xx) –
a self-applying function applied to itself will never reduce to
a normal form. It can be easily proven that any term that
can be typed in the simple type system has the SN (strong
normalization) property – any path of reductions of that
term will terminate. The question raised by Curry’s
discovery was – can one construct a more advanced logic
than the one represented by the simple type system, but
one that is still based only on strongly normalizable terms?
We now know that the answer is positive, and highly so:
one can represent higher-order intuitionistic logic using this
sort type system, and add inductively defined predicates to
the logic to make it easier to formalize certain concepts.
One such system is the Calculus of Inductive
Constructions (CIC), which is the theoretical basis for an
interactive proof assistant program named Coq (Herbelin
et al. 2006). For a sample of the expressive power of the
system, one can point to the formalized version of the fourcolor
theorem proof – since the proof itself is a tangible
mathematical object, this removes the need to “believe” a
computer-based check of each of the hundreds of cases –
one only has to believe the theory behind the prover,
namely, the CIC itself. For a more logically interesting
example, a (constructive) proof of Gödel’s incompleteness
397