## Section: Scientific Foundations

### General Overview

In the specification of computational systems, logics are generally
used in one of two approaches. In the *computation-as-model*
approach, computations are encoded as mathematical structures,
containing such items as nodes, transitions, and state. Logic is used
in an external sense to make statements *about* those structures.
That is, computations are used as models for logical expressions.
Intensional operators, such as the modals of temporal and dynamic
logics or the triples of Hoare logic, are often employed to express
propositions about the change in state. This use of logic to
represent and reason about computation is probably the oldest and most
broadly successful use of logic in computation.

The *computation-as-deduction* approach, uses directly pieces of
logic's syntax (such as formulas, terms, types, and proofs) as elements
of the specified computation. In this much more rarefied setting,
there are two rather different approaches to how computation is
modeled.

The *proof normalization* approach views the state of a
computation as a proof term and the process of computing as
normalization (know variously as -reduction or
cut-elimination). Functional programming can be explained using
proof-normalization as its theoretical basis [50] and
has been used to justify the design of new functional programming
languages [22] .

The *proof search* approach views the state of a computation as a
sequent (a structured collection of formulas) and the process of
computing as the process of searching for a proof of a sequent: the
changes that take place in sequents capture the dynamics of
computation. Logic programming can be explained using proof search as
its theoretical basis [54] and has been used to justify
the design of new logic programming languages [53] .

The divisions proposed above are informal and suggestive: such a classification is helpful in pointing out different sets of concerns represented by these two broad approaches (reductions, confluence, etc, versus unification, backtracking search, etc). Of course, a real advance in computation logic might allow us merge or reorganize this classification.

Although type theory has been essentially designed to fill the gap between these two kinds of approaches, it appears that each system implementing type theory up to now only follows one of the approaches. For example, the Coq system implementing the Calculus of Inductive Constructions (CIC) uses proof normalization while the Twelf system [57] , implementing the Edinburgh Logical Framework (LF, a sub-system of CIC), follows the proof search approach (normalization appears in LF, but it is much weaker than in, say, CIC).

The Parsifal team works on both the proof normalization and proof search approaches to the specification of computation.