Abstract.
The paper examines hierarchies for nondeterministic and deterministic ordered readtimes Branching programs. The currently known hierarchies for deterministic OBDD models of Branching programs for are proved by B. Bollig, M. Sauerhoff, D. Sieling, and I. Wegener in 1998. Their lower bound technique was based on communication complexity approach. For nondeterministic OBDD it is known that, if is constant then polynomial size OBDD computes same functions as polynomial size OBDD (The result of Brosenne, Homeister and Waack, 2006). In the same time currently known hierarchies for nondeterministic read times Branching programs for are proved by Okolnishnikova in 1997, and for probabilistic read times Branching programs for are proved by Hromkovic and Saurhoff in 2003.
We show that increasing for polynomial size nodeterministic OBDD makes model more powerful if is not constant. Moreover, we extend the hierarchy for probabilistic and nondeterministic OBDDs for . These results extends hierarchies for read times Branching programs, but OBDD has more regular structure. The lower bound techniques we propose are a “functional description” of Boolean function presented by nondeterministic OBDD and communication complexity technique. We present similar hierarchies for superpolynomial and subexponential width nondeterministic OBDDs.
Additionally we expand the hierarchies for deterministic OBDDs using our lower bounds for . We also analyze similar hierarchies for superpolynomial and subexponential width OBDDs.
Key words and phrases:
Branching programs, Binary decision diagrams, OBDD, deterministic and nondeterministic models, hierarchy, computational complexityKhadiev \titOn the Hierarchies for Deterministic, Nondeterministic and Probabilistic Ordered Readtimes Branching Programs \shorttitOn the Hierarchies for OBDD, NOBDD and POBDD
0 \subclass03D15, 68Q15, 68Q17, 68Q10
1. Preliminaries and Results
Ordered Read times Branching Programs (OBDD) are well known models for Boolean functions computation. A good source for different models of branching programs is the book by Ingo Wegener [18].
A branching program over a set of Boolean variables is a directed acyclic graph with two distinguished nodes (a source node) and (a sink node). We denote such a program as or just . Each inner node of is associated with a variable . Deterministic has exactly two outgoing edges labeled and respectively; for a such node , nondeterministic has several outgoing edges labeled and respectively.
The program (deterministic or nondeterministic) computes the Boolean function () as follows: for each we let if and only if there exists at least one path (called accepting path for ) such that all edges along this path are consistent with .
Branching program is called syntactic readtimes BP if for any path (consistent or inconsistent) from the source to a sink node of the program reads each variable at most times [9].
A branching program is leveled if the nodes can be partitioned into levels and a level so that the nodes in are the sink nodes and nodes in each level with have outgoing edges only to nodes in the next level . For a leveled the source node is a node from the first level whereas the sink node is a node from the last level of nodes.
The width of a leveled branching program is the maximum of number of nodes in levels of
A leveled branching program is called oblivious if all inner nodes of one level are labeled by the same variable. A branching program is called read once if each variable is tested on each path only once.
An oblivious leveled read once branching program is also called Ordered Binary Decision Diagram (OBDD) and for nondeterministic case is NOBDD.
OBDD (NOBDD) reads variables in its individual order . We call the order of .
The Branching program is called OBDD (NOBDD) if it consists on layers, where th () layer of is an OBDD (NOBDD). Let be an order of , . And . We call order the order of . Therefore we conclude that OBDD is a specific case of syntactic readtimes BP.
The size of branching program is a number of nodes of program . Note, that for OBDD (NOBDD) we have
The length of branching program is the length of the longest path from source to a sink node. Clearly we have, that for OBDD (NOBDD) its length is
We can consider probabilistic OBDD by the same way. Vertexes of this model’s graph can have more that two outgoing edges and we choose the edge according to probabilistic mechanism. We grantee that computation will be finished with probability .
In the paper will be considered bounded error model. Program returns on input with bounded error if probability . In that case . And returns if . In that case .
Known lower bounds and hierarchies. Let PBP be the set of Boolean functions that can be computed by syntactic readtimes BP of polynomial size, and NPBP be the set of Boolean functions for nondeterministic case. Let POBDD be the set of Boolean functions that can computed by OBDD of polynomial size, and NPOBDD be the set of Boolean functions for nondeterministic case.
One of the first explicit hard functions for the syntactic BPs was introduced in [9] by Borodin, Razborov and Smolensky. For each they presented an explicit function, which needs nonpolynomial size syntactic BPs for some appropriate constant .
Thathachar in paper [17] presented a family of explicit Boolean functions depending on integer parameter which cannot be represented as length polynomial size syntactic nondeterministic kBP. In addition, the technique from [17] allows to prove the following proper inclusion for :
This result extends the result of Okolnishnikova [15] that proved the following hierarchy:
Probabilistic BP was investigated by Hromkovich and Sauerhoff in 2003 [12]. They proved lower bound for explicit Boolean function . Authors showed that bounded error probabilistic BP should have a size at least , for . Using that results Hromkovich and Sauerhoff got hierarchy for polynomial size bounded error probabilistic BP: BPPBP BPPBP, for .
What is known for the readtimes BP models with an extra “ordered reading” restrictions?
For the case of OBDD models Bolling, Sauerhoff, Sieling, Wegener suggested an explicit Boolean function which cannot be represented by nonlinear length polynomial size OBDDs. In addition their technique allows to prove the following proper inclusions, for
For small width OBDD we presented lower bounds in paper [6], which allows to extends the Bolling–Sauerhoff–Sieling–Wegener hierarchy for sublinear width, similar to width hierarchy which was proved in [14].
Ablayev and Karpinski in [5] introduced an explicit Boolean function which is hard for polynomial size nondeterministic OBDD for , but can be computed by boundederror probabilistic OBDD. In another word the function from [5] has the following property: .
Brosenne, Homeister and Waack [7] showed that for any constant holds .
Our contribution. In Sections 2 and 5 we consider Boolean function (Shuffled Equality) which is presented in [4], this is modification of function from [5], [1], [2]. We prove that cannot be represented by polynomial size NOBDDs for . Our technique is the so called “functional description” of Boolean function presented in a corresponding NOBDD. Namely, we develop a technique of presentation NOBDD as special decomposition, which presented in Section 2. This technique is motivated by the paper [9].
Based on our lower bound in Section 5 we prove the following proper inclusion (Corollary 1 and 2). For and it holds that
These results presented by Theorems 5 and 6 and for polynomial size OBDD. The hierarchy is based on function. Corollary 1 for nondeterministic case and Corollary 2 for deterministic one.
Additionally, we present the hierarchies for superpolynomial and subexponential sizes (Corollary 1 and 2).
The result for deterministic case extends Bolling–Sauerhoff–Sieling–Wegener hierarchy in polynomial case. Hierarchies for superpolynomial and subexponential size are new. In nondeterministic case we show that increasing for nodeterministic OBDD makes model more powerful, if is not constant. And prove hierarchy which extends Thathachar’s and Okolnishnikova’s hierarchies but for model with more regular structure (OBDD).
Second group of results is based on result from communication complexity. Namely, we develop a technique of presentation OBDD as special communication protocol. We take this result from [6] and prove similar results for nondeterministic and probabilistic OBDDs in the paper. In Sections 3 and 4 we consider Boolean function (Shuffled Address Function) which is presented in [14]. We prove that cannot be represented by constant width OBDDs for and sublinear width OBDDs for .
Based on our lower bound in Section 5 we prove the following proper inclusion (Corollary 3, 4) and 5).
These results presented by Theorems 7, 8 and 9. The hierarchy is based on function. Corollary 3 for nondeterministic case, Corollary 4 for deterministic case and Corollary 5 for probabilistic case.
The result for deterministic case extends Bolling–Sauerhoff–Sieling–Wegener hierarchy for sublinear width. In nondeterministic case we prove hierarchy which extends Thathachar’s and Okolnishnikova’s hierarchies but for model with more regular structure (OBDD) and sublinear width. For probabilistic case we prove hierarchy which extends Hromkovich and Saurhoff hierarchy but for model with more regular structure (OBDD) and sublinear width.
These two groups of results, which based on “functional description” and communication complexity technique, complement each other. First group of results cannot be applied for sublinear width, but second one cannot be applied for polynomial width. The both groups extend Bolling–Sauerhoff–Sieling–Wegener hierarchy in different cases.
2. Decomposition and Simulation of Nondeterministic Ordered Readtimes Branching Programs
2.1. Decomposition of Nondeterministic Ordered Readtimes Branching Programs
We denote by the class of Boolean functions that are computable by NOBDDs of width .
We denote by the class of Boolean functions that are computable by NOBDDs of width .
Let be a set of Boolean functions, over , which are presented in the following form:
(1) 
where .
Lemma 1.
For integer , such that , the following statement is true: .
Proof. Let be an th layer () of . is an leveled NOBDD. Let be a set of nodes of the first level of and be a set of nodes of the th (last) level of . Clearly we have the situation when for the th level of nodes of is coincide with the first level of nodes of , that is .
We call a sequence of nodes of program a trace and denote it as if and only if the following statements are true:

,

for ,

.
It is easy to see that any path of the program contains a (uniquely determined) trace where nodes appear along in this prescribed order. We denote by the set of all traces of program .
For a trace , for by we denote the function computed by the program .
Now we define the following function :
(2) 
This function expresses the fact that there is at least one trace and at least one accepting path for the input being considered such that contains trace . Hence, and we only have to check that the representation (2) has the desired form (1).
Indeed, the function is computed by the program which is a NOBDD of width with the source and sink . Hence, .
Furthermore, according to the definition of trace, the total number of traces does not exceed :
These two facts complete the proof of the lemma.
2.2. Constructing Nondeterministic Ordered Readones Branching Program by Decomposition of Nondeterministic Ordered Readtimes Branching Program
In this section we show that we can associate decomposition of Boolean function with computing by NOBDD.
Theorem 1.
For integer , such that , following statement is true:
Proof. Informally speaking we prove that the NOBDD can be simulated by NOBDD of lager width than . Note that the idea of such simulation is folklore and is used, for example, in [13], [10].
Let us present it formally.
Let , then is computed by NOBDD of width . According to Lemma 1 we have , hence the function is introduced in the following form:
for .
In order to show that we construct NOBDD of with .
The graph of consists from parallel parts, which are chosen in nondeterministic way in the first step. Each part is associated with different parts for different traces and we denote it .
Let , for the trace , is subprogram of determined by exactly all paths that contains trace T. Note that .
First of all, we show that we can simulate for trace with NOBDD of width , note that computes boolean function .
A graph of contains levels of nodes . The first level of is =, where is th level of .
The th level of is for .
Last level of is =.
Transition from state under input is determined in transitions of under input on the levels .
Obviously, that for some NOBDD reaches terminate node if reaches terminate node and it means that program has used trace .
Also we have by definition of .
It should be pointed out that contains all . In the first step chooses one of in nondetermionistic way and then work according to . Moreover, note that , hence .
The NOBDD computes Boolean function , due to (2).
2.3. Lower bound for Boolean Function .
Let set be one of the following sets:

is polynomial. It means that OBDD (NOBDD) has polynomial size.

, and it means that OBDD (NOBDD) has super polynomial size.

, , and it means that OBDD (NOBDD) has subexponential size.
Let and be the set of Boolean functions that have representation as OBDD and NOBDD with width , respectively.
We consider Boolean function , which was defined in [4], as a modification of Boolean function Shuffled Equality which was defined in [5] and [1].
Function . Let be multiple of such that . The Boolean function depends only on the first bits.
For any given input , we define two binary strings and in the following way. We call odd bits of the input marker bits and even bits value bits. For any satisfying , the value bit belongs to if the corresponding marker bit and belongs to otherwise.
Lemma 2.
, for , , and , for any .
Proof. At first we use property, that was proved in [4]:
(3) 
Let us assume that there exits an NOBDD of width such that computes , hence . Then by Theorem 1 we have .
Therefore, the following statement is true: , because . We have due to statement (3), hence . This is contradicts to the statement . Hence .
3. Lower Bounds for Nondeterministic and Deterministic Ordered Readtimes Branching Programs. Communication Complexity Technique
We start with necessary definitions and notations.
Let be a partition of the set into two parts and . Below we will use equivalent notations and .
Let be a subfunction of , where is a mapping . Function is obtained from by applying . We denote to be number of different subfunctions with respect to partition .
Let be the set of all permutations of . We say, that partition agrees with permutation , if for some , the following is right: . We denote a set of all partitions which agrees with .
Let
From paper [6] we have the following lower bound for deterministic case.
Theorem 2.
[6] Let function is computed by OBDD of width , then
We can proof lower bound for nondeterministic case by the similar way.
Theorem 3.
Let function is computed by NOBDD of width , then
We present the proof in the next section.
3.1. The Proof of Theorem 3
The proof of the Theorem is based on the representation of NOBDD computation process as a communication protocol of special form (Lemma 3) and on the description of computation process in matrix form (Lemma 4).
Now we define two party round automata communication nondeterministic protocol that simulates NOBDD computation.
Definition 1 (Nondeterministic Automata protocol).
Let be an odd integer, , be a partition of the set of variables.
We define an automata communication nondeterministic protocol as follows:
is a two party round communication protocol. Protocol uses the partition of variables among Alice (A) and Bob (B). Let be a partition of the input according to . Player A always starts the computation and Player B produces a result.
 Round 1:

Player generates the first set of messages (), nondeterministically chooses one of the messages and sends it to Player .
 Round 2:

Player generates the second set of messages ()), nondeterministically chooses one of the messages and sends it to Player .
 Round 3:

Player generates ()), nondeterministically chooses one of the messages and sends it to Player .
 Round 4:

Player generates ()), nondeterministically chooses one of the messages and sends it to Player . etc.
…
 Round :

Player receives and produces a result of computation or .
The result of computation on is if exists at least one sequence , such that result is , and otherwise. Boolean function is computed by protocol (presented by ) if for all .
Remark 1.
“Automata” property for protocol means the following fact: set of messages on current round depends only on input and previous message .
We say that automata nondeterministic protocol is agreed with NOBDD if and .
Lemma 3.
Let function be computed by NOBDD of width . Then can be computed by automata nondeterministic protocol that agreed with program
Proof. Let us construct automata nondeterministic protocol by NOBDD with the partition . Let , input according to and the protocol have two players and .
 Round 1:

Player emulates the first layers of program on levels which tests variables from . Then program reaches the set of vertexes and forms the set of messages , each of the messages is a binary encoding of numbers of vertexes from . After that nondeterministically chooses , and sends it to Player .
 Round 2:

Player gets and emulates the first layer of program on levels which tests variables from , starting from the vertex which number was encoded in . Then program reaches the set of vertexes and forms set of messages , each of the messages is a binary encoding of numbers of vertexes from . After that Player nondeterministicaly chooses , and sends it to Player .
 Round 3:

Player gets and emulates the second layer of program on levels which tests variables from , starting from the vertex which number was encoded in . Then program reaches the set of vertexes and forms set of messages , each of the messages is a binary encoding of numbers of vertexes from . After that Player nondeterministicaly chooses , and sends it to Player .
 Round 4:

Player gets and emulates the second layer of program on levels which tests variables from , starting from the vertex which number was encoded in . Then program reaches the set of vertexes and forms set of messages , each of the messages is a binary encoding of numbers of vertexes from . After that Player nondeterministicaly chooses , and sends it to Player .
etc.
 Round :

Player gets and emulates the last layer of program on levels which tests variables from , starting from the vertex which number was encoded in . Then program reaches one of the sink nodes and returns answer.
If there exists a path from root node to sink node in program then the sequence of messages should also be in existence. In this case protocol returns . In other case protocol returns . Hence .
Lemma 4.
Let Boolean function be computed by automata nondeterministic communication protocol then
for .
Proof. The main idea of the proof of Lemma 4 is to put protocol computation in a matrix form and to compute number of special submatrices of protocol computation matrix.
Firstly, let us describe matrix form protocol computation.
First of all, we define matrix that represents a computation procedure of protocol on input .
We define submatrices and as following:
The blocks and are blocks of size . The block describes computation of round . And block describes computation of round . If Alice (Bob) receives a message and a message from the set of messages then in th row, th column of block we put . Otherwise we put .
Additionally we define vectors and that describe the first and the last rounds respectively. Vector defines set of messages , which was formed on the first round of protocol . Each element of vector corresponds to one of matrix’s line. If message belongs to then , other elements are .
Vector . Each element of vector corresponds to one of matrix’s line. Vector , where such that
Secondly, let us show that for any we have following statement:
where is transposed and
Let vector describes computation of protocol after rounds on input .
It implies that we can compute in such a manner: .
According to the definition of we have following fact: iff protocol returns . Hence the forthcoming statement is true:
According to this statement we can see that if any such that and then . The proof is as follows:
It is easy to see that any subfunction , for is computed by . Hence cannot greats number of different protocols . And according to previous fact, a number of different protocols cannot greats number of different pairs .
Using combinatoric arguments we get that number of such pairs does not greats . Therefore we proved claim of Lemma.
Note that OBDD is partial case of NOBDD and the proof of Theorem 2 is very similar. The one difference is following: set always contains only one element.
3.2. Lower bound for Boolean Function .
We consider Boolean function , which was defined in [14].
Function . Let us define Boolean function . Informal, we divide a input into two parts, and each part into blocks. Each block has address and value. Function is iterative:

Phase . We find block with address in the first part of input and compute the value of this block. That is the address of the block from the second part.

Phase . We take the block from the second part with computed address and compute the value of the block and henceforth we get a new address of a new block from the first part.
…

Phase . We find a block with a new address in second (first) part and check the value of this block. If value of the block greats then value of is , and otherwise.
If we do not find the block with sought address on any phase then the value of is also .
Formally, Boolean function for integer and such that
(4) 
We divide input variables to blocks. There are variables in each block. After that we divide each block to address and value variables. First variables of block are address and other variables of block are value.
We call value variables of th block and are address variables, for .
Boolean function is iterative process based on the definition of the following six functions.
Function obtains firsts part of block’s address. This block will be used only in a step of iteration which number is computed using this function:
Function obtains the second part of block’s address. It is the address of a block within one step of iteration:
Function obtains a number of block by a number of step and address within this step of iteration:
Function obtains the value of a block that has an address within th step of iteration:
Two functions and obtain the value of th step of iteration. Function obtains the base for value of step of iteration:
Function obtains the value of th step of iteration:
Note that the address of current block is computed on the previous step.
The result of Boolean function is computed by the following way:
Let set be one of the following sets:

is constant,

, ,

, .