DOCSLIB.ORG

Recent Developments on Circuit Satisfiability Algorithms

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Recent Developments on Circuit Satisfiability Algorithms Recent Developments on Circuit Satisfiability Algorithms Suguru TAMAKI Kyoto University Fine-Grained Complexity and Algorithm Design Reunion, December 14, 2016, Simons Institute, Berkeley, CA After the Fine-Grained Complexity and Algorithm OurDesign ProgramProblem (Aug. 19 – Dec. 18, 2015), many papers on Circuit SAT algorithms have been published: Chan-Williams, ``Deterministic APSP, Orthogonal Vectors, and More: Quickly Derandomizing Razborov-Smolensky,’’ SODA’16 Chen-Santhanam, ``Satisfiability on Mixed Instances,‘’ ITCS’16 Chen-Santhanam-Srinivasan, ``Average-Case Lower Bounds and Satisfiability Algorithms for Small Threshold Circuits,’’ CCC’16 Williams, ``Strong ETH Breaks With Merlin and Arthur: Short Non-Interactive Proofs of Batch Evaluation,’’ CCC’16 2 Golovnev-Kulikov-Smal-T, ``Circuit Size Lower Bounds Ourand #SATProblem Upper Bounds Through a General Framework,’’ MFCS’16 Sakai-Seto-T-Teruyama, ``Bounded Depth Circuits with Weighted Symmetric Gates: Satisfiability, Lower Bounds and Compression,’’ MFCS’16 Alman-Chan-Williams, ``Polynomial Representations of Threshold Functions and Algorithmic Applications,’’ FOCS’16 Lokshtanov-Paturi-T-Williams-Yu, ``Beating Brute Force for Systems of Polynomial Equations over Finite Fields,’’ SODA’17 T, ``A Satisfiability Algorithm for Depth Two Circuits with a Sub-Quadratic Number of Symmetric and Threshold Gates’’ …… 3 Our Problem Circuit Satisfiability (SAT) 1? Input Boolean Circuit ∧ C :{0,1}n →{0,1} ∨ ≡ Output Yes/No n ∃x ∈{0,1} ,C(x) =1 x1 + ¬ → Yes ? n x ∀x ∈{0,1} ,C(x) = 0 x2 3 x1 → No ? ? ? 4 Our Problem Circuit Satisfiability (SAT) 1 Input Boolean Circuit ∧ C :{0,1}n →{0,1} ∨ ≡ Output Yes/No n ∃x ∈{0,1} ,C(x) =1 x1 + ¬ → Yes 1 n x ∀x ∈{0,1} ,C(x) = 0 x2 3 x1 → No 0 0 1 5 Our Problem Circuit Satisfiability (SAT) Canonical NP-complete problem [Cook-Levin] ∎ Solved in time 2 × poly ( : #variables, : size of a circuit ) ∎ -SAT input only from a circuit class e.g. = ( -)CNF, AC0, AC0[ ], ACC0, TC0, NC1 (Formula),… ∎ 6 Example CNF-SAT =( -)CNF formulas (conjunctions of clauses) e.g. = ( ) (¬ ¬ ) (¬ ) CNF is -CNF1 if2 each clause2 has3 at4 most 3literals ∨ ∧ ∨ ∨ ∧ ∧ ⋯ Best known algorithms 3-CNF: 1.308 [Hertli’14, randomized] 1.331 [Makino-T-Yamamoto’13, deterministic] . ( ) -CNF: 2 [Paturi-Pudlak-Saks-Zane’05, randomized] 1 64 . (1− ) 2 [Moser-Scheder’11, deterministic] 1 44 1− 7 Hardness of Circuit SAT? (Strong) Exponential Time Hypothesis (``quantitatively strengthening’’ of P NP) [Impagliazzo-Paturi-Zane] ≠ ETH > 0, 3-CNF-SAT DTIME[2 ] SETH > 0, , -CNF-SAT DTIME[2( ) ] ∃ ∉ 1− ETH & ∀SETH are∃ widely used to∉ prove the optimality of exact, parametrized, approximation and dynamic algorithms (cf. ``fine-grained complexity’’ theory) 8 General Research Goals 1. Design non-trivial algorithms for a stronger circuit class Non-trivial: super-polynomially (or exponentially) faster than 2 Stronger circuit class: ( -)CNF AC0 AC0[ ] ACC0 TC0 NC1 … CKT ⊂ ⊂ ⊂ ⊆ ⊆ ⊆ ⊆ 2. If non-trivial algorithms exist for -SAT, then improve the running time prove the difficulty of improvement ∎ additional properties: deterministic, counting, P-space,… ∎ ∎ 9 Why Algorithms for Circuit SAT? 1. Useful SAT can encode many combinatorial problems efficiently ∎ (sometimes) inspire algorithms for other problems e.g. All-Pairs Shortest Paths (APSP) [Williams’14,…] ∎ 10 Why Algorithms for Circuit SAT? 2. Connections to circuit lower bounds (This Talk) [black box] non-trivial -SAT algorithm ⇒ NEXP [Williams’10,11,…] (NEXP: nondeterministic exponential time) ∎ ⊈ [white box] analysis of -SAT algorithm ⇒ average-case lower bounds ∎ [Santhanam’10,Seto-T’12,Chen-Kabanets-Kolokolova-Shaltiel- Zuckerman’14,…] 11 Boolean Circuit Complexity studies the power of circuit classes defined using several parameters: 2 polylogn nε #gates: O(n),O(n ),...,poly(n),...,n ,...,2 ,... Gate type: AND, OR, NOT, XOR, MOD, MAJORITY, THRESHOLD… Structure: ・fanin: 2, 3, …,const, … , unbounded ・fanout: 1, 2, …, const, …, unbounded ・depth: 2, 3, …, const, …, log n, …, polylog n, … ・graph class: tree (=formula, fan-out=1), planar, … 12 Circuit Classes ( -)CNF AC0 AC0[ ] ACC0 TC0 NC1 … CKT ( -)CNF⊂: conjunction⊂ ⊂of disjunctions⊆ ⊆ of (at⊆ most⊆ ) literals AC0: constant-depth, unbounded-fan-in, AND/OR/NOT ∎ AC0[ ]: AC0 + mod gates ( : prime power) ∎ ACC0: AC0 + mod gates ( : integer 2) ∎ TC0: constant-depth, unbounded-fan-in, ∎ ≥ linear threshold (THR) gates: sgn( ) ∎ NC1: fan-in 2, fan-out 1, AND/OR/NOT(/XOR) ∑=1 − CKT: fan-in 2, AND/OR/NOT(/XOR) ∎ : composition of and e.g. CNF=AND OR ∎ 1 2 1 2 (Note: assume #gates = poly( ) unless otherwise ∎ ∘ ∘ specified) 13 Circuit Lower Bounds Typical question: Can a family of Boolean circuits {Cn} from a circuit class compute a problem X? (Cn is an n-variate circuit for each n) Important case (NP CKT?): ・ =CKT: circuits with poly(n) number of gates ⊆ ・X=NP-complete problem, e.g., SAT, clique,… If the answer is no, then P NP (by P CKT) (Approach to P vs. NP [Sipser’s Program]) ≠ ⊊ 14 Research Frontier (-2015) … AC0[ ] ACC0 ACC0 THR TC0 NC1 … CKT ⊂ ⊂ ⊆ ∘ ⊆ ⊆ ⊆ ⊆ Non-trivial -SAT algorithm: ACC0 THR with a super-poly #gates [Williams’14] depth 2 TC0 with a linear #wires [Impagliazzo-Paturi- Schneider’13,…]∎ ∘ ∎ AC0: constant-depth, unbounded-fan-in, AND/OR/NOT ACC0: AC0 + mod gates ( : integer 2) ∎ TC0: constant-depth, unbounded-fan-in, ∎ ≥ linear threshold (THR) gates: sgn( ) ∎ 1 2: composition of 1 2 ∑=1 − ∎ ∘ ∘ 15 Research Frontier (2016) Non-trivial -SAT algorithm: ACC0 THR with a super-poly #gates [Williams’14] depth 2 TC0 with a linear #wires [Impagliazzo-Paturi- Schneider’13,…]∎ ∘ ∎ New Results! (Note: #gates #wires) ( ) (1) depth TC0 with #wires / [Chen-Santhanam- ≤ Srinivasan’16] 1+1 2 (2) depth 2 TC0 with #gates ≪ . [Alman-Chan-Williams’16, T] (3) depth 3 TC0 with #gates 1.99, where the top gate is ≪ unweighted majority [ACW’16] 1 19 (4) Extensions of (2) to ACC0≪THR THR and (3) to MAJ AC0 THR AC0 THR with corresponding restrictions [ACW’16] ∘ ∘ 16 ∘ ∘ ∘ ∘ Research Frontier (-2015) … AC0[ ] ACC0 ACC0 THR TC0 NC1 … CKT Lower⊂ Bounds ⊂ for ⊆: ∘ ⊆ ⊆ ⊆ ⊆ majority, mod AC0[ ] [Razborov’87,Smolensky’87] NEXP ACC0 THR [Williams’14] ∎ ∉ 0 / parity depth TC with #wires ∎ ⊈ ∘ inner product depth TC0 with #gates1+1 3 ∎ ∉ ≪ [Impagliazzo-Paturi-Saks’93,Gröger-Turán’91] ∉ ≪ AC0[ ]: AC0 + mod gates ( : prime power) ACC0: AC0 + mod gates ( : integer 2) ∎ TC0: constant-depth, unbounded-fan-in, ∎ ≥ linear threshold (THR) gates: sgn( ) ∎ 1 2: composition of 1 2 ∑=1 − 17 ∎ ∘ ∘ Research Frontier (2016) Lower Bounds for : NEXP ACC0 THR [Williams’14] 0 / parity depth TC with #wires ∎ ⊈ ∘ inner product depth TC0 with #gates1+1 3 ∎ ∉ ≪ [Impagliazzo-Paturi-Saks’93,Gröger-Turán’91] ∉ ≪ New Results! [Kane-Williams’16] (1) P s.t. depth 2 TC0 with #wires . or #gates . ∃ ∈ ∉ (2) P s.t.2 49 depth 3 TC0 with1 49 ≪ ≪ #wires . or #gates . ∃ ∈ ∉ where the top2 49 gate is unweighted1 49 majority ≪ ≪ 18 Research Frontier (2016) Lower Bounds for : NEXP ACC0 THR [Williams’14] 0 / parity depth TC with #wires ∎ ⊈ ∘ inner product depth TC0 with #gates1+1 3 ∎ ∉ ≪ [Impagliazzo-Paturi-Saks’93,Gröger-Turán’91] ∉ ≪ New Results! (consequences of non-trivial SAT algorithms) (1) E s.t. depth 2 TC0 with #gates . [Alman- Chan-Williams’16,NP T] 1 99 cf. ∃ ∈P, #gates ∉ . [Kane-Williams’16] ≪ (2) Extensions of (1) to1 49 ACC0 THR THR with corresponding restrictions∃ ∈ [ACW’16≪] ∘ ∘ 19 Algorithm Design Paradigms Paradigm 1: Restrict and Simplify (Divide and Conquer) Step 1 Construct a partition (or covering) = {0,1} based on the input Step1 ∪ 2 2 For∪ ⋯ each , simplify | and check the satisfiability of it (recursively or by another algorithm) Typically is a subcube, affine subspace, solution space of polynomial equations etc. 20 Algorithm Design Paradigms Paradigm 2: Polynomial Method (Low Rank Decomposition) Step 1 Take a ``big OR’’ of the input : ( , ) , ′ ′ Step 2≔ Represent∨∈ 0 1 as , = ( ( ) ( )) ′ ′/ ′ for some , : 0,1 and : =1 0,1 ′ 푦푦 ℎ ∑ 푦 푦푦 − 2 Step 3 Define 2 / × and→ × 2ℎ →/ matrices ′ ′ − 2 − 2 , , ( ) , Note that ( ′ ) ′′ = ( ) ( ) ′ ≔ , ≔ 푦푦 i.e. the truth table of is obtained via rectangular matrix ′ ∑=1 푦 푦푦 multiplication (with applied′ later) 21 ℎ A Glance at Some Recent -SAT algorithms 22 Some Recent -SAT algorithms Attempts to handle TC0 (probably ACC0 THR) depth 2 TC0 with a sub-quadratic #gates ⊈ ∘ AC0 with a limited #symmetric gates: ( ) ∎ ∎ ∑=1 Faster algorithms within AC0[ ] ( ACC0 THR) Systems of degree Polynomial Equations over GF( ) ⊆ ∘ AND XOR AND XOR ∎ AC0[ ] ∎ ∘ ∘ ∘ ∎ 23 Depth 2 TC0 with a sub-quadratic #gates 24 Motivation Think about interesting TC0 ACC0 THR i.e. = depth 2 TC0 with #gates = ( ) ⊂ ∖ ∘ (Note: ACC0 THR is unknown) Open question ⊈ until∘ 2015 0 E s.t. depth-2 TC with #gates = ( ) NP ∃ (E∈ : languages ∉ computable by ( ) 2 NP -time Turing machines with NP oracle) Possible Attack Non-trivial deterministic algorithms for E [Ben-Sasson-Viola’14] NP ⇒ ⊈ 25 Recent -SAT algorithms (1) Theorem [Alman-Chan-Williams’16, T]: Let = depth 2 TC0 with #gates = There is a deterministic algorithm for # -SAT that runs in time poly( , ) 2 ( , ), , = / / − , > 0 where 1 2+ 1 Ω ∃ Corollary: E s.t. holds with = ( . ) NP 1 99 ∃ ∈ ∉ Note: These results are incomparable with [Chen-Santhanam-Srinivasan’16,Kane-Williams’16] 26 Sketch of the Proof by [T] based on the Polynomial Method in Circuit Complexity follow the framework for ACC0 THR [Williams’14] probabilistic
Load more

Recommended publications
  • Week 1: an Overview of Circuit Complexity 1 Welcome 2
    Topics in Circuit Complexity (CS354, Fall’11) Week 1: An Overview of Circuit Complexity Lecture Notes for 9/27 and 9/29 Ryan Williams 1 Welcome The area of circuit complexity has a long history, starting in the 1940’s. It is full of open problems and frontiers that seem insurmountable, yet the literature on circuit complexity is fairly large. There is much that we do know, although it is scattered across several textbooks and academic papers. I think now is a good time to look again at circuit complexity with fresh eyes, and try to see what can be done. 2 Preliminaries An n-bit Boolean function has domain f0; 1gn and co-domain f0; 1g. At a high level, the basic question asked in circuit complexity is: given a collection of “simple functions” and a target Boolean function f, how efficiently can f be computed (on all inputs) using the simple functions? Of course, efficiency can be measured in many ways. The most natural measure is that of the “size” of computation: how many copies of these simple functions are necessary to compute f? Let B be a set of Boolean functions, which we call a basis set. The fan-in of a function g 2 B is the number of inputs that g takes. (Typical choices are fan-in 2, or unbounded fan-in, meaning that g can take any number of inputs.) We define a circuit C with n inputs and size s over a basis B, as follows. C consists of a directed acyclic graph (DAG) of s + n + 2 nodes, with n sources and one sink (the sth node in some fixed topological order on the nodes).
    [Show full text]
  • The Complexity Zoo
    The Complexity Zoo Scott Aaronson www.ScottAaronson.com LATEX Translation by Chris Bourke [email protected] 417 classes and counting 1 Contents 1 About This Document 3 2 Introductory Essay 4 2.1 Recommended Further Reading ......................... 4 2.2 Other Theory Compendia ............................ 5 2.3 Errors? ....................................... 5 3 Pronunciation Guide 6 4 Complexity Classes 10 5 Special Zoo Exhibit: Classes of Quantum States and Probability Distribu- tions 110 6 Acknowledgements 116 7 Bibliography 117 2 1 About This Document What is this? Well its a PDF version of the website www.ComplexityZoo.com typeset in LATEX using the complexity package. Well, what’s that? The original Complexity Zoo is a website created by Scott Aaronson which contains a (more or less) comprehensive list of Complexity Classes studied in the area of theoretical computer science known as Computa- tional Complexity. I took on the (mostly painless, thank god for regular expressions) task of translating the Zoo’s HTML code to LATEX for two reasons. First, as a regular Zoo patron, I thought, “what better way to honor such an endeavor than to spruce up the cages a bit and typeset them all in beautiful LATEX.” Second, I thought it would be a perfect project to develop complexity, a LATEX pack- age I’ve created that defines commands to typeset (almost) all of the complexity classes you’ll find here (along with some handy options that allow you to conveniently change the fonts with a single option parameters). To get the package, visit my own home page at http://www.cse.unl.edu/~cbourke/.
    [Show full text]
  • Glossary of Complexity Classes
    App endix A Glossary of Complexity Classes Summary This glossary includes selfcontained denitions of most complexity classes mentioned in the b o ok Needless to say the glossary oers a very minimal discussion of these classes and the reader is re ferred to the main text for further discussion The items are organized by topics rather than by alphab etic order Sp ecically the glossary is partitioned into two parts dealing separately with complexity classes that are dened in terms of algorithms and their resources ie time and space complexity of Turing machines and complexity classes de ned in terms of nonuniform circuits and referring to their size and depth The algorithmic classes include timecomplexity based classes such as P NP coNP BPP RP coRP PH E EXP and NEXP and the space complexity classes L NL RL and P S P AC E The non k uniform classes include the circuit classes P p oly as well as NC and k AC Denitions and basic results regarding many other complexity classes are available at the constantly evolving Complexity Zoo A Preliminaries Complexity classes are sets of computational problems where each class contains problems that can b e solved with sp ecic computational resources To dene a complexity class one sp ecies a mo del of computation a complexity measure like time or space which is always measured as a function of the input length and a b ound on the complexity of problems in the class We follow the tradition of fo cusing on decision problems but refer to these problems using the terminology of promise problems
    [Show full text]
  • Interactive Oracle Proofs with Constant Rate and Query Complexity∗†
    Interactive Oracle Proofs with Constant Rate and Query Complexity∗† Eli Ben-Sasson1, Alessandro Chiesa2, Ariel Gabizon‡3, Michael Riabzev4, and Nicholas Spooner5 1 Technion, Haifa, Israel [email protected] 2 University of California, Berkeley, CA, USA [email protected] 3 Zerocoin Electronic Coin Company (Zcash), Boulder, CO, USA [email protected] 4 Technion, Haifa, Israel [email protected] 5 University of Toronto, Toronto, Canada [email protected] Abstract We study interactive oracle proofs (IOPs) [7, 43], which combine aspects of probabilistically check- able proofs (PCPs) and interactive proofs (IPs). We present IOP constructions and techniques that let us achieve tradeoffs in proof length versus query complexity that are not known to be achievable via PCPs or IPs alone. Our main results are: 1. Circuit satisfiability has 3-round IOPs with linear proof length (counted in bits) and constant query complexity. 2. Reed–Solomon codes have 2-round IOPs of proximity with linear proof length and constant query complexity. 3. Tensor product codes have 1-round IOPs of proximity with sublinear proof length and constant query complexity. (A familiar example of a tensor product code is the Reed–Muller code with a bound on individual degrees.) For all the above, known PCP constructions give quasilinear proof length and constant query complexity [12, 16]. Also, for circuit satisfiability, [10] obtain PCPs with linear proof length but sublinear (and super-constant) query complexity. As in [10], we rely on algebraic-geometry codes to obtain our first result; but, unlike that work, our use of such codes is much “lighter” because we do not rely on any automorphisms of the code.
    [Show full text]
  • User's Guide for Complexity: a LATEX Package, Version 0.80
    User’s Guide for complexity: a LATEX package, Version 0.80 Chris Bourke April 12, 2007 Contents 1 Introduction 2 1.1 What is complexity? ......................... 2 1.2 Why a complexity package? ..................... 2 2 Installation 2 3 Package Options 3 3.1 Mode Options .............................. 3 3.2 Font Options .............................. 4 3.2.1 The small Option ....................... 4 4 Using the Package 6 4.1 Overridden Commands ......................... 6 4.2 Special Commands ........................... 6 4.3 Function Commands .......................... 6 4.4 Language Commands .......................... 7 4.5 Complete List of Class Commands .................. 8 5 Customization 15 5.1 Class Commands ............................ 15 1 5.2 Language Commands .......................... 16 5.3 Function Commands .......................... 17 6 Extended Example 17 7 Feedback 18 7.1 Acknowledgements ........................... 19 1 Introduction 1.1 What is complexity? complexity is a LATEX package that typesets computational complexity classes such as P (deterministic polynomial time) and NP (nondeterministic polynomial time) as well as sets (languages) such as SAT (satisfiability). In all, over 350 commands are defined for helping you to typeset Computational Complexity con- structs. 1.2 Why a complexity package? A better question is why not? Complexity theory is a more recent, though mature area of Theoretical Computer Science. Each researcher seems to have his or her own preferences as to how to typeset Complexity Classes and has built up their own personal LATEX commands file. This can be frustrating, to say the least, when it comes to collaborations or when one has to go through an entire series of files changing commands for compatibility or to get exactly the look they want (or what may be required).
    [Show full text]
  • A Short History of Computational Complexity
    The Computational Complexity Column by Lance FORTNOW NEC Laboratories America 4 Independence Way, Princeton, NJ 08540, USA [email protected] http://www.neci.nj.nec.com/homepages/fortnow/beatcs Every third year the Conference on Computational Complexity is held in Europe and this summer the University of Aarhus (Denmark) will host the meeting July 7-10. More details at the conference web page http://www.computationalcomplexity.org This month we present a historical view of computational complexity written by Steve Homer and myself. This is a preliminary version of a chapter to be included in an upcoming North-Holland Handbook of the History of Mathematical Logic edited by Dirk van Dalen, John Dawson and Aki Kanamori. A Short History of Computational Complexity Lance Fortnow1 Steve Homer2 NEC Research Institute Computer Science Department 4 Independence Way Boston University Princeton, NJ 08540 111 Cummington Street Boston, MA 02215 1 Introduction It all started with a machine. In 1936, Turing developed his theoretical com- putational model. He based his model on how he perceived mathematicians think. As digital computers were developed in the 40's and 50's, the Turing machine proved itself as the right theoretical model for computation. Quickly though we discovered that the basic Turing machine model fails to account for the amount of time or memory needed by a computer, a critical issue today but even more so in those early days of computing. The key idea to measure time and space as a function of the length of the input came in the early 1960's by Hartmanis and Stearns.
    [Show full text]
  • TC Circuits for Algorithmic Problems in Nilpotent Groups
    TC0 Circuits for Algorithmic Problems in Nilpotent Groups Alexei Myasnikov1 and Armin Weiß2 1 Stevens Institute of Technology, Hoboken, NJ, USA 2 Universität Stuttgart, Germany Abstract Recently, Macdonald et. al. showed that many algorithmic problems for finitely generated nilpo- tent groups including computation of normal forms, the subgroup membership problem, the con- jugacy problem, and computation of subgroup presentations can be done in LOGSPACE. Here we follow their approach and show that all these problems are complete for the uniform circuit class TC0 – uniformly for all r-generated nilpotent groups of class at most c for fixed r and c. Moreover, if we allow a certain binary representation of the inputs, then the word problem and computation of normal forms is still in uniform TC0, while all the other problems we examine are shown to be TC0-Turing reducible to the problem of computing greatest common divisors and expressing them as linear combinations. 1998 ACM Subject Classification F.2.2 Nonnumerical Algorithms and Problems, G.2.0 Discrete Mathematics Keywords and phrases nilpotent groups, TC0, abelian groups, word problem, conjugacy problem, subgroup membership problem, greatest common divisors Digital Object Identifier 10.4230/LIPIcs.MFCS.2017.23 1 Introduction The word problem (given a word over the generators, does it represent the identity?) is one of the fundamental algorithmic problems in group theory introduced by Dehn in 1911 [3]. While for general finitely presented groups all these problems are undecidable [22, 2], for many particular classes of groups decidability results have been established – not just for the word problem but also for a wide range of other problems.
    [Show full text]
  • Limits to Parallel Computation: P-Completeness Theory
    Limits to Parallel Computation: P-Completeness Theory RAYMOND GREENLAW University of New Hampshire H. JAMES HOOVER University of Alberta WALTER L. RUZZO University of Washington New York Oxford OXFORD UNIVERSITY PRESS 1995 This book is dedicated to our families, who already know that life is inherently sequential. Preface This book is an introduction to the rapidly growing theory of P- completeness — the branch of complexity theory that focuses on identifying the “hardest” problems in the class P of problems solv- able in polynomial time. P-complete problems are of interest because they all appear to lack highly parallel solutions. That is, algorithm designers have failed to find NC algorithms, feasible highly parallel solutions that take time polynomial in the logarithm of the problem size while using only a polynomial number of processors, for them. Consequently, the promise of parallel computation, namely that ap- plying more processors to a problem can greatly speed its solution, appears to be broken by the entire class of P-complete problems. This state of affairs is succinctly expressed as the following question: Does P equal NC ? Organization of the Material The book is organized into two parts: an introduction to P- completeness theory, and a catalog of P-complete and open prob- lems. The first part of the book is a thorough introduction to the theory of P-completeness. We begin with an informal introduction. Then we discuss the major parallel models of computation, describe the classes NC and P, and present the notions of reducibility and com- pleteness. We subsequently introduce some fundamental P-complete problems, followed by evidence suggesting why NC does not equal P.
    [Show full text]
  • Some NP-Complete Problems
    Appendix A Some NP-Complete Problems To ask the hard question is simple. But what does it mean? What are we going to do? W.H. Auden In this appendix we present a brief list of NP-complete problems; we restrict ourselves to problems which either were mentioned before or are closely re- lated to subjects treated in the book. A much more extensive list can be found in Garey and Johnson [GarJo79]. Chinese postman (cf. Sect. 14.5) Let G =(V,A,E) be a mixed graph, where A is the set of directed edges and E the set of undirected edges of G. Moreover, let w be a nonnegative length function on A ∪ E,andc be a positive number. Does there exist a cycle of length at most c in G which contains each edge at least once and which uses the edges in A according to their given orientation? This problem was shown to be NP-complete by Papadimitriou [Pap76], even when G is a planar graph with maximal degree 3 and w(e) = 1 for all edges e. However, it is polynomial for graphs and digraphs; that is, if either A = ∅ or E = ∅. See Theorem 14.5.4 and Exercise 14.5.6. Chromatic index (cf. Sect. 9.3) Let G be a graph. Is it possible to color the edges of G with k colors, that is, does χ(G) ≤ k hold? Holyer [Hol81] proved that this problem is NP-complete for each k ≥ 3; this holds even for the special case where k =3 and G is 3-regular.
    [Show full text]
  • Descriptive Complexity: a Logicians Approach to Computation
    Descriptive Complexity: A Logician’s Approach to Computation N. Immerman basic issue in computer science is there are exponentially many possibilities, the complexity of problems. If one is but in this case no known algorithm is faster doing a calculation once on a than exponential time. medium-sized input, the simplest al- Computational complexity measures how gorithm may be the best method to much time and/or memory space is needed as Ause, even if it is not the fastest. However, when a function of the input size. Let TIME[t(n)] be the one has a subproblem that will have to be solved set of problems that can be solved by algorithms millions of times, optimization is important. A that perform at most O(t(n)) steps for inputs of fundamental issue in theoretical computer sci- size n. The complexity class polynomial time (P) ence is the computational complexity of prob- is the set of problems that are solvable in time lems. How much time and how much memory at most some polynomial in n. space is needed to solve a particular problem? ∞ Here are a few examples of such problems: P= TIME[nk] 1. Reachability: Given a directed graph and k[=1 two specified points s,t, determine if there Even though the class TIME[t(n)] is sensitive is a path from s to t. A simple, linear-time to the exact machine model used in the com- algorithm marks s and then continues to putations, the class P is quite robust. The prob- mark every vertex at the head of an edge lems Reachability and Min-triangulation are el- whose tail is marked.
    [Show full text]
  • Circuit Complexity and Computational Complexity
    Circuit Complexity and Computational Complexity Lecture Notes for Math 267AB University of California, San Diego January{June 1992 Instructor: Sam Buss Notes by: Frank Baeuerle Sam Buss Bob Carragher Matt Clegg Goran Gogi¶c Elias Koutsoupias John Lillis Dave Robinson Jinghui Yang 1 These lecture notes were written for a topics course in the Mathematics Department at the University of California, San Diego during the winter and spring quarters of 1992. Each student wrote lecture notes for between two and ¯ve one and one half hour lectures. I'd like to thank the students for a superb job of writing up lecture notes. January 9-14. Bob Carragher's notes on Introduction to circuit complexity. Theorems of Shannon and Lupanov giving upper and lower bounds of circuit complexity of almost all Boolean functions. January 14-21. Matt Clegg's notes on Spira's theorem relating depth and formula size Krapchenko's lower bound on formula size over AND/OR/NOT January 23-28. Frank Baeuerle's notes on Neciporuk's theorem Simulation of time bounded TM's by circuits January 30 - February 4. John Lillis's notes on NC/AC hierarchy Circuit value problem Depth restricted circuits for space bounded Turing machines Addition is in NC1. February 6-13. Goran Gogi¶c's notes on Circuits for parallel pre¯x vector addition and for symmetric functions. February 18-20. Dave Robinson's notes on Schnorr's 2n-3 lower bound on circuit size Blum's 3n-o(n) lower bound on circuit size February 25-27. Jinghui Yang's notes on Subbotovskaya's theorem Andreev's n2:5 lower bound on formula size with AND/OR/NOT.
    [Show full text]
  • 7. Overview of Modern QMC Algorithms
    7. Overview of modern QMC algorithms Friday, 9 July 2010 Modern Monte Carlo algorithms • Which system sizes can be studied? temperature local updates modern algorithms 3D Tc 16’000 spins 16’000’000 spins 0.1 J 200 spins 1’000’000 spins 0.005 J ––– 50’000 spins 3D Tc 32 bosons 1’000’000 bosons 0.1 t 32 bosons 10’000 bosons Friday, 9 July 2010 When to use SSE? • For quantum magnets • loop cluster algorithm if there is spin inversion symmetry • directed loops if there is no spin inversion symmetry • For hardcore bosons: • loop cluster algorithm if there is particle-hole symmetry • directed loops if there is no particle-hole symmetry • Which models? • 2-site interactions are rather straightforward • multi-site interactions require more thought Friday, 9 July 2010 When to use path integrals? • For Bose-Hubbard models • Use the worm algorithm in continuous time path integrals • This expands only in the hopping t and not the much larger repulsion U • For non-local in time actions • Appear in dissipative (Caldeira-Legget type) models, coupling to phonons, DMFT, ... • Cluster algorithms are again possible in case of spin-inversion symmetry Friday, 9 July 2010 8. Wang-Landau sampling and optimized ensembles for quantum systems Friday, 9 July 2010 First order phase transitions Tunneling out of meta-stable state is suppressed exponentially liquid gas gas liquid τ ∝exp(−cLd −1 /T) P Critical slowing down solved by cluster updates liquid How can we tunnel critical ? point out of metastable state? gas T Friday, 9 July 2010 First order phase transitions • Tunneling problem at a first order phase transition is solved by changing the ensemble to create a flat energy landscape • Multicanonical sampling (Berg and Neuhaus, Phys.
    [Show full text]