2,009 research outputs found
Efficiently Simulating Higher-Order Arithmetic by a First-Order Theory Modulo
In deduction modulo, a theory is not represented by a set of axioms but by a
congruence on propositions modulo which the inference rules of standard
deductive systems---such as for instance natural deduction---are applied.
Therefore, the reasoning that is intrinsic of the theory does not appear in the
length of proofs. In general, the congruence is defined through a rewrite
system over terms and propositions. We define a rigorous framework to study
proof lengths in deduction modulo, where the congruence must be computed in
polynomial time. We show that even very simple rewrite systems lead to
arbitrary proof-length speed-ups in deduction modulo, compared to using axioms.
As higher-order logic can be encoded as a first-order theory in deduction
modulo, we also study how to reinterpret, thanks to deduction modulo, the
speed-ups between higher-order and first-order arithmetics that were stated by
G\"odel. We define a first-order rewrite system with a congruence decidable in
polynomial time such that proofs of higher-order arithmetic can be linearly
translated into first-order arithmetic modulo that system. We also present the
whole higher-order arithmetic as a first-order system without resorting to any
axiom, where proofs have the same length as in the axiomatic presentation
A linearized stabilizer formalism for systems of finite dimension
The stabilizer formalism is a scheme, generalizing well-known techniques
developed by Gottesman [quant-ph/9705052] in the case of qubits, to efficiently
simulate a class of transformations ("stabilizer circuits", which include the
quantum Fourier transform and highly entangling operations) on standard basis
states of d-dimensional qudits. To determine the state of a simulated system,
existing treatments involve the computation of cumulative phase factors which
involve quadratic dependencies. We present a simple formalism in which Pauli
operators are represented using displacement operators in discrete phase space,
expressing the evolution of the state via linear transformations modulo D <=
2d. We thus obtain a simple proof that simulating stabilizer circuits on n
qudits, involving any constant number of measurement rounds, is complete for
the complexity class coMod_{d}L and may be simulated by O(log(n)^2)-depth
boolean circuits for any constant d >= 2.Comment: 25 pages, 3 figures. Reorganized to collect complexity results; some
corrections and elaborations of technical results. Differs slightly from the
version to be published (fixed typos, changes of wording to accommodate page
breaks for a different article format). To appear as QIC vol 13 (2013),
pp.73--11
Classical simulations of Abelian-group normalizer circuits with intermediate measurements
Quantum normalizer circuits were recently introduced as generalizations of
Clifford circuits [arXiv:1201.4867]: a normalizer circuit over a finite Abelian
group is composed of the quantum Fourier transform (QFT) over G, together
with gates which compute quadratic functions and automorphisms. In
[arXiv:1201.4867] it was shown that every normalizer circuit can be simulated
efficiently classically. This result provides a nontrivial example of a family
of quantum circuits that cannot yield exponential speed-ups in spite of usage
of the QFT, the latter being a central quantum algorithmic primitive. Here we
extend the aforementioned result in several ways. Most importantly, we show
that normalizer circuits supplemented with intermediate measurements can also
be simulated efficiently classically, even when the computation proceeds
adaptively. This yields a generalization of the Gottesman-Knill theorem (valid
for n-qubit Clifford operations [quant-ph/9705052, quant-ph/9807006] to quantum
circuits described by arbitrary finite Abelian groups. Moreover, our
simulations are twofold: we present efficient classical algorithms to sample
the measurement probability distribution of any adaptive-normalizer
computation, as well as to compute the amplitudes of the state vector in every
step of it. Finally we develop a generalization of the stabilizer formalism
[quant-ph/9705052, quant-ph/9807006] relative to arbitrary finite Abelian
groups: for example we characterize how to update stabilizers under generalized
Pauli measurements and provide a normal form of the amplitudes of generalized
stabilizer states using quadratic functions and subgroup cosets.Comment: 26 pages+appendices. Title has changed in this second version. To
appear in Quantum Information and Computation, Vol.14 No.3&4, 201
Simulating chemistry efficiently on fault-tolerant quantum computers
Quantum computers can in principle simulate quantum physics exponentially
faster than their classical counterparts, but some technical hurdles remain.
Here we consider methods to make proposed chemical simulation algorithms
computationally fast on fault-tolerant quantum computers in the circuit model.
Fault tolerance constrains the choice of available gates, so that arbitrary
gates required for a simulation algorithm must be constructed from sequences of
fundamental operations. We examine techniques for constructing arbitrary gates
which perform substantially faster than circuits based on the conventional
Solovay-Kitaev algorithm [C.M. Dawson and M.A. Nielsen, \emph{Quantum Inf.
Comput.}, \textbf{6}:81, 2006]. For a given approximation error ,
arbitrary single-qubit gates can be produced fault-tolerantly and using a
limited set of gates in time which is or ; with sufficient parallel preparation of ancillas, constant average
depth is possible using a method we call programmable ancilla rotations.
Moreover, we construct and analyze efficient implementations of first- and
second-quantized simulation algorithms using the fault-tolerant arbitrary gates
and other techniques, such as implementing various subroutines in constant
time. A specific example we analyze is the ground-state energy calculation for
Lithium hydride.Comment: 33 pages, 18 figure
A Dual-Engine for Early Analysis of Critical Systems
This paper presents a framework for modeling, simulating, and checking
properties of critical systems based on the Alloy language -- a declarative,
first-order, relational logic with a built-in transitive closure operator. The
paper introduces a new dual-analysis engine that is capable of providing both
counterexamples and proofs. Counterexamples are found fully automatically using
an SMT solver, which provides a better support for numerical expressions than
the existing Alloy Analyzer. Proofs, however, cannot always be found
automatically since the Alloy language is undecidable. Our engine offers an
economical approach by first trying to prove properties using a
fully-automatic, SMT-based analysis, and switches to an interactive theorem
prover only if the first attempt fails. This paper also reports on applying our
framework to Microsoft's COM standard and the mark-and-sweep garbage collection
algorithm.Comment: Workshop on Dependable Software for Critical Infrastructures (DSCI),
Berlin 201
Tableaux Modulo Theories Using Superdeduction
We propose a method that allows us to develop tableaux modulo theories using
the principles of superdeduction, among which the theory is used to enrich the
deduction system with new deduction rules. This method is presented in the
framework of the Zenon automated theorem prover, and is applied to the set
theory of the B method. This allows us to provide another prover to Atelier B,
which can be used to verify B proof rules in particular. We also propose some
benchmarks, in which this prover is able to automatically verify a part of the
rules coming from the database maintained by Siemens IC-MOL. Finally, we
describe another extension of Zenon with superdeduction, which is able to deal
with any first order theory, and provide a benchmark coming from the TPTP
library, which contains a large set of first order problems.Comment: arXiv admin note: substantial text overlap with arXiv:1501.0117
- …