Critical Properties and Complexity Measures of Read-Once Boolean Functions

In this paper, we define a quasi-order on the set of read-once Boolean functions and show that this is a well-quasi-order. This implies that every parameter measuring complexity of the functions can be characterized by a finite set of minimal subclasses of read-once functions, where this parameter is unbounded. We focus on two parameters related to certificate complexity and characterize each of them in the terminology of minimal classes.


Introduction
A Boolean function f is called read-once if it can be represented by a Boolean expression using the operations of conjunction, disjunction and negation, in which every variable appears exactly once. In many applications and theoretical studies of read-once functions, including the present paper, the operation of negation is irrelevant, because the unique occurrence of a negated variable x can be renamed as x.
Read-once functions constitute a small but remarkable class of Boolean functions. They enjoy many nice properties and find applications across various fields, such as computational learning theory [2], circuit design [16], game theory [17], fault diagnosis [29], etc. A subclass of read-once functions, known as linear read-once [26] or nested canalyzing [21] functions, is important in biological applications. The importance of read-once functions is also due to the fact that they are closely related to other mathematical structures, such as cographs [20], separable permutations [1], or series-parallel partial orders. For more information on read-once functions we refer the reader to the book [13], which is one of the most comprehensive sources of information on Boolean functions and which devotes a chapter to this class.
All read-once functions have a simple structure, but not all of them are equally simple. With a closer look at this class, we discover a complex world, where many parameters measuring complexity of the functions, such as sensitivity or certificate complexity, can be arbitrarily large. On the other hand, we observe that this world is well-organized. To formalize this notion, we define a quasi-order on the functions in this class and show that this is a well-quasi-order. This implies, in particular, that for every parameter, which is unbounded in the class of read-once functions, there is a collection of "critical points", i.e. minimal subclasses where the parameter jumps to infinity.
The notion of critical classes, also known as critical properties [25], can be viewed as a generalization of the notion of minimal obstructions, which is a customary way of describing downward closed partial orders (lower sets). In the land of permutations, lower sets are known as pattern classes and every pattern class can be described in the terminology of minimal permutations avoiding it. In the world of graphs, there exist different partial orders (minors, topological minors, induced minors, vertex minors, subgraphs, induced subgraphs etc.) and each lower set admits a characterization in terms of minimal obstructions (minimal minors, topological minors, etc.). The universe of Boolean functions also admits different types of orderings (see e.g. [12,37]) and closed classes of functions admit various characterizations in terms of minimal obstructions (see e.g. [38]). In particular, in [35] the reader can find a characterization of the class of read-once functions in the terminology of minimal subfunctions that do not belong to this class.
To emphasize the importance of the characterization of closed classes of combinatorial structures in terms of minimal obstructions, let us consider the following example. In 1969 Journal of Combinatorial Theory published a paper entitled 'An interval graph is a comparability graph' [19]. One year later, the same journal published another paper entitled 'An interval graph is not a comparability graph' [14]. Each of the two classes is closed under taking induced subgraphs, and for each of them, there is a list of minimal forbidden induced subgraphs. Apparently, in 1969 this list was not available for at least one of them, because forbidden graphs provide a simple way of comparing two classes. Now let us shift our discussion from lower sets to families of lower sets and ask whether a family A of sets, which is downward closed under the inclusion relation, can be characterized in terms of minimal sets that do not belong to A. In a well-quasi-ordered world, the answer to this question is 'yes'. For instance, the graph minor relation is known to be a well-quasi-order [33], and in the family of minor-closed classes of graphs the planar graphs constitute a unique minimal obstruction for classes of bounded tree-width [32]. The pattern containment relation defined on the set of permutations is generally not a well-quasi-order. However, it may become a well-quasi-order when restricted to specific classes, such as separable permutations. As a result, any property of pattern classes of separable permutations can be described by means of critical classes, i.e. minimal classes that do not possess this property. In particular, in [1] the family of subclasses of separable permutations that have rational generating functions has been characterized by means of two critical classes. Similarly, in [8] the family of subclasses of cographs of bounded linear clique-width has been characterized by means of two subclasses, where this parameter is unbounded.
In the present paper, we develop a similar approach to identifying critical properties of read-once functions. Three most important complexity measures of Boolean functions are sensitivity, block sensitivity and certificate complexity, denoted s(f ), bs(f ) and C(f ), respectively. It is known that for any Boolean function f we have s(f ) ≤ bs(f ) ≤ C(f ) and C(f ) ≤ bs(f )s(f ). Also, the solution [18] of a long-standing open problem, known as sensitivity conjecture, shows that bs(f ) ≤ s(f ) c for a constant c. Therefore, all three parameters are equivalent in any class X of functions in the sense that either all of them are bounded or all are unbounded in X. Moreover, in the universe of read-once functions the three parameters coincide [27] and admit a simple characterization in terms of critical classes: elementary disjunctions, i.e. functions of the form x 1 ∧ . . . ∧ x k , and elementary conjunctions, i.e. functions of the form x 1 ∨ . . . ∨ x k are the only two unavoidable structures in any read-once function of large certificate complexity. This conclusion has a Ramseytype flavour and can be derived directly from Ramsey's Theorem by analogy with the fact that cliques (complete subgraphs) and independent sets (edgeless subgraphs) are the only two unavoidable structures in any graph of large order (the number of vertices).
We observe that Ramsey-type arguments is a typical approach to identifying unavoidable structures [36] and many graph parameters have been characterized in this way, see e.g. [11,24]. With the advent of parameterized complexity, the gallery of graph parameters has been enriched with a myriad of new representatives, such as shrub-depth [15] or distinguishing number [4], that allow to distinguish various new graph properties and provide a fine-grained analysis of their complexity.
To enrich the gallery of Boolean complexity measures, in this paper we introduce two new parameters, both extending certificate complexity, and characterize each of them in terms of critical properties of read-once functions. A graph-theoretic analog of one of these two parameters has been recently shown to be responsible for the Ramsey number to be linear in a class of graphs [6]. In the terminology of critical properties of functions this parameter is characterized by two classes: read-once DNFs (disjunctive normal forms) and read-once CNFs (conjunctive normal forms). Interestingly, translated to the language of separable permutations, these two classes of functions coincide with the two classes of permutations that are critical for classes with rational generating functions.
The organization of the paper is as follows. In Section 2, we introduce basic terminology and notation. In Section 3, we define a quasi-order on the set of read-once functions and show that this is a well-quasi-order. Section 4 is devoted to two new parameters and their characterization in terms of minimal classes of read-once functions, where these parameters are unbounded. Section 5 concludes the paper with a number of remarks and open problems.

Read-Once Formulas, Trees, and Functions
Let V be a countable set of variables.

Formulas
The notion of a formula over the basis {∨, ∧} is defined as follows: • A variable from V is a formula over the basis {∨, ∧}. Note that in formulas, ∨ and ∧ are symbols of Boolean operators. A formula F over the basis {∨, ∧} is called a read-once formula if each variable, that appears in F , appears in F exactly once. We will represent read-once formulas over the basis {∨, ∧} by read-once trees over the same basis.

Trees
First, we define the notion of a binary tree with the output. This is a directed tree in which we fix a node, called the output, and orient all edges towards the output. In this tree, each node either • has no entering edges, in which case we call it an input or • has exactly two entering edges that are labelled with l and r, in which case we call it a gate.
Each node of the tree with the exception of the output has exactly one leaving edge. The output has no leaving edges.
Let v, v 1 , v 2 , v 3 be nodes of a binary tree with the output. If two edges labelled with l and r leave the nodes v 1 and v 2 , respectively, and enter the node v, then we call v 1 and v 2 the parents of v. The node v 1 is called the l-parent of v and the node v 2 is called the r-parent of v. If an edge leaves the node v and enters the node v 3 , then we call v 3 the child of v.
A read-once tree over the basis {∨, ∧} (ROT) is a binary tree with the output in which inputs are labelled with pairwise different variables from V and each gate is labelled with a symbol of Boolean operator from the set {∨, ∧}. A gate labelled with the symbol ∨ is called a ∨-gate, and a gate labelled with the symbol ∧ is called a ∧-gate.

Correspondence Between Trees and Formulas
There is a one-to-one correspondence between read-once trees and read-once formulas over the basis {∨, ∧} that can be described as follows.
Let T be a read-once tree. With each node v of T we associate a formula F v over the basis {∨, ∧}. If v is an input labelled with a variable x then F v = x. Let v be a gate with the l-parent v 1 and the r- Let v o be the output of T . We associate with the read-once tree T the formula Conversely, with each read-once formula F over the basis {∨, ∧} we associate a ROT T F in the following way: • If F = x, then T F contains only one node labelled with the variable x, which is simultaneously the input and the output.
, then T F consists of ROTs T F 1 , T F 2 , a ∨-gate v, and two edges that leave outputs of T F 1 and T F 2 and enter v, which is the output of T . These edges are labelled with l and r, respectively.
, then T F consists of ROTs T F 1 , T F 2 , a ∧-gate v, and two edges that leave outputs of T F 1 and T F 2 and enter v, which is the output of T . These edges are labelled with l and r, respectively.

Functions
Let F be a formula over the basis {∨, ∧}. We associate with the formula F a Boolean function f F in the following way (∨ and ∧ are Boolean operators): Let x 1 , . . . , x n be all the variables that appear in the formula F . The domain of f F is the set of valuations of these variables. We will write f F = f F (x 1 , . . . , x n ) and say that f F depends on variables x 1 , . . . , x n .
A Boolean function f is called a read-once function over the basis {∨, ∧} (ROF) if there exists a read-once formula F over the basis {∨, ∧} such that f = f F . The latter equality means that the functions f and f F depend on the same variables and have equal values for the same valuations of these variables. If T is a read-once tree, we also denote We say that a variable x i is relevant for a Boolean function f = f (x 1 , . . . , x n ) if there exist two n-tuplesᾱ andβ in {0, 1} n such thatᾱ andβ are different only in the i-th digit and f (ᾱ) = f (β).
The following claim can be easily proved by induction on the number of symbols ∨ and ∧ in a formula F describing a read-once function f = f F .
Let f be a read-once function depending on variables x 1 , . . . , x n and F be a read-once formula over the basis {∨, ∧} such that f = f F . From Claim 1 it follows that x 1 , . . . , x n are all the variables that appear in the formula F .

From Quasi-Ordering to Well-Quasi-Ordering
A binary relation ≤ on a set W is a quasi-order (also known as preorder) if it is reflexive and transitive. Two elements x, y ∈ W are said to be comparable with respect to ≤ if either x ≤ y or y ≤ x. Otherwise, x and y are incomparable. A set of pairwise comparable elements is called a chain and a set of pairwise incomparable elements an antichain. If x ≤ y and y ≤ x, we write x < y. A chain x 1 > x 2 > . . . is called strictly decreasing. A quasi-order (W, ≤) is a well-quasi-order if it contains neither infinite strictly decreasing chains nor infinite antichains.
In order to define a quasi-order on the set of read-once functions, we start by defining the operation of removal of variables.

Removal of Variables from Read-Once Functions
The operation of removal of a variable is applicable only to functions depending on at least 2 variables. To define this operation, we consider a read-once function f and a variable x on which f depends.
Assume first that f is given together with a read-once formula F representing it. Speaking informally, the operation of removal of x from f can be viewed as the operation of "erasing" x from F and then modifying F accordingly, to make it a read-once formula again. In the terminology of read-once trees, this modification can be formally described as follows.
Let T = T F and let v x be the input of T labelled by x. The removal of v x from T is the operation that transforms T into another read-once tree, denoted T − v x , in the following way. We denote by v 1 the child of v x , by v 2 the second parent of v 1 , and by v 3 the child of v 1 , if v 1 is not the output. The removal of v x consists in removing the nodes v x and v 1 , and the edges leaving the nodes v x , v 2 , and v 1 . If v 1 is not the output in T , then we also add a new edge from v 2 to v 3 (see Fig. 1 for an illustration). If v 1 is the output in T , then v 2 becomes the output in This operation also is equivalent to substituting x with an appropriate constant, 0 or 1, in F .
According to Claim 1, all the n − 1 variables of the function obtained by this substitution are relevant. Note that if we substitute x with 1, then all the variables from the sub-formula F v 2 become irrelevant and the function obtained by this substitution has strictly fewer than n − 1 relevant variables.
depends on n−1 variables. We denote this function by f −x i and say that f −x i is obtained from f by the removal of variable x i .

Quasi-Ordering and Closed Classes of ROTs and ROFs
In this section, we define quasi-orders on the sets of read-once trees and read-once functions. To this end, we need to introduce two more operations.
The operation renaming of variables applies to the variables attached to inputs and uses only the variables from the set V . After renaming, all variables must be pairwise different. The operation renaming of labels applies to the labels l and r attached to edges, and after renaming any two edges entering the same node must have different labels, i.e. one edge must be labelled with l and the other one with r.
Definition 1 We will say that a read-once tree T 1 is a subtree of a read-once tree T 2 if T 1 can be obtained from T 2 by a (possibly empty) sequence of three operations: removal of inputs, renaming of variables and renaming of labels.
In a similar way, we define the notion of a subfunction. The only difference is that the operation of renaming of labels is irrelevant in this case, since this operation applied to a read-once tree T does not change the function corresponding to T .

Definition 2
We will say that a read-once function f 1 is a subfunction of a read-once function f 2 if f 1 can be obtained from f 2 by a (possibly empty) sequence of two operations: removal of variables and renaming of variables.
The notions of subtree and subfunction define binary relations of the sets of trees and functions, respectively. It is not difficult to see that these relations are reflexive and transitive, i.e. they are quasi-orders. However, they are not partial orders, since they are not antisymmetric. Indeed, the following two functions The notions of subtree and subfunction naturally lead to the notions of (downward) closed classes of trees and functions, respectively.

Definition 3
We will say that a set T of read-once trees is a closed class if T ∈ T implies T ∈ T for every subtree T of T .

Definition 4
We will say that a set F of read-once functions is a closed class if f ∈ F implies f ∈ F for every subfunction f of f .

Remark 2
When we talk about closed classes of trees, the actual labelling of the input nodes and the edges of a tree is irrelevant, since all possible valid labellings of the tree are present in the class. This allows us to consider partially labelled read-once trees, i.e. trees in which the input nodes and the edges are not labelled. Each partially labelled ROT T describes a set of ROTs obtained from T by labelling the inputs with pairwise different variables from V and by labelling the edges so that any two edges entering the same node are labelled one with l and the other one with r.
Let X be a set of read-once functions (trees). We denote by [X] the closure of X, i.e. the set consisting of all functions (trees) in X and all their subfunctions (subtrees). If κ is a numerical parameter defined on the functions (trees) in X, then we call X κ-bounded if there is a constant c such that κ(f ) ≤ c for every function (tree) f in X.

Well-Quasi-Ordering of Read-Once Functions
In this section, we show that the quasi-order defined in Section 3.2 is a well-quasi-oder. To this end, we use the notion of quasi-embedding that can be defined as follows. A map It is known (and not difficult to see) that, if there exists a quasi-embedding X → Y , and (Y, ) is a well-quasi-order, then (X, ≤) is a well-quasi-order too.
By mapping a read-once function to any read-once tree representing it we obtain a quasi-embedding, which is not difficult to see. Therefore, it suffices to show that the set of read-once trees is well-quasi-ordered under the subtree relation. This will be done by defining a quasi-embedding of this set into the set of all rooted trees well-quasi-ordered by the topological minor relation.
To make the reduction easier, we assume, without loss of generality, that the edges of a rooted tree are directed and that all of them are directed towards the root. A subdivision of an edge x → y by a new vertex z is the operation of replacement of x → y with two new edges x → z and z → y. A tree T is a subdivision of a tree T if T can be obtained from T by a sequence of edge subdivisions. A rooted tree T 1 is a topological minor of a rooted tree T 2 if there is a subdivision T of T 1 that can be obtained from T 2 by deleting some nodes.
If T 1 is a topological minor of T 2 , then there is an injective mapping φ of the node set of T 1 into the node set of T 2 such that for every edge x → y in T 1 there is a directed path from φ(x) to φ(y) in T 2 . Without loss of generality, we assume that if y is a child of x 1 and x 2 in T 1 , then φ(y) is the unique common node of the two directed paths connecting φ(x 1 ) and φ(x 2 ) to φ(y) in T 2 . We also assume that the nodes of the trees are labelled by elements from a well-quasi-ordered set (Q, ≤) and require that φ maps a node x of T 1 with label l(x) ∈ Q to a node y of T 2 with label l(y) ∈ Q such that l(x) ≤ l(y). We will say that a mapping φ satisfying this property respects the labels. In this terminology the famous Kruskal's theorem for trees [22] can be stated as follows.

Theorem 1
The set of all rooted trees, whose nodes are equipped with labels from a wellquasi-ordered set, is well-quasi-ordered under the topological minor relation that respects the labels.
We now use this result in order to show that read-once trees are well-quasi-ordered under the subtree relation. To define a labelling of the node set of a read-once tree T we use symbols ∨ and ∧ for the gate nodes and symbol ∅ for the input nodes, and assume that ∅ ≤ ∨ and ∅ ≤ ∧, while ∨ and ∧ are incomparable.

Lemma 1
Let T 1 and T 2 be two read-once trees, whose nodes are equipped with labels from {∨, ∧, ∅}. If T 1 is a topological minor of T 2 with a mapping φ that respects the labels, then T 1 is a subtree of T 2 .
Proof Without loss of generality we may assume that φ maps an input x of T 1 to an input φ(x) of T 2 , because if it is not the case, φ can be easily transformed into a mapping satisfying this property by replacing φ(x) with any input of T 2 for which there is a directed path to φ(x). Then the desired conclusion can be derived by induction on the number k of inputs of T 2 that do not belong to the set of images of φ. If k = 0, then there is a bijection between the node set of T 1 and the node set of T 2 , because both trees are binary. Therefore, since T 1 is a topological minor of T 2 , the two trees coincide.
Assume now that k > 0 and let x be an input of T 2 , which is not an image of φ. The removal of x transforms T 2 into another read-once tree T 2 , which is a topological minor of T 2 . Indeed, the inverse operation can be viewed as a subdivision of an edge and addition of a node (examine Fig. 1 from right to left for an illustration). It is also not difficult to see that T 2 contains T 1 as a topological minor. Indeed, the child of x that disappears together with x cannot be an image of any node of T 1 , because T 1 is a binary tree and the inputs of T 1 are mapped to inputs of T 2 . By induction assumption, T 1 is a subtree of T 2 and hence T 1 is a subtree of T 2 .
This lemma proves more than just well-quasi-orderability of read-once trees, because Kruskal's tree theorem admits various generalizations. In particular, Nash-Williams proved in [31] that infinite (in addition to finite) trees are better-quasi-ordered, and this was later strengthened by Laver (in [23], Theorem 2.2) to labelled infinite trees, provided the set of labels is better-quasi-ordered (which is the case for any finite set).
The full definition of better-quasi-ordering is technical, and outside of the scope of this paper (see, e.g., [3] for a short introduction). What is important to us is that a quasi-embedding X → Y into a better-quasi-order (Y, ) implies that (X, ≤) is a betterquasi-order too (see, e.g., [3], Lemma 5.3). Thus Lemma 1 shows that the set of read-once trees is better-quasi-ordered.
The additional strength of better-quasi-ordering can be summarised with the following proposition (see, e.g., [3]), where (X, ≤) is an arbitrary quasi-order and L(X) is the set of downward closed sets of X.

Proposition 1 If (X, ≤) is a better-quasi-order, then (X, ≤) is a well-quasi-order and (L(X), ⊆) is a better-quasi-order.
The above discussion leads us to the following conclusion.

Corollary 1 The set of read-once functions is well-quasi-ordered under the subfunction relation and the set of closed classes of read-once functions is well-quasi-ordered under the inclusion relation.
One important consequence of well-quasi-orderability of the set of closed classes under inclusion can be stated as follows.

Corollary 2 For every parameter κ, which is unbounded on the set of read-once functions, there is a finite collection of minimal closed subclasses of read-once functions, where this parameter is unbounded.
This result suggests a quasi-order on the set of parameters and a way of comparing two parameters. For two parameters κ 1 and κ 2 , we will write κ 1 κ 2 if the family of κ 1 -bounded closed classes contains the family of κ 2 -bounded closed classes.

Corollary 3
If κ 1 and κ 2 are two parameters, then κ 1 κ 2 if and only if for every minimal closed class F 1 , where κ 1 is unbounded, there is a minimal closed class F 2 , where κ 2 is unbounded, such that F 2 ⊆ F 1 .
Proof Assume first that for every minimal closed class F 1 where κ 1 is unbounded, there is a minimal closed class F 2 where κ 2 is unbounded such that F 2 ⊆ F 1 . Let X be a κ 2bounded closed class and suppose that κ 1 is unbounded in this class. Then X contains a minimal class F 1 , where κ 1 is unbounded, which in turn contains a minimal class F 2 , where κ 2 is unbounded. This contradicts our assumption that X is κ 2 -bounded and proves that X is κ 1 -bounded, i.e. κ 1 κ 2 .
Conversely, suppose κ 1 κ 2 , and let F 1 be a minimal closed class where κ 1 is unbounded. Since κ 1 κ 2 , κ 2 is also unbounded in F 1 , and by Corollary 2, F 1 contains a minimal closed class F 2 where κ 2 is unbounded, as required.
Finally, we observe that the quasi-order defined for parameters in the universe of readonce functions is, in fact, a well-quasi-order due to better-quasi-orderability of the functions.

Parameters
As we mentioned in the introduction, three important complexity measures of Boolean functions are certificate complexity, block sensitivity, and sensitivity. For read-once functions, these three parameters coincide, as was shown in [27], and therefore, we define only one of them.
Informally, the certificate complexity of a Boolean function f defined on an ndimensional hypercube can be described as follows. On a Boolean pointδ the certificate complexity equals n minus the dimension of a largest sub-hypercube containingδ that defines a constant function. Then C 0 (f ) is the maximum of this measure taken over 0 points, C 1 (f ) is the maximum taken over 1 points, and C(f ) is the total maximum taken over all points of the hypercube.
It is not difficult to see (in particular, it follows from Lemma 2 below) that in the class of read-once functions certificate complexity can be arbitrarily large. By Lemma 2, this parameter is unbounded even in the class F ∧ of elementary conjunctions, i.e. functions of the form x 1 ∧ . . . ∧ x n , and in the class F ∨ of elementary disjunctions, i.e. functions of the form x 1 ∨ . . . ∨ x n . On the other hand, any closed class of read-once functions excluding at least one elementary conjunction and at least one elementary disjunction is finite, i.e. consists of finitely many functions up to renaming of variables, which is not difficult to see and which also follows from Lemmas 3 and 4 below. Therefore, the characterization of certificate complexity in the terminology of minimal classes is trivial: certificate complexity is bounded in a closed class F of read-once functions if and only if F contains neither F ∧ nor F ∨ .
We observe that one more important parameter, known as deterministic decision tree complexity, admits the same characterization in terms of minimal classes, because it is bounded below by block sensitivity and above by the square of certificate complexity [9]. Therefore, deterministic decision tree complexity is bounded in a closed class F if and only if F is finite up to renaming of variables in functions, similarly to certificate complexity, block sensitivity, and sensitivity. In other words, all these four parameters are equivalent with respect to the quasi-order defined in the previous section. Moreover, all of them lie at the bottom of the hierarchy that describes this quasi-order in the sense that there are no parameters that lie strictly below them.
To extend this hierarchy, we introduce two new complexity measures of a Boolean function f (x 1 , . . . , x n ): These parameters are closely related to the complexity of nondeterministic decision trees computing f . In deterministic decision trees, each internal node is labelled with a variable and has two leaving edges labelled with 0 and 1, respectively. In nondeterministic decision trees, the root is not labelled with a variable. In this node, we choose nondeterministically the first query (variable). All other internal nodes are labelled with variables, but each such node can have more than one leaving edge labelled with 0 and more than one leaving edge labelled with 1. We distinguish conventional nondeterministic decision trees that accept all tuples from {0, 1} n , 0-nondeterministic decision trees that accept only tuplesδ ∈ {0, 1} n for which f (δ) = 0, and 1-nondeterministic decision trees that accept only tuplesδ ∈ {0, 1} n for which f (δ) = 1. Then C(f ) is the minimum depth of a conventional nondeterministic decision tree computing f , C 0 (f ) is the minimum depth of a 0-nondeterministic decision tree computing f , and C 1 (f ) is the minimum depth of a 1-nondeterministic decision tree computing f . Note that 1-nondeterministic decision trees were studied in [28,30] as decision trees computing Boolean functions strongly nondeterministically.
If F is an α-bounded class of read-once functions, then for each function in F, there is either a 0-nondeterministic or 1-nondeterministic decision tree of bounded depth. If F is a β-bounded class, then there exists a positive constant t such that, for each function f (x 1 , . . . , x n ) in F, n/C(f ) ≤ t and C(f ) ≥ n/t, i.e., the minimum depth of a conventional nondeterministic decision tree computing f is at least n/t. By definition, α is upper bounded by certificate complexity. It is also interesting to observe that, for all read-once functions f , β(f ) ≤ α(f ). To see this, consider a read-once function f on n inputs. Without loss of generality, suppose that C 0 (f ) ≤ C 1 (f ). Then, by definition, C(f ) = C 1 (f ), α(f ) = C 0 (f ), and β(f ) = n/C(f ) = n/C 1 (f ). By Lemma 7, we have n ≤ C 0 (f )C 1 (f ), and dividing through by C 1 (f ), we conclude that From the double inequality β(f ) ≤ α(f ) ≤ C(f ) we conclude that the family of Cbounded classes is contained in the family of α-bounded classes, which in turn is contained in the family of β-bounded classes. In fact, both containments are proper, i.e. neither C can be upper bounded by a function of α, nor α can be upper bounded by a function of β, which follows, in particular, from our characterization of these parameters in terms of critical classes. We start with some auxiliary results.

Auxiliary results
Let T be a read-once tree. We denote C 0 (T ) = C 0 (f T ), C 1 (T ) = C 1 (f T ). It is clear that, for each input v of the ROT T , C 0 (f v ) = C 1 (f v ) = 1. We can find values of C 0 (f v ) and C 1 (f v ) for each gate v of T using the following statement. T be a ROT, v be a gate of T , and v 1 , v 2 be parents of v.

Lemma 2 ([27], Lemma 2) Let
If v is a ∨-gate, then If v is a ∧-gate, then We denote by h ∨ (T ) the ∨-depth of the ROT T which is the maximum number of ∨gates in a path from an input to the output of T . We denote by h ∧ (T ) the ∧-depth of the ROT T which is the maximum number of ∧-gates in a path from an input to the output of T . The following statement gives us lower and upper bounds on the value C 0 (T ) depending on the ∨-depth h ∨ (T ) of T .

Lemma 3 Let T be a ROT. Then h
Then T contains only ∧-gates. Using Lemma 2 and the fact that C 0 (f v ) = 1 for any input v of T we obtain C 0 (T ) = 1. Therefore the considered inequality holds if h ∨ (T ) = 0.
Let n ≥ 0 and C 0 (T ) ≤ 2 h ∨ (T ) for any ROT T with h ∨ (T ) ≤ n. Consider a ROT T with h ∨ (T ) = n + 1. This ROT contains at least one ∨-gate. Using Lemma 2 one can show that C 0 (T ) ≥ 2. Let v be a gate of T for which C 0 (f v ) = C 0 (T ) and the length of path from v to the output of T is maximum. Let us show that v is a ∨-gate. Assume the contrary. By Lemma 2, C 0 (f v ) = C 0 (f v ) for a parent v of v, but this is impossible since v is a gate and the length of path from v to the output is greater than the length of path from v to the output. Therefore v is a ∨-gate. Let v 1 and v 2 be parents of v, and T v 1 and T v 2 be subROTs of T with outputs v 1 and v 2 , respectively. It is clear that h ∨ (T v 1 ) ≤ n and h ∨ (T v 2 ) ≤ n. Using the inductive hypothesis we obtain that C 0 (T v 1 ) ≤ 2 n and C 0 (T v 2 ) ≤ 2 n . By Lemma 2, Let us show that h ∨ (T ) + 1 ≤ C 0 (T ). To this end, we consider a path from an input of T to the output which contains m = h ∨ (T ) ∨-gates v 1 , . . . , v m . Using Lemma 2 and the fact that C 0 (f v ) = 1 for any input v of T one can show that C 0 (f v i ) ≥ i + 1 for i = 1, . . . , m Similarly, we can prove the following statement which gives us lower and upper bounds on the value C 1 (T ) depending on the ∧-depth h ∧ (T ) of T .

Parameter α
In this section we study the parameter and characterize the family of α-bounded closed classes of read-once functions in terms of minimal closed classes, where this parameter is unbounded.
We start by characterizing α-bounded closed classes of read-once trees in Section 4.2.1 and then extend our results to α-bounded closed classes of read-once functions in Section 4.2.2.

α-Bounded Closed Classes of Read-Once Trees
For a read-once tree T , we define α(T ) = α(f T ). The following result provides a criterion for a set of read-once trees to be α-bounded.

Lemma 5 A set T of ROTs is α-bounded if and only if it can be represented in the form
Proof Let T be α-bounded and let a be a natural number such that α(T ) ≤ a for each tree T ∈ T . Denote T ∨ = {T : T ∈ T , C 0 (T ) ≤ a} and T ∧ = {T : T ∈ T , C 1 (T ) ≤ a}. It is clear that T = T ∨ ∪T ∧ . From Lemmas 3 and 4 it follows that h ∨ (T ) ≤ a−1 for any T ∈ T ∨ and h ∧ (T ) ≤ a − 1 for any T ∈ T ∧ . Therefore T ∨ is h ∨ -bounded and T ∧ is h ∧ -bounded.
Let T can be represented in the form Then there exists a natural number b such that h ∨ (T ) ≤ b for any ROT T ∈ T ∨ , and there exists a natural number c such that h ∧ (T ) ≤ c for any ROT T ∈ T ∧ . From Lemmas 3 and 4 it follows that C 0 (T ) ≤ 2 b for any T ∈ T ∨ and C 1 (T ) ≤ 2 c for any T ∈ T ∧ . Denote a = max{2 b , 2 c }. Then α(T ) ≤ a for any ROT T ∈ T .
According to Remark 2, when we deal with closed classes of read-once trees, the actual labelling of the input nodes and the edges of a tree is irrelevant, allowing us to consider partially labelled read-once trees. For natural k and m, let us denote by 1 (k, m), 2 (k, m),  Let the sequences a 1 , a 2 , . . . be not bounded from above. Then there exists an infinite subsequence of this sequence a j 1 , a j 2 , . . . such that a j 1 < a j 2 < . . .. We now consider two subcases of this case.
Case 1a. Let the sequence c j 1 , c j 2 , . . . be not bounded from above. Then there exists a natural p such that a j p ≥ k and c j p ≥ k. By the removal of inputs, we can transform the ROT T j p into a ROT i (k, k) with i ∈ {1, 2}. This ROT belongs to T .
Case 1b. Let the sequence c j 1 , c j 2 , . . . be bounded from above. In this case, the sequence d j 1 , d j 2 , . . . is not bounded from above. Therefore there exists a natural p such that a j p ≥ k and d j p ≥ k. By the removal of inputs, we can transform the ROT T j p into a ROT 3 (k, k). This ROT belongs to T .
Case 2. The case when the sequence c 1 , c 2 , . . . is not bounded from above can be analyzed by analogy with Case 1.
Case 3. Let both sequences a 1 , a 2 , . . . and c 1 , c 2 , . . . be bounded from above. Then there exists a natural m such that b t ≥ t − m and d t ≥ t − m for t = 1, 2, . . .. Let p be a natural number for which b p ≥ 2k and d p ≥ 2k, and τ p = v 1 , . . . , v l be the common part of the paths π ∨ p and π ∧ p in the ROT T p . Let j be the minimum number from the set {1, . . . , l} such that the path v 1 , . . . , v j contains k ∨-gates or k ∧-gates. Assume without loss of generality that the path v 1 , . . . , v j contains k ∨-gates. Then this path contains at most k − 1 ∧-gates. Therefore the path v j +1 , . . . , v l contains at least k + 1 ∧-gates. By the removal of inputs, we can transform the ROT T p into a ROT i (k, k) with i ∈ {3, 4}. This ROT belongs to T .

Theorem 2 Let T be a closed class of ROTs. Then T is α-bounded if and only if T contains none of the classes
Proof Let T be α-bounded. Then T contains none of the classes T 1 , T 2 , T 3 , T 4 since, according to Lemma 5, the classes T 1 , T 2 , T 3 , T 4 are not α-bounded.
Let T contain none of the classes T 1 , T 2 , T 3 , T 4 . Then T is α-bounded, because otherwise, by Lemma 6, T contains at least one class from the set {T 1 , T 2 , T 3 , T 4 }.

α-Bounded Closed Classes of Read-Once Functions
For all k, m = 0, 1, 2, . . . such that k + m ≥ 1, we define the following two read-once functions: . It is not difficult to see that Using Lemma 5 we conclude that the classes F 1 and F 2 are not α-bounded.

Theorem 3 Let F be a closed class of ROFs. Then F is α-bounded if and only if F contains none of the classes
Proof Let F be α-bounded. Then F contains none of the classes F 1 , F 2 since these classes are not α-bounded.
Let F contain none of the classes F 1 , F 2 . We now show that F is α-bounded. Assume the contrary: F is not α-bounded. Denote by T the set of read-once trees containing for each function g ∈ F all trees T such that f T = g. It is clear that the set T is closed under the operation of renaming of labels. Since the class F is closed under the operation of renaming of variables, the set T is closed under the operation of renaming of variables. Using Remark 1, we obtain that T is closed under the operation of removal of variables. Therefore T is a closed class of ROTs. Since F is not α-bounded, the class T is not αbounded. By Lemma 6, T contains at least one of the classes T 1 , T 2 , T 3 , T 4 . Therefore, F contains one of the classes F 1 , F 2 . This contradicts our initial assumption and completes the proof of the theorem.

Parameter β
In this section, we study the parameter β(f ) that, for any Boolean function f with n relevant variables, is defined in the following way: To characterize the parameter β in the terminology of minimal closed classes of readonce functions, which are not β-bounded, first we make the following observation, which follows directly from the definition of certificate complexity.

Claim 2 C(T ) ≤ C(T ) for any subtree T of a read-once tree T .
We also quote the following result, which was proved in [27] (see Theorem 3) in the terminology of read-once functions. Now we denote by V(t) and (t) partially labelled read-once trees corresponding to disjunction and conjunction of t variables, respectively, see Fig. 3, and prove a lemma concerning read-once trees that do not contain either V(t) or (t) as subtrees.

Lemma 8 If T is a read-once tree with n inputs that does not contain V(t) or (t), then n ≤ 2 t C(T ).
Proof We prove the result for (t), since for V(t) the proof is similar. Let v be the output of T and let v 1 , v 2 be the parents of v. We consider two subtrees T 1 and T 2 of T with outputs v 1 and v 2 , respectively, and denote the number of inputs in these trees by n 1 and n 2 , respectively.
If v is a ∨-gate, then applying Lemmas 2, 4 and 7, we obtain by Lemma 2.
To prove the main result of this section we denote by 1 (p, t) and 2 (p, t) partially labelled read-once trees represented in Fig. 4. Also, let  Proof Let f n be a read-once function represented by a read-once tree 1 ( √ n, √ n) with n + √ n + 1 inputs. Then β(f n ) = n/( √ n + 1) + 1 and hence the parameter β is unbounded in the class P 1 . Similarly, it is unbounded in the class P 2 , which proves the "only if" part of the theorem.
To prove the "if" part, we fix natural numbers p, q, t and show that if T is a read-once tree with n inputs containing neither 1 (p, t) nor 2 (q, t), then n ≤ C(T )2 2(p+q+t) .
Let v be the output of T and v 1 , v 2 the parents of v. We consider two subtrees T 1 and T 2 of T with outputs v 1 and v 2 , respectively.
Case 1: Assume that either (a) v is a ∨-gate and neither T 1 nor T 2 contains (t), or (b) v is a ∧-gate and neither T 1 nor T 2 contains V(t).
In case 1(a) T does not contain (t) and in case 1(b) T does not contain V(t). In both cases, n ≤ 2 t C(T ) by Lemma 8. Case 2: Assume that either (a) v is a ∨-gate and both T 1 and T 2 contain (t), or (b) v is a ∧-gate and both T 1 and T 2 contain V(t).
Case 2(b) implies the same conclusion by similar arguments. Case 3: Assume that either (a) v is a ∨-gate, T 1 contains (t) and T 2 does not contain (t), or (b) v is a ∧-gate, T 1 contains V(t) and T 2 does not contain V(t).
Then we define T := T 1 and apply to T the above case analysis iteratively as long as we are in Case 3. When we encounter either Case 1 or Case 2, we stop. Assume first that the analysis has stopped, when we encountered Case 1. Then the original tree T has been partitioned into subtrees of two types: subtrees that do not contain (t) and subtrees that do not contain V(t). The output of every subtree of the first type has a ∨gate as a child. Therefore, the union of all these subtrees, which we denote by T ∨ and which is a tree obtained from T by removing all inputs from the subtrees of the second type, does not contain (t). Similarly, the output of every subtree of the second type has a ∧-gate as a child, and hence the union of all these subtrees, denoted T ∧ , does not contain V(t). Denoting the number of inputs in T ∨ and T ∧ by n ∨ and n ∧ respectively, we obtain n = n ∨ + n ∧ ≤ C(T ∨ )2 t + C(T ∧ )2 t ≤ 2C(T )2 t ≤ C(T )2 2(p+q+t) .
In order to translate Theorem 4 to the language of read-once functions, we denote

Concluding Remarks and Open Problems
In this paper, we defined a quasi-order on the set of read-once Boolean functions and showed that this is a well-quasi-order. This conclusion defines a quasi-order on the set of parameters that measure complexity of read-once functions and provides a uniform way of describing parameters through critical classes, i.e. minimal classes where the parameters jump to infinity. We observed in the paper that a number of important complexity measures, such as certificate complexity or deterministic decision tree complexity, are equivalent in the universe of read-once Boolean functions and lie at the bottom of the hierarchy of parameters. To extend the hierarchy, we have introduced two new parameters α and β related to certificate complexity and characterized both of them by means of critical classes, showing that α lies strictly above certificate complexity and β lies strictly above α. We believe that the new parameters will find applications in various aspects of the analysis of Boolean functions, such as, for instance, parameter-efficient learning of Boolean functions [10].
There is a variety of other parameters that measure complexity of Boolean functions, such as submodular goal value [5], average sensitivity [34], various nonlinearity measures [7], etc. Characterizing them through critical classes remains a challenging open problem.