Size-Treewidth Tradeoffs for Circuits Computing the Element Distinctness Function

In this work we study the relationship between size and treewidth of circuits computing variants of the element distinctness function. First, we show that for each n, any circuit of treewidth t computing the element distinctness function δ n : {0, 1} n → {0, 1} must have size at least Ω ( n 2 2 O ( t ) log n ) $\Omega (\frac {n^{2}}{2^{O(t)} \log n})$ . This result provides a non-trivial generalization of a super-linear lower bound for the size of Boolean formulas (treewidth 1) due to Nečiporuk. Subsequently, we turn our attention to read-once circuits, which are circuits where each variable labels at most one input vertex. For each n, we show that any read-once circuit of treewidth t and size s computing a variant τ n : {0, 1} n → {0, 1} of the element distinctness function must satisfy the inequality t ⋅ log s ≥ Ω ( n log n ) $t\cdot \log s \geq \Omega (\frac {n}{\log n})$ . Using this inequality in conjunction with known results in structural graph theory, we show that for each fixed graph H, read-once circuits computing τ n which exclude H as a minor must have size at least Ω(n 2/log4 n). For certain well studied functions, such as the triangle-freeness function, this last lower bound can be improved to Ω(n 2/log 2n).


Introduction
The problem of explicitly defining a function in NP which requires super-linear circuit size has proven to be notoriously hard.Currently, the best known lower bound for a function in NP is of the order1 of 3n − o (1) for circuits with arbitrary fan-in-2 gates [4,9], and of the order of 5n − o (1) for circuits with gates from the binary De-Morgan basis [20,23].In the particular case of Boolean formulas, Nečiporuk proved an Ω(n 2 / log n) lower bound for the size of Boolean formulas over the full binary basis computing the n-bit element distinctness function [27].Intuitively, the element distinctness function δ n : {0, 1} n → {0, 1} takes as input a sequence of m numbers s 1 , s 2 , ..., s m ∈ {1, ..., m 2 } encoded as binary strings with 2 log m bits, and returns 1 if and only if all numbers in this sequence are distinct.Remarkably, Nečiporuk's lower bound has resisted improvements during the last four decades, and remains the strongest known lower bound for the size of formulas over the full binary basis.In the restricted setting of formulas over the De-Morgan basis, a size lower bound of n 3−o (1) was obtained by Håstad [17] using different techniques.
In this work, we consider the problem of proving circuit size lower bounds for circuits of low treewidth.During the past decade a considerable amount of research has been devoted to the study of the computational power and the combinatorial properties of circuits parameterized by treewidth [1,2,6,13,14,18,21].In our first result we generalize Nečiporuk's lower bound to the context of circuits of low treewidth.
Theorem 1 Let C be a circuit of treewidth t computing the element distinctness function δ n .Then C has size Ω( n 2  2 O(t) log n ).
Here the size of a circuit C is defined as its wire-complexity, i.e., the total number of edges in C. Therefore, our lower bound holds for circuits containing unbounded fan-in AND and OR gates, and more generally, unbounded fan-in associatively constructible gates, which we will define in Section 2. Theorem 1 generalizes Nečiporuk's non-linear lower bound, from the context of Boolean formulas (that is to say, circuits of treewidth 1) to the context of circuits of low treewidth.In particular, our result implies an Ω(n 2 / log n) lower bound for the size of circuits whose underlying undirected graph belongs to several interesting classes, such as trees (treewidth at most 1), TTSP series-parallel graphs (treewidth at most 2), outer-planar graphs (treewidth at most 2), Halin graphs (treewidth at most 3), k-outerplanar graphs for fixed k (treewidth at most O(k)), etc.Additionally, Theorem 1 implies non-linear lower bounds even for circuits of treewidth o(log n).
It is worth comparing our result with another prominent restricted family of circuits for which no non-linear lower bound is known, namely, circuits whose underlying graph belongs to the class of Valiant Series-Parallel graphs [34].We refer to [7] for a clear definition of this class.It can be shown that the class of Valiant-seriesparallel graphs strictly contains the class of TTSP-series-parallel graphs (which have treewidth 2).Nevertheless, Valiant-series-parallel graphs are incomparable with graphs of treewidth k, for k ≥ 3. On the one hand, there are Valiant-series-parallel graphs of treewidth at least k for every k ∈ N.For instance, the k × k grid-graph is Valiant-series-parallel but has treewidth k.On the other hand, it is easy to construct graphs of treewidth 3 which are not Valiant-series-parallel.Proving a non-linear lower bound for Valiant-series-parallel circuits remains a major open problem in circuit complexity [29,31].
Next, we turn our attention to read-once circuits, which are circuits where each variable labels at most one input vertex.These circuits have also been known in the VLSI literature as semilective circuits [19].Read-once circuits parameterized by treewidth have been studied by the SAT-solving and proof-complexity communities.Part of the interest in these circuits is due to the fact that the satisfiability problem for read-once circuits of size s and treewidth t can be solved in time 2 O(t) • s O (1)   [1,2,6,14].Questions related to the design of optimal VLSI circuits have motivated the study of the complexity of planar read-once circuits computing explicit functions (i.e.functions in NP).Within this line of research, quadratic lower bounds have been obtained for the size of planar read-once circuits computing both multiple-output functions [24] and single-output functions [32].We contrast these quadratic lower bounds with the fact that for multilective planar circuits, i.e., planar circuits in which variables can label arbitrarily many input gates, the best known lower bounds are of the order of O(n log n) for single-output functions and of the order of O(n 3/2 ) for multiple-output functions [33].
In this work we introduce the symmetric non-deterministic state complexity (symmetric-NSC) of a Boolean function, a complexity measure that is lower-bounded by the size of the smallest read-once oblivious branching program computing the function in question.We show that if C is a read-once circuit of size s and treewidth t computing a function f n : {0, 1} n → {0, 1} of symmetric-NSC snsc(f n ), then t • log s ≥ Ω(log snsc(f n )).Using this tradeoff in conjunction with known results from structural graph theory, we show that for each fixed graph H , read-once H -minorfree 2 circuits computing f n must have size at least Ω log 2 snsc(f n ) . Subsequently, we introduce a variant τ n : {0, 1} n → {0, 1} of the element distinctness function and show that its symmetric-NSC is lower bounded by 2 Ω(n/ log n) .From these results we have that read-once H -minor-free circuits computing τ n require size Ω(n 2 / log 4 n).Near-quadratic lower bounds can also be obtained for the size of read-once H -minorfree circuits computing certain well studied functions, such as the triangle-freeness function n , and the triangle-parity function Clique 3,n .A result from [11] implies that the symmetric-NSC of these functions is lower-bounded by 2 Ω(n) .Therefore, read-once H -minor-free circuits computing both n and Clique 3,n require size ). 2 We say that a circuit C is H -minor-free if its underlying undirected graph excludes H as a minor.

Preliminaries
Let Σ be a finite set of symbols.A k-ary gate over Σ is a function g : where k ≥ 1.We say that a k-ary gate g is associatively constructible if either k = 1 or k ≥ 2 and there exists an associative commutative operation ⊕ : In this last case, we may alternatively say that g is a k-ary ⊕-gate.Unbounded fan-in AND and OR gates are clearly associatively constructible.An unbounded fan-in MOD r gate can be simulated by an associatively constructible gate g that computes the sum of its inputs modulo r, together with a unary gate g : Σ → Σ that returns 0 if this sum is congruent to 0 mod r, and which returns 1 otherwise.
An associatively constructible circuit with n inputs is a directed acyclic graph C = (V , E, g) where V is a set of vertices, E is a set of directed edges, and g is a function that labels each vertex v ∈ V with a symbol from Σ, a gate over Σ, or a variable from {x 1 , ..., x n }.The function g must satisfy the following conditions.
1.If the in-degree of v is 0, then g(v) is either an element of Σ or a variable in {x 1 , ..., x n }. 2. If the in-degree of v is k, then g(v) is an associatively constructible k-ary gate over Σ.
Vertices of in-degree 0 are called inputs.An input is initialized if it is labeled with an element of Σ, and uninitialized if it is labeled with a variable.Vertices of out-degree 0 are called outputs.A formula is a circuit, with a unique output, whose underlying graph is a tree.We say that a circuit C = (V , E, g) is read once if no two input vertices are labeled with the same variable.Since our circuits may contain associatively constructible gates of unbounded fan-in and unbounded fan-out, we define the size |C| of a circuit C as the number of edges in C. Below, we define the notion of tree-decomposition of a circuit.Definition 1 (Tree-Decomposition and Treewidth) A tree-decomposition of a circuit C = (V , E, g) is a triple T = (N, F, β) where (N, F ) is a tree with set of nodes N and set of arcs F , and β : N → 2 V is a function that associates with each node u ∈ N a subset β(u) of vertices of V such that the following three conditions are satisfied.

1.
u∈N β(u The width of T is defined as The treewidth of a circuit C, denoted tw(C), is the minimum width of a tree-decomposition of C.
We note that the directions of the edges of a circuit play no role in the definition of tree-decomposition.In other words, only the underlying undirected graph of C is relevant when considering its treewidth.
Let C = (V , E, g) be an associatively constructible circuit.For each v ∈ V , we let indeg(v) = |{v | (v , v) ∈ E}| be the in-degree of v, and outdeg(v) = |{v | (v, v ) ∈ E}| be the out-degree of v.We let ι : Σ → Σ be the identity gate, which sends each element a ∈ Σ to itself.We say that C is normalized if for every vertex v ∈ V , outdeg(v) > 1 implies that g(v) = ι and that indeg(v) = 1.We note that any associatively constructible circuit C of treewidth t can be transformed into a normalized circuit C of size at most 2 • |C| and treewidth at most 2 • t computing the same function as C. Indeed, the transformation consists into splitting each vertex v with outdeg(v) > 1 into two vertices v in , v out connected by an edge (v in , v out ), where v in is labeled with the same gate as v, v out is labeled with the identity gate ι, the inneighbors of v in C are in-neighbors of v in in C , and the out-neighbors of v in C are the out-neighbors of v out in C .
Circuits with constant treewidth may have arbitrarily large maximum in-degree and maximum out-degree.Lemma 1 below states that, at the expense of a linear increase in size and treewidth, one can reduce the maximum in-degree and out-degree of a circuit C to a constant without changing the function computed by C. A variant of Lemma 1 was originally proved in [25].We include a self-contained proof of this lemma for completeness.
Lemma 1 ) Let C be a associatively constructible circuit of treewidth t, computing a function f : Σ n → Σ.Then f can be computed by a normalized circuit C of size |C | = O(|C|), maximum-degree at most 3, maximum in-degree at most 2, maximum out-degree at most 2, and treewidth at most O(t).Additionally, for each variable x, the number of input vertices labeled with x in C is equal to the number of input vertices labeled with x in C .
Proof First, we derive from C a normalized circuit Ĉ = (V , E, g) of size at most 2 • |C| and treewidth at most 2 • t, which computes the same function as C.
Let T = (N, F, β) be a tree decomposition of Ĉ of width at most 2 • t.We may assume that this decomposition satisfies the following additional properties.

(N, F
) is a sub-cubic tree, i.e., each node has degree at most 3. 2. There is an injective function μ : E → N such that μ(v, v ) has degree at most 2 and for each } be the set of nodes of T whose associated bag contains the vertex v. Let ρ : V → N be an injective function satisfying the following properties.
Note that if outdeg(v) = 0 then ρ(v) can be any node in N(v).Note also that since Ĉ is normalized, if outdeg(v) ≥ 1 then indeg(v) = 1.Therefore, Condition 3 above is well defined.Since T is a tree decomposition, for each v ∈ V the set N(v) induces a connected subtree T (v) = (N(v), F (v)) of (N, F ). Intuitively, for each v ∈ V , the function ρ chooses a root for the tree T (v).Note that ρ(v) and any other node in N(v) have at most two children.The leaves of the subtree T (v) are the nodes in N(v) at maximal depth with respect to the root ρ(v).We say that a leaf u of T (v) is useful if either outdeg(v) ≤ 1 and there exists (v, v ) ∈ E such that μ(v, v ) = u, or if outdeg(v) > 1 and there exists (v, v ) ∈ E with μ(v, v ) = u.We say that the tree decomposition T is reduced with respect the pair (μ, ρ) if for every v ∈ V all leaves in N(v) are useful.We can assume without loss of generality that T is reduced, since if u is a non-useful leaf of N(v), then we may safely remove v from the bag β(u) and still have a valid tree decomposition of Ĉ with at most the same width as T .Now we are in a position to describe the construction of the circuit C = (V , E , g ).Intuitively, each vertex v of the circuit C will correspond to a rooted binary tree τ (v) in C which has the same shape as the subtree 3 If g(v) is a k-ary ⊕ gate, then the nodes of τ (v) which have two children are labeled by g with the binary ⊕ gate, while all other nodes are labeled with the identity gate ι.If v is labeled with a unary gate, then the root of τ (v) is labeled with g(v) and all other nodes of τ (v) are labeled with the identity gate ι.On the other hand, if outdeg(v) > 1, then τ (v) is outbranching.In this case, all nodes of τ (v) are labeled with the identity gate ι.Finally, the edge set E is defined as follows.For each (v, v ) ∈ E with outdeg(v) > 1, we add an edge from a node of the out-branching tree τ (v) to a node of the in-branching tree τ (v ).On the other hand for each (v, v ) ∈ E with indeg(v) ≤ 1 we add an edge from the root of τ (v) to a node of τ (v ).The precise way in which such edges are created is specified in the formal construction below.
Note that the first set corresponds to edges between distinct trees, while the second set corresponds to edges belonging to in-branching trees, and the third set corresponds to edges belonging to out-branching trees.
Finally, the gate map g is formally defined as follows.For each v ∈ V with outdeg(v) > 1, we set g ([v, u]) = ι for every u ∈ N(v).On the other hand, for each v ∈ V with outdeg(v) ≤ 1, and each u ∈ N(v) we proceed as follows.
1.If g(v) is a k-ary ⊕-gate for some associative commutative operation ⊕, then we set g We note that in this case the subtree induced by N(v) is a line, since N(v) has a unique useful leave.3.If v is an input of C, then N(v) has a single node u and we set g ([v, u]) = g(v).
A tree decomposition T = (N, F, β ) of C can be obtained as follows. 4For each u ∈ N, we set Since the tree (N, F ) is ternary, the width of T is at most 4 times the width of T .Note that the size of the circuit C constructed above is of the order of O(t • |C|).Nevertheless this size can be reduced to O(|C|), i.e., without the multiplicative dependence on t, by contracting maximal induced paths v 1 v 2 ....v r where all vertices are labeled with the identity gate into a single vertex labeled with the identity gate.Since contraction can only decrease the treewidth of a graph, the statement of the theorem is proved.
Lemma 1 implies that to prove non-linear size lower bounds for associatively constructible circuits of constant treewidth, it is enough to prove non-linear lower bounds for circuits of constant treewidth and constant maximum fan-in and fan-out.
Below, we define the notion of rooted carving decomposition of a circuit, a variant of the notion of carving decomposition defined in [30].If T is a rooted tree, we denote by nodes(T ) the set of all nodes of T , and by leaves(T ) the set of all leaves of T .For each node u ∈ nodes(T ), we let T [u] denote the subtree of T rooted at u. Definition 2 (Carving Decomposition) A rooted carving decomposition of a circuit C = (V , E, g) is a pair (T , γ ) where T is a rooted binary tree and γ : leaves(T ) → V is a bijection mapping each leaf u ∈ leaves(T ) to a single vertex γ (u) ∈ V .
Observe that the internal nodes of a carving decomposition T are unlabeled.Given a node u ∈ nodes(T ), we let The carving width carw(C) of a circuit C is the minimum width of a carving decomposition of C. The following lemma relates carving width and treewidth of an associatively constructible circuit.

Lemma 2 Let C = (V , E, g) be an associatively constructible circuit of treewidth t. There is a circuit C of size |C | = O(|C|), maximum degree 3, and carving width O(t) such that C and C compute the same function. Additionally, for each variable x, the number of input vertices labeled with x in C is equal to the number of input vertices labeled with x in C .
Proof By Lemma 1, if C is an associatively constructible circuit of treewidth t, then one can construct a circuit C of size O(|C|), maximum degree at most 3 and treewidth at most O(t) which computes the same function as C. Additionally, for each variable x, the number of input vertices labeled with x in C is equal to the number of input vertices labeled with x in C .Since any graph of treewidth w and maximum degree has carving-width O( • w) (Lemma 4 of [26]), the carving width of C is bounded by O(t).

Nečiporuk's Method
In this section, we briefly describe Nečiporuk's method for proving non-linear lower bounds on the size of Boolean formulas over the complete binary basis.For our purposes, it will be convenient to divide this method into three steps.Our first main result (Theorem 1) follows from a generalization of Step 1 given below.A complete proof of Nečiporuk's theorem can be found in [22].
Step 1 Let X = {x 1 , ..., x n } be a set of variables, f : {0, 1} X → {0, 1} be a Boolean function on X, and Y ⊆ X be a subset of variables of X.We denote by N f (Y ) the number of distinct functions that can be obtained by initializing all variables in X\Y with values in {0, 1}.The first step in the proof of Nečiporuk's theorem consists in providing an upper bound for N f (Y ).If f can be computed by a Boolean formula F , such an upper bound can be given in terms of the number of inputs of F labeled with variables in Y .
Proposition 1 Let f : {0, 1} X → {0, 1} be a function computable by a Boolean formula F .Let Y ⊆ X be a subset of variables such that at most l inputs of F are labeled with variables in We briefly sketch the proof of Proposition 1.Let g : {0, 1} Y → {0, 1} be a function obtained from f by initializing all variables in X\Y according to an assignment α : X\Y → {0, 1}.Let F g be the Boolean formula obtained from F by initializing inputs labeled with variables in X\Y according to α.Then, F g computes g, and has at most l uninitialized inputs.Now, the formula F g can be shrunk into a formula F g which still computes the function g, but which satisfy the following two properties.
1. F g has at most l inputs, all of which are labeled with variables in Y .2. All internal nodes of F g have fan-in (precisely) 2.
These two properties imply that F g has at most l −1 internal nodes.Since there are 16 possible Boolean functions of fan-in 2, there are at most 16 Step 2 The second step consists in exhibiting an explicit Boolean function with many sub-functions.Intuitively, a function f : {0, 1} X → {0, 1} has many sub-functions if the quantity N f (Y ) is large for some subsets Y ⊆ X of suitable size.Let X = {x 1 , ..., x n } be a set of n = 2m log m distinct variables partitioned into m blocks Y 1 , Y 2 , ..., Y m , where each block Y i has 2 log m variables.The element distinctness function δ n : {0, 1} X → {0, 1} is defined as follows for each assignment s 1 , s 2 , ..., s m of the blocks Y 1 , Y 2 , ..., Y m respectively.
The following lemma states that the element distinctness function defined in (1) has many sub-functions.
Lemma 3 (See [22], Section 6.5) Let δ n : {0, 1} X → {0, 1} be the element distinctness function defined in (1), where |X| = n and Step 3 In the third step, we combine Proposition 1 with Lemma 3 to obtain a non-linear lower bound for the size of Boolean formulas computing the element distinctness function δ n : {0, 1} X → {0, 1} defined in (1).Let F be a Boolean formula computing δ n .Let l i denote the number of inputs of F labeled with some variable in Y i .By Proposition 1, we have that N δ n (Y i ) ≤ 2 O(l i ) .On the other hand, by Lemma 3, n) .Combining these two inequalities, we have that ( This implies that l i ≥ Ω(n).In other words, there are Ω(n) inputs of F labeled with variables from Y i .Since there are m = Ω( n log n ) blocks Y i , we have that the number of inputs of F labeled with variables in X is at least Ω( n 2 log n ).

Generalizing Nečiporuk's Theorem
In this section we will generalize Nečiporuk's non-linear lower bound to the context of circuits of low treewidth (Theorem 1).We call attention to the fact that this lower bound concerns circuits in which each variable can label arbitrarily many input vertices.The following lemma, which generalizes Proposition 1, is the main technical result toward the proof of Theorem 1.
The next two subsections will be dedicated to the proof of Lemma 4. Before, we show how Lemma 4 can be used to prove Theorem 1.
Proof of Theorem 1 Let |X| = n = 2m log m, and Y 1 , ..., Y m be a partition of the variables in X, where for each i, |Y i | = 2 log m.Let l i be the number of inputs of C labeled with a variable from Y i .By Lemma 3, t) .Therefore, by combining these two inequalities, we have 2 O(t) ).Since there are m = Ω( n log n ) blocks of variables Y i , we have that the number of inputs of C is at least

Defining Relations via Constraint Satisfaction Problems
In this subsection we will introduce some terminology and basic results which will be used in the proof of Lemma 4. Let X be a set of variables.An assignment of X is a function a : X → {0, 1} that associates with each variable x ∈ X a value a(x) ∈ {0, 1}.We let {0, 1} X denote the set of all assignments of X.A relation over X is any subset R ⊆ {0, 1} X .We say that each variable x ∈ X is constrained by R. In some places we write var(R) to denote the set of variables constrained by R. If a is an assignment of X, and Y ⊆ X, then we let a| Y denote the restriction of a to Y .More precisely, for each x ∈ Y , a| Y (x) = a(x).We say that an assignment a ∈ {0, The following immediate observation states that the result of restricting a relation R ⊆ {0, 1} X to a subset X and subsequently to a subset Y ⊆ X is equivalent to restricting R directly to Y .
Below, we define the notion of constraint satisfaction problem over X. Definition 3 A constraint satisfaction problem (CSP) over a set of variables X is a set of relations where for each i ∈ {1, ..., r}, R i is a relation over some subset X i ⊆ X of variables.
A CSP K over a set of variables X can be used to define a relation R(K) over X. Intuitively, the relation R(K) consists of all assignments over X that satisfy each relation in K.
Let K be a CSP over a set of variables X and let S ⊆ K.We denote by c(S) the set of variables that are simultaneously constrained by some relation in S and some relation K\S.We say that c(S) is the cutset of S with respect to K. Given a CSP K over a set of variables X, and a subset Y ⊆ X, we will deal with the problem of obtaining a CSP K with less relations than K, but with the property that The following simple lemma will be crucial for this goal.
Lemma 5 Let K = {R 1 , ..., R r } be a CSP over a set of variables X, let Y ⊆ X, and S ⊆ K be such that var(S) ∩ Y ⊆ c(S).Consider the CSP Proof First we note that K is a CSP over the set of variables X = (X\var(S)) ∪ c(S).Second, we note that the relation induced by K on X is precisely the restriction of R(K) to the variables in X .In other words, R(K)| X = R(K ).Finally, since Y ⊆ X and var(S) ∩ Y ⊆ c(S), we have that Y ⊆ X .Therefore, by Observation 1,

Circuits vs CSPs
In this section we prove Lemma 4. The idea behind the proof is the following.Let C = (V , E, g) be a circuit of carving width w computing a function f : {0, 1} Y → {0, 1}.As a first step, we associate with C a CSP K(C) over a set of variables Y ∪ {x e | e ∈ E}.This CSP has the property that R(K(C))| Y consists precisely of those assignments that cause C to evaluate to 1.In a second step, we use the fact that C has carving width w to obtain a new CSP K such that each relation in K constrains at most 2 • w variables, and such that the number of relations in K is proportional to the number of uninitialized inputs of C.This new CSP K has the property that Finally, if we are given a function f : {0, 1} X → {0, 1} and a subset Y ⊆ X of variables with |Y | = l, then we will have that there are at most 2 l•2 O(w) distinct functions arising by restricting all variables in X\Y to values in {0, 1}.Definition 4 (CSP Derived from a Circuit) Let C = (V , E, g) be a circuit whose inputs are labeled with variables from Y .We let Intuitively, the variables Y are input variables of the circuit C, while the variables {x e | e ∈ E} are used to keep track of the evaluation of the circuit C when the variables in Y are initialized.The relation R(K(C)) associated with the CSP K(C) contains all assignments of Y ∪ {x e | e ∈ E} which encode an initialization of the input variables together with an evaluation of the gates of the circuits which evaluate to 1.If we restrict the relation R(K(C)) to the variables in Y , then we recover precisely the set of assignments that cause C to evaluate to 1.
We note that the number of relations in R(K(C)) is precisely the number of gates of C, and therefore there is no a priori correspondence between the number of relations in R(K(C)) and the number of inputs of C labeled by variables in Y .The following theorem says that if C is a circuit of carving width w then one can construct a CSP K whose size is proportional to the number of inputs of C labeled with variables in Y , in such a way that the number of variables constrained by each relation in K is proportional to w, and such that Theorem 2 (CSP Reduction) Let C be a circuit of carving width w computing a function f : {0, 1} Y → {0, 1}.Let l ≥ |Y | be the number of inputs of C labeled with variables in Y .Then there exits a CSP It is worth noting that the CSP K in Theorem 2 is obtained from the CSP K(C) by applying several non-trivial simplification steps.Before proving Theorem 2 we show how this theorem can be used to prove Lemma 4.

Proof of
We note that by the way in which the CSP K b is constructed in the proof of Theorem 2, the set of variables constrained by each relation Therefore, since there are at most 2 2 O(t) possible relations for each i ∈ {1, ..., k b }, we can conclude that there are at most 2 l•2 O(t) distinct functions which can be obtained from f by restricting the variables outside Y .In other words, In the remainder of this subsection, we prove Theorem 2. Let C = (V , E, g) be a circuit of carving-width w computing a function We note that Y ∪ {x e | e ∈ E} is the set of variables constrained by relations in K.We say that a relation R v is a Yrelation if R v constrains some variable in Y .Let (T , γ ) be a carving decomposition of (V , E).For a node u of T we let leaves(T [u], Y ) denote the set of leaves u of be the sub-CSP of K(C) formed by the relations associated to vertices of C that label the leaves of the connected component T i .Let c(S i ) = var(K(C)\S i ) ∩ var(S i ) be the cut-set of S i with respect to K(C).In other words, c(S i ) is the set of variables that are constrained by some relation in S i , and another relation in K\S i .Note that c(S i ) ∩ Y = ∅, since the connected component T i has no Y -node.Additionally, the fact that (T , γ ) is a carving decomposition of C of width w implies the following claim.
Claim The number of variables in c(S i ) is at most 2 • w.

Let R i = R(S i )| c(S i )
. Then we define our CSP as follows.
Note that each subset of relations S i ⊆ K(C) corresponding to the connected component T i is replaced by a unique relation R i .By Lemma 6, there are at most 2•|leaves(T , Y )|−1 connected components in T .Therefore, the number of relations in K is upper-bounded by To prove this claim, let K 0 , K 1 , ..., K k be a sequence of CSPs where K 0 = K(C), and for each i ∈ {1, ..., k}, K i = (K i−1 \S i ) ∪ {R i }.Then clearly we have that K = K k .We claim that for each j ∈ {0, ..., k}, K j | Y = K(C)| Y .In the base case k = 0, and the claim follows trivially.Now assume that

Symmetric Non-deterministic State Complexity
Let Σ be a finite set of symbols.In this section we define the notion of symmetric non-deterministic state complexity of functions of the form f : Σ n → {0, 1} and of finite languages included in Σ n .We note that this notion is polynomially related with the size of the smallest non-deterministic oblivious, read-once branching program [35] computing f .A non-deterministic finite automaton (NFA) over Σ is a 5-tuple We write q a −→ q to denote that the triple (q, a, q ) belongs to R. We say that a string w = w 1 w 2 ...w n ∈ Σ n is accepted by A if there is a sequence q 0 −→ q n such that q 0 ∈ Q 0 and q n ∈ Q F .We denote by L(A) the set of all strings accepted by A.
Let L ⊆ Σ n be a set of length-n strings over Σ.The non-deterministic state complexity (NSC) of L, denoted nsc(L), is defined as the minimum number of states of a NFA accepting L. Let f : Σ n → {0, 1} be a function.We denote by L(f ) the set of all strings w ∈ Σ n for which f (w) = 1.We define the non-deterministic state complexity of f as nsc(f ) := nsc(L(f )).
For each positive integer n, we let Perm(n) be the set of all permutations of the set [n] = {1, ..., n}.If π : [n] → [n] is a permutation in Perm(n) and w ∈ Σ n , then we let π(w) be the string in Σ n that is defined by setting π(w) π(j ) = w j for each j ∈ [n].Intuitively, the j -th position of w is mapped to the position π(j ) of π(w).If L ⊆ Σ n is a set of length-n strings over Σ, then we denote by π(L) the language obtained from L by permuting the coordinates of each string in L according to π.More precisely, The symmetric non-deterministic state complexity (symmetric-NSC) of a language L ⊆ Σ n is defined as the minimum non-deterministic state complexity of a permuted version of L.
Definition 5 (Symmetric Nondeterministic State Complexity) Let L ⊆ Σ n .The symmetric non-deterministic state complexity of L is defined as The symmetric-NSC of a function f : Σ n → {0, 1} is defined as snsc(f ) = snsc(L(f )).
We note that the symmetric-NSC of a function f : {0, 1} n → {0, 1} is lowerbounded by the size of the smallest non-deterministic oblivious read-once |Σ|way branching program computing f .Therefore, functions requiring exponential size branching programs of this particular form have exponential symmetric non-deterministic state complexity.Two examples of such functions are the triangle-freeness function n : {0, 1} n → {0, 1}, and the triangle-parity function Clique 3,n : {0, 1} n → {0, 1}.Both functions take as input an array x = (x ij ) 1≤i<j ≤m consisting of n = m 2 Boolean variables representing an undirected graph G(x) on m vertices {1, ..., m}.The graph G(x) has an edge connecting vertices i and j , with i < j, if and only if x ij = 1.The triangle-freeness function n returns 1 on an input x if and only if the graph G(x) does not contain a triangle.The triangleparity function Clique 3,n returns 1 if and only if the parity of the number of the triangles in G(x) is odd.Building on techniques from communication complexity theory [28], it can be shown that read-once non-deterministic branching programs computing the functions n and Clique 3,n require size 2 Ω(n) [11].Therefore, the same lower bound holds for the symmetric-NSC of these functions.Theorem 3 ([11]) snsc( n ) ≥ 2 Ω(n) and snsc( Clique 3,n ) ≥ 2 Ω(n) .

On a Variant of the Element Distinctness Function
We say that a binary string w is even if w has an even number of ones.Analogously, we say that w is odd if w has an odd number of ones.For each r ∈ N, we let even(r) denote the set of all strings of even parity in the set {0, 1} r .Let Σ(m) = {1, ..., m}, and P(m) ⊆ Σ(m) m be the set of all length-m strings over Σ(m) = {1, ..., m} whose entries are pairwise distinct.Let n = ( log m + 1) • m and let b : {1, ..., m} → even( log m + 1) be an injection that maps each number j ∈ {1, ..., m} to an even binary string b(j ) of length log m + 1.We let be the binary language that is obtained from P(m) by mapping each string in P(m) to its binary representation.We define the even element distinctness function τ n : {0, 1} n → {0, 1} as the function that returns 1 on an input w ∈ {0, 1} n if and only if w ∈ B(n).Note that by definition, the symmetric-NSC of τ n is the symmetric-NSC of B(n).

Theorem 4 The function τ
The proof of Theorem 4 will use the following result.
Theorem 5 ) Let L ⊆ Σ n be a set of length-n strings over Σ, and suppose that there exists a set Then any non-deterministic finite automaton accepting L has at least k states.
The set F in Theorem 5 is called a fooling set for L. We will prove Theorem 4 by constructing, for each permutation π : [n] → [n], a fooling set F π of size 2 Ω(n/ log n) for the language π(B(n)).To construct F π it will be convenient to view strings as Boolean functions over sets of positions.In other words, if S is a set of positive integers, then a string over S is simply a Boolean function w : S → {0, 1}.We note that we allow S to be any set of positive integers and not necessarily an interval of the form [n] = {1, ..., n}.The parity of w is defined as the parity of the number of positions in which w evaluates to 1: par(w) = |{i ∈ S | w(i) = 1}| mod 2. The restriction of w to a subset T ⊆ S is the string w| T : T → {0, 1} which is defined by setting w| T (i) = w(i) for every i ∈ T .
If S ⊆ [n], w : S → {0, 1} is a string, and π : [n] → [n] is a permutation, then we let π(w) be the string w : π(S) → {0, 1} that is defined by setting w (π(i)) = w(i) for each i ∈ S. We let L = {1, ..., n/2 } and R = { n/2 + 1, ..., n} be respectively the first and the second halves of the set [n] = {1, ..., n}.We say that a permutation π : If S and S are subsets of [n] such that S ∩ S = ∅, and w : S → {0, 1} and w : S → {0, 1} are strings with domain S and S respectively, then the concatenation of w with w is simply the function w • w : S ∪ S → {0, 1} which is equal to w when restricted to S and equal to w when restricted to S .

Lemma 7
Let S be a subset of [n] = {1, ..., n}.Let L ⊆ {0, 1} n be a set of strings with domain [n] such that w| S is even for every w ∈ L. Let π : [n] → [n] be a permutation, and w 1 and w 2 be binary strings with domain [n] such that We show that w / ∈ π(L).The proof is by contradiction.Assume that w ∈ π(L).Since π(w 1 )| π(S)∩L is even and π(w 2 )| π(S)∩R is odd, we have that w| π(S) is odd.But by definition, w ∈ π(L) if and only if there exists w ∈ L such that w = π(w ).Since by assumption w | S is even for every w ∈ L, we have that π(w )| π(S) = w| π(S) is also even.Thus we have reached a contradiction and we conclude that w / ∈ π(L).The proof that π(w 2 )| π(S)∩L • π(w 1 )| π(S)∩R / ∈ L is analogous.
Let n = (1 + log m ) • m, and let I 1 , ..., I m be the sequence of subsets of [n] such that for each i ∈ [m], In other words, I 1 , ..., I m is a partition of the set [n] into m consecutive intervals of equal size.We say that I 1 , ..., I m is the uniform interval partition of [n].

Lemma 8 Let π : [n] → [n]
be a permutation where n = ( log m + 1) • m, and let I 1 , ..., I m be the uniform interval partition of [n].Let w 1 and w 2 be strings in B(n) such that for some i, j ∈ [m], with i = j , the following conditions are satisfied.
We show that w / ∈ π(B(n)).The proof is by contradiction.Assume that w ∈ π(B(n)).Then there is a string w ∈ B(n) such that w = π(w ).Since by assumption, π(I i ) ⊆ L and π(I j ) ⊆ R, Now let π −1 be the inverse of π.Then, w = π −1 (w).Additionally, But by assumption, w 1 | I i ≡ w 2 | I j , and therefore, w | I i ≡ w | I j .This contradicts the assumption that w ∈ B(n), since for each string w ∈ B(n) and each i, j ∈ [m] with i = j , we must have w and I 1 , ..., I m be the uniform interval partition of [n].Let I i 1 , ..., I i k , I 1 , ..., I l and I r 1 , ..., I r l be pairwise distinct intervals of this partition satisfying the following conditions.1.I i j is split by π for every j ∈ {1, ..., k}. 2. π(I j ) ⊆ L and π(I r j ) ⊆ R for each j ∈ {1, ..., l}.
2. c j : I j → {0, 1} are strings with domain I j .3. d j : I r j → {0, 1} are strings with domain I r j .4. π(a j )| π(I i j )∩L is even and π(a j )| π(I i j )∩R is even.

π(b j )| π(I i j )∩L is odd and π(b j )| π(I i j )∩R is odd.
Next, we define a set of 2 k+l strings which will give rise to a fooling set for π(B(n)) of size 2 k+l .For each (k + l) tuple of bits x ∈ {0, 1} k , y ∈ {0, 1} l , let w[xy] be any string in B(n) satisfying the following properties.In other words, for each j ∈ {1, ..., k}, the substring of w[xy] corresponding to the positions in I i j is either equivalent to a j (if x j = 0), or equivalent to b j (if x j = 1).Analogously, for each j ∈ {1, ..., l}, either the substring corresponding to the positions I j is equivalent to c j and the substring corresponding to I r j is equivalent to d j (if y j = 0), or vice-versa (if y j = 1).Now we let F k,l π be the set of pairs of strings obtained by splitting the permuted version π(w[xy]) of each string w[xy] into two parts of equal size.

Theorem 6
The set F k,l π defined in (8) is a fooling set for π(B(n)) of size 2 k+l .
Proof It should be clear that, by construction, the set F k,l π has 2 k+l pairs.Therefore, we just need to show that if xy and x y are (k + l)-bit strings differing in at least one entry, then neither Note that since xy = x y , we have that x j = x j for some j ∈ {1, ..., k}, or y j = y j for some j ∈ {1, ..., l} (or both).
First, suppose that x j = x j for some j ∈ {1, ..., k}.We may assume without loss of generality that x j = 0 and x j = 1, since otherwise we may just swap the roles of the strings xy and x y .

Since w[xy]| I i j ≡ a j , we have that π(w[xy])| π(I i j )∩L is even and π(w[xy])| π(I
Now suppose that y j = y j for some j ∈ {1, ..., l}.We may assume without loss of generality that y j = 0 and y j = 1, since otherwise, we may simply swap the roles of xy and x y .Under this assumption, Next, we will show that one can always choose appropriate values for k and l in such a way that the fooling set F k,l π has size at least 2 m/4 = 2 Ω(n/ log n) .We start by stating the following proposition, which is a straightforward consequence of Hall's marriage theorem [10].
Proposition 2 Let G = (A ∪B, E) be a bipartite graph with vertex partitions A and B be such that |A| ≤ |B|.If each vertex in A has degree at least |A| then G has a matching of size |A|.

Proof
The proof is by induction on the size of A. In the base case, in which |A| = 1, the proposition holds trivially.Now assume the proposition holds for every graph such that |A| ≤ n.Let G = (A ∪B , E ) be a graph such that |A | = n + 1. Select an arbitrary edge v, u where v ∈ A and u ∈ B .Let G = (A ∪B, E) be the graph obtained by deleting v and u together with all edges incident with these vertices.Then we have that each vertex in A has at least n neighbors.By the induction hypothesis, G has a matching M = {{v 1 , u 1 }, ..., {v n , u n }}.Then we have that M ∪ {{v, u}} is a matching for G .Proposition 2 will be used to prove the following crucial lemma.
be a permutation, and I 1 , ..., I m be the uniform interval partition of [n].Let I i 1 , ..., I i k be the intervals that are split by π.If k ≤ m/4 then there exists a sequence a 1 , ..., a k , b 1 , ..., b k of pairwise inequivalent even strings where for each j ∈ {1, ..., k}, a j , b j : I i j → {0, 1} are strings with domain I i j , and the following conditions are satisfied.

π(b j )| π(I i j )∩L is odd and π(b j )| π(I i j )∩R is odd.
Proof Let M = {1, ..., log m + 1}.If s : M → {0, 1} is a string with domain M, then for each j ∈ {1, ..., k}, we let p s j : I i j → {0, 1} be the string with domain I i j such that p s j ≡ s.Let G = (A ∪ B, E) be a bipartite graph whose vertex set is partitioned into sets For each j ∈ {1, ..., k}, we add the edge {a j , v s } to E if and only if π(p s j )| π(I i j )∩L is even and π(p s j )| π(I i j )∩R is even.Analogously, we add the edge {b j , v s } to E if and only if π(p s j )| π(I i j )∩L is odd and π(p s j )| π(I i j )∩R is odd.We note that since there are 2 |π(I i j )∩L|−1 even strings with domain π(I i j ) ∩ L, and 2 |π(I i j )∩R|−1 even strings with domain π(I i j ) ∩ R, we have that there are 2 Now, assume that the number k of intervals split by π is less than m/4.The following proposition states that there are plenty of pairs of the form (I j , I r j ) such that π(I j ) ⊆ L and π(I r j ) ⊆ R. ).Now we have that for each position q ∈ L , there must exist an interval I s which is not split by π such that q ∈ π(I s ) ⊆ L. This implies that there must exist at least l = m/2 − 1 − k intervals I 1 , ..., I l such that π(I j ) ⊆ L for each j ∈ {1, ..., l}.By a similar reasoning, there exists l intervals I r 1 , ..., I r l such that π(I r j ) ⊆ R for every j ∈ {1, ..., l}.
By combining Lemma 9 with Proposition 3, we have the following theorem.Therefore, these strings can be used to define the fooling set F m 4 ,0 π .On the other hand, if k < m/4, then Proposition 3 implies that there are at least l = m/2 − 1 − k ≥ m/4 pairs ( 1 , r 1 ), ( 2 , r 2 ), ..., ( l , r l ) such that π(I j ) ⊆ L and π(I r j ) ⊆ R for every j ∈ {1, ..., l}.Let c 1 , ..., c m/4 , d 1 , ..., d m/4 be pairwise inequivalent even strings such that for each j ∈ {1, ..., m/4}, c j : I j → {0, 1} is a string with domain I j , and d j : I r j → {0, 1} is a string with domain I r j .Note that these strings exist, since there are at least m even distinct strings with domain I j and m even distinct strings with domain I r j for each j ∈ {1, ..., k}.Therefore, these strings can be used to construct the fooling set F 0,m/4 .

Super-Linear Lower Bounds for Read-Once Circuits Excluding a Minor
In this section we show that exponential lower bounds for the symmetric nondeterministic complexity of a function f n : {0, 1} n → {0, 1} imply super-linear lower bounds for the size of read-once circuits excluding a fixed graph H as a minor.We start by establishing a connection between the symmetric-NSC of a circuit, and its pathwidth.More precisely, we show that any function that can be computed by a read-once circuit of pathwidth k has symmetric-NSC at most 2 k • |C|.Definition 6 (Path Decomposition) A path decomposition of a circuit C = (V , E, g) is a sequence P = (B 1 , B 2 , ..., B m ) of subsets of vertices of G satisfying the following properties.
iii) For each edge (u, v) ∈ E there is an j such that {u, v} ⊆ B j .
The sets B i are the bags of the decomposition.The path-width of P is defined as the size of its largest bag minus one.In other words pw(G, P) = max i {|B i |}−1.The pathwidth of a graph G is defined as pw(G) = min P pw(G, P) where P ranges over all path decompositions of G. Let C be a read-once circuit and P = (B 1 , B 2 , ..., B m ) be a path decomposition of C. If v is a vertex of C then we let first(v, P) denote the smallest i such that v ∈ B i .We say that a path decomposition P is ordered if for each two vertices v and v , we have that first(v, P) = first(v , P).It can be shown that if a circuit C has m vertices and pathwidth w, then C has an ordered path decomposition with O(m) bags and width O(w).If P is an ordered path decomposition of a readonce circuit C and x is a variable labeling input v, then we define first(x, P) = first(v, P).
Theorem 8 Let C be a read-once circuit and P = (B 1 , B 2 , ..., B m ) be a good path decomposition of C of width w.Let x 1 x 2 ...x n be an ordering of the variables of C such that first(x i , P) < first(x i+1 , P) for each i ∈ {1, ..., n − 1}.Then for each b ∈ Σ, one can construct an NFA with m • |Σ| O(w) states accepting the following language.
Theorem 8 will be proven Section 5.1.As a corollary of Theorems 8 and 4 we have a trade-off between the size of a circuit and its pathwidth.
Theorem 9 Let f n : {0, 1} n → {0, 1} be a function of symmetric-NSC snsc(f n ).Then for any read-once circuit computing f n , the following inequality is satisfied.
It is well known that the pathwidth of any graph is greater than its treewidth by at most a multiplicative logarithmic factor [5].In other words, the following relation between the pathwidth and treewidth of a circuit (graph) can be verified: pw(C) ≤ tw(C) • O(log |C|).Therefore, stated in terms of treewidth, (9)  Therefore, combining (10) with Theorem 10 we have the following theorem.We say that a circuit C is H -minor-free if its underlying undirected graph is H -minorfree.
Theorem 11 Let C be an H -minor-free, read-once circuit computing a Boolean Finally, as a corollary of Theorems 11, 3 and 4 we have that the trianglefreeness function n , the triangle-parity function Clique 3,n and the even element distinctness function τ n require H -minor-free read-once circuits of near quadratic size.).

Proof of Theorem 8
Let C be a read-once circuit and P = (B Intuitively, if u is an in-neighbor of v, then u belongs to AI(i, v) if B i is the first bag containing both u and v together.We note that for each edge (u, v) ∈ E there exists a unique i such that u ∈ AI(i, v).Intuitively, given an initialization for the input variables of C, we will simulate the evaluation of the gates of C directly into the path decomposition P = (B 1 , B 2 , ..., B m ).The value of a vertex v is computed gradually while the path decomposition is traversed from left to right.For each i, the set AI(i, v) consists of those vertices in B i whose value will be taken into consideration toward the computation of the total value of v.This process is well defined due to the fact that for each in-neighbor u of v, there exists precisely one i for which u ∈ AI(i, v).
The process of propagating the value of a circuit along a path decomposition can be formalized via the notion of evaluation defined below (Definition 7).If v is a vertex of C labeled with a ⊕-gate of arity k and AI(i, v) = {u 1 , ..., u r }, then we write u∈AI(i,v) t i (u) as a shortcut for t i (u 1 ) ⊕ t i (u 2 ) ⊕ ... ⊕ t i (u r ).Note that since the operation ⊕ is assumed to be associative and commutative, we do not need to worry with brackets nor with the order in which operations are performed.Also, for simplicity, we may assume that the operation ⊕ has an identity5 so that we can set u∈AI(i,v) t i (u) as the identity of ⊕ whenever AI(i, v) is empty.

For every
For each i, and each vertex v ∈ B i , we say that t i (v) is the total evaluation of v on bag B i , while p i (v) is the partial evaluation of v on B i .Intuitively the value of t i (v) is preemptively guessed, and t i (v) = t j (v) for each two bags B i and B j containing v. On the other hand, the partial evaluation p i (v) keeps track of the partial sum corresponding to all inputs of v that have appeared up to bag B i .At the last bag in which v occurs, the partial evaluation of v must equal its total evaluation.
To formalize the intuitive explanation given above, let E be an evaluation of C on P and let I E : Inputs(C) → Σ denote the function that initializes the inputs of C consistently with the values assigned by E to these inputs along the path decomposition.More precisely, for each input u of C, I E (u) = a if and only if there is some i such that u ∈ B i and t i (u) = a.We denote by val(C, I E , v) the value of the circuit at gate v when the inputs of C are initialized according to I E .Lemma 10 below states that an evaluation E of a read-once circuit C on a path decomposition P is consistent with the computation realized by C when its inputs are initialized according to I E .In other words, val(C, I E , v) = t i (v) for each i and each v ∈ B i .
Lemma 10 Let C be a read-once circuit, P = (B 1 , B 2 , ..., B m ) be a path decomposition of C and E = (p 1 , t 1 )...(p m , t m ) be an evaluation of C on P. Then for each i ∈ {1, ..., m}, and each vertex v ∈ B i , t i (v) = val(C, I E , v).
Proof The proof is by induction on the depth of the vertex v in C. In the base case, v is an input vertex.In this case, there exists some i for which v ∈ B i and I E (v) = val(C, I E , v) = t i (v).Since the total sum t i (v) has the same value for each bag containing the vertex v, we have that t j (v) = I E (v).Now assume that the claim is valid for every vertex of depth at most d and let v be a vertex of depth d + 1.Note that for each edge (u, v) there is a unique j such that u ∈ AI(j, v).Therefore, by Condition 1b and Condition 2b, we have that if i = last(v, P), then p i (v) = (u,v)∈E t (u) = (u,v)∈E val(C, I E , u) = val(C, I E , v).Since by Condition 1c, p i (v) = t i (v), we have that t i (v) = val(C, I E , v).
Let C be a read-once circuit.For each variable x labeling a vertex v of C, we write first(x, P) in place of first(v, P).In other words, first(x, P) denotes the index of the first bag of P in which the vertex v occurs.Note that first(x, P) is well defined, since in a read-once circuit each input variable labels at most one vertex.Now let x 1 , ..., x n be the sequence of all variables labeling inputs of C, such that first(x j , P) < first(x j +1 , P) for each j ∈ {1, ..., n}.Then an assignment to the inputs of C can be represented by a string a = a 1 a 2 ...a n where for each j ∈ {1, ..., n}, a j is the value assigned to variable x j .
Proof of Theorem 8 For each i ∈ {1, ..., m}, we say that a pair of functions p, t : B i → Σ is an assignment for B i , if together, p and t satisfy Conditions 1a-1c of Definition 7. In our first step toward the proof of Theorem 8, we will construct an NFA that accepts all sequences of assignments encoding an evaluation of C on P. To make this notion precise, for each i ∈ {1, ..., m}, let i = {(p, t) | (p, t) is an assignment for B i } be the set of all assignments for B i .Since the width of P is w, we have that | i | ≤ |Σ| 2w .We say that i is the alphabet of assignments of B i .Now let = m i=1 i .We construct an NFA A = (Q, , , Q 0 , F ) that accepts a string E = (p 1 , t 1 )(p 2 , t 2 )...(p m , t m ) over if and only if E is an evaluation of C on P. The set of states Q = Q 0 ∪ Q 1 ∪... ∪ Q m is partitioned into m + 1 levels.The level Q 0 = {q 0 } has a unique initial state.For each i ∈ {1, ..., m}, the level Q i = {q i,p,t |(p, t) ∈ i } has one state q i,p,t for each assignment (p, t) of the bag B i .The final states of A are those lying at Q m , that is to say, F = Q m .We say that an assignment (p i , t i ) of B i is compatible with an assignment (p i+1 , t i+1 ) of B i+1 if the functions p i , p i+1 , t i and t i+1 satisfy Conditions 2b and 2b of Definition 7.
The transition relation has one transition (q 0 , (p 1 , t 1 ), q 1,p 1 ,t 1 ) for each assignment (p 1 , t 1 ) of the bag B 1 , and one transition (q i,p i ,t i , (p i+1 , t i+1 ), q i+1,p i+1 ,t i+1 ) for each pair (p i , t i ) and (p i+1 , t i+1 ) of compatible assignments.It is straightforward to check that A accepts a string E = (p 1 , t 1 )(p 2 , t 2 )...(p m , t m ) if and only if for each i ∈ {1, ..., m}, (p i , t i ) is an assignment of B i , and for each i ∈ {1, ..., m − 1}, (p i , t i ) is compatible with (p i+1 , t i+1 ).In other words, E is accepted by A if and only if E is an evaluation of C on P. Now, let v be the output vertex of C. Let A be the automaton over obtained by deleting all states q i,p,t such that v ∈ B i and t (v) = b.Then we have that A accepts an evaluation E if and only if it causes the circuit C to evaluate to b.
Finally, we will construct an automaton A that extracts from each such evaluation E, only the information concerning the assignments of values to the uninitialized variables.Let i 1 = first(x 1 , P), ..., i n = first(x n , P) and let v i be the unique input vertex of C labeled with x i .Consider the projection α : → {0, 1, ε} (where ε is the empty string) whose action is defined as follows.If we regard the symbol ε as being the empty string symbol, then the automaton α(A) may be regarded as an automaton with ε-transitions that accepts a string a 1 a 2 ...a n ∈ Σ n if and only if the circuit C evaluates to b when its inputs x 1 x 2 ...x n are are initialized with a 1 a 2 ...a n .This automaton can be transformed into an automaton without ε-transitions with the same number of states by folklore results in automata theory.

Lemma 4
Let f : {0, 1} X → {0, 1} be a Boolean function which is computable by a circuit C of treewidth t.By Lemma 2, there exists a circuit C of size |C | ≤ O(|C|), maximum degree 3 and carving width w = O(t) such that C computes f .Additionally, for each variable x, the number of input vertices labeled with x in C is equal to the number of input vertices labeled with x in C .Now let Y ⊆ X.Then each initialization b ∈ {0, 1} X\Y of the variables in X\Y , gives rise to a circuit C b in which all l uninitialized inputs are labeled with variables in Y .Let f b : {0, 1} Y → {0, 1} be the function computed by the circuit C b .By Theorem 2, there is a CSP K R b i does not depend on the initialization b.In other words, for each two distinct initializations b, b ∈ {0, 1} X\Y , we have that k b = k b and that R b i constrains the same variables as R b i for each i ∈ {1, ..., k b }.
then we say that a node u = u is the Y -parent of u if u is the ancestor of u at minimal distance from u with the property that u is itself a Y -node.We let nodes(T , Y ) denote the set of all Y -nodes of T .Lemma 6 |nodes(T , Y )| = 2 • |leaves(T , Y )| − 1.Proof First, we show that if u is an internal Y -node of T then u has precisely two Y -children.Suppose that u has at most one Y -child.Then by definition u is not a Ynode, since in this case either leaves(T [u.l], Y ) = ∅ or leaves(T [u.r], Y ) = ∅.Now suppose that u has at least 3 Y -children.Since T is a binary tree, two Y -children of u are either descendants of u.l or descendants of u.r.Lets assume that z and z are two distinct Y -children of u which are also descendants of u.l.We observe that neither z is a descendant of z nor z is a descendant of z, since otherwise, only one of these two vertices could have been a Y -child of u.Now let u be the closest ancestor of z which is also an ancestor of z .Then u is by definition a Y -node.Since u is a strict descendant of u, this contradicts the assumption that u is the Y -parent of z and z .Now let T [Y ] be the tree whose nodes are Y -nodes of T and such that (u, v) is an arc of T [Y ] if and only if u is the Y -parent of v. Then by the discussion above we have that T [Y ] is a binary tree with |leaves(T , Y )| leaves.Since any binary tree with l leaves has l − 1 internal nodes, the total number of Y -nodes in T is 2 • |leaves(T , Y )| − 1.Now let T = T \nodes(T , Y ) be the forest which is obtained by deleting from T all of its Y -nodes.Then the number of connected components in the forest T is at most |nodes(T , Y )| = 2|leaves(T , Y )| − 1.We let T 1 , ..., T k , for k ≤ |nodes(T , Y )| be the connected components of T .For each i ∈ {1, ..., k}, let [n] → [n] splits a subset S ⊆ [n] if π(S) ∩ L = ∅ and π(S) ∩ R = ∅.In other words, π splits S if some elements of S are mapped by π to the first half of [n] and some elements of S are mapped by π to the second half of [n].

Theorem 7 , m 4 π
Let n = m•( log m +1), π : [n] → [n] be a permutation, and I 1 , ..., I m be the uniform interval partition [n].Let k be the number of intervals split by π.If k ≥ m/4, then the fooling set F m 4 ,0 π is well defined.If k < m/4, then the fooling set F 0is well defined.Proof Let I i 1 , I i 2 , ..., I i k be the intervals that are split by π.If k ≥ m/4, then by Lemma 9, there exists pairwise inequivalent strings a 1 , ..., a m/4 , b 1 , ..., b m/4 such that a j , b j : I i i → {0, 1} are strings with domain I i j , where both π(a j )| π(I i j )∩L and π(a j )| π(I i j )∩R are even, and both π(b j )| π(I i j )∩L and π(b j )| π(I i j )∩R are odd.

Corollary 1
Let C, C and C be H -minor-free, read-once circuits computing the triangle-freeness function n , the triangle-parity function Clique 3,n and the even element distinctness function τ n respectively.Then |C| ≥ Ω( be the CSP over the variables Y ∪ {x e | e ∈ E} which is defined as follows. .If v is the output vertex of C, and v is the target of edges e 1 , ..., e k , then R v is a relation over the variables Y v = {x e 1 , ..., .xe k }, and a : {x e 1 , ..., x e k } → Σ is in R 1.If v is an input vertex labeled by g with a variable x, and v is the source of edges e 1 , ..., e k , then R v is a relation over the variables Y v = {x, x e 1 , ..., x e k }, and an assignment a : Y v → Σ is in R v if and only if a(x) = a(x e 1 ) = ... = a(x e k ). 2. If v is an internal vertex labeled with a gate g(v), v is the target of edges e 1 , ...e k , and v is the source of edges e 1 , ..., e k , then R v is a relation over the variables Y v = {x e 1 , ..., x e k , x e 1 , ..., x e k }, and an assignment a : Y v → Σ is in R v if and only if g(v)(a(x e 1 ), ..., a(x e k )) = a(x e 1 ) = ... = a(x e k ).v if and only if g(v)(x e 1 , ..., x e k ) = 1.
|π(I i j )|−2 ≥ m/2 strings which are even in both π(I i j ) ∩ L and in π(I i j ) ∩ R. Therefore, the vertex a j has at least m/2 neighbors.Analogously, the vertex b j has at least m/2 neighbors.Since k ≤ m/4, we have that |A| ≤ m/2.Therefore, by Proposition 2, G has a matching M with k edges.Now, for each j ∈ {1, ..., k}, we set a j = p s j if and only if the edge {a j , v s } belongs to M. Analogously, we set b j = p s j if and only if the edge {b j , v s } ∈ M. Since M is a matching, all strings a 1 , ..., a k , b 1 , ..., b k are pairwise inequivalent.