Marco Bellia

The relation between logic and functional languages: A survey

Abstract The paper considers different methods of integrating the functional and logic programming paradigms, starting with the identification of their semantic differences. The main methods to extend functional programs with logic features (i.e. unification) are then considered. These include narrowing, completion, SLD-resolution of equational formulas, and set abstraction. The different techniques are analyzed from several viewpoints, including the ability to support both paradigms, lazy evaluation, and concurrency.

C-expressions: a variable-free calculus for equational logic programming

Abstract A relevant drawback between the theory and the current implementations of logic programming languages is represented by the use of metalevel structures, like substitutions, and mechanisms, like mgu and instantiation, to deal with the substitution rule. Substitution rule is highly involved in the formalization of proof procedures, including narrowing and resolution. We put the substitution rule as an additional operator, mgi, of the algebra of the language terms and provide them with a variable-free abstract representation, c-expressions. A formal definition of the operations of the algebra is given through rules which, replacing equal by equal define a calculus having a special class of c-expressions as normal forms. The calculus provides for a formal construction of reduction machines for unification, rewriting and narrowing, all having c-expressions as programs.

Applicative communicating processes in first order logic

We describe a first order applicative language for the specification of deterministic systems of communicating computing agents a la Kahn-MacQueen. Both the sequential and parallel interpreter we give are based on lazy evaluation, are demand driven and can handle infinite streams and non-terminating procedures. An equivalent least fixed-point semantics is then presented which neatly copes with the above features of the language. It is worth noting that computations in our logical based model can be considered as formal proofs, thus making formal reasoning about programs easier.

Properties of Java Simple Closures

In the last years, the Java community has been arguing about adding closures to Java in order to improve expressivity. The debate has not yet terminated but all proposals seem to converge towards a notion of Simple Closures which contain only the essential features of anonymous functions. This paper addresses the problem of defining a rigorous semantics for Simple Closures. The technique adopted is well known and has already been used to prove interesting properties of other extensions of Java. A minimal calculus is defined: Featherweight Java extended with Simple Closures. Syntax and semantics of such a calculus are defined and type safety, backward compatibility, and the abstraction property are proved.

Lazy Linear Combinatorial Unification

In this paper we define a two-rule reduction system for the lazy computation of unification on first-order terms. The computation consists of a sequence of reductions which is almost linear with the size of the input. Every reduction transforms the problem into an equivalent one which is a better approximation of the solution. The approach is based on a combinatorial system which provides abstractions for terms and term unification, and does not resort to any specific reduction control strategy. The abstraction on both data and control makes our system suitable in any applicative context where unification is required.

Combinatory Forms for Equational Programming: Instances, Unification and Narrowing

A relevant drawback of current implementations of logic programming languages is represented by the use of substitutions to keep bindings of logical variables, l-variables. Powerful compilation techniques, i.e. translation to combinatory logic, and implementation techniques such as reduction machines, have shown how to overcome this problem in the context of functional languages. The paper addresses a similar approach to equational logic programming: equations are translated into variable-free combinations and correspondingly narrowing is reformulated in terms of a set of reduction rules.

The Equivalence of Reduction and Translation Semantics of Java Simple Closures

FGCJ is a minimal core calculus that extends Featherweight Generic Java, FGJ, with lambda expressions for Java Simple Closures. It has been introduced to study, in a reduction semantics framework, properties of Java Simple Closures, including type safety and abstraction property. F is a source-to-source, translation rule system from Java 1.5 extended with lambda expressions, back to ordinary Java 1.5. It has been introduced to study, in a translation semantics framework, the design and the implementation features of lambda expressions, including simple closures, this transparency, not local variables and relations with anonymous class objects. In this paper we prove that the reduction semantics and the translation semantics commute in FGACJ. Where FGACJ is a minimal core calculus that extends FGCJ, by adding Java interfaces and anonymous class objects and that allows a restricted definition of translation semantics F.

JavaΩ: The Structures and the Implementation of a Preprocessor for Java with m and mc parameters

M_parameters extend Java by allowing methods to have methods as parameters. [8] furnishes a semantics of m parameters and applications in OO programming. In this paper, we present an implementation of the extended language based on program preprocessing. We also discuss the integration of the extended programs with ordinary Java programs, and hence Java API. Furthermore, mc parameters are defined: they are a variant of m parameters for which the class hierarchy of the method passed as parameter must be provided in the formal and actual parameter. Semantics for mc parameters is given but, in this case, an implementation with callbacks [20] is proposed. Eventually, we discuss how mc_parameters deal with overloaded methods.

Programming Self-Assembly of DNA Tiles

The paper considers molecular programming in the abstract Tile Assembly Model, aTAM. Using simple constructions, an interpreter for the full Combinatory Logic, CL, is formally defined in aTAM. It provides an approach for sequential programming in aTAM, and produces a DNA molecular machine. This machine lives in a suitable solution and when receives a seed that linearly encodes a CL program and an input for the program, produces a grid which encodes a computation of the program on its input. The paper considers the construction cost and some alternative approaches. Finally, as a case study in distributed programming in aTAM, the paper considers the consensus problem and shows how an aTAM program for it can be formally derived by using π-calculus. Keywords: DNA Tile self assembly, aTAM model, Combinatory Logic, π−calculus, Consensus problem 1. Computing with DNA tiles The aTAM [1] is, together with its variants [2, 3], the basic formalism of molecular computing in which self-assembly [4] applies to DNA tiles. DNA tiles are molecules of DNA that have a fixed, 4-sticky ends connection, 3D structure, as in Figure 1.a2, according to which self-assemble to form structures which grow even, indefinitely, as sketched in Figure 1.b. Various geometries [5, 6] have been studied for tiles however our considerations are not affected from the tile shape. The aTAM is an extension of the Wang formalism [7] of the plan tiling where the tiles are 4-sides connection, 2D structures that can be graphically represented by unit squares, as in Figure 1.a1. The aTAM self-assembly matches the Wang tiling laws [1]: tiles cover a (plan) grid and adjacent tiles have same values on the abutting sides. The ∗Address for correspondence: Dipartimento di Informatica, University of Pisa, Italy 36 M. Bellia and M.E. Occhiuto / Programming Self-Assembly of DNA Tiles correspondence between the Wang formalism and the Turing Machine formalism, TM, [8], shown in Figure 4, leads to a same notion of program and of computation in both Wang formalism and aTAM: A program is a finite set of tiles. A computation is a grid tiling, i.e. a cover, without holes, of the (infinite) plan, using (infinitely) many copies of the tiles of the program. The program input is the tile (structure) that is initially put on the grid: It is called computation seed and is changed in order to obtain different computations of the program. A tile that needs to be replicated in a grid, is called prototile in aTAM. Figure 3 shows a fragment of a grid where each rectangle represents a sub(program)-computation of the (main) program. The molecular nature of tiles makes each aTAM program one concrete computing machine. The intermolecular force of the Watson-Crick double helix supplies each aTAM program tile of the energy source to replicate and to self-assemble in an autonomous and spontaneous way. The aTAM is indeed a formalism for the design, at the molecular level, of autonomous nano-machines that live in solutions with controlled temperature and salt concentration [4, 9, 1]. For this reason aTAM and the Wang formalism differ in the self-assembly process: D1) In aTAM, the tiling proceeds self-assembling a tile at a time and produces a sequence of grid growths, without holes, that starts from the seed tile. In the Wang formalism, how tilings are obtained is ignored. D2) When more than one is possible, in aTAM the choice of the tile that self-assembles is non-deterministic. In contrast, in the Wang formalism the choice is determinate and under system control. D3) In aTAM, the tiles have in addition, a binding strength value that allows a tile to self-assemble even if some adjacent sides are mismatched or are not yet in the grid. The Wang formalism forbids that adjacent sides have mismatching values. D4) An aTAM program has two additional parameters (the binding strength function and the threshold temperature) in order to describe the biochemical conditions of the system (phisical structure of the tiles plus solution) in which self-assembly is assumed to be operated. D5) The amount of the different proto-tiles that are involved in an aTAM program has been shown to be critical in experimental physical reproductions of the program, leading to grid growths that lose planarity and finally collapse into meaningless aggregations of molecules. Obviously, the formalism of Wang, where the tiles are geometric abstractions, is in no way affected by the aspects in D4 and D5. Even the notion of programming in aTAM should overlook the strongly physical aspects mentioned in D4 and consider instead, the limits posed by D5 as a recommendation on containing the size of the aTAM programs. Hence, Programming in aTAM means providing, given any computable problem, a solution which can be effectively formulated in aTAM. The formulation must consist of a ‘small’ finite set of aTAM proto-tiles that, given each seed (which encodes an instance of the problem), self-assemble generating a grid which encodes a computation of the instance solution. Although the literature [10] shows examples of problems that have elegant formulations as aTAM programs, aTAM remains awkward to be used as a programming language and even worst for program development. For this reason, other formalisms and techniques have been studied to provide languages and tool for program development in aTAM [11, 10, 12]. [12] discussed some of them and proposed a methodology for programming sequential algorithms in aTAM. The methodology introduced two languages, SKI# and SKI-Tile. SKI# is a programming language based on combinator reduction and SKI-Tile is a language especially designed for compiling SKI# in aTAM. The programs of SKI-Tile are aTAM programs which generate tilings that can be interpreted as sequences of combinator reductions. A transformation from SKI# in SKI-Tile completes the approach. The next Section provides an overview of SKI#, SKI-Tile, the principles of the translation into aTAM programs, the properties and the limits of the approach. To overcome some limits and as a complementary approach to sequential programming in aTAM, Section 3 shows the construction of an aTAM program which defines an interpreter for SKI# and the full CL. The M. Bellia and M.E. Occhiuto / Programming Self-Assembly of DNA Tiles 37 (a1) (l’,r’,l,r)

Java SAM Typed Closures: A Sound and Complete Type Inference System for Nominal Types

The last proposal for Java closures, as emerged in JSR 000335, is mainly innovative in: 1 Use of nominal types, SAM types, for closures; 2 Introduction of target types and compatibility for a contextual typing of closures; 3 Need for a type inference that reconstructs the omitted type annotations of closures and closure arguments. The paper provides a sound and complete type system, with nominal types, for such a type inference and discusses role and formalization of targeting and of compatibility in the designed inference process.