It is known that, for every constant k⩾3, the presence of a k-clique (a complete sub-graph on k vertices) in an n-vertex graph cannot be detected by a monotone boolean circuit using much fewer than nk gates. We show that, for every constant k, the presence of an (n-k)-clique in an n-vertex graph can be detected by a monotone circuit using only a logarithmic number of fanin-2 OR gates; the total number of gates does not exceed O(n2logn). Moreover, if we allow unbounded fanin, then a logarithmic number of gates is enough.

This paper presents the optimal compression for sequences with unde- fined values. Let we have (N m) undefined and m defined positions in the boolean sequence ! V of length N. The sequence code length can't be less then m in general case, otherwise at least two sequences will have the same code. We present the coding algorithm which generates codes of almost m length, i.e. almost equal to the lower bound. The paper presents the decoding circuit too. The circuit has low com- plexity which depends from the inverse density of defined values D( ! V ) = N m . The decoding circuit includes RAM and random logic. It performs sequential decoding. The total RAM size is proportional to the log " D( ! V ) " ,

This paper presents the optimal compression for sequences with undefined values. Let we have $(N-m)$ undefined and $m$ defined positions in the boolean sequence $vv V$ of length $N$. The sequence code length can't be less then $m$ in general case, otherwise at least two sequences will have the same code. We present the coding algorithm which generates codes of almost $m$ length, i.e. almost equal to the lower bound. The paper presents the decoding circuit too. The circuit has low complexity which depends from the inverse density of defined values $D(vv V) = frac{N}{m}$. The decoding circuit includes RAM and random logic. It performs sequential decoding. The total RAM size is proportional to the $$logleft(D(vv V) ight) ,$$ the number of random logic cells is proportional to $$log logleft(D(vv V) ight) * left(log log logleft(D(vv V) ight) ight)^2 .$$ So the decoding circuit will be small enough even for the very low density sequences. The decoder complexity doesn't depend of the sequence length at all.

We prove an optimal bound for the function L(n, m, ε) that gives the worst-case circuit-size complexity to approximate partial boolean functions having n inputs and domain size m within degree at least ε. Our bound applies to any partial boolean function and any approximation degree, completing the study of boolean function approximation introduced in [15]. We also provide the approximation degree (i.e. the value ε) achieved by polynomial size circuits on a ‘random’ boolean function. Our results give a new upper bound for the hardness function h(f), the function denoting the minimum value l for which there exists a circuit of size at most l that approximates a boolean function f with degree at least 1/l [14]. The contribution in the proof of the upper bound for L(n, m, ε) can be viewed as a set of technical results that globally show how boolean linear operators are “well” distributed over the class of 4-regular domains. We show how to apply this property to approximate partial boolean functions on general domains.

Given a positive number δ ∈ (0,1), a subset H ⊑ {0,1}n is a δ-Hitting Set for a class R of boolean functions with n inputs if, for any function f ∈ R such that Pr (f=1)≥δ, there exists an element h ∈ H such that f(h)=1. Our paper presents a new deterministic method to efficiently construct δ-Hitting Set for the class of systems (i.e. logical conjunctions) of boolean linear functions. Systems of boolean linear functions can be considered as the algebraic generalization of boolean combinatorial rectangular functions, the only significative example for which an efficient deterministic construction of Hitting Sets were previously known. In the restricted case of boolean rectangular functions, our method (even though completely different) achieves equivalent results to those obtained in [11]. Our results also gives an upper bound on the minimum cardinality of solution covers for the class of systems of linear equations defined over a finite field. Furthermore, as preliminary result, we show a new upper bound on the circuit complexity of integer monotone functions generalizing previous results obtained in [12].

The High degree subgraph problem is to find a subgraph H of a graph G such that the minimum degree of H is as large as possible. This problem is known to be P-hard so that parallel approximation algorithms are very important for it. Our first goal is to determine how effectively the approximation algorithm based on a well-known extremal graph result parallelizes. In particular, we show that two natural decision problems associated with this algorithm are P-complete: these results suggest that the parallel implementation of the algorithm itself requires more sophisticated techniques. Successively, we study the High degree subgraph problem for random graphs with any edge probability function and we provide different parallel approximation algorithms depending on the type of this function.

We show that hitting sets can derandomize any probabilistic, two-sided error algorithm. This gives a positive answer to a fundamental open question in probabilistic algorithms. More precisely, we present a polynomial time deterministic algorithm which uses any given hitting set to approximate the fractions of 1's in the output of any boolean circuit of polynomial size. This new algorithm implies that if a quick hitting set generator with logarithmic price exists then BPP = P. Furthermore, we generalize this result by showing that the existence of a quick hitting set generator with price k implies that BPTIME(t) \(\subseteq DTIME(2^{O(k(t^{O(1)} ))} )\). The existence of quick hitting set generators is thus a new weaker sufficient condition to obtain BPP = P; this can be considered as another strong indication that the gap between probabilistic and deterministic computational power is not large.

It is known, that ordinary isomorphisms (associativity and commutativity of “times”, isomorphisms for “times” unit and currying) provide a complete axiomatisation of isomorphism of types in multiplicative linear lambda calculus (isomorphism of objects in a free symmetric monoidal closed category). One of the reasons to consider linear isomorphism of types instead of ordinary isomorphism was that better complexity could be expected. Meanwhile, no upper bounds reasonnably close to linear were obtained. We describe an algorithm deciding if two types are linearly isomorphic with complexity O(nlog 2(n)).

Up to know, the known derandomization methods have been derived assuming average-case hardness conditions. In this paper we instead present the first worst-case hardness conditions sufficient to obtain P=BPP. Our conditions refer to the worst-case circuit complexity of Boolean operators computable in time exponential in the input size. Such results are achieved by a new method that departs significantly from the usual known methods based on pseudo-random generators. Our method also gives a worst-case hardness condition for the circuit complexity of Boolean operators computable in NC (with respect to their output size) to obtain NC=BPNC.

We address the problem of organizing a set T of shared data into the memory modules of a Distributed Memory Machine (DMM) in order to minimize memory access conflicts during read operations. In this paper we present a new randomized scheme that, with high probability, performs any set of r unrelated read operations on the shared data set T in O(log r + log log|T|) parallel time with no memory conflicts and using O(r) processors. The set T is distributed into m DMM memory modules where m is polynomial in r and logarithmic in T, and the overall size of the shared memory used by our scheme is not larger than (1 + 1/ log |T|)|T|(this means that there is “almost” no data replication). The memory organization scheme and most part of all the computations of our method do not depend on the read requests, so they can be performed once and for all during an off-line phase. This is a relevant improvement over the previous deterministic method recently given in [1] when “real-time” applications are considered.

We address the problem of organizing a set T of shared data into the memory modules of a Distributed Memory Machine (DMM) in order to minimize memory access connicts (i.e. memory contention) during read operations. Previous solutions for this problem can be found as fundamental subprocedures of the PRAM simulation methods on DMM presented during the last years. The eeciency of such solutions relies on the assumption that the set of shared data is relatively small. Indeed, each shared data is replicated in at least two copies; moreover, the number of processors and that of memory modules are polynomial in the number of the shared data. This assumption is reasonable to the aim of PRAM simulations (where the shared data consist only on the shared program variables) but it is not realistic in the case of parallel systems for large public-accessible databases where the number of available resources (such as processors and memory modules) is tipically signiicantly (say exponentially) smaller than the size of the database. As for the latter case, we present a new randomized scheme that given any positive parameter , with high probability, performs any set of r unrelated read operations on the shared data set T in O(logr + log) parallel time with no memory contention using r processors (where each processor consists of O(r 3 +) Boolean gates of fan-in two). The set T is distributed into m DMM memory modules where m is polynomial in r and , and the overall size of the shared memory used by our scheme is not larger than (1 + 1=())jTj) (this means that the data replication can be made arbitrarily small). Our solution is thus very eecient in the case of a large number of shared data. Furthermore, the memory organization scheme and most part of all the computations do not depend on the read requests, so they can be performed once and for all during an oo-line phase.

In several previous works the construction of a computationally hard function with respect to a certain class of algorithms or Boolean circuits has been used to derive small pseudo-random spaces. In this paper, we revert this connection by presenting two new direct relations between the efficient construction of pseudo-random (both two-sided and one-sided) sets for Boolean affine spaces and the explicit construction of Boolean functions having hard branching program complexity. In the case of 1-read branching programs (1- Br.Pr. ), we show that the construction of non trivial (i.e. of cardinality 2 o(n) ) discrepancy sets (i.e. two-sided pseudo-random sets) for Boolean affine spaces of dimension greater than n /2 yield a set of explicit Boolean functions having very hard 1- Br.Pr. size. By combining the best known construction of Ɛ-biased sample spaces for linear tests and a simple "Reduction" Lemma, we derive the required discrepancy set and obtain a Boolean function in P having 1- Br.Pr. size not smaller than 2 n-O (log 2 n ) and a Boolean function in DTIME(2 O (log 2 n )) having 1- Br.Pr. size not smaller than 2 n-O (log n ). The latter bound is optimal and both of them are exponential improvements over the best previously known lower bound that was 2 n -3 n 1=2 [21]. As for non deterministic syntactic k -read branching programs ( k-Br.Pr. ), we introduce a new method to derive explicit, exponential lower bounds that involves the construction of hitting sets (one-sided pseudo-random sets) for affine spaces of dimension o ( n /2). Using an appropriate "orthogonal" representation of small Boolean affine spaces, we efficiently construct these hitting sets thus obtaining an explicit Boolean function in P that has k-Br.Pr. size not smaller than 2 n 1- o (1) for any k = o (log n /log log n . This improves over the previous best known lower bounds given in [8,11, 17] for some range of k .

We show that quick hitting set generators can replace quick pseudorandom generators to derandomize any probabilistic two-sided error algorithms. Up to now quick hitting set generators have been known as the general and uniform derandomization method for probabilistic one-sided error algorithms, while quick pseudorandom generators as the generators as the general and uniform method to derandomize probabilistic two-sided error algorithms. Our method is based on a deterministic algorithm that, given a Boolean circuit C and given access to a hitting set generator, constructs a discrepancy set for C . The main novelty is that the discrepancy set depends on C , so the new derandomization method is not uniform (i.e., not oblivious ). The algorithm works in time exponential in k(p(n)) where k (*) is the price of the hitting set generator and p (*) is a polynomial function in the size of C . We thus prove that if a logarithmic price quick hitting set generator exists then BPP = P.

It is known that ordinary isomorphisms (associativity and commutativity of "times", isomorphisms for "times" unit and currying) provide a complete axiomatisation for linear isomorphism of types. One of the reasons to consider linear isomorphism of types instead of ordinary isomorphism was that better complexity could be expected. Meanwhile, no upper bounds reasonably close to linear were obtained. We describe an algorithm deciding if two types are linearly isomorphic with complexity Cn(log2(n)).

A subset H f0; 1g n is a Hitting Set for a class R of boolean functions with n inputs if, for any function f 2 R such that Pr (f = 1) (where 2 (0; 1) is some xed value), there exists an element ~ h 2 H such that f (~ h) = 1. The eecient construction of Hitting Sets for non trivial classes of boolean functions is a fundamental problem in the theory of derandomization. Our paper presents a new method to eeciently construct Hitting Sets for the class of systems of boolean linear functions. Systems of boolean linear functions can be also considered as the algebraic generalization of boolean combinatorial rectangular functions studied by Linial et al in 11]. In the restricted case of boolean rectangular functions, our method (even though completely diierent) achieves equivalent results to those obtained in 11]. Our method gives also an interesting upper bound on the circuit complexity of the solutions of any system of linear equations deened over a nite eld. Furthermore, as preliminary result, we show a new upper bound on the circuit complexity of integer monotone functions that generalizes the upper bound previously obtained by Lupanov in 12].

The complexity of a nondeterministic function is the minimum possible complexity of its determinisation. The entropy of a nondeterministic function, F, is minus the logarithm of the ratio between the number of determinisations of F and the number of all deterministic functions. We obtain an upper bound on the complexity of a nondeterministic function with restricted entropy for the worst case. These bounds have strong applications in the problem of algorithm derandomization. A lot of randomized algorithms can be converted to deterministic ones if we have an effective hitting set with certain parameters (a set is hitting for a set system if it has a nonempty intersection with any set from the system). Linial, Luby, Saks and Zuckerman (1993) constructed the best effective hitting set for the system of k-value, n-dimensional rectangles. The set size is polynomial in k log n / epsilon. Our bounds of nondeterministic functions complexity offer a possibility to construct an effective hitting set for this system with almost linear size in k log n / epsilon.

It is known that, for every constant k 3, the presence of a k-clique (a complete subgraph on k vertices) in an n-vertex graph cannot be detected by a monotone boolean circuit using fewer than (( n/logn)k) gates. We show that, for every constant k, the presence of an (n k)-clique in an n- vertex graph can be detected by a monotone circuit using only O(n2 logn) gates. Moreover, if we allow unbounded fanin, then O(logn) gates are enough.