An Efficient Algorithm to Test Potentially Bipartiteness of Graphical Degree Sequences

1 Introduction

Given an arbitrary graphical degree sequence $d$ , let $R (d)$ denote the set of all of its non-isomorphic realizations. As usual, let $χ (G)$ and $ω (G)$ denote the chromatic number and clique number of a finite simple undirected graph $G$ respectively. It is known from Punnim Punnim2002A that for any given $d$ the set ${χ (G) : G \in R (d)}$ is exactly a set of integers in some interval. Define $X (d)$ to be $max {χ (G) : G \in R (d)}$ and $χ (d)$ to be $min {χ (G) : G \in R (d)}$ . These two quantities can be interesting for the structural properties of all the graphs in $R (d)$ .

Good lower and upper bounds on $X (d)$ are known from Dvořák and Mohar Dvorak2013 in terms of $Ω (d) = max {ω (G) : G \in R (d)}$ , which can be easily computed for any given $d$ using the algorithm from Yin Yin2012 . For example, $X (d) \geq Ω (d)$ , $X (d) \leq \frac{4}{5} Ω (d) + \frac{1}{5} max (d) + 1$ and $X (d) \leq \frac{6}{5} Ω (d) + \frac{3}{5}$ .

It appears computationally intractable to compute $χ (d)$ for any given zero-free $d$ . In this paper we are concerned with the related, somewhat easier, decision problem of whether $χ (d) = 2$ . Clearly, this is equivalent to decide whether $d$ has a bipartite realization, which is actually the first listed unsolved problem in Rao Rao1981 to characterize potentially bipartite graphical degree sequences and which remains unsolved to our knowledge. Note that the input $d$ is a single sequence of vertex degrees. A related problem is to decide, given two sequences of positive integers $(a_{1}, a_{2}, \dots, a_{m}; b_{1}, b_{2}, \dots, b_{n})$ , where $a_{1} \geq a_{2} \geq \dots \geq a_{m}$ and $b_{1} \geq b_{2} \geq \dots \geq b_{n}$ and $\sum_{i = 1}^{m} a_{i} = \sum_{i = 1}^{n} b_{i}$ , whether there is a bipartite graph whose two partite sets have $a = (a_{1}, a_{2}, \dots, a_{m})$ and $b = (b_{1}, b_{2}, \dots, b_{n})$ as their respective degree sequences. This problem can be easily solved by applying the Gale-Ryser theorem Gale1957 ; Ryser1957 , which states that the answer is “yes” if and only if the conjugate of $a$ dominates $b$ (or, equivalently, the conjugate of $b$ dominates $a$ ). Here we use the common definition of domination between two partitions of the same integer: a partition $p = (p_{1}, p_{2}, \dots)$ dominates a partition $q = (q_{1}, q_{2}, \dots)$ if $\sum_{i = 1}^{j} p_{i} \geq \sum_{i = 1}^{j} q_{i}$ for each $j = 1, 2, \dots$ . By convention, $p_{j} = 0$ for $j > ℓ (p)$ , where $ℓ (p)$ denotes the number of parts in the partition $p$ . We also use $| p |$ to denote the weight of the partition $p$ , that is, the sum of all the parts of $p$ .

The rest of the paper is organized as follows. Section 2 describes the algorithm to decide whether a given $d$ has a bipartite realization. Section 3 gives a time complexity analysis of the algorithm. Section 4 presents some experimental results. Section 5 discusses alternative designs of the algorithm and comments on the complexity of the decision problem. Section 6 concludes with further research directions.

2 Description of the Algorithm

Clearly, to decide whether any zero-free graphical degree sequence $d = (d_{1} \geq d_{2} \geq \dots \geq d_{n})$ with weight $| d | = \sum_{i = 1}^{n} d_{i}$ has a bipartite realization, we first need to determine whether it has a bipartition into $a$ and $b$ of equal weights $| d | / 2$ (for convenience, we call such bipartitions of $d$ candidate bipartitions). One may feel it challenging to find a candidate bipartition of $d$ in the first place, because it looks exactly like the well-known subset sum problem, which is known to be NP-complete GareyJohnson1979 . Fortunately, since every term in $d$ of length $n$ is less than $n$ , this restricted subset sum problem can be solved easily through dynamic programming in polynomial time GareyJohnson1979 ; Koiliaris2019 . In fact, many inputs admit a large number of candidate bipartitions. Now we can see that the decision problem boils down to checking whether $d$ has at least one candidate bipartition and, if this is the case, whether any of those candidate bipartitions satisfies the Gale-Ryser condition.

A naive algorithm can simply enumerate all candidate bipartitions of $d$ and check each of them against the Gale-Ryser condition. Such an algorithm necessarily runs in exponential time in the worst case. Our algorithm is more sophisticated than that. It has two phases. The first phase utilizes up to seven rules that can all be easily checked. As a matter of fact, in Section 4 we will show that most of the inputs can be resolved by this phase alone. The second is the enumeration phase, in which we do “brute-force” search in a clever way.

In describing and justifying the seven rules in the first phase, we seek a candidate bipartition of $d$ into the left side $a$ and the right side $b$ in such a way that at least half of the largest terms in $d$ appear in $a$ , without loss of generality. For example, for any input $d$ of length 50 with the largest term 34 whose multiplicity is 5 (i.e. there are exactly 5 copies of 34 in $d$ ), we will seek a candidate bipartition such that the left side $a$ contains at least 3 copies of 34.

Rule 1.

If $d$ does not have a candidate bipartition, then it is not potentially bipartite.

Proof.

This rule is obvious. As mentioned above, this rule can be easily implemented through dynamic programming for the subset sum problem. ∎

Rule 2.

If $| d | > \frac{n^{2}}{2}$ , then $d$ is not potentially bipartite.

Proof.

Based on Mantel’s theorem Mantel1907 , any simple undirected bipartite graph on $n$ vertices has at most $\frac{n^{2}}{4}$ edges. So the degree sum cannot exceed $\frac{n^{2}}{2}$ for any $d$ that is potentially bipartite. ∎

Rule 3.

If $d_{1} + d_{n + 1 - d_{1}} > n$ , then $d$ is not potentially bipartite.

Proof.

Suppose $d$ is potentially bipartite. The left partite set contains a vertex $v_{1}$ of degree $d_{1}$ so the right partite set contains at least $d_{1}$ vertices ( $v_{1}^{'} s$ neighbors), each of which has a degree at most $n - d_{1}$ since the left partite set has at most $n - d_{1}$ vertices. Consequently, $d$ must contain at least $d_{1}$ degrees that are $\leq n - d_{1}$ . Therefore, $d_{n + 1 - d_{1}}$ must be $\leq n - d_{1}$ for $d$ to be potentially bipartite. ∎

Rule 4.

If $\sum_{i = 1}^{n - d_{1}} d_{i} < \frac{| d |}{2}$ , then $d$ is not potentially bipartite.

Proof.

As mentioned in the proof of Rule 3, the left partite set has at most $n - d_{1}$ vertices. Clearly, the degree sum $| a |$ of the left side $a$ is impossible to exceed $\sum_{i = 1}^{n - d_{1}} d_{i}$ . Therefore, $\sum_{i = 1}^{n - d_{1}} d_{i}$ must be at least $\frac{| d |}{2}$ for $d$ to be potentially bipartite. ∎

Rule 5.

If $\sum_{d_{i} > n - d_{1}} d_{i} > \frac{| d |}{2}$ , then $d$ is not potentially bipartite.

Proof.

As shown in the proof of Rule 3, each of the right side degrees in $b$ is at most $n - d_{1}$ . Therefore, every degree larger than $n - d_{1}$ must be in the left side $a$ and the sum of such degrees should not exceed $\frac{| d |}{2}$ for any $d$ that is potentially bipartite. ∎

For the following rule, we will need the concept of residue of a finite simple undirected graph $G$ or a graphical degree sequence $d$ introduced in Favaron et al. Favaron1991 and we use $R (G)$ and $R (d)$ as notations. We also use $¯ ¯¯ ¯ d$ to denote the complementary graphical degree sequence of $d$ : $(n - 1 - d_{n} \geq n - 1 - d_{n - 1} \geq \dots \geq n - 1 - d_{1})$ , which is the degree sequence of the complementary graph of any realization of $d$ .

Rule 6.

If $R (¯ ¯¯ ¯ d) \geq 3$ , then $d$ is not potentially bipartite.

Proof.

As proved in Favaron1991 , the residue $R (d)$ of a graphical degree sequence $d$ is a lower bound on the independence number of any realization of $d$ . Then clearly $R (¯ ¯¯ ¯ d)$ is a lower bound on the clique number of any realization of $d$ . The result follows because any graph with a clique of size at least 3 is not bipartite. ∎

The following is a similar rule that uses the concept of Murphy’s bound introduced in Murphy MURPHY1991 , denoted $β (G)$ or $β (d)$ here, which is also a lower bound on the independence number of any realization of $d$ .

Rule 7.

If $β (¯ ¯¯ ¯ d) \geq 3$ , then $d$ is not potentially bipartite.

If the input $d$ passes the tests of all of the above seven rules and cannot be resolved as a “no” instance, then our algorithm will enter the enumeration phase. From Rule 5 we know that by now we must have $\frac{| d |}{2} \geq \sum_{d_{i} > n - d_{1}} d_{i}$ . In the special case that equality holds, which means the left side $a$ must contain exactly those degrees that are larger than $n - d_{1}$ should $d$ be potentially bipartite, our algorithm can immediately stop based on the result of the Galy-Ryser conditional test on this candidate bipartition of $d$ . Otherwise, our algorithm continues with $S = \frac{| d |}{2} - \sum_{d_{i} > n - d_{1}} d_{i} > 0$ , which is the sum of the additional degrees that need to be in the left side $a$ besides those that are larger than $n - d_{1}$ . For convenience, we use $a_{f}$ to denote the subsequence of $d$ consisting of those degrees that are larger than $n - d_{1}$ . Note that $a_{f}$ is an empty sequence when $n \geq 2 d_{1}$ .

The second phase will then enumerate candidate bipartitions of $d$ into $(a, b)$ by specifying which degrees will be in the left side $a$ , which also automatically specifies $b = d - a$ . As we already know, we need to choose a subsequence of $d - a_{f}$ (i.e. from those degrees in $d$ that are at most $n - d_{1}$ ) with sum $S$ and concatenate $a_{f}$ with this subsequence of degrees to form $a$ based on the above discussion. Several restrictions regarding $ℓ (a)$ can be put on the left side $a$ for the candidate bipartitions $(a, b)$ to possibly satisfy the Galy-Ryser conditional test so that our algorithm will enumerate as few candidate bipartitions as possible.

Restriction 1.

The number of degrees $ℓ (a)$ in the left side $a$ cannot exceed $n - d_{1}$ . This is because the right side $b$ contains at least $d_{1}$ degrees.

Restriction 2.

Let $l_{1}$ be the maximum number of degrees in $d$ with sum at most $\frac{| d |}{2}$ . Then the number of degrees $ℓ (a)$ in the left side $a$ cannot exceed $l_{1}$ . This is because the degrees in the left side $a$ must have sum $\frac{| d |}{2}$ .

Restriction 3.

Let $d_{m}$ be the minimum largest degree in any subsequence of $d$ with sum at least $\frac{| d |}{2}$ . Then the number of degrees $ℓ (a)$ in the left side $a$ must be at least $d_{m}$ . This is because the largest degree in the right side $b$ must be at least $d_{m}$ and the conjugate of $a$ should dominate $b$ .

Restriction 4.

Let $l_{2}$ be the minimum number of degrees in $d$ with sum at least $\frac{| d |}{2}$ . Then the number of degrees $ℓ (a)$ in the left side $a$ must be at least $l_{2}$ . The reason is similar to that for Restriction 2.

It’s not hard to see that $d_{m}$ , $l_{1}$ and $l_{2}$ can all be easily calculated with greedy algorithms. The above discussion shows we can enumerate all subsequences $a$ of $d$ that satisfies the following three requirements:

it includes all degrees in $a_{f}$ (i.e. those degrees in $d$ that are greater than $n - d_{1}$ ).
it has sum $| a | = \frac{| d |}{2}$ .
its number of degrees $ℓ (a)$ should satisfy $max {d_{m}, l_{2}} \leq ℓ (a) \leq min {n - d_{1}, l_{1}}$ .

In order to find a successful (i.e. satisfying the Gale-Ryser condition) candidate bipartition $(a, b)$ of $d$ , our intuition is to include a suitable number of large degrees from $d - a_{f}$ and as many small degrees of $d - a_{f}$ as possible into $a$ without violating requirement 3 mentioned above. In this way $b = d - a$ will not include many of the largest degrees in $d$ while $a$ will still include enough number of degrees, which makes it more likely for the conjugate of $a$ to dominate $b$ .

Following this intuition we calculate a maximum index $x_{0} \in {1, 2, \dots, n}$ such that $a$ cannot include all ${d_{1}, d_{2}, \dots, d_{x_{0}}, d_{x_{0} + 1}}$ in order for its conjugate to dominate $b$ . This index $x_{0}$ can be easily calculated as follows. Starting from $x = 1$ , if for some $x$ , when we include all ${d_{1}, d_{2}, \dots, d_{x}}$ in $a$ and include from $d - {d_{1}, d_{2}, \dots, d_{x}}$ as many smallest degrees as possible into $a$ while still maintaining the correct sum $| a | = \frac{| d |}{2}$ , and when the number of degrees $ℓ (a)$ in $a$ starts to fall below $max {d_{m}, l_{2}}$ , then $x_{0}$ can be chosen to be $x - 1$ .

After $x_{0}$ has been calculated, we will try to find out if we can include a subsequence $d_{S}$ of ${d_{1}, d_{2}, \dots, d_{x_{0}}}$ into $a$ together with some degrees in $d - d_{S}$ such that the conjugate of $a$ dominates $b$ . Without loss of generality, this subsequence $d_{S}$ can be chosen to be the largest terms of ${d_{1}, d_{2}, \dots, d_{x_{0}}}$ . Or, equivalently, we can remove the smallest terms from ${d_{1}, d_{2}, \dots, d_{x_{0}}}$ one at a time to get these subsequences. For each such subsequence $d_{S} = {d_{1}, d_{2}, \dots, d_{x}}$ , where $ℓ (a_{f}) \leq x \leq x_{0}$ since $d_{S}$ necessarily includes all degrees in $a_{f}$ according to the above discussion, we perform the following two enumerative steps to fully construct $a$ :

starting from the largest possible, choose some degree $d_{y}$ from $d - d_{S^{'}}$ and include some copies of $d_{y}$ into $a$ . We also stipulate that no degree larger than $d_{y}$ from $d - d_{S^{'}}$ will be included into $a$ . Here $d_{S^{'}}$ is defined as follows. If $d_{S}$ includes all copies of $d_{x}$ from $d$ , then $d_{S^{'}}$ includes $d_{S}$ together with all copies of the degree from $d$ which is immediately smaller than $d_{x}$ . If $d_{S}$ does not include all copies of $d_{x}$ from $d$ , then $d_{S^{'}}$ includes $d_{S}$ together with all the remaining copies of $d_{x}$ from $d$ . The motivation for such a definition is that we don’t want $d_{y}$ to equal a degree we have just excluded from a previous consideration of $d_{S}$ when $x$ is being reduced starting from $x_{0}$ .
include some small terms that are all less than $d_{y}$ from $d - d_{S^{'}} - d_{y}$ into $a$ , where $d_{y}$ is the subsequence of $d$ consisting of all copies of $d_{y}$ . We can generate a number of possible combinations of small terms with each combination summing to a suitable value based on the choice of $d_{S}$ and the choice in the enumerative step (1) and having a suitable number of terms so that $ℓ (a)$ satisfies the inequality in the above requirement 3. An appropriate procedure can be designed for this purpose such that combinations with more smaller terms are generated first and each combination can be generated in $O (n)$ time.

Note that both of these steps are enumerative steps. Step (1) must be exhaustive by trying each possible distinct $d_{y}$ from $d - d_{S^{'}}$ and each of the possible number of copies up to its multiplicity in $d$ . Step (2) can be non-exhaustive, which means we can impose a limit $l_{c}$ on the number of possible combinations of small terms to be included into $a$ . This parameter $l_{c}$ is the place where our algorithm is customizable and in reality we can choose $l_{c}$ to be a constant or a low degree polynomial of $n$ . This non-exhaustive enumeration step does open the possibility of our algorithm making an error on some “yes” input instances if the specified limit $l_{c}$ will cause our algorithm to skip some of the possible combinations. However, this step will not introduce any error on “no” input instances. We also note that some of the choices in these two steps can be pruned during the enumerative process to speed up the enumeration phase when they will cause $ℓ (a)$ to fail to satisfy the inequality in the above requirement 3. In fact, the lower bound on $ℓ (a)$ can be improved during the process as $x$ is being reduced so that the minimum largest degree in $b$ increases.

The reader may have noticed that these enumerative steps are more sophisticated and complicated than the simple naive scheme of enumerating all possible subsequences of $d - a_{f}$ with sum $S$ . We will discuss several alternative enumeration schemes later in Section 5. The presented enumeration scheme here is the fastest we found through experiments.

During the enumeration phase, the algorithm will stop and output “yes” if a successful candidate bipartition $(a, b)$ is found. Otherwise, it will stop enumeration and output “no” when the subsequence $d_{S}$ becomes shorter than $a_{f}$ , or, in the case that $a_{f}$ is empty, when $d_{S}$ includes less than half of the largest degrees $d_{1}$ from $d$ .

We note that the enumeration phase can be easily parallelized with respect to the different choices of $d_{S}$ . However, it may not be worth it given the good run time performance of the serial version unless the input is long and hard (say $n = ℓ (d) > 500$ ). See the following sections for run time complexity analysis and experimental evaluations.

3 Analysis of Run Time Complexity

The seven rules in the first phase can all be checked in polynomial time. It can be easily verified that the total running time of these rules is $O (n^{3})$ .

In the second phase, the three quantities $d_{m}$ , $l_{1}$ and $l_{2}$ can all be computed in $O (n)$ time. The maximum index $x_{0}$ can be calculated in $O (n^{2})$ time. The number of choices for $d_{S}$ is $O (n)$ . For each choice of $d_{S}$ , the number of choices for $d_{y}$ and its number of copies to be included in $a$ in the enumerative step (1) is $O (n)$ . The maximum number $l_{c}$ of combinations of the remaining small terms to be included in $a$ in the enumerative step (2) can be chosen to be $O (1)$ , $O (n)$ , etc. Each combination can be generated in $O (n)$ time. Whenever a full left side $a$ has been constructed, the Galy-Ryser conditional test on the candidate bipartition $(a, b)$ can be performed in $O (n)$ time. Overall, we can see that the second phase runs in $O (n^{5})$ time when $l_{c}$ is $O (n)$ . Note this run time is achieved at the expense of the algorithm possibly producing an erroneous output on some “yes” instances. However, the observed error rate is so low that we consider the limit on $l_{c}$ worthwhile. On the other hand, if no limit is placed on $l_{c}$ , then our algorithm will always produce a correct output, at the expense of possibly running in exponential time in the worst case.

In summary, our algorithm can be customized to run in polynomial time with satisfactory low error rates (see Section 4 for some evidence of error rates). Also note that it is a deterministic instead of a randomized algorithm.

4 Experiments

We mainly tested our implementation of the decision algorithm with the parameter $l_{c}$ customized as $l_{c} \leq n$ . We first show the low error rates of the algorithm and then show the good run time performance.

4.1 Error Rates

We first demonstrate the somewhat surprising power of the seven rules in the first phase. In Table 1 we show the number $r (n)$ of all zero-free graphical degree sequences of length $n$ that can be resolved by one of these rules and their proportion among all $D (n)$ zero-free graphical degree sequences of length $n$ . Based on the description of the rules, these $r (n)$ instances are all “no” instances. The function values $r (n)$ are obtained through a program that incorporates our decision algorithm into the algorithm to enumerate all degree sequences of a certain length from Ruskey et al. Ruskey1994 . Let $B (n)$ be the number of zero-free potentially bipartite graphical degree sequences of length $n$ . Clearly $B (n) \leq D (n) - r (n)$ since some of the “no” instances are resolved in the second phase. It looks safe to conclude from this table that $\frac{r (n)}{D (n)}$ tends to 1 as $n$ grows towards infinity and so $\frac{B (n)}{D (n)}$ tends to 0. Note that these are just empirical observations. Rigorous proofs of the asymptotic orders of these functions or their relative orders might require advanced techniques Wang2019 .

In fact, those instances that can be resolved by one of the seven rules are not the only ones that can avoid the enumeration phase of our algorithm. For example, those instances that have $S = \frac{| d |}{2} - | a_{f} | = 0$ can also be resolved immediately following the tests of the rules according to our description in Section 2.

$n$	$D (n)$	$r (n)$	$\frac{r (n)}{D (n)}$
6	71	53	0.746479
7	240	203	0.845833
8	871	770	0.884041
9	3148	2902	0.921855
10	11655	10995	0.943372
11	43332	41603	0.960099
12	162769	158074	0.971155
13	614198	601556	0.979417
14	2330537	2295935	0.985153
15	8875768	8780992	0.989322
16	33924859	33663505	0.992296
17	130038230	129315300	0.994441
18	499753855	497745844	0.995982
19	1924912894	1919319963	0.997094
20	7429160296	7413535855	0.997897
21	28723877732	28680124185	0.998477
22	111236423288	111113621955	0.998896
23	431403470222	431058118392	0.999199

Table 1: The number

D (n)

of zero-free graphical degree sequences of length

n

, and the number

r (n)

of them that can be resolved by one of the seven rules.

Next we demonstrate the low error rates of our algorithm. In Table 2 we show the number $B_{w} (n)$ of all zero-free potentially bipartite graphical degree sequences of length $n$ that will be incorrectly reported as a “no” instance if we set $l_{c} = 1$ and their proportion among all $B (n)$ zero-free potentially bipartite graphical degree sequences of length $n$ . Even with the smallest possible $l_{c}$ , our algorithm makes very few errors on the “yes” instances. In fact, if we set $l_{c} = n$ , then our algorithm makes no error on all zero-free graphical degree sequences of length $n \leq 23$ . However, the observed trend is that the limit $l_{c}$ need to grow with $n$ for our algorithm to always make no error. We are unable to prove whether there is any polynomial of $n$ to bound $l_{c}$ such that our algorithm can always give correct outputs or the error rate is always below some constant. If $l_{c}$ grows faster than a polynomial of $n$ , then our algorithm could run more than polynomial time in the worst case. In our experiments we did not find any “yes” instance of length $n \geq 50$ that will be misclassified by our algorithm under the setting of $l_{c} = n$ .

$n$	$B (n)$	$B_{w} (n)$	$\frac{B_{w} (n)}{B (n)}$ (with $l_{c} = 1$ )
6	18	0	0
7	37	0	0
8	100	0	0
9	241	0	0
10	640	0	0
11	1639	0	0
12	4378	0	0
13	11601	2	0.000172399
14	31318	8	0.000255444
15	84642	32	0.000378063
16	230789	117	0.000506957
17	631159	482	0.000763674
18	1736329	1667	0.000960072
19	4790928	6107	0.0012747
20	13272233	20826	0.00156914
21	36869887	72879	0.00197665
22	102727688	244266	0.0023778
23	286893582	821331	0.00286284

Table 2: The number

B (n)

of zero-free potentially bipartite graphical degree sequences of length

n

, and the number

B_{w} (n)

of them that will be misclassified as “no” instances if

l_{c}

is set to 1.

We note that the error rates reported in Table 2 is with respect to the $B (n)$ “yes” instances. The error rate will be much lower if they are computed with respect to all $D (n)$ instances of length $n$ because, as we know from Table 1, by far the majority of the “no” instances have already been correctly detected by the seven rules. For example, $\frac{B_{w} (23)}{D (23)} = 1.9 \times 10^{- 6}$ at the setting of $l_{c} = 1$ . Plus, increasing $l_{c}$ from $O (1)$ to $O (n)$ also further reduces the error rate. For example, $\frac{B_{w} (23)}{D (23)} = 0$ at the setting of $l_{c} = 23$ .

4.2 Run Time Performance

We now demonstrate the run time performance of our algorithm with the setting of $l_{c} = n$ . Here the reported run times were obtained through a C++ implementation tested under typical Linux workstations. We have already shown in Section 3 that our algorithm runs in polynomial time if $l_{c}$ is bounded by a polynomial of $n$ . We generated random graphical degree sequences of specified length $n$ , largest term $d_{1}$ and smallest term $d_{n}$ . For a wide range of $n \leq 500$ , we found that the hardest instances for our algorithm are approximately in the range of $0.5 n \leq d_{1} \leq 0.6 n$ and $1 \leq d_{n} \leq 0.1 n$ . The instances in these ranges are the most likely to cause our algorithm to enter the enumeration phase. However, even the hardest instances we tested for $n \leq 500$ can be finished in about a couple of minutes, which are necessarily those “no” instances that will go through the entire enumeration phase without any successful candidate bipartition being found. All the tested instances that are decided in the first phase can be finished almost instantly. All of the tested “yes” instances detected in the enumeration phase can be decided in at most tens of seconds due to the empirical fact that most of the “yes” instances have a successful candidate bipartition that can be found even when $l_{c}$ is set to 1.

5 Discussions

We mentioned in Section 2 that our algorithm is customizable through the limit $l_{c}$ in the enumerative step (2). In this section we describe several alternatives to the enumeration phase.

In the enumerative step (1) we have chosen $d_{y}$ from largest to smallest. Instead, we can choose $d_{y}$ from smallest to largest. On average, we found that the former has better run time performance.

In the enumerative step (2) we prefer to enumerate the combinations of smallest terms first. Instead, we can choose to enumerate those of largest terms first. On average, we still found that the former has better run time performance.

The enumerative steps (1) and (2) can even be combined into one step to make the enumeration phase simpler. That is, we can exhaustively enumerate all possible combinations of terms from $d - d_{S^{'}}$ with an appropriate sum subject to the requirement 3 about the number of terms $ℓ (a)$ in $a$ . (Or, to make it more naive, we could exhaustively enumerate all possible combinations of terms from $d - a_{f}$ with the sum $S$ .) With these schemes we still face the choice of enumerating largest terms first or smallest terms first. On average, the choice of “smallest terms first” still enjoys better run time performance. However, in order to achieve similar low error rates in these alternative schemes with this choice of “smallest terms first,” the limit on the number of combinations to be generated will usually have to be much larger than the chosen limit $l_{c}$ in our design in Section 2, causing these alternatives to have much worse run time performance on those instances that require the second phase to decide. If no limit is placed on the number of combinations to be generated, these alternatives will all produce correct outputs always. Nevertheless, the run time performance could become terrible. For example, for some hard instances with length $n$ from 100 to 300, it could take days to detect a successful candidate bipartition for “yes” instances and tens of days to decide for “no” instances when unlimited $l_{c}$ is chosen, a clear evidence of exponential run time behavior. For longer hard instances in the range $300 \leq n \leq 500$ , these more naive enumeration phases with unlimited $l_{c}$ might take years or longer time to finish.

As mentioned before, our algorithm always gives the correct conclusion for “no” instances. But it could give an incorrect output for some “yes” instances depending on the limit $l_{c}$ set in the enumeration phase. This kind of behavior can be contrasted with some randomized algorithms. The error our algorithm might make is fixed and it comes from the fact that not all potentially bipartite graphical degree sequences exhibit the kind of pattern that can be captured by the particular “limited” search process of our algorithm. Simply put, our algorithm is deterministic. If it makes an error on an input under a particular setting of $l_{c}$ , it always makes an error on that input with that setting. If a randomized algorithm makes an error on an input, then it could produce a correct output the next time it runs.

Now we comment on the complexity of the decision problem of potentially bipartiteness of graphical degree sequences. It is obviously in $N P$ . We don’t know whether it is in co- $N P$ or in $P$ , nor do we know whether it is $N P$ -complete. Whenever our algorithm reports an input as an “yes” instance, it can also output a successful candidate bipartition. We are not sure if this is necessary for this decision problem. For example, the well-known decision problem of primality of integers can be decided in polynomial time AKS2004 . However, a “composite” output does not come with a prime factor. It is known from the prime number theorem Hadamard1896 ; Poussin1896 that almost all integers are composite. In this sense, the polynomial solvability of the primality testing problem seems intuitive. We would also like to compare this problem with the decision problem of whether a given graph is of class 1 or class 2, i.e. whether its edge chromatic number is equal to $Δ$ or $Δ + 1$ where $Δ$ is the maximum degree of the given graph. It is known from ERDOS1977 that almost all graphs on $n$ vertices are of class 1 as $n$ grows towards infinity. However, it is $N P$ -complete to decide whether a graph is of class 1 or class 2 Holyer1981 . These facts sound more unintuitive. It is almost certain from our experimental results that the proportion of zero-free graphical degree sequences of length $n$ that are not potentially bipartite approaches 1 as $n$ grows towards infinity. Is it possible that the decision problem is actually in $P$ ? Or, could it be that some hidden classes of hard instances are overlooked by our experiments and the decision problem is actually $N P$ -complete or $N P$ -intermediate, should $P \neq N P$ .

In this paper we dealt with the decision problem of whether $χ (d) = 2$ . In the case that $d$ is not potentially bipartite and it is desired to compute $χ (d)$ , we can decide, for each successive fixed $k \geq 3$ , whether there is a $k$ -colorable realization of $d$ , until the answer becomes “yes.” We conjecture that each of these decision problems is $N P$ -complete.

6 Summary and directions for future research

We presented a fast algorithm to test whether a graphical degree sequence is potentially bipartite. The algorithm works very well in practice. It remains open whether the decision problem can be solved in polynomial time. The complexity of the decision problem whether $χ (d) \leq k$ is also to be resolved.

7 Acknowledgements

This research has been supported by a research seed grant of Georgia Southern University. The computational experiments have been supported by the Talon cluster of Georgia Southern University.

References

[1] Manindra Agrawal, Neeraj Kayal, and Nitin Saxena. Primes is in P. Annals of Mathematics, 160(2):781–793, 2004.
[2] de la Vallée Poussin. Recherches analytiques la théorie des nombres premiers. Ann. Soc. scient. Bruxelles, 20:183–256, 1896.
[3] Zdeněk Dvořák and Bojan Mohar. Chromatic number and complete graph substructures for degree sequences. Combinatorica, 33(5):513–529, 2013.
[4] Paul Erdős and Robin J. Wilson. On the chromatic index of almost all graphs. Journal of Combinatorial Theory, Series B, 23(2):255–257, 1977.
[5] O. Favaron, M. Mahéo, and J.-F. Saclé. On the residue of a graph. Journal of Graph Theory, 15(1):39–64, 1991.
[6] D. Gale. A theorem on flows in networks. Pacific J. Math, 7(2):1073–1082, 1957.
[7] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman & Co., New York, NY, USA, 1979.
[8] J. Hadamard. Sur la distribution des zéros de la fonction zeta(s) et ses conséquences arithmétiques. Bull. Soc. math. France, 24:199–220, 1896.
[9] I. Holyer. The $N P$ -completeness of edge-coloring. SIAM Journal on Computing, 10(4):718–720, 1981.
[10] Konstantinos Koiliaris and Chao Xu. Faster pseudopolynomial time algorithms for subset sum. ACM Trans. Algorithms, 15(3):40:1–40:20, 2019.
[11] W. Mantel. Problem 28 (solution by H. Gouwentak, W. Mantel, J. Teixeira de Mattes, F. Schuh and W. A. Wythoff). Wiskundige Opgaven, 10:60–61, 1907.
[12] Owen Murphy. Lower bounds on the stability number of graphs computed in terms of degrees. Discrete Mathematics, 90(2):207–211, 1991.
[13] Narong Punnim. Degree sequences and chromatic numbers of graphs. Graphs and Combinatorics, 18(3):597–603, 2002.
[14] S. B. Rao. A survey of the theory of potentially P-graphic and forcibly P-graphic degree sequences. In Siddani Bhaskara Rao, editor, Combinatorics and Graph Theory: Lecture Notes in Mathematics, vol 885, pages 417–440. Springer Berlin Heidelberg, 1981.
[15] Frank Ruskey, Robert Cohen, Peter Eades, and Aaron Scott. Alley CATs in search of good homes. In 25th S.E. Conference on Combinatorics, Graph Theory, and Computing, volume 102, pages 97–110. Congressus Numerantium, 1994.
[16] H. J. Ryser. Combinatorial properties of matrices of zeros and ones. Canadian Journal of Mathematics, 9:371–377, 1957.
[17] Kai Wang. Efficient counting of degree sequences. Discrete Mathematics, 342(3):888–897, 2019.
[18] Jian-Hua Yin. A short constructive proof of A.R. Rao’s characterization of potentially $k_{r + 1}$ -graphic sequences. Discrete Applied Mathematics, 160(3):352–354, 2012.

An Efficient Algorithm to Test Potentially Bipartiteness of Graphical Degree Sequences

Authors

An efficient algorithm to test forcibly-connectedness of graphical degree sequences

Efficient Algorithm for Checking 2-Chordal (Doubly Chordal) Bipartite Graphs

On the Complexity of Nucleolus Computation for Bipartite b-Matching Games

High-dimensional sequence transduction

Efficient constructions of the Prefer-same and Prefer-opposite de Bruijn sequences

Less Arbitrary waiting time

Near-optimal Bootstrapping of Hitting Sets for Algebraic Circuits

1 Introduction

2 Description of the Algorithm

Rule 1.

Proof.

Rule 2.

Proof.

Rule 3.

Proof.

Rule 4.

Proof.

Rule 5.

Proof.

Rule 6.

Proof.

Rule 7.

Restriction 1.

Restriction 2.

Restriction 3.

Restriction 4.

3 Analysis of Run Time Complexity

4 Experiments

4.1 Error Rates

4.2 Run Time Performance

5 Discussions

6 Summary and directions for future research

7 Acknowledgements

References

An Efficient Algorithm to Test Potentially Bipartiteness of Graphical Degree Sequences

Authors

An efficient algorithm to test forcibly-connectedness of graphical degree sequences

Efficient Algorithm for Checking 2-Chordal (Doubly Chordal) Bipartite Graphs

On the Complexity of Nucleolus Computation for Bipartite b-Matching Games

High-dimensional sequence transduction

Efficient constructions of the Prefer-same and Prefer-opposite de Bruijn sequences

Less Arbitrary waiting time

Near-optimal Bootstrapping of Hitting Sets for Algebraic Circuits

This week in AI

1 Introduction

2 Description of the Algorithm

Rule 1.

Proof.

Rule 2.

Proof.

Rule 3.

Proof.

Rule 4.

Proof.

Rule 5.

Proof.

Rule 6.

Proof.

Rule 7.

Restriction 1.

Restriction 2.

Restriction 3.

Restriction 4.

3 Analysis of Run Time Complexity

4 Experiments

4.1 Error Rates

4.2 Run Time Performance

5 Discussions

6 Summary and directions for future research

7 Acknowledgements

References