12 research outputs found
Fast Reed-Solomon Interactive Oracle Proofs of Proximity
The family of Reed-Solomon (RS) codes plays a prominent role in the construction of quasilinear probabilistically checkable proofs (PCPs) and interactive oracle proofs (IOPs) with perfect zero knowledge and polylogarithmic verifiers. The large concrete computational complexity required to prove membership in RS codes is one of the biggest obstacles to deploying such PCP/IOP systems in practice.
To advance on this problem we present a new interactive oracle proof of proximity (IOPP) for RS codes; we call it the Fast RS IOPP (FRI) because (i) it resembles the ubiquitous Fast Fourier Transform (FFT) and (ii) the arithmetic complexity of its prover is strictly linear and that of the verifier is strictly logarithmic (in comparison, FFT arithmetic complexity is quasi-linear but not strictly linear). Prior RS IOPPs and PCPs of proximity (PCPPs) required super-linear proving time even for polynomially large query complexity.
For codes of block-length N, the arithmetic complexity of the (interactive) FRI prover is less than 6 * N, while the (interactive) FRI verifier has arithmetic complexity <= 21 * log N, query complexity 2 * log N and constant soundness - words that are delta-far from the code are rejected with probability min{delta * (1-o(1)),delta_0} where delta_0 is a positive constant that depends mainly on the code rate. The particular combination of query complexity and soundness obtained by FRI is better than that of the quasilinear PCPP of [Ben-Sasson and Sudan, SICOMP 2008], even with the tighter soundness analysis of [Ben-Sasson et al., STOC 2013; ECCC 2016]; consequently, FRI is likely to facilitate better concretely efficient zero knowledge proof and argument systems.
Previous concretely efficient PCPPs and IOPPs suffered a constant multiplicative factor loss in soundness with each round of "proof composition" and thus used at most O(log log N) rounds. We show that when delta is smaller than the unique decoding radius of the code, FRI suffers only a negligible additive loss in soundness. This observation allows us to increase the number of "proof composition" rounds to Theta(log N) and thereby reduce prover and verifier running time for fixed soundness
Compositional competitiveness for distributed algorithms
We define a measure of competitive performance for distributed algorithms
based on throughput, the number of tasks that an algorithm can carry out in a
fixed amount of work. This new measure complements the latency measure of Ajtai
et al., which measures how quickly an algorithm can finish tasks that start at
specified times. The novel feature of the throughput measure, which
distinguishes it from the latency measure, is that it is compositional: it
supports a notion of algorithms that are competitive relative to a class of
subroutines, with the property that an algorithm that is k-competitive relative
to a class of subroutines, combined with an l-competitive member of that class,
gives a combined algorithm that is kl-competitive.
In particular, we prove the throughput-competitiveness of a class of
algorithms for collect operations, in which each of a group of n processes
obtains all values stored in an array of n registers. Collects are a
fundamental building block of a wide variety of shared-memory distributed
algorithms, and we show that several such algorithms are competitive relative
to collects. Inserting a competitive collect in these algorithms gives the
first examples of competitive distributed algorithms obtained by composition
using a general construction.Comment: 33 pages, 2 figures; full version of STOC 96 paper titled "Modular
competitiveness for distributed algorithms.
Improving explicit model checking for Petri nets
Model checking is the automated verification that systematically checks if a given behavioral property holds for a given model of a system. We use Petri nets and temporal logic as formalisms to describe a system and its behavior in a mathematically precise and unambiguous manner. The contributions of this thesis are concerned with the improvement of model checking efficiency both in theory and in practice. We present two new reduction techniques and several supplementary strength reduction techniques. The thesis also enhances partial order reduction for certain temporal logic classes
Using Restarts in Constraint Programming over Finite Domains - An Experimental Evaluation
The use of restart techniques in complete Satisfiability (SAT) algorithms has made
solving hard real world instances possible. Without restarts such algorithms could not
solve those instances, in practice. State of the art algorithms for SAT use restart
techniques, conflict clause recording (nogoods), heuristics based on activity variable in
conflict clauses, among others. Algorithms for SAT and Constraint problems share many
techniques; however, the use of restart techniques in constraint programming with finite
domains (CP(FD)) is not widely used as it is in SAT. We believe that the use of restarts in
CP(FD) algorithms could also be the key to efficiently solve hard combinatorial
problems.
In this PhD thesis we study restarts and associated techniques in CP(FD) solvers. In
particular, we propose to including in a CP(FD) solver restarts, nogoods and heuristics
based in nogoods as this should improve search algorithms, and, consequently, efficiently
solve hard combinatorial problems.
We thus intend to: a) implement restart techniques (successfully used in SAT) to
solve constraint problems with finite domains; b) implement nogoods (learning) and
heuristics based on nogoods, already in use in SAT and associated with restarts; and c)
evaluate the use of restarts and the interplay with the other implemented techniques.
We have conducted the study in the context of domain splitting backtrack search
algorithms with restarts. We have defined domain splitting nogoods that are extracted
from the last branch of the search algorithm before the restart. And, inspired by SAT
solvers, we were able to use information within those nogoods to successfully help the
variable selection heuristics. A frequent restart strategy is also necessary, since our
approach learns from restarts
LIPIcs, Volume 251, ITCS 2023, Complete Volume
LIPIcs, Volume 251, ITCS 2023, Complete Volum