7,231 research outputs found
On the Cryptographic Hardness of Local Search
We show new hardness results for the class of Polynomial Local Search problems (PLS):
- Hardness of PLS based on a falsifiable assumption on bilinear groups introduced by Kalai, Paneth, and Yang (STOC 2019), and the Exponential Time Hypothesis for randomized algorithms. Previous standard model constructions relied on non-falsifiable and non-standard assumptions.
- Hardness of PLS relative to random oracles. The construction is essentially different than previous constructions, and in particular is unconditionally secure. The construction also demonstrates the hardness of parallelizing local search.
The core observation behind the results is that the unique proofs property of incrementally-verifiable computations previously used to demonstrate hardness in PLS can be traded with a simple incremental completeness property
PC Software for optimizing groundwater contaminant plume capture and containment
Simulation/optimization (S/0) models can be used to speed the process of computing desirable groundwater pumping strategies for plume management. They make the process of computing optimal strategies fairly straightforward and can help minimize the labor and cost of groundwater contaminant cleanup
Programming and Proving with Distributed Protocols
Distributed systems play a crucial role in modern infrastructure, but are notoriously difficult to
implement correctly. This difficulty arises from two main challenges: (a) correctly implementing
core system components (e.g., two-phase commit), so all their internal invariants hold, and (b)
correctly composing standalone system components into functioning trustworthy applications (e.g.,
persistent storage built on top of a two-phase commit instance). Recent work has developed several
approaches for addressing (a) by means of mechanically verifying implementations of core distributed
components, but no methodology exists to address (b) by composing such verified components into
larger verified applications. As a result, expensive verification efforts for key system components are
not easily reusable, which hinders further verification efforts.
In this paper, we present Disel, the first framework for implementation and compositional
verification of distributed systems and their clients, all within the mechanized, foundational context
of the Coq proof assistant. In Disel, users implement distributed systems using a domain specific
language shallowly embedded in Coq and providing both high-level programming constructs as well
as low-level communication primitives. Components of composite systems are specified in Disel as
protocols, which capture system-specific logic and disentangle system definitions from implementation
details. By virtue of Disel’s dependent type system, well-typed implementations always satisfy
their protocols’ invariants and never go wrong, allowing users to verify system implementations
interactively using Disel’s Hoare-style program logic, which extends state-of-the-art techniques for
concurrency verification to the distributed setting. By virtue of the substitution principle and frame
rule provided by Disel’s logic, system components can be composed leading to modular, reusable
verified distributed systems.
We describe Disel, illustrate its use with a series of examples, outline its logic and metatheory,
and report on our experience using it as a framework for implementing, specifying, and verifying
distributed systems
Proofs as stateful programs: A first-order logic with abstract Hoare triples, and an interpretation into an imperative language
We introduce an extension of first-order logic that comes equipped with
additional predicates for reasoning about an abstract state. Sequents in the
logic comprise a main formula together with pre- and postconditions in the
style of Hoare logic, and the axioms and rules of the logic ensure that the
assertions about the state compose in the correct way. The main result of the
paper is a realizability interpretation of our logic that extracts programs
into a mixed functional/imperative language. All programs expressible in this
language act on the state in a sequential manner, and we make this intuition
precise by interpreting them in a semantic metatheory using the state monad.
Our basic framework is very general, and our intention is that it can be
instantiated and extended in a variety of different ways. We outline in detail
one such extension: A monadic version of Heyting arithmetic with a wellfounded
while rule, and conclude by outlining several other directions for future work.Comment: 29 page
- …