423,914 research outputs found
Answer Sets for Logic Programs with Arbitrary Abstract Constraint Atoms
In this paper, we present two alternative approaches to defining answer sets
for logic programs with arbitrary types of abstract constraint atoms (c-atoms).
These approaches generalize the fixpoint-based and the level mapping based
answer set semantics of normal logic programs to the case of logic programs
with arbitrary types of c-atoms. The results are four different answer set
definitions which are equivalent when applied to normal logic programs. The
standard fixpoint-based semantics of logic programs is generalized in two
directions, called answer set by reduct and answer set by complement. These
definitions, which differ from each other in the treatment of
negation-as-failure (naf) atoms, make use of an immediate consequence operator
to perform answer set checking, whose definition relies on the notion of
conditional satisfaction of c-atoms w.r.t. a pair of interpretations. The other
two definitions, called strongly and weakly well-supported models, are
generalizations of the notion of well-supported models of normal logic programs
to the case of programs with c-atoms. As for the case of fixpoint-based
semantics, the difference between these two definitions is rooted in the
treatment of naf atoms. We prove that answer sets by reduct (resp. by
complement) are equivalent to weakly (resp. strongly) well-supported models of
a program, thus generalizing the theorem on the correspondence between stable
models and well-supported models of a normal logic program to the class of
programs with c-atoms. We show that the newly defined semantics coincide with
previously introduced semantics for logic programs with monotone c-atoms, and
they extend the original answer set semantics of normal logic programs. We also
study some properties of answer sets of programs with c-atoms, and relate our
definitions to several semantics for logic programs with aggregates presented
in the literature
A functional quantum programming language
We introduce the language QML, a functional language for quantum computations
on finite types. Its design is guided by its categorical semantics: QML
programs are interpreted by morphisms in the category FQC of finite quantum
computations, which provides a constructive semantics of irreversible quantum
computations realisable as quantum gates. QML integrates reversible and
irreversible quantum computations in one language, using first order strict
linear logic to make weakenings explicit. Strict programs are free from
decoherence and hence preserve superpositions and entanglement - which is
essential for quantum parallelism.Comment: 15 pages. Final version, to appear in Logic in Computer Science 200
Recommended from our members
Programming and proving with classical types
The propositions-as-types correspondence is ordinarily presen-
ted as linking the metatheory of typed λ-calculi and the proof theory
of intuitionistic logic. Griffin observed that this correspondence could
be extended to classical logic through the use of control operators. This
observation set off a flurry of further research, leading to the development
of Parigot’s λμ-calculus. In this work, we use the λμ-calculus as the
foundation for a system of proof terms for classical first-order logic. In
particular, we define an extended call-by-value λμ-calculus with a type
system in correspondence with full classical logic. We extend the language
with polymorphic types, add a host of data types in ‘direct style’, and
prove several metatheoretical properties. All of our proofs and definitions
are mechanised in Isabelle/HOL, and we automatically obtain an inter-
preter for a system of proof terms cum programming language—called
μML—using Isabelle’s code generation mechanism. Atop our proof terms,
we build a prototype LCF-style interactive theorem prover—called μTP—
for classical first-order logic, capable of synthesising μML programs from
completed tactic-driven proofs. We present example closed μML programs
with classical tautologies for types, including some inexpressible as closed
programs in the original λμ-calculus, and some example tactic-driven
μTP proofs of classical tautologies
Global semantic typing for inductive and coinductive computing
Inductive and coinductive types are commonly construed as ontological
(Church-style) types, denoting canonical data-sets such as natural numbers,
lists, and streams. For various purposes, notably the study of programs in the
context of global semantics, it is preferable to think of types as semantical
properties (Curry-style). Intrinsic theories were introduced in the late 1990s
to provide a purely logical framework for reasoning about programs and their
semantic types. We extend them here to data given by any combination of
inductive and coinductive definitions. This approach is of interest because it
fits tightly with syntactic, semantic, and proof theoretic fundamentals of
formal logic, with potential applications in implicit computational complexity
as well as extraction of programs from proofs. We prove a Canonicity Theorem,
showing that the global definition of program typing, via the usual (Tarskian)
semantics of first-order logic, agrees with their operational semantics in the
intended model. Finally, we show that every intrinsic theory is interpretable
in a conservative extension of first-order arithmetic. This means that
quantification over infinite data objects does not lead, on its own, to
proof-theoretic strength beyond that of Peano Arithmetic. Intrinsic theories
are perfectly amenable to formulas-as-types Curry-Howard morphisms, and were
used to characterize major computational complexity classes Their extensions
described here have similar potential which has already been applied
Logical Step-Indexed Logical Relations
Appel and McAllester's "step-indexed" logical relations have proven to be a
simple and effective technique for reasoning about programs in languages with
semantically interesting types, such as general recursive types and general
reference types. However, proofs using step-indexed models typically involve
tedious, error-prone, and proof-obscuring step-index arithmetic, so it is
important to develop clean, high-level, equational proof principles that avoid
mention of step indices. In this paper, we show how to reason about binary
step-indexed logical relations in an abstract and elegant way. Specifically, we
define a logic LSLR, which is inspired by Plotkin and Abadi's logic for
parametricity, but also supports recursively defined relations by means of the
modal "later" operator from Appel, Melli\`es, Richards, and Vouillon's "very
modal model" paper. We encode in LSLR a logical relation for reasoning
relationally about programs in call-by-value System F extended with general
recursive types. Using this logical relation, we derive a set of useful rules
with which we can prove contextual equivalence and approximation results
without counting steps
Towards Parameterized Regular Type Inference Using Set Constraints
We propose a method for inferring \emph{parameterized regular types} for
logic programs as solutions for systems of constraints over sets of finite
ground Herbrand terms (set constraint systems). Such parameterized regular
types generalize \emph{parametric} regular types by extending the scope of the
parameters in the type definitions so that such parameters can relate the types
of different predicates. We propose a number of enhancements to the procedure
for solving the constraint systems that improve the precision of the type
descriptions inferred. The resulting algorithm, together with a procedure to
establish a set constraint system from a logic program, yields a program
analysis that infers tighter safe approximations of the success types of the
program than previous comparable work, offering a new and useful efficiency vs.
precision trade-off. This is supported by experimental results, which show the
feasibility of our analysis
- …