#### DMCA

## Constructing Small Tree Grammars and Small Circuits for Formulas (2014)

### Citations

259 | The parallel evaluation of general arithmetic expressions - Brent - 1974 |

136 |
A combinatorial problem.
- Bruijn
- 1946
(Show Context)
Citation Context ...n-theoretic argument shows that for almost all strings of length n, the smallest SLP has size Ω(n/ logσ n). For SLPs, one can, in contrast to other models like Boolean circuits, construct explicit strings that achieve this worst-case bound: FSTTCS 2014 460 Constructing Small Tree Grammars and Small Circuits for Formulas I Proposition 1. Let Σ be an alphabet of size σ. For every n ≥ σ2, one can construct in time poly(n, σ) a string sσ,n ∈ Σ∗ of length n such that every SLP for sσ,n has size Ω(n/ logσ n). Proof. Let r = dlogσ ne ≥ 2. The sequence sσ,n is in fact a prefix of a de Bruijn sequence [9]. Let x1, . . . xσr−1 be a list of all words from Σr−1. Construct a directed graph by taking these strings as vertices and drawing an a-labelled edge (a ∈ Σ) from xi to xj if xi = bw and xj = wa for some w ∈ Σr−2 and b ∈ Σ. This graph has σr edges and every vertex of this graph has indegree and outdegree σ. Hence, it has a Eulerian cycle, which can be viewed as a sequence u, b1, b2, . . . , bσr , where u ∈ Σr−1 is the start vertex, and the edge traversed in the ith step is labelled with bi ∈ Σ. Define sσ,n as the prefix of ub1b2 · · · bσr of length n. The construction implies that sσ,n has n− ... |

117 |
Variations on the common subexpression problem.
- Downey, Sethi, et al.
- 1980
(Show Context)
Citation Context ...h of the derivation tree DG . For instance, the depth of the TSLP from Example 2 is 4. A commonly used compact tree compression scheme is obtained by writing down repeated subtrees only once. In that case all occurrences except for the first are replaced by a pointer to the first one. This leads to a node-labelled directed acyclic graph (dag). It is known that every tree has a unique minimal dag, which is called the the dag of the initial tree. An example can be found in Figure 2, where the right graph is the dag of the tree in the middle. The dag of a tree t can be constructed in time O(|t|) [10]. Dags correspond to TSLPs where every nonterminal has rank 0. 4 Constructing a small TSLP for a tree In this section we construct a TSLP G for a given tree t of size n. We then prove that |G |∈ O(n/ logn). For the remainder of this section we restrict our input to binary trees, i. e., every node has either zero or two children. Formally, we consider trees from T (F0 ∪ F2). The following idea of splitting a tree recursively into smaller parts of roughly equal size is well-known, see e. g. [4, 26]. For our later analysis, it is important to bound the number of parameters in the resulting nonter... |

107 | Fast Parallel Computation of Polynomials Using Few Processors. - Valiant, Skyum, et al. - 1983 |

93 |
The Art of Computer Programming, Vol. I, Fundamental Algorithms.
- Knuth
- 1968
(Show Context)
Citation Context ...tforward to adapt our algorithm to trees where every node has at most r children for a fixed constant r. One only has to prove a version of Lemma 3 for r-ary trees. The multiplicative constant in the O ( n logσ n ) bound for the final TSLP will depend on r. On FSTTCS 2014 466 Constructing Small Tree Grammars and Small Circuits for Formulas the other hand, for unranked trees, where the number of children of a node is arbitrary, our algorithm does not work. This problem can be solved by transforming an unranked tree into a binary tree of the same size using the first-child next-sibling encoding [18]. For this binary tree we get a TSLP of size O ( n logσ n ) . For traversing a compressed unranked tree t, another well-known encoding is favorable. Let ct be a compressed representation (e. g., a TSLP) of t. The goal is to represent t in space O(|ct|) such that one can efficiently navigate from a node to (i) its parent node, (ii) its first child, (iii) its next sibling, and (iv) its previous sibling (if they exist). For top dags [3], it was shown that a single navigation step can be done in time O(log |t|). Using the right binary encoding, we can prove the same result for TSLPs: Let r be the ... |

82 |
Grammar-based codes: A new class of universal lossless source codes,
- Kieffer, Yang
- 2000
(Show Context)
Citation Context ... be a constant larger than one in the further discussion). An information-theoretic argument shows that for almost all strings of length n (up to an exponentially small part) the smallest SLP has size Ω( nlogn ). Explicit examples of strings for which the smallest SLP has size Ω( nlogn ) result from de Bruijn sequences; see Section 2. On the other hand, many grammar-based compressors produce for every string of length n an SLP of size O( nlogn ). This holds for instance for the above mentioned LZ78, RePair, and BISECTION, and in fact for all compressors that produce so-called irreducible SLPs [16]. This fact is used in [16] to construct universal string compressors based on grammar-based compressors. In this paper, we follow the latter approach, but for trees instead of strings. A tree in this paper is always a rooted ordered tree over a ranked alphabet, i. e., every node is labelled with a symbol and the rank of this symbol is equal to the number of children of the node. In [6], grammar-based compression was extended from strings to trees. For this, linear context-free tree grammars were used. Linear context-free tree grammars that produce only a single tree are also known as tree str... |

80 | Application of Lempel-Ziv factorization to the approximation of grammar-based compression. - Rytter - 2003 |

70 |
Tree-size bounded alternation
- RUZZO
- 1980
(Show Context)
Citation Context ...e the tree into pieces of roughly equal size, using a well-known lemma from [19]. But care has to be taken to bound the ranks of the nonterminals of the resulting TSLP. As soon as we get a tree with three holes during the decomposition (which corresponds in the TSLP to a nonterminal of rank three) we do an intermediate step that decomposes the tree into two pieces having only two holes each. This may involve an unbalanced decomposition. On the other hand, such an unbalanced decomposition is only necessary in every second step. This trick to bound the number of holes by three was used by Ruzzo [25] in his analysis of space-bounded alternation. The TSLP produced in the first step can be identified with its derivation tree. Thanks to the fact that all nonterminals have rank at most three, we can encode the derivation tree by a tree with O(σ) many labels. Moreover, this derivation tree is weakly balanced in the following sense. For each edge (u, v) in the derivation tree such that both u and v are internal nodes, the derivation tree is balanced at u or v. These facts allow us to show that the minimal dag of the derivation tree has size at most O( nlogσ n ). The nodes of this dag are the no... |

62 | The smallest grammar problem. - Charikar, Lehman, et al. - 2005 |

57 |
On the OBDDrepresentation of general Boolean functions",
- Liaw, Lin
- 1992
(Show Context)
Citation Context ...orem with n leaves. Moreover, let us fix a number k ≥ γ that will be defined later. Let top(t, k) be the tree obtained from t by FSTTCS 2014 464 Constructing Small Tree Grammars and Small Circuits for Formulas ≤k ≤k v1 v′1 v2 v′2 v3 v′3 v4 v′4 v5 ≥βk ≥βk ≥β(1+β)k ≥β(1+β)k ≥k or or Figure 3 A chain within a top tree. The subtree rooted at v1 has more than k leaves. removing all nodes with leaf size at most k. We first bound the number of different subtrees with at most k leaves in t. Afterwards we will estimate the size of the remaining tree top(t, k). The same strategy is used for instance in [13, 20] to derive a worst-case upper bound on the size of binary decision diagrams. Claim 1. The number of different subtrees of t with at most k leaves is bounded by dk with d = 4σ2. A subtree of t with i leaves has exactly 2i− 1 nodes, each labelled with one of σ labels. Let Cm = 1m+1 (2m m ) be the mth Catalan number. It is known that Cm ≤ 4m. If the labels are ignored, there are Ci−1 different subtrees with i leaves. In conclusion, we get the following bound: ∑k i=1 Ci−1 · σ2i−1 ≤ ∑k−1 i=0 4i · σ2i+1 = σ (4σ2)k−1 4σ2−1 ≤ (4σ 2)k. Claim 2. The number of nodes of top(t, k) is bounded by c · nk for ... |

50 | Efficient memory representation of XML document trees
- Busatto, Lohrey, et al.
- 2008
(Show Context)
Citation Context ...duce for every string of length n an SLP of size O( nlogn ). This holds for instance for the above mentioned LZ78, RePair, and BISECTION, and in fact for all compressors that produce so-called irreducible SLPs [16]. This fact is used in [16] to construct universal string compressors based on grammar-based compressors. In this paper, we follow the latter approach, but for trees instead of strings. A tree in this paper is always a rooted ordered tree over a ranked alphabet, i. e., every node is labelled with a symbol and the rank of this symbol is equal to the number of children of the node. In [6], grammar-based compression was extended from strings to trees. For this, linear context-free tree grammars were used. Linear context-free tree grammars that produce only a single tree are also known as tree straight-line programs (TSLPs) or straight-line context-free tree grammars (SLCF tree grammars). TSLPs generalize dags (directed acyclic graphs), which are widely used as a compact tree representation. Whereas dags only allow to share repeated subtrees, TSLPs can also share repeated internal tree patterns. Several grammar-based tree compressors were developed in [1, 6, 15, 23]. The algorit... |

45 |
On time-hardware complexity tradeoffs for Boolean functions
- Spira
- 1971
(Show Context)
Citation Context ...is 2n− o(n)). It is important to note that our size bound O( nlogσ n ) only holds for ranked trees and does not directly apply to unranked trees (that are, for instance, the standard tree model for XML). To overcome this limitation, one can transform an unranked tree of size n into its first-child-next-sibling encoding [18, Paragraph 2.3.2], which is a ranked tree of size n. Then, the first-child-next-sibling encoding can be transformed into a TSLP of size O( nlogσ n ). Our main result has an interesting application for the classical problem of transforming formulas into small circuits. Spira [26] has shown that for every Boolean formula of size n there exists an equivalent Boolean circuit of depth O(logn) and size O(n). Brent [4] extended Spira’s theorem to formulas over arbitrary semirings and moreover improved the constant in the O(logn) bound. Subsequent improvements that mainly concern constant factors can be found in [5]. An easy corollary of our O( nlogσ n ) bound for TSLPs is that for every (not necessarily commutative) semiring (or field), every formula of size n, in which only m ≤ n different variables occur, can be transformed into a circuit of depth O(logn) and size O(n·log... |

32 | Tree Automata Techniques and Applications. http://tata. gforge.inria.fr - Comon, Dauchet, et al. - 2007 |

26 | A fully linear-time approximation algorithm for grammar-based compression. - Sakamoto - 2005 |

23 | Universal Lossless Compression Via Multilevel Pattern Matching.
- Kieffer, Yang, et al.
- 2000
(Show Context)
Citation Context ...as shown that the so-called top dag of an unranked and unlabelled tree of size n has size O( nlog0.19 n ) [3]. The top dag can be seen as a slight variant of a TSLP for an unranked tree. In this paper, we present a grammar-based tree compressor that transforms a given node-labelled ranked tree of size n with σ different node labels into a TSLP of size O( nlogσ n ) and depth O(logn), where the depth of a TSLP is the depth of the corresponding derivation tree. In particular, for an unlabelled binary tree we get a TSLP of size O( nlogn ). Our compressor is an extension of the BISECTION algorithm [17] from strings to trees and works in two steps (the following outline works only for binary trees, but it can be easily adapted to trees of higher ranks): In the first step, we hierarchically decompose the tree into pieces of roughly equal size, using a well-known lemma from [19]. But care has to be taken to bound the ranks of the nonterminals of the resulting TSLP. As soon as we get a tree with three holes during the decomposition (which corresponds in the TSLP to a nonterminal of rank three) we do an intermediate step that decomposes the tree into two pieces having only two holes each. This m... |

17 | Size-depth tradeoffs for algebraic formulas.
- Bshouty, Cleve, et al.
- 1995
(Show Context)
Citation Context ....3.2], which is a ranked tree of size n. Then, the first-child-next-sibling encoding can be transformed into a TSLP of size O( nlogσ n ). Our main result has an interesting application for the classical problem of transforming formulas into small circuits. Spira [26] has shown that for every Boolean formula of size n there exists an equivalent Boolean circuit of depth O(logn) and size O(n). Brent [4] extended Spira’s theorem to formulas over arbitrary semirings and moreover improved the constant in the O(logn) bound. Subsequent improvements that mainly concern constant factors can be found in [5]. An easy corollary of our O( nlogσ n ) bound for TSLPs is that for every (not necessarily commutative) semiring (or field), every formula of size n, in which only m ≤ n different variables occur, can be transformed into a circuit of depth O(logn) and size O(n·logmlogn ). Hence, we refine the size bound from O(n) to O( n·logm logn ) (Theorem 9). Another interesting point of our formula-to-circuit conversion is that most of the construction (namely the construction of a TSLP for the input formula) is purely syntactic. The remaining part (the transformation of the TSLP into a circuit) is straigh... |

17 | Analytic variations on the common subexpression problem
- Flajolet, Sipala, et al.
- 1990
(Show Context)
Citation Context ...hecking and the evaluation of tree automata can be done in polynomial time for TSLPs. It is interesting to compare our O( nlogσ n ) bound with the known bounds for dag compression. A counting argument shows that for almost all unlabelled binary trees, the size of a smallest TSLP is Ω( nlogn ), and hence (by our main result) Θ( n logn ). This implies that the average size of the minimal TSLP, where the average is taken for the uniform distribution on unlabelled binary trees of size n, is Θ( nlogn ) as well. In contrast, the size of the minimal dag for trees of size n is Θ(n/ √ logn) on average [11] but n in the worst case. 2 Strings and Straight-Line Programs Before we come to grammar-based tree compression, let us briefly discuss grammar-based string compression. A straight-line program, briefly SLP, is a context-free grammar that produces a single string. Formally, it is a tuple G = (N,Σ, P, S), where N is a finite set of nonterminals, Σ is a finite set of terminal symbols (Σ ∩ N = ∅), S ∈ N is the start nonterminal, and P is a finite set of productions of the form A → w for A ∈ N , w ∈ (N ∪Σ)∗ such that: (i) if (A→ u), (A→ v) ∈ P then u = v, and (ii) the binary relation {(A,B) ∈ N × ... |

15 | Lower bounds for non-commutative computation (extended abstract). - Nisan - 1991 |

12 |
Memory bounds for recognition of contextfree and context-sensitive languages.
- Stearns, Hartmanis
- 1965
(Show Context)
Citation Context ...led ranked tree of size n with σ different node labels into a TSLP of size O( nlogσ n ) and depth O(logn), where the depth of a TSLP is the depth of the corresponding derivation tree. In particular, for an unlabelled binary tree we get a TSLP of size O( nlogn ). Our compressor is an extension of the BISECTION algorithm [17] from strings to trees and works in two steps (the following outline works only for binary trees, but it can be easily adapted to trees of higher ranks): In the first step, we hierarchically decompose the tree into pieces of roughly equal size, using a well-known lemma from [19]. But care has to be taken to bound the ranks of the nonterminals of the resulting TSLP. As soon as we get a tree with three holes during the decomposition (which corresponds in the TSLP to a nonterminal of rank three) we do an intermediate step that decomposes the tree into two pieces having only two holes each. This may involve an unbalanced decomposition. On the other hand, such an unbalanced decomposition is only necessary in every second step. This trick to bound the number of holes by three was used by Ruzzo [25] in his analysis of space-bounded alternation. The TSLP produced in the firs... |

10 | On parallel evaluation of classes of circuits - Kosaraju - 1990 |

10 | Algorithmics on SLP-compressed strings: a survey,
- Lohrey
- 2012
(Show Context)
Citation Context ...have © Danny Hucke, Markus Lohrey, and Eric Noeth; licensed under Creative Commons License CC-BY 34th Int’l Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2014). Editors: Venkatesh Raman and S. P. Suresh; pp. 457–468 Leibniz International Proceedings in Informatics Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany 458 Constructing Small Tree Grammars and Small Circuits for Formulas an approximation ratio of O(log(n/g)), where g is the size of a smallest SLP for the input string, and each of them works in linear time; see [22] for references. Another approach is to analyze the maximal size of SLPs produced by C on strings of length n over the alphabet Σ (the size of Σ is considered to be a constant larger than one in the further discussion). An information-theoretic argument shows that for almost all strings of length n (up to an exponentially small part) the smallest SLP has size Ω( nlogn ). Explicit examples of strings for which the smallest SLP has size Ω( nlogn ) result from de Bruijn sequences; see Section 2. On the other hand, many grammar-based compressors produce for every string of length n an SLP of size ... |

9 | Real-time traversal in grammarbased compressed files.
- Gasieniec, Kolpakov, et al.
- 2005
(Show Context)
Citation Context ...belled by a new symbol. We get |bin(t) |≤ 3|t|. In particular, we obtain a TSLP of size O ( n logσ n ) for bin(t), where n = |t |and σ = |labels(t)|. Note that a traversal step in the initial tree t (going to the parent node, first child, next sibling, or previous sibling) can be simulated by O(log r) many traversal steps in bin(t) (going to the parent node, left child, or right child). But for a binary tree s, it was recently shown that a TSLP G for s can be represented in space O(|G|) such that a single traversal step takes time O(1) [21] (this generalizes a corresponding result for strings [12]). Hence, we can navigate in t in time O(log r) ≤ O(log |t|). 5 Arithmetical Circuits In this section, we present our main application of Theorem 7. Let S = (S,+, ·) be a (not necessarily commutative) semiring. Thus, (S,+) is a commutative monoid with identity element 0, (S, ·) is a monoid with identity element 1, and · left and right distributes over +. We use the standard notation of arithmetical formulas and circuits over S: An arithmetical formula (resp. arithmetical circuit) is a binary tree (resp. dag) where internal nodes are labelled with the semiring operations + and ·, and leaf nodes... |

8 | Classifying polynomials and identity testing. - Agrawal, Saptharishi - 2009 |

8 | Least upper bounds on OBDD sizes - HEAP, MERCER - 1994 |

7 |
A bisection algorithm for grammar-based compression of ordered trees.
- Akutsu
- 2010
(Show Context)
Citation Context ...hildren of the node. In [6], grammar-based compression was extended from strings to trees. For this, linear context-free tree grammars were used. Linear context-free tree grammars that produce only a single tree are also known as tree straight-line programs (TSLPs) or straight-line context-free tree grammars (SLCF tree grammars). TSLPs generalize dags (directed acyclic graphs), which are widely used as a compact tree representation. Whereas dags only allow to share repeated subtrees, TSLPs can also share repeated internal tree patterns. Several grammar-based tree compressors were developed in [1, 6, 15, 23]. The algorithm from [15] achieves an approximation ratio of O(logn) (for a constant set of node labels). On the other hand, for none of the above mentioned compressors it is known, whether for any input tree with n nodes the size of the output grammar is bounded by O( nlogn ), as it is the case for many grammar-based string compressors. Recently, it was shown that the so-called top dag of an unranked and unlabelled tree of size n has size O( nlog0.19 n ) [3]. The top dag can be seen as a slight variant of a TSLP for an unranked tree. In this paper, we present a grammar-based tree compressor t... |

7 | Approximation of grammar-based compression via recompression - Jeż - 2013 |

6 | XML compression via DAGs, in: - Lohrey, Maneth, et al. - 2013 |

4 | Tree compression with top trees.
- Bille, Gørtz, et al.
- 2013
(Show Context)
Citation Context ...ated subtrees, TSLPs can also share repeated internal tree patterns. Several grammar-based tree compressors were developed in [1, 6, 15, 23]. The algorithm from [15] achieves an approximation ratio of O(logn) (for a constant set of node labels). On the other hand, for none of the above mentioned compressors it is known, whether for any input tree with n nodes the size of the output grammar is bounded by O( nlogn ), as it is the case for many grammar-based string compressors. Recently, it was shown that the so-called top dag of an unranked and unlabelled tree of size n has size O( nlog0.19 n ) [3]. The top dag can be seen as a slight variant of a TSLP for an unranked tree. In this paper, we present a grammar-based tree compressor that transforms a given node-labelled ranked tree of size n with σ different node labels into a TSLP of size O( nlogσ n ) and depth O(logn), where the depth of a TSLP is the depth of the corresponding derivation tree. In particular, for an unlabelled binary tree we get a TSLP of size O( nlogn ). Our compressor is an extension of the BISECTION algorithm [17] from strings to trees and works in two steps (the following outline works only for binary trees, but it ... |

4 | Approximation of smallest linear tree grammar - Jeż, Lohrey |

4 |
XML tree structure compression using RePair.
- Lohrey, Maneth, et al.
- 2013
(Show Context)
Citation Context ...hildren of the node. In [6], grammar-based compression was extended from strings to trees. For this, linear context-free tree grammars were used. Linear context-free tree grammars that produce only a single tree are also known as tree straight-line programs (TSLPs) or straight-line context-free tree grammars (SLCF tree grammars). TSLPs generalize dags (directed acyclic graphs), which are widely used as a compact tree representation. Whereas dags only allow to share repeated subtrees, TSLPs can also share repeated internal tree patterns. Several grammar-based tree compressors were developed in [1, 6, 15, 23]. The algorithm from [15] achieves an approximation ratio of O(logn) (for a constant set of node labels). On the other hand, for none of the above mentioned compressors it is known, whether for any input tree with n nodes the size of the output grammar is bounded by O( nlogn ), as it is the case for many grammar-based string compressors. Recently, it was shown that the so-called top dag of an unranked and unlabelled tree of size n has size O( nlog0.19 n ) [3]. The top dag can be seen as a slight variant of a TSLP for an unranked tree. In this paper, we present a grammar-based tree compressor t... |

4 |
Parameter reduction and automata evaluation for grammar-compressed trees.
- Lohrey, Maneth, et al.
- 2012
(Show Context)
Citation Context ... ∑ (A→t)∈P |t|. For instance, the TSLP from Example 2 has size 12. A TSLP is in Chomsky normal form if for every production A(x1, . . . , xn)→ t(x1, . . . , xn) one of the following two cases holds: t(x1, . . . , xn) = B(x1, . . . , xi−1, C(xi, . . . , xk), xk+1, . . . , xn) for B,C ∈ N (1) t(x1, . . . , xn) = f(x1, . . . , xn) for f ∈ Fn. (2) If the tree t in the corresponding rule A → t is of type (1), we write index(A) = i. If otherwise t is of type (2), we write index(A) = 0. One can transform every TSLP efficiently into an equivalent TSLP in Chomsky normal form with a small size increase [24]. We only consider TSLPs in Chomsky normal form in the following. We define the rooted, ordered derivation tree DG of a TSLP G = (S, P ) in Chomsky normal form as for string grammars: The inner nodes of the derivation tree are labelled by nonterminals and the leaves are labelled by terminal symbols. Formally, we start with the root node of DG and assign it the label S. For every node in DG labelled by A, where the right-hand side t of the rule for A is of type (1), we attach a left child labelled by B and a right child labelled by C. If the right-hand side t of the rule for A is of type (2), w... |

1 |
On lower bounds for multiplicative circuits and linear circuits in noncommutative domains.
- Arvind, Raja, et al.
- 2014
(Show Context)
Citation Context ... Σ) from xi to xj if xi = bw and xj = wa for some w ∈ Σr−2 and b ∈ Σ. This graph has σr edges and every vertex of this graph has indegree and outdegree σ. Hence, it has a Eulerian cycle, which can be viewed as a sequence u, b1, b2, . . . , bσr , where u ∈ Σr−1 is the start vertex, and the edge traversed in the ith step is labelled with bi ∈ Σ. Define sσ,n as the prefix of ub1b2 · · · bσr of length n. The construction implies that sσ,n has n− r + 1 different substrings of length r. By the so-called mk-Lemma from [7], every SLP for sσ,n has size at least n−r+1r > n r − 1 ≥ n logσ(n)+1 − 1. J In [2] a set of n binary strings of length n is constructed such that any concatenation circuit that computes this set has size Ω(n2/ log2 n). A concatenation circuit for a set S of strings is simply an SLP such that every string from S is derived from a nonterminal of the SLP. Using the above construction, this lower bound can be improved to Ω(n2/ logn): Simply take the string s2,n2 and write it as s1s2 · · · sn with |si |= n. Then any concatenation circuit for {s1, . . . , sn} has size Ω(n2/ logn). 3 Trees and Tree Straight-Line Programs For every i ≥ 0, we fix a countably infinite set Fi (resp., ... |

1 | Size-depth tradeoffs for boolean fomulae - Bonet, Buss - 1994 |

1 | Traversing grammar-compressed trees with constant delay. http://www.eti.uni-siegen.de/ti/veroeffentlichungen/14-traversal.pdf - Lohrey |

1 | A universal grammar-based code for lossless compression of binary trees.
- Zhang, Yang, et al.
- 2014
(Show Context)
Citation Context ...ns D. Hucke, M. Lohrey, and E. Noeth 467 for every nonterminal A of rank one gates that evaluate to the above polynomials a0, a1, a2. E.g., for a rule of the form A(x)→ B(C(x)) one has to substitute the polynomial pC(x) into pB(x) and carry out the obvious simplifications. For a nonterminal A of rank 0, the circuit simply contains a gate that evaluates to the polynomial to which valG(A) evaluates. J Theorem 9 can also be shown for fields instead of semirings. In this case, the expression is built up using variables, the constants −1, 0, 1, and the field operations +, · and /. 6 Future work In [27] a universal (in the information-theoretic sense) code for binary trees is developed. This code is computed in two phases: In a first step, the minimal dag for the input tree is constructed. Then, a particular binary encoding is applied to the dag. It is shown that the average redundancy of the resulting code converges to zero (see [27] for definitions) for every probability distribution on binary trees that satisfies the so-called domination property (a somewhat technical condition) and the representation ratio negligibility property. The latter means that the average size of the dag divided ... |