We study two quite different approaches to understanding the complexity of fundamental problems in numerical analysis: • The Blum-Shub-Smale model of computation over the reals. • A problem we call the “Generic Task of Numerical Computation, ” which captures an aspect of doing numerical computation in floating point, similar to the “long exponent model ” that has been studied in the numerical computing community. We show that both of these approaches hinge on the question of understanding the complexity of the following problem, which we call PosSLP: Given a division-free straight-line program producing an integer N, decide whether N> 0. • In the Blum-Shub-Smale model, polynomial time computation over the reals (on discrete inputs) is polynomial-time equivalent to PosSLP, when there are only algebraic constants. We conjecture that using transcendental constants provides no additional power, beyond nonuniform reductions to PosSLP, and we present some preliminary results supporting this conjecture. • The Generic Task of Numerical Computation is also polynomial-time equivalent to PosSLP. We prove that PosSLP lies in the counting hierarchy. Combining this with work of Tiwari, we obtain that the Euclidean Traveling Salesman Problem lies in the counting hierarchy – the previous best upper bound for this important problem (in terms of classical complexity classes) being PSPACE. In the course of developing the context for our results on arithmetic circuits, we present some new observations on the complexity of ACIT: the Arithmetic Circuit Identity Testing problem. In particular, we show that if n! is not ultimately easy, then ACIT has subexponential complexity.

Arithmetic circuits are the focus of renewed attention in the complexity theory community. It is easy to list a few of the reasons for the increased interest: • Innovative work by Kabanets and Impagliazzo [KI03] shows that, in

Constant-depth arithmetic circuits have been defined and studied in [AAD97, ABL98]; these circuits yield the function classes #AC . These function classes in turn provide new characterizations of the computational power of threshold circuits, and provide a link between the circuit classes AC (where many lower bounds are known) and TC (where essentially no lower bounds are known). In this paper, we resolve several questions regarding the closure properties of #AC .

This paper studies expressivity bounds for extensions of first-order logic with counting and unary quantifiers in the presence of relations of large degree. There are several motivations for this work. First, it is known that first-order logic with counting quantifiers captures uniform TC 0 over ordered structures. Thus, proving expressivity bounds for first-order with counting can be seen as an attempt to show TC 0 $ DLOG using techniques of descriptive complexity. Second, the presence of auxiliary built-in relations (e.g., order, successor) is known to make a big impact on expressivity results in finite-model theory and database theory (where logics with counting and unary quantifiers have recently been used to model query languages with aggregation). For those logics, our goal is to extend techniques from "pure" setting to that of auxiliary relations. Until now, all known results on the limitations of expressive power of the counting and unary quantifier extensions of first-order...

This paper addresses the problems of counting proof trees (as introduced by Venkateswaran and Tompa) and counting proof circuits, a related but seemingly more natural question. These problems lead to a common generalization of straight-line programs which we call polynomial replacement systems. We contribute a classication of these systems and we investigate their complexity. Diverse problems falling in the scope of this study include, for example, counting proof circuits, and evaluating f[; +g-circuits over the natural numbers. A number of complexity results are obtained, e.g., the former problem is shown #P-complete, while the latter is shown to be equivalent to a particular type of replacement systems. 1 Introduction 1.1 Motivation ^ x1 x2 g2 g1 _ g3 _ _ g4 When + and replace _ and ^ in the adjacent gure, the gate g 1 on input x 1 = x 2 = 1 evaluates to 9. Equivalently, the tree-like Boolean circuit T obtained from the circuit drawn has 9 proof trees [VT89],...

Fabrizio Angiulli 1 , Giovambattista Ianni 2 , and Luigi Palopoli 3 1 ISI-CNR c/o Universita della Calabria, DEIS, Via P. Bucci 41C, Rende, Italy angiulli@isi.cs.cnr.it 2 Universita della Calabria, DEIS, Via P. Bucci 41C, Rende, Italy ianni@deis.unical.it 3 Universita di Reggio Calabria, DIMET, Loc. Feo di Vito, Reggio Calabria, Italy palopoli@ing.unirc.it Abstract. In this paper we describe our ongoing research towards establishing the complexity of mining association rules from relational databases. We consider both quantitative, categorical and boolean association rules and various forms of quality indexes, including confidence, support, gain, laplace. The presented results show that all these problems are, generally, computationally hard to solve, even if we are able to single out some interesting tractable special cases.

The class ACC consists of circuit families with constant depth over unbounded fan-in AND, OR, NOT, and MODm gates, where m> 1 is an arbitrary constant. We prove: • NTIME[2 n] does not have non-uniform ACC circuits of polynomial size. The size lower bound can be slightly strengthened to quasi-polynomials and other less natural functions. • ENP, the class of languages recognized in 2O(n) time with an NP oracle, doesn’t have non-uniform ACC circuits of 2no(1) size. The lower bound gives an exponential size-depth tradeoff: for every d there is a δ> 0 such that ENP doesn’t have depth-d ACC circuits of size 2nδ. Previously, it was not known whether EXP NP had depth-3 polynomial size circuits made out of only MOD6 gates. The high-level strategy is to design faster algorithms for the circuit satisfiability problem over ACC circuits, then prove that such algorithms entail the above lower bounds. The algorithm combines known properties of ACC with fast rectangular matrix multiplication and dynamic programming, while the second step requires a subtle strengthening of the author’s prior work [STOC’10]. Supported by the Josef Raviv Memorial Fellowship.

Razborov and Rudich identified an imposing barrier that stands in the way of progress toward the goal of proving superpolynomial lower bounds on circuit size. Their work on “natural proofs” applies to a large class of arguments that have been used in complexity theory, and shows that no such argument can prove that a problem requires circuits of superpolynomial size, even for some very restricted classes of circuits (under reasonable cryptographic assumptions). This barrier is so daunting, that some researchers have decided to focus their attentions elsewhere. Yet the goal of proving circuit lower bounds is of such importance, that some in the community have proposed concrete strategies for surmounting the obstacle. This lecture will discuss some of these strategies, and will dwell at length on a recent approach proposed by Michal Koucky and the author.

Inducing association rules is one of the central tasks in data mining applications. Quantitative association rules induced from databases describe rich and hidden relationships holding within data that can prove useful for various application purposes (e.g., market basket analysis, customer profiling, and others). Even though such association rules are quite widely used in practice, a thorough analysis of the computational complexity of inducing them is missing. This paper intends to provide a contribution in this setting. To this end, we first formally define quantitative association rule mining problems, which entail boolean association rules as a special case, and then analyze their computational complexities, by considering both the standard cases, and a some special interesting case, that is, association rule induction over databases with null values, fixed-size attribute set databases, sparse databases, fixed threshold problems. 1

A recurring theme in the literature on derandomization is that probabilistic algorithms can be simulated quickly by deterministic algorithms, if one can obtain impressive (i.e., superpolynomial, or even nearly-exponential) circuit size lower bounds for certain problems. In contrast to what is needed for derandomization, existing lower bounds seem rather pathetic (linear-size lower bounds for general circuits [IM02], nearly cubic lower bounds for formula size [H˚as98], nearly n log log n size lower bounds for branching programs [BSSV03], n 1+cd for depth d threshold circuits [IPS97]). Here, we present two instances where “pathetic ” lower bounds of the form n 1+ɛ would suffice to derandomize interesting classes of probabilistic algorithms. We show: • If the word problem over S5 requires constant-depth threshold circuits of size n1+ɛ for some ɛ> 0, then any language accepted by uniform polynomial-size probabilistic threshold circuits is accepted by a uniform family of deterministic constant-depth threshold circuits of subexponential size. • If there are no constant-depth arithmetic circuits of size n1+ɛ for the problem of multiplying a sequence of n 3-by-3 matrices, then for every constant d, black-box identity testing for depth-d arithmetic circuits with bounded individual degree can be performed by a uniform family of deterministic constant-depth AC0 circuits of subexponential size.