Welcome to the course Concrete Complexity Theory

1
Welcome to the courseConcrete Complexity Theory

• Winter Term 2008/09
• Lecture 9, 9.1.09
• Friedhelm Meyer auf der Heide

2

• Part 1
• Boolean Circuits

3

• Unbounded Fan-In Circuits

4
Unbounded fan-in circuits

• We consider the (associative, commutative)
  operations AND, OR, MOD3, and allow such gates
  with unbounded fan-in
  (MOD3(x1,, xl) 0 iff ? xi 0 mod(3).)
• An unbounded fan-in circuit (ub-circuit) is a dag
  with 2n leaves labelled x1, xn, x1,,xn. Inner
  nodes are labelled with AND, OR, or MOD3.
• Computation, size and depth are defined as for
  circuits.
• (Note Often a canonical form of ub-circuits is
  considered. It only used AND and OR gates, and
  consists of alternating AND and OR levels.)

5
The lower bound by Razbarov/Smolenski

• Main Theorem Every ub-circuit of depth d for
  Parityn has size at least .
  
• Especially, if the circuits has polynomial size,
  its depth is ?(log(n)/loglog(n)).
• Remark A ub-circuit (even without MOD3) with
  polynomial size and depth O(log(n)/loglog(n)) can
  compute Parityn.

6
The proof structure
ub - circuit
7
Proof of Theorem 1

• We need

ub - circuit
(An analogous results holds for AND.)
8
The approximators
9
Bounding the number of errors

• There are no errors on level 0.

10
Bounding the number of errors

• We have Each of the s gates adds at most 2n ?
  errors, ? ?/s.
• Thus The approximator g for f differs from f at
  at most s ? 2n ? 2n inputs.
• It is a polynomial of degree at most Dd over GF3.
  It is not multilinear.
• But as we are only interested for inputs from
  0,1n, we can replace it by a multilinear one by
  replacing each factor xik, for kgt 1, by xi.
• qed.

11
Proof of Theorem 2

• Proof Transform the input space 0,1n to
  -1,1n by x ? 1-2x.
• This results in the transformed parity function
  XOR -1,1n ! -1,1 with XOR(x1,, xn)
  ?i1,,n xi. As this transformation maintains
  degrees, we can as well prove the theorem for
  XOR instead of XOR.

12
Proof of Theorem 2

• Let p -1,1n ! -1,1 be a polynomial over GF3
  with degree pn.
• Let A x 2 -1,1n , p(x) XOR(x).
• Let F f A ! -1,1. Consider f 2 F with
  representation
• as a multi-linear polynomial over GF3, ai 2 0,
  1, 2 . (This
  representation exists!)
• Claim f A ! -1,1 can be described by a
  multi-linear polynomial over GF3 with degree at
  most ½ (n pn).
• This implies
• 3A F multi-linear polys over GF3 with
  degree at most ½ (n pn)
• , for r ½ (n pn)

13
Proof of Theorem 2

• Thus , for r ½ (n
  pn)
• The following lemma implies Theorem 2.
• Lemma 2

14

• Part 2
• Computations over the reals
• and over the integers

15
Computation trees for real or integer inputs

• Let S µ , -, , /, DIV, c, DIVc be a set of
  operations, C µ R a set of constants. A
  Computation Tree T with operation set S and
  allowed constants C, an (S,C)-CT for inputs x 2
  Rn (or Nn or Zd ), is a finite rooted tree with
  outdegree 0,1,or 3. (c, DIVc means scalar
  multiplication, integer division by constants.)
• Nodes v with degree 0, the leaves, are labelled
  accept or reject.
• Nodes v with degree 1, the computation nodes,
  compute a function f Rn ! R.
• f is either c for some c2 C, or
• f(x) xi for some i 2 1,,n, or
• f f1 f2 for some 2 S and
  functions f1, f2 previously computed on
• the path from the root to v.
• Nodes v with degree 3, the branching nodes, are
  labeled with a function f previously computed on
  the path from the root to v.
• Input x follows a path from the root to a leaf,
  always choosing the left/middle/right branch at a
  branching node labelled f,
• if f(x)gt 0 / 0 / lt 0). (Note Often,
  branching nodes have degree 2 for / lt.)

16
An computation tree (with branching degree 2)
17
Computation trees for real or integer inputs

• T accepts x, iff x arrives at an accepting leaf.
  
• T recognizes the language L x 2 Rd, T
  accepts x µ Rd .
• Our complexity measure is the depth of T.
• Special classes of CTs
• We often assume that CR (or Z) and write S-CT
  instead of (S,C)-CT.
• If S , -, , / , we refer to an S-CT as
  an
  algebraic computation tree , ACT.
• If we ignore computation nodes, and restrict the
  branching nodes to using polynomials of degree at
  most d, we talk about
  an algebraic decision tree of order d, dth order
  ADT. (Note only the branching nodes contribute
  to the depth.)
• A first order ADT is called a linear decision
  tree (LDT).
• An LDT that only uses functions of the form xi
  xj as branchings, is called a comparison tree.

18
A linear decision tree (with branching degree 2)
19
Thank you for your attention!
Friedhelm Meyer auf der Heide Heinz Nixdorf
Institute Computer Science Department University
of Paderborn Fürstenallee 11 33102 Paderborn,
Germany Tel. [phone] Fax
49 (0) 52 51/62 64 82 E-Mail fmadh_at_upb.de http/
/www.upb.de/cs/ag-madh