DOCSLIB.ORG

Approximations of Consistent Query Answers 1

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Approximations of Consistent Query Answers 1 Approximations of Consistent Query Answers 1 Jef Wijsen UMONS DaQuaTa International Workshop 2016 Lyon, 12{13 December 2016 1Joint work with Floris Geerts, Paris Koutris, and Fabian Pijcke Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 1 / 54 Outline 1 Motivation 2 On the Complexity of Embracing Primary Key Violations 3 First-Order Under-Approximations Of Consistent Query Answers 4 Beyond (Un)certainty: Counts and Probabilities 5 Attack Graphs, a Complexity Classification Tool 6 Final Thoughts Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 2 / 54 Outline 1 Motivation 2 On the Complexity of Embracing Primary Key Violations 3 First-Order Under-Approximations Of Consistent Query Answers 4 Beyond (Un)certainty: Counts and Probabilities 5 Attack Graphs, a Complexity Classification Tool 6 Final Thoughts Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 3 / 54 Data Quality Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 4 / 54 Data Quality Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 4 / 54 Consistent and Complete Relational Database Integrity constraints are satisfied. The database contains all (and only) the facts that are true (Closed-World Assumption). No missing values. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 5 / 54 Dealing with Imperfect Data It is common to have inconsistent data, incomplete data, missing data, uncertain data. What can we do with this data? Some data quality problems already have principled solutions: incomplete data [IJ84], NULLs in SQL [Lib16]. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 6 / 54 Dealing with Imperfect Data It is common to have inconsistent data, incomplete data, missing data, uncertain data. What can we do with this data? Some data quality problems already have principled solutions: incomplete data [IJ84], NULLs in SQL [Lib16]. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 6 / 54 Dealing with Imperfect Data It is common to have inconsistent data, incomplete data, missing data, uncertain data. What can we do with this data? Some data quality problems already have principled solutions: incomplete data [IJ84], NULLs in SQL [Lib16]. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 6 / 54 Dealing with Imperfect Data It is common to have inconsistent data, incomplete data, missing data, uncertain data. What can we do with this data? Some data quality problems already have principled solutions: incomplete data [IJ84], NULLs in SQL [Lib16]. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 6 / 54 Dealing with Imperfect Data It is common to have inconsistent data, incomplete data, missing data, uncertain data. What can we do with this data? Some data quality problems already have principled solutions: incomplete data [IJ84], NULLs in SQL [Lib16]. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 6 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL | ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL | ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL M ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL M ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL M ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL M ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Embrace Imperfections Example P PID FirstName LastName BloodType Gendre ··· 1 John Adams NULL M ··· 2 Jan Peeters A+ M ··· 3 Jean Dubois A+ M ··· 3 Jean Dubois AB+ M ··· Caveat If we embrace imperfections, we should rethink query answering. For example, what should be the answer to the following queries? SELECT COUNT(DISTINCT PID) SELECT COUNT(DISTINCT PID) FROM P FROM P WHERE BloodType=`A+'; WHERE BloodType<>`A+'; Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 7 / 54 Outline 1 Motivation 2 On the Complexity of Embracing Primary Key Violations 3 First-Order Under-Approximations Of Consistent Query Answers 4 Beyond (Un)certainty: Counts and Probabilities 5 Attack Graphs, a Complexity Classification Tool 6 Final Thoughts Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 8 / 54 Embrace Primary Key Violations Data model We allow (primary) key violations. Example (Keys are underlined) WorksFor Agent Dept ManagedBy Dept Mgr Budget Sherlock MI6 CIA John 60M James CIA MI6 Alex 60M James MI6 =) James works for either CIA or MI6. Definition (Block) A block is a maximal set of tuples of the same relation with the same value for the key. (Blocks are separated by dashed lines.) Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 9 / 54 Embrace Primary Key Violations Data model We allow (primary) key violations. Example (Keys are underlined) WorksFor Agent Dept ManagedBy Dept Mgr Budget Sherlock MI6 CIA John 60M James CIA MI6 Alex 60M James MI6 =) James works for either CIA or MI6. Definition (Block) A block is a maximal set of tuples of the same relation with the same value for the key. (Blocks are separated by dashed lines.) Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 9 / 54 Certainty Semantics Definition (Repair and Certainty) A repair is obtained by selecting exactly one tuple from each block. A Boolean query is certain if it is true in all repairs. Certainty semantics WorksFor Agent Dept ManagedBy Dept Mgr Budget Sherlock MI6 CIA John 60M James CIA MI6 Alex 60M James MI6 Is the budget of James' department equal to 60M? 9d9m (WorksFor(`James'; d) ^ ManagedBy(d; m; `60M')) is certain. Is James' department managed by Alex? 9d9b (WorksFor(`James'; d) ^ ManagedBy(d; `Alex'; b)) is not certain. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 10 / 54 Certainty Semantics Definition (Repair and Certainty) A repair is obtained by selecting exactly one tuple from each block. A Boolean query is certain if it is true in all repairs. Certainty semantics WorksFor Agent Dept ManagedBy Dept Mgr Budget Sherlock MI6 CIA John 60M James CIA MI6 Alex 60M James MI6 Is the budget of James' department equal to 60M? 9d9m (WorksFor(`James'; d) ^ ManagedBy(d; m; `60M')) is certain. Is James' department managed by Alex? 9d9b (WorksFor(`James'; d) ^ ManagedBy(d; `Alex'; b)) is not certain. Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 10 / 54 The Computational Complexity of Deciding Certainty I Relation with exponentially many repairs WorksFor Agent Dept 1 MI6 1 CIA This WorksFor relation contains 2n 2 MI6 p 2n 2 CIA tuples and has 2 distinct . repairs. n MI6 n CIA Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 11 / 54 The Computational Complexity of Deciding Certainty II Example of Low Complexity Let q1 = 9d9b (WorksFor(`James'; d) ^ ManagedBy(d; `Alex'; b)) For example, q1 is certain in the following database: ManagedBy Dept Mgr Budget WorksFor Agent Dept CIA Alex 50M James CIA CIA Alex 60M James MI6 MI6 Alex 60M One can verify that q1 is certain iff the following query is true: 9d WorksFor(`James'; d) ^ 8dWorksFor(`James'; d) ! 9m9b[ManagedBy(d; m; b) ^ 8m8b(ManagedBy(d; m; b) ! m = `Alex')] Jef Wijsen (UMONS) Approximations of CQA DaQuaTa 2016 12 / 54 The Computational Complexity of Deciding Certainty II Example of Low Complexity Let q1 = 9d9b (WorksFor(`James'; d) ^ ManagedBy(d; `Alex'; b))
Load more

Recommended publications
  • Computational Complexity: a Modern Approach
    i Computational Complexity: A Modern Approach Draft of a book: Dated January 2007 Comments welcome! Sanjeev Arora and Boaz Barak Princeton University [email protected] Not to be reproduced or distributed without the authors’ permission This is an Internet draft. Some chapters are more finished than others. References and attributions are very preliminary and we apologize in advance for any omissions (but hope you will nevertheless point them out to us). Please send us bugs, typos, missing references or general comments to [email protected] — Thank You!! DRAFT ii DRAFT Chapter 9 Complexity of counting “It is an empirical fact that for many combinatorial problems the detection of the existence of a solution is easy, yet no computationally efficient method is known for counting their number.... for a variety of problems this phenomenon can be explained.” L. Valiant 1979 The class NP captures the difficulty of finding certificates. However, in many contexts, one is interested not just in a single certificate, but actually counting the number of certificates. This chapter studies #P, (pronounced “sharp p”), a complexity class that captures this notion. Counting problems arise in diverse fields, often in situations having to do with estimations of probability. Examples include statistical estimation, statistical physics, network design, and more. Counting problems are also studied in a field of mathematics called enumerative combinatorics, which tries to obtain closed-form mathematical expressions for counting problems. To give an example, in the 19th century Kirchoff showed how to count the number of spanning trees in a graph using a simple determinant computation. Results in this chapter will show that for many natural counting problems, such efficiently computable expressions are unlikely to exist.
    [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]
  • 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]
  • The Classes FNP and TFNP
    Outline The classes FNP and TFNP C. Wilson1 1Lane Department of Computer Science and Electrical Engineering West Virginia University Christopher Wilson Function Problems Outline Outline 1 Function Problems defined What are Function Problems? FSAT Defined TSP Defined 2 Relationship between Function and Decision Problems RL Defined Reductions between Function Problems 3 Total Functions Defined Total Functions Defined FACTORING HAPPYNET ANOTHER HAMILTON CYCLE Christopher Wilson Function Problems Outline Outline 1 Function Problems defined What are Function Problems? FSAT Defined TSP Defined 2 Relationship between Function and Decision Problems RL Defined Reductions between Function Problems 3 Total Functions Defined Total Functions Defined FACTORING HAPPYNET ANOTHER HAMILTON CYCLE Christopher Wilson Function Problems Outline Outline 1 Function Problems defined What are Function Problems? FSAT Defined TSP Defined 2 Relationship between Function and Decision Problems RL Defined Reductions between Function Problems 3 Total Functions Defined Total Functions Defined FACTORING HAPPYNET ANOTHER HAMILTON CYCLE Christopher Wilson Function Problems Function Problems What are Function Problems? Function Problems FSAT Defined Total Functions TSP Defined Outline 1 Function Problems defined What are Function Problems? FSAT Defined TSP Defined 2 Relationship between Function and Decision Problems RL Defined Reductions between Function Problems 3 Total Functions Defined Total Functions Defined FACTORING HAPPYNET ANOTHER HAMILTON CYCLE Christopher Wilson Function Problems Function
    [Show full text]
  • Total Functions in the Polynomial Hierarchy 11
    Electronic Colloquium on Computational Complexity, Report No. 153 (2020) TOTAL FUNCTIONS IN THE POLYNOMIAL HIERARCHY ROBERT KLEINBERG∗, DANIEL MITROPOLSKYy, AND CHRISTOS PAPADIMITRIOUy Abstract. We identify several genres of search problems beyond NP for which existence of solutions is guaranteed. One class that seems especially rich in such problems is PEPP (for “polynomial empty pigeonhole principle”), which includes problems related to existence theorems proved through the union bound, such as finding a bit string that is far from all codewords, finding an explicit rigid matrix, as well as a problem we call Complexity, capturing Complexity Theory’s quest. When the union bound is generous, in that solutions constitute at least a polynomial fraction of the domain, we have a family of seemingly weaker classes α-PEPP, which are inside FPNPjpoly. Higher in the hierarchy, we identify the constructive version of the Sauer- Shelah lemma and the appropriate generalization of PPP that contains it. The resulting total function hierarchy turns out to be more stable than the polynomial hierarchy: it is known that, under oracles, total functions within FNP may be easy, but total functions a level higher may still be harder than FPNP. 1. Introduction The complexity of total functions has emerged over the past three decades as an intriguing and productive branch of Complexity Theory. Subclasses of TFNP, the set of all total functions in FNP, have been defined and studied: PLS, PPP, PPA, PPAD, PPADS, and CLS. These classes are replete with natural problems, several of which turned out to be complete for the corresponding class, see e.g.
    [Show full text]
  • Optimisation Function Problems FNP and FP
    Complexity Theory 99 Complexity Theory 100 Optimisation The Travelling Salesman Problem was originally conceived of as an This is still reasonable, as we are establishing the difficulty of the optimisation problem problems. to find a minimum cost tour. A polynomial time solution to the optimisation version would give We forced it into the mould of a decision problem { TSP { in order a polynomial time solution to the decision problem. to fit it into our theory of NP-completeness. Also, a polynomial time solution to the decision problem would allow a polynomial time algorithm for finding the optimal value, CLIQUE Similar arguments can be made about the problems and using binary search, if necessary. IND. Anuj Dawar May 21, 2007 Anuj Dawar May 21, 2007 Complexity Theory 101 Complexity Theory 102 Function Problems FNP and FP Still, there is something interesting to be said for function problems A function which, for any given Boolean expression φ, gives a arising from NP problems. satisfying truth assignment if φ is satisfiable, and returns \no" Suppose otherwise, is a witness function for SAT. L = fx j 9yR(x; y)g If any witness function for SAT is computable in polynomial time, where R is a polynomially-balanced, polynomial time decidable then P = NP. relation. If P = NP, then for every language in NP, some witness function is A witness function for L is any function f such that: computable in polynomial time, by a binary search algorithm. • if x 2 L, then f(x) = y for some y such that R(x; y); P = NP if, and only if, FNP = FP • f(x) = \no" otherwise.
    [Show full text]
  • On Total Functions, Existence Theorems and Computational Complexity
    Theoretical Computer Science 81 (1991) 317-324 Elsevier Note On total functions, existence theorems and computational complexity Nimrod Megiddo IBM Almaden Research Center, 650 Harry Road, Sun Jose, CA 95120-6099, USA, and School of Mathematical Sciences, Tel Aviv University, Tel Aviv, Israel Christos H. Papadimitriou* Computer Technology Institute, Patras, Greece, and University of California at Sun Diego, CA, USA Communicated by M. Nivat Received October 1989 Abstract Megiddo, N. and C.H. Papadimitriou, On total functions, existence theorems and computational complexity (Note), Theoretical Computer Science 81 (1991) 317-324. wondeterministic multivalued functions with values that are polynomially verifiable and guaran- teed to exist form an interesting complexity class between P and NP. We show that this class, which we call TFNP, contains a host of important problems, whose membership in P is currently not known. These include, besides factoring, local optimization, Brouwer's fixed points, a computa- tional version of Sperner's Lemma, bimatrix equilibria in games, and linear complementarity for P-matrices. 1. The class TFNP Let 2 be an alphabet with two or more symbols, and suppose that R G E*x 2" is a polynomial-time recognizable relation which is polynomially balanced, that is, (x,y) E R implies that lyl sp(lx()for some polynomial p. * Research supported by an ESPRIT Basic Research Project, a grant to the Universities of Patras and Bonn by the Volkswagen Foundation, and an NSF Grant. Research partially performed while the author was visiting the IBM Almaden Research Center. 0304-3975/91/$03.50 @ 1991-Elsevier Science Publishers B.V.
    [Show full text]
  • Finding Diverse and Similar Solutions in Constraint Programming
    Finding Diverse and Similar Solutions in Constraint Programming Emmanuel Hebrard Brahim Hnich Barry O’Sullivan Toby Walsh NICTA and UNSW University College Cork University College Cork NICTA and UNSW Sydney, Australia Ireland Ireland Sydney, Australia [email protected] [email protected] [email protected] [email protected] Abstract Parkes, & Roy 1998). Finally, suppose you are trying to ac- It is useful in a wide range of situations to find solutions quire constraints interactively. You ask the user to look at which are diverse (or similar) to each other. We therefore solutions and propose additional constraints to rule out in- define a number of different classes of diversity and simi- feasible or undesirable solutions. To speed up this process, larity problems. For example, what is the most diverse set it may help if each solution is as different as possible from of solutions of a constraint satisfaction problem with a given previously seen solutions. cardinality? We first determine the computational complexity In this paper, we introduce several new problems classes, of these problems. We then propose a number of practical so- each focused on a similarity or diversity problem associated lution methods, some of which use global constraints for en- with a NP-hard problems like constraint satisfaction. We forcing diversity (or similarity) between solutions. Empirical distinguish between offline diversity and similarity problems evaluation on a number of problems show promising results. (where we compute the whole set of solutions at once) and their online counter-part (where we compute solutions in- Introduction crementally).
    [Show full text]
  • Dichotomy Theorems for Generalized Chromatic Polynomials
    Simons Institute: The Classification Program of Counting Complexity March, 31 2016 The Difficulty of Counting: Dichotomy Theorems for Generalized Chromatic Polynomials. Johann A. Makowsky] ] Faculty of Computer Science, Technion - Israel Institute of Technology, Haifa, Israel e-mail: [email protected] http://www.cs.technion.ac.il/∼janos ********* Partially joint work with A. Goodall, M. Hermann, T. Kotek, S. Noble and E.V. Ravve. Graph polynomial project: http://www.cs.technion.ac.il/∼janos/RESEARCH/gp-homepage.html File:simons-title 1 Simons Institute: The Classification Program of Counting Complexity March, 31 2016 The Difficulty of Counting File:simons-cartoon 2 Simons Institute: The Classification Program of Counting Complexity March, 31 2016 Intriguing Graph Polynomials Boris Zilber and JAM, September 2004, in Oxford BZ: What are you studying nowadays? JAM: Graph polynomials. BZ: Uh? What? Can you give examples .... JAM: Matching polynomial, chromatic polynomial, Tutte polynomial, characteristic polynomial, ::: (detailed definitions) ::: BZ: I know these! They all occur as growth polynomials in my work on @0-categorical, !-stable models! JAM: ??? Let's see! File:simons-zilber 3 Simons Institute: The Classification Program of Counting Complexity March, 31 2016 A detailed exposition of the work which resulted from this conversation can be found in: Model Theoretic Methods in Finite Combinatorics M. Grohe and J.A. Makowsky, eds., Contemporary Mathematics, vol. 558 (2011), pp. 207-242 American Mathematical Society, 2011 Especially the papers • On Counting Generalized Colorings T. Kotek, J. A. Makowsky, and B. Zilber • Application of Logic to Combinatorial Sequences and Their Recurrence Relations E. Fischer, T. Kotek, and J. A.
    [Show full text]
  • Introduction to the Theory of Complexity
    Introduction to the theory of complexity Daniel Pierre Bovet Pierluigi Crescenzi The information in this book is distributed on an “As is” basis, without warranty. Although every precaution has been taken in the preparation of this work, the authors shall not have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work. First electronic edition: June 2006 Contents 1 Mathematical preliminaries 1 1.1 Sets, relations and functions 1 1.2 Set cardinality 5 1.3 Three proof techniques 5 1.4 Graphs 8 1.5 Alphabets, words and languages 10 2 Elements of computability theory 12 2.1 Turing machines 13 2.2 Machines and languages 26 2.3 Reducibility between languages 28 3 Complexity classes 33 3.1 Dynamic complexity measures 34 3.2 Classes of languages 36 3.3 Decision problems and languages 38 3.4 Time-complexity classes 41 3.5 The pseudo-Pascal language 47 4 The class P 51 4.1 The class P 52 4.2 The robustness of the class P 57 4.3 Polynomial-time reducibility 60 4.4 Uniform diagonalization 62 5 The class NP 69 5.1 The class NP 70 5.2 NP-complete languages 72 v vi 5.3 NP-intermediate languages 88 5.4 Computing and verifying a function 92 5.5 Relativization of the P 6= NP conjecture 95 6 The complexity of optimization problems 110 6.1 Optimization problems 111 6.2 Underlying languages 115 6.3 Optimum measure versus optimum solution 117 6.4 Approximability 119 6.5 Reducibility and optimization problems 125 7 Beyond NP 133 7.1 The class coNP
    [Show full text]
  • Rettinger.2272.Pdf (0.3
    Towards the Complexity of Riemann Mappings (Extended Abstract) Robert Rettinger1 Department of Mathematics and Computer Science University of Hagen, Germany Abstract. We show that under reasonable assumptions there exist Rie- mann mappings which are as hard as tally ]-P even in the non-uniform case. More precisely, we show that under a widely accepted conjecture from numerical mathematics there exist single domains with simple, i.e. polynomial time computable, smooth boundary whose Riemann map- ping is polynomial time computable if and only if tally ]-P equals P. Additionally, we give similar results without any assumptions using tally UP instead of ]-P and show that Riemann mappings of domains with polynomial time computable analytic boundaries are polynomial time computable. 1 Introduction In this paper we will prove lower bounds on the complexity of Riemann map- pings, i.e. conformal mappings of a simply connected domain onto D. Though the existence of such mappings is well known, computability results or even com- plexity results were unknown for a long time. Despite the fact that constructive proof methods were known for the problem (see [Hen86])) before, a characteriza- tion of those domains which have computable Riemann mappings was proven not before [Her99]. In a recent paper, Binder, Braverman and Yampolsky [BBY07] gave sharp bounds on the complexity of the corresponing functor, i.e. the func- tor which maps domains to their Riemann mappings: This functor is ]-P com- plete. (Actually the authors showed that this functor is ]-P hard and belongs to PSPACE. Using similar techniques, however, even a sharp upper bound of ]-P can be proven (see [Ret08a]).) Using the proof techniques of [BBY07] it is not hard to show that this functor remains ]-P complete even if we restrict the class of domains to those domains which have analytic boundaries.
    [Show full text]
  • COMPUTATIONAL COMPLEXITY Contents
    Part III Michaelmas 2012 COMPUTATIONAL COMPLEXITY Lecture notes Ashley Montanaro, DAMTP Cambridge [email protected] Contents 1 Complementary reading and acknowledgements2 2 Motivation 3 3 The Turing machine model4 4 Efficiency and time-bounded computation 13 5 Certificates and the class NP 21 6 Some more NP-complete problems 27 7 The P vs. NP problem and beyond 33 8 Space complexity 39 9 Randomised algorithms 45 10 Counting complexity and the class #P 53 11 Complexity classes: the summary 60 12 Circuit complexity 61 13 Decision trees 70 14 Communication complexity 77 15 Interactive proofs 86 16 Approximation algorithms and probabilistically checkable proofs 94 Health warning: There are likely to be changes and corrections to these notes throughout the course. For updates, see http://www.qi.damtp.cam.ac.uk/node/251/. Most recent changes: corrections to proof of correctness of Miller-Rabin test (Section 9.1) and minor terminology change in description of Subset Sum problem (Section6). Version 1.14 (May 28, 2013). 1 1 Complementary reading and acknowledgements Although this course does not follow a particular textbook closely, the following books and addi- tional resources may be particularly helpful. • Computational Complexity: A Modern Approach, Sanjeev Arora and Boaz Barak. Cambridge University Press. Encyclopaedic and recent textbook which is a useful reference for almost every topic covered in this course (a first edition, so beware typos!). Also contains much more material than we will be able to cover in this course, for those who are interested in learning more. A draft is available online at http://www.cs.princeton.edu/theory/complexity/.
    [Show full text]