Computation Environments, An Interactive Semantics for Turing Machines (which P is not equal to NP considering it)

To scrutinize notions of computation and time complexity, we introduce and formally define an interactive model for computation that we call it the \emph{computation environment}. A computation environment consists of two main parts: i) a universal processor and ii) a computist who uses the computability power of the universal processor to perform effective procedures. The notion of computation finds it meaning, for the computist, through his \underline{interaction} with the universal processor. We are interested in those computation environments which can be considered as alternative for the real computation environment that the human being is its computist. These computation environments must have two properties: 1- being physically plausible, and 2- being enough powerful. Based on Copeland' criteria for effective procedures, we define what a \emph{physically plausible} computation environment is. We construct two \emph{physically plausible} and \emph{enough powerful} computation environments: 1- the Turing computation environment, denoted by $E_T$, and 2- a persistently evolutionary computation environment, denoted by $E_e$, which persistently evolve in the course of executing the computations. We prove that the equality of complexity classes $\mathrm{P}$ and $\mathrm{NP}$ in the computation environment $E_e$ conflicts with the \underline{free will} of the computist. We provide an axiomatic system $\mathcal{T}$ for Turing computability and prove that ignoring just one of the axiom of $\mathcal{T}$, it would not be possible to derive $\mathrm{P=NP}$ from the rest of axioms. We prove that the computist who lives inside the environment $E_T$, can never be confident that whether he lives in a static environment or a persistently evolutionary one.Comment: 33 pages, interactive computation, P vs N

On the Relation of Interaction Semantics to Continuations and Defunctionalization

In game semantics and related approaches to programming language semantics, programs are modelled by interaction dialogues. Such models have recently been used in the design of new compilation methods, e.g. for hardware synthesis or for programming with sublinear space. This paper relates such semantically motivated non-standard compilation methods to more standard techniques in the compilation of functional programming languages, namely continuation passing and defunctionalization. We first show for the linear {\lambda}-calculus that interpretation in a model of computation by interaction can be described as a call-by-name CPS-translation followed by a defunctionalization procedure that takes into account control-flow information. We then establish a relation between these two compilation methods for the simply-typed {\lambda}-calculus and end by considering recursion

A general theory of action languages

We present a general theory of action-based languages as a paradigm, for the description, of those computational systems which include elements of concurrency and networking, and extend this approach to describe dist.ributed systems and also t,o describe the interaction of a system, with an environment. As part of this approach we introduce the Action Language as a common model for the class of nondeterministic concurrent programming languages and define its intensional and interaction semantics in terrors of continuous transformation of environment behavior. This semantics i.s specialized for programs with stores, and extended to describe distributed computations

Propositional computability logic I

In the same sense as classical logic is a formal theory of truth, the recently initiated approach called computability logic is a formal theory of computability. It understands (interactive) computational problems as games played by a machine against the environment, their computability as existence of a machine that always wins the game, logical operators as operations on computational problems, and validity of a logical formula as being a scheme of "always computable" problems. The present contribution gives a detailed exposition of a soundness and completeness proof for an axiomatization of one of the most basic fragments of computability logic. The logical vocabulary of this fragment contains operators for the so called parallel and choice operations, and its atoms represent elementary problems, i.e. predicates in the standard sense. This article is self-contained as it explains all relevant concepts. While not technically necessary, however, familiarity with the foundational paper "Introduction to computability logic" [Annals of Pure and Applied Logic 123 (2003), pp.1-99] would greatly help the reader in understanding the philosophy, underlying motivations, potential and utility of computability logic, -- the context that determines the value of the present results. Online introduction to the subject is available at http://www.cis.upenn.edu/~giorgi/cl.html and http://www.csc.villanova.edu/~japaridz/CL/gsoll.html .Comment: To appear in ACM Transactions on Computational Logi

Towards Interactive Logic Programming

Linear logic programming uses provability as the basis for computation. In the operational semantics based on provability, executing the additive-conjunctive goal $G_1 \& G_2$ from a program $P$ simply terminates with a success if both $G_1$ and $G_2$ are solvable from $P$. This is an unsatisfactory situation, as a central action of \& -- the action of choosing either $G_1$ or $G_2$ by the user -- is missing in this semantics. We propose to modify the operational semantics above to allow for more active participation from the user. We illustrate our idea via muProlog, an extension of Prolog with additive goals.Comment: 8 pages. It describes two execution models for interactive logic programmin

An interactive semantics of logic programming

We apply to logic programming some recently emerging ideas from the field of reduction-based communicating systems, with the aim of giving evidence of the hidden interactions and the coordination mechanisms that rule the operational machinery of such a programming paradigm. The semantic framework we have chosen for presenting our results is tile logic, which has the advantage of allowing a uniform treatment of goals and observations and of applying abstract categorical tools for proving the results. As main contributions, we mention the finitary presentation of abstract unification, and a concurrent and coordinated abstract semantics consistent with the most common semantics of logic programming. Moreover, the compositionality of the tile semantics is guaranteed by standard results, as it reduces to check that the tile systems associated to logic programs enjoy the tile decomposition property. An extension of the approach for handling constraint systems is also discussed.Comment: 42 pages, 24 figure, 3 tables, to appear in the CUP journal of Theory and Practice of Logic Programmin