59 research outputs found
Nearly optimal independence oracle algorithms for edge estimation in hypergraphs
We study a query model of computation in which an n-vertex k-hypergraph can
be accessed only via its independence oracle or via its colourful independence
oracle, and each oracle query may incur a cost depending on the size of the
query. In each of these models, we obtain oracle algorithms to approximately
count the hypergraph's edges, and we unconditionally prove that no oracle
algorithm for this problem can have significantly smaller worst-case oracle
cost than our algorithms
Approximately counting and sampling small witnesses using a colourful decision oracle
In this paper, we prove "black box" results for turning algorithms which decide whether or not a witness exists into algorithms to approximately count the number of witnesses, or to sample from the set of witnesses approximately uniformly, with essentially the same running time. We do so by extending the framework of Dell and Lapinskas (STOC 2018), which covers decision problems that can be expressed as edge detection in bipartite graphs given limited oracle access; our framework covers problems which can be expressed as edge detection in arbitrary k-hypergraphs given limited oracle access. (Simulating this oracle generally corresponds to invoking a decision algorithm.) This includes many key problems in both the fine-grained setting (such as k-SUM, k-OV and weighted k-Clique) and the parameterised setting (such as induced subgraphs of size k or weight-k solutions to CSPs). From an algorithmic standpoint, our results will make the development of new approximate counting algorithms substantially easier; indeed, it already yields a new state-of-the-art algorithm for approximately counting graph motifs, improving on Jerrum and Meeks (JCSS 2015) unless the input graph is very dense and the desired motif very small. Our k-hypergraph reduction framework generalises and strengthens results in the graph oracle literature due to Beame et al. (ITCS 2018) and Bhattacharya et al. (CoRR abs/1808.00691)
Approximating Holant problems by winding
We give an FPRAS for Holant problems with parity constraints and
not-all-equal constraints, a generalisation of the problem of counting
sink-free-orientations. The approach combines a sampler for near-assignments of
"windable" functions -- using the cycle-unwinding canonical paths technique of
Jerrum and Sinclair -- with a bound on the weight of near-assignments. The
proof generalises to a larger class of Holant problems; we characterise this
class and show that it cannot be extended by expressibility reductions.
We then ask whether windability is equivalent to expressibility by matchings
circuits (an analogue of matchgates), and give a positive answer for functions
of arity three
Efficiently Enumerating Hitting Sets of Hypergraphs Arising in Data Profiling
We devise an enumeration method for inclusion-wise minimal hitting sets in hypergraphs. It has delay O(mk* +1 · n2) and uses linear space. Hereby, n is the number of vertices, m the number of hyperedges, and k* the rank of the transversal hypergraph. In particular, on classes of hypergraphs for which the cardinality k* of the largest minimal hitting set is bounded, the delay is polynomial. The algorithm solves the extension problem for minimal hitting sets as a subroutine. We show that the extension problem is W[3]-complete when parameterised by the cardinality of the set which is to be extended. For the subroutine, we give an algorithm that is optimal under the exponential time hypothesis. Despite these lower bounds, we provide empirical evidence showing that the enumeration outperforms the theoretical worst-case guarantee on hypergraphs arising in the profiling of relational databases, namely, in the detection of unique column combinations
Fine-Grained Reductions from Approximate Counting to Decision
In this paper, we introduce a general framework for fine-grained reductions
of approximate counting problems to their decision versions. (Thus we use an
oracle that decides whether any witness exists to multiplicatively approximate
the number of witnesses with minimal overhead.) This mirrors a foundational
result of Sipser (STOC 1983) and Stockmeyer (SICOMP 1985) in the
polynomial-time setting, and a similar result of M\"uller (IWPEC 2006) in the
FPT setting. Using our framework, we obtain such reductions for some of the
most important problems in fine-grained complexity: the Orthogonal Vectors
problem, 3SUM, and the Negative-Weight Triangle problem (which is closely
related to All-Pairs Shortest Path).
We also provide a fine-grained reduction from approximate #SAT to SAT.
Suppose the Strong Exponential Time Hypothesis (SETH) is false, so that for
some and all there is an -time algorithm for k-SAT. Then we
prove that for all , there is an -time algorithm for
approximate #-SAT. In particular, our result implies that the Exponential
Time Hypothesis (ETH) is equivalent to the seemingly-weaker statement that
there is no algorithm to approximate #3-SAT to within a factor of
in time (taking as part of the input).Comment: An extended abstract was presented at STOC 201
Randomised algorithms for counting and generating combinatorial structures
SIGLEAvailable from British Library Document Supply Centre- DSC:D85048 / BLDSC - British Library Document Supply CentreGBUnited Kingdo
Liveness of Randomised Parameterised Systems under Arbitrary Schedulers (Technical Report)
We consider the problem of verifying liveness for systems with a finite, but
unbounded, number of processes, commonly known as parameterised systems.
Typical examples of such systems include distributed protocols (e.g. for the
dining philosopher problem). Unlike the case of verifying safety, proving
liveness is still considered extremely challenging, especially in the presence
of randomness in the system. In this paper we consider liveness under arbitrary
(including unfair) schedulers, which is often considered a desirable property
in the literature of self-stabilising systems. We introduce an automatic method
of proving liveness for randomised parameterised systems under arbitrary
schedulers. Viewing liveness as a two-player reachability game (between
Scheduler and Process), our method is a CEGAR approach that synthesises a
progress relation for Process that can be symbolically represented as a
finite-state automaton. The method is incremental and exploits both
Angluin-style L*-learning and SAT-solvers. Our experiments show that our
algorithm is able to prove liveness automatically for well-known randomised
distributed protocols, including Lehmann-Rabin Randomised Dining Philosopher
Protocol and randomised self-stabilising protocols (such as the Israeli-Jalfon
Protocol). To the best of our knowledge, this is the first fully-automatic
method that can prove liveness for randomised protocols.Comment: Full version of CAV'16 pape
Finding The Lazy Programmer's Bugs
Traditionally developers and testers created huge numbers of explicit tests, enumerating interesting cases, perhaps
biased by what they believe to be the current boundary conditions of the function being tested. Or at
least, they were supposed to.
A major step forward was the development of property testing. Property testing requires the user to write a few
functional properties that are used to generate tests, and requires an external library or tool to create test data
for the tests. As such many thousands of tests can be created for a single property. For the purely functional
programming language Haskell there are several such libraries; for example QuickCheck [CH00], SmallCheck
and Lazy SmallCheck [RNL08].
Unfortunately, property testing still requires the user to write explicit tests. Fortunately, we note there are
already many implicit tests present in programs. Developers may throw assertion errors, or the compiler may
silently insert runtime exceptions for incomplete pattern matches.
We attempt to automate the testing process using these implicit tests. Our contributions are in four main
areas: (1) We have developed algorithms to automatically infer appropriate constructors and functions needed
to generate test data without requiring additional programmer work or annotations. (2) To combine the
constructors and functions into test expressions we take advantage of Haskell's lazy evaluation semantics by
applying the techniques of needed narrowing and lazy instantiation to guide generation. (3) We keep the type
of test data at its most general, in order to prevent committing too early to monomorphic types that cause
needless wasted tests. (4) We have developed novel ways of creating Haskell case expressions to inspect elements
inside returned data structures, in order to discover exceptions that may be hidden by laziness, and to make
our test data generation algorithm more expressive.
In order to validate our claims, we have implemented these techniques in Irulan, a fully automatic tool for
generating systematic black-box unit tests for Haskell library code. We have designed Irulan to generate high
coverage test suites and detect common programming errors in the process
Pseudodeterministic lagorithms and the structure of probabilistic time
We connect the study of pseudodeterministic algorithms to two major open problems about the structural complexity of BPTIME: proving hierarchy theorems and showing the existence of complete problems. Our main contributions can be summarised as follows.
A new pseudorandom generator and its consequences. We build on techniques developed to prove hierarchy theorems for probabilistic time with advice (Fortnow and Santhanam, FOCS 2004) to construct the first unconditional pseudorandom generator of polynomial stretch computable in pseudodeterministic polynomial time (with one bit of advice) that is secure infinitely often against polynomial-time computations. As an application of this construction, we obtain new results about the complexity of generating and representing prime numbers. For instance, we show unconditionally for each ε > 0 that infinitely many primes pn have a succinct representation in the following sense: there is a fixed probabilistic polynomial time algorithm that generates pn with high probability from its succinct representation of size O(|pn|ε). This offers an exponential improvement over the running time of previous results, and shows that infinitely many primes have succinct and efficient representations.
Structural results for probabilistic time from pseudodeterministic algorithms. Oliveira and Santhanam (STOC 2017) established unconditionally that there is a pseudodeterministic algorithm for the Circuit Acceptance Probability Problem (CAPP) that runs in sub-exponential time and is correct with high probability over any samplable distribution on circuits on infinitely many input lengths. We show that improving this running time or obtaining a result that holds for every large input length would imply new time hierarchy theorems for probabilistic time. In addition, we prove that a worst-case polynomial-time pseudodeterministic algorithm for CAPP would imply that BPP has complete problems.
Equivalence between pseudodeterministic constructions and hierarchies. We establish an equivalence between a certain explicit pseudodeterministic construction problem and the existence of strong hierarchy theorems for probabilistic time. More precisely, we show that pseudodeterministically constructing in exponential time strings of large rKt complexity (Oliveira, ICALP 2019) is possible if and only if for every constructive function T(n) ≤ exp(o(exp(n))) we have BPTIME[poly(T)] ⊈ i.o.BPTIME[T]/logT.
More generally, these results suggest new approaches for designing pseudodeterministic algorithms for search problems and for unveiling the structure of probabilistic time
- …