3,947 research outputs found
Quantum Programming Made Easy
We present IQu, namely a quantum programming language that extends Reynold's
Idealized Algol, the paradigmatic core of Algol-like languages. IQu combines
imperative programming with high-order features, mediated by a simple type
theory. IQu mildly merges its quantum features with the classical programming
style that we can experiment through Idealized Algol, the aim being to ease a
transition towards the quantum programming world. The proposed extension is
done along two main directions. First, IQu makes the access to quantum
co-processors by means of quantum stores. Second, IQu includes some support for
the direct manipulation of quantum circuits, in accordance with recent trends
in the development of quantum programming languages. Finally, we show that IQu
is quite effective in expressing well-known quantum algorithms.Comment: In Proceedings Linearity-TLLA 2018, arXiv:1904.0615
Wave-Style Token Machines and Quantum Lambda Calculi
Particle-style token machines are a way to interpret proofs and programs,
when the latter are written following the principles of linear logic. In this
paper, we show that token machines also make sense when the programs at hand
are those of a simple quantum lambda-calculus with implicit qubits. This,
however, requires generalising the concept of a token machine to one in which
more than one particle travel around the term at the same time. The presence of
multiple tokens is intimately related to entanglement and allows us to give a
simple operational semantics to the calculus, coherently with the principles of
quantum computation.Comment: In Proceedings LINEARITY 2014, arXiv:1502.0441
SICStus MT - A Multithreaded Execution Environment for SICStus Prolog
The development of intelligent software agents and other
complex applications which continuously interact with their
environments has been one of the reasons why explicit concurrency has
become a necessity in a modern Prolog system today. Such applications
need to perform several tasks which may be very different with respect
to how they are implemented in Prolog. Performing these tasks
simultaneously is very tedious without language support.
This paper describes the design, implementation and evaluation of a
prototype multithreaded execution environment for SICStus Prolog. The
threads are dynamically managed using a small and compact set of
Prolog primitives implemented in a portable way, requiring almost no
support from the underlying operating system
Classical Control, Quantum Circuits and Linear Logic in Enriched Category Theory
We describe categorical models of a circuit-based (quantum) functional
programming language. We show that enriched categories play a crucial role.
Following earlier work on QWire by Paykin et al., we consider both a simple
first-order linear language for circuits, and a more powerful host language,
such that the circuit language is embedded inside the host language. Our
categorical semantics for the host language is standard, and involves cartesian
closed categories and monads. We interpret the circuit language not in an
ordinary category, but in a category that is enriched in the host category. We
show that this structure is also related to linear/non-linear models. As an
extended example, we recall an earlier result that the category of W*-algebras
is dcpo-enriched, and we use this model to extend the circuit language with
some recursive types
Dagstuhl News January - December 2002
"Dagstuhl News" is a publication edited especially for the members of the Foundation "Informatikzentrum Schloss Dagstuhl" to thank them for their support. The News give a summary of the scientific work being done in Dagstuhl. Each Dagstuhl Seminar is presented by a small abstract describing the contents and scientific highlights of the seminar as well as the perspectives or challenges of the research topic
Quantum Programming with Inductive Datatypes: Causality and Affine Type Theory
Inductive datatypes in programming languages allow users to define useful
data structures such as natural numbers, lists, trees, and others. In this
paper we show how inductive datatypes may be added to the quantum programming
language QPL. We construct a sound categorical model for the language and by
doing so we provide the first detailed semantic treatment of user-defined
inductive datatypes in quantum programming. We also show our denotational
interpretation is invariant with respect to big-step reduction, thereby
establishing another novel result for quantum programming. Compared to
classical programming, this property is considerably more difficult to prove
and we demonstrate its usefulness by showing how it immediately implies
computational adequacy at all types. To further cement our results, our
semantics is entirely based on a physically natural model of von Neumann
algebras, which are mathematical structures used by physicists to study quantum
mechanics
Quantifying Resource Use in Computations
It is currently not possible to quantify the resources needed to perform a
computation. As a consequence, it is not possible to reliably evaluate the
hardware resources needed for the application of algorithms or the running of
programs. This is apparent in both computer science, for instance, in
cryptanalysis, and in neuroscience, for instance, comparative neuro-anatomy. A
System versus Environment game formalism is proposed based on Computability
Logic that allows to define a computational work function that describes the
theoretical and physical resources needed to perform any purely algorithmic
computation. Within this formalism, the cost of a computation is defined as the
sum of information storage over the steps of the computation. The size of the
computational device, eg, the action table of a Universal Turing Machine, the
number of transistors in silicon, or the number and complexity of synapses in a
neural net, is explicitly included in the computational cost. The proposed cost
function leads in a natural way to known computational trade-offs and can be
used to estimate the computational capacity of real silicon hardware and neural
nets. The theory is applied to a historical case of 56 bit DES key recovery, as
an example of application to cryptanalysis. Furthermore, the relative
computational capacities of human brain neurons and the C. elegans nervous
system are estimated as an example of application to neural nets.Comment: 26 pages, no figure
- …