In the setting considering non-induced bicliques, the state-of-the-art approach is MICA of Alexe et al. . MICA employs a consensus mechanism to iteratively find maximal bicliques by combining them together, resulting in an algorithm, where is the number of MBs. We introduce a new algorithm OCT-MICA which leverages odd cycle transversals and runs in time.
Since all graphs have OCT sets (although they can be size , as in cliques), OCT-MIB, OCT-MIB-ii@, and OCT-MICA can all be run in the general case; their correctness does not require minimality or optimality of the OCT set. Further, we implement OCT-MIB-ii@, Enum-MIB and OCT-MICA in open source C++ code, and evaluate their performance on a suite of synthetic graphs with known OCT decompositions. Our experiments show that OCT-MICA and OCT-MIB-ii@ are the dominant algorithms for their respective problems in many settings. Their efficiencies allow us to run on larger graphs than in .
We begin with preliminaries and a brief discussion of related work in Section 2, then describe each of our three new algorithms and provide proofs of their correctness and runtimes in Section 3. We highlight several implementation details in Section 4, before presenting our experimental evaluation in Section 5.
2.1 Related work
The complexity of finding bicliques is well-studied, beginning with the results of Garey and Johnson  which establish that in bipartite graphs, finding the largest balanced biclique is NP-hard but the largest biclique can be found in polynomial time. Particularly relevant to the mining setting, Kuznetsov showed that enumerating MBs in a bipartite graph is #P-complete . Finding the biclique with the largest number of edges was shown to be NP-complete in general graphs , but the case of bipartite graphs remained open for many years. Several variants (including the weighted version) were proven NP-complete in  and in 2000, Peeters finally resolved the problem, proving the edge maximization variant is NP-complete in bipartite graphs .
For the problem of enumerating MIBs, the best known algorithm in general graphs is due to Dias et al. ; in the non-induced setting, approaches include a consensus algorithm MICA , an efficient algorithm for small arboricity , and a general framework for enumerating maximal cliques and bicliques , with MICA the most efficient among them, running in . We note that, as described, the method in  may fail to enumerate all MIBs; a modified, correct version was given in .
There has also been significant work on enumerating MIBs in bipartite graphs. We note that since all bicliques in a bipartite graph are necessarily induced, non-induced solvers for general graphs (such as MICA) can be applied, and have been quite competitive. The best known algorithm however, is due to Zhang et al.  and directly exploits the bipartite structure. Other approaches in bipartite graphs include frequent closed itemset mining  and transformations to the maximal clique problem ; faster algorithms are known when a lower bound on the size of bicliques to be enumerated is assumed [23, 26].
Kloster et al.  extended techniques for bipartite graphs to the general setting using odd cycle transversals, a form of “near-bipartiteness” which arises naturally in many applications [10, 24, 27]. This work resulted in OCT-MIB, an algorithm for enumerating MIBs in a general graph, parameterized by the size of a given OCT set. Although finding a minimum size OCT set is NP-hard, the problem of deciding if an OCT set with size exists is fixed parameter tractable (FPT) with algorithms in  and  running in times and
, respectively. We note non-optimal OCT sets only affect the runtime (not correctness) of our algorithms, allowing us to use heuristic solutions. Recent implementations of a heuristic ensemble alongside algorithms from [2, 12] alleviate concerns about finding an OCT decomposition creating a barrier to usability.
2.2 Notation and terminology
Let be a graph; we set and . We define to be the neighborhood of and write for ’s non-neighbors. An independent set is a maximal independent set (MIS) if is not contained in any other independent set of . Unless otherwise noted, we assume without loss of generality that is connected.
A biclique in a graph consists of non-empty disjoint sets such that every vertex of is neighbors with every vertex of . We say a biclique is induced if both and are independent sets in . A maximal biclique (MB) in is a biclique not properly contained in any other; a maximal induced biclique (MIB) is analogous among induced bicliques. We use and to denote the number of MBs and MIBs in , respectively. If is an OCT set in , we denote the corresponding OCT decomposition of by , where the induced subgraph is bipartite. We write and for and , respectively.
In this section we provide three novel algorithms, two of which of solve Maximal Induced Biclique Enumeration (Enum-MIB and OCT-MIB-ii@) and the other of which solves Maximal Biclique Enumeration (OCT-MICA). Both Enum-MIB and OCT-MIB-ii@ follow the same general framework, which we now describe.
3.1 MIB Algorithm Framework
The MIB-enumeration algorithms both use two subroutines, MakeIndMaximal and AddTo. MakeIndMaximal takes in , where is an induced biclique and , and either returns a MIB where , , , or returns . If it returns and then there is another MIB which contains and . AddTo takes in where is an induced biclique and , and returns the induced biclique where is added to , is removed from , and is removed from if ; otherwise, is returned. Both MakeIndMaximal and AddTo operate in time. We defer algorithmic details and proofs of the complexity and correctness for these routines to the Appendix.
The MIB-enumeration framework (shown in Algorithm 1) begins by finding a seed set of MIBs . At a high level, it operates by attempting to add vertices from the designated set to previously found MIBs to make them maximal. We utilize a dictionary to track which MIBs have already been found and a queue to store bicliques which have not yet been explored. We now prove two technical lemmas used to show the correctness of this framework.
Let be a MIB in graph which contains a non-empty subset of , another MIB in . Running AddTo with parameters and returns a biclique which contains , , and if .
By construction, must be independent from and completely connected to . Thus, none of will be removed from and all of will remain in , as required. Therefore, as long as , the desired biclique is returned.
In Algorithm 1, if there exists a MIB in such that , and , for each MIB in , then all MIBs in are included in .
Assume not. Let be a MIB in which is not in with maximum. Let be the MIB in such that , and and let . Without loss of generality assume and .
Consider the iteration of Algorithm 1 when and (lines 5-6). By Lemma 1, one of the calls to AddTo returns an induced biclique which contains , , and . Both sides of are non-empty (since and ). If we obtain a contradiction, as MakeIndMaximal would return , resulting in its addition to . Otherwise, either MakeIndMaximal returns or a biclique which is added to . Since both sides of are nonempty, if MakeIndMaximal returns , there exists a MIB in containing and . Let be such a MIB; since it has more vertices in than , it must be in , and we set . In either case, , . We can repeat this argument for the new , noting that will include vertices on both sides. Thus, the argument still holds without any assumption on the non-empty side of the intersection and will strictly decrease; when it reaches 0, , a contradiction.
Note that as MakeIndMaximal only returns MIBs, this framework will only include MIBs in . Together with Lemma 2, this yields the following corollary.
If for every MIB there is a MIB such that , and , then upon completion of Algorithm 1, will contain exactly the MIBs in .
Recall that AddTo and MakeIndMaximal each run in time. Combining this with the fact that each MIB in is popped at most once from we have:
The time complexity of this framework is , where is the time needed by FindSeedSet to compute .
We now present Enum-MIB, which follows the MIB-enumeration framework. To form , for each vertex we run MakeIndMaximal where and add it to . We also let . To show the correctness of this approach, we note that and any MIB contains the empty set. Thus all that remains to show is that for each MIB there is a MIB in with which it has a non-empty intersection. As every is in some MIB in , this condition is met. Thus, via Corollary 1, Enum-MIB will find all MIBs. There may be duplicates in which can be removed in time per duplicate. As MakeIndMaximal runs in time, by Corollary 2, the time complexity of Enum-MIB is . We note that Enum-MIB is essentially a simplified version of the LexMIB algorithm from  which does not guarantee lexicographic order on output.
Next we describe OCT-MIB-ii@, an algorithm for enumerating all MIBs in a graph with a given OCT decomposition . OCT-MIB-ii@ also makes use of the MIB-enumeration framework described in Section 3.1. In the calls to MakeIndMaximal we let . To form , we begin by running iMBEA  to find the set of MIBs in . For each we run MakeIndMaximal on . This creates a set of MIBs in .
Then for each node , we find the set of MISs in . This can be done in time per MIS using the algorithm of Tsukiyama et al. . For each MIS found, run MakeIndMaximal on the induced biclique . Let the multiset of all MIBs produced by this process be denoted . Note that a MIB may be in up to times (once per , stemming from an MIS in ), but we can remove duplicates from in per MIB, forming . We then let . Thus, FindSeedSet runs in per unique MIB found, and by Corollary 2, the total time complexity of OCT-MIB-ii@ is .
To show the correctness of OCT-MIB-ii@, we must show that for every MIB in , we include a MIB in which includes all of its non-OCT nodes and a node in the MIB if the MIB is completely contained in . If an entire MIB is contained in , then any MIB containing for suffices. If a MIB has non-OCT nodes on both sides, then there must be a MIB in which contains these non-OCT nodes because there is a MIB in containing them. If a MIB has all of its non-OCT nodes on one side, then there is an OCT node which is neighbors with all of the non-OCT nodes, which thus must be contained in an MIS in . Thus, by Corollary 1, we find all of the MIBs in .
OCT-MICA is an algorithm for enumerating the maximal bicliques (MBs) in a general graph with a given OCT decomposition . We adapt the approach of MICA , which relies on a seed set of bicliques which “cover” the graph. Specifically, we restrict MICA’s coverage requirement for the seed set to only the OCT set and leverage iMBEA  to enumerate the MBs entirely within . This reduces the runtime from to .
OCT-MICA begins by running iMBEA (line 2 in Algorithm 2) to get , the MBs in , in time , where is the number of edges in and . Using MakeMaximal, we convert elements of to be maximal with respect to (lines 3-4). MakeMaximal runs in time and its algorithmic details are deferred to the Appendix. OCT-MICA then initializes its seed set of size consisting of bicliques from the stars of the OCT set (lines 6-8), and adds these to the working set of all identified MBs (line 9). Similar to MICA, the remainder of the algorithm builds new bicliques by combining (via Consensus, see Appendix) pairs of elements from the seed set and previously identified MBs (lines 11-20), until no new bicliques are generated. This runs in time .
OCT-MICA returns exactly , the set of maximal bicliques in .
Running iMBEA and MakeMaximal ensures all maximal bicliques from were found and added to . Thus, we restrict our attention to maximal bicliques with at least one node from , and proceed similarly to the proof of Theorem 3 in . We say that a biclique absorbs a biclique if and or and .
We show that every biclique in is absorbed by some biclique in by induction on , the number of OCT vertices in . In the base case (), is contained in and is absorbed by a biclique in . We now consider ; without loss of generality, assume contains some OCT vertex . Then is absorbed by some biclique , where is formed from the star centered on . Further, has fewer vertices from OCT than , so by induction it is absorbed by some biclique , where . Now is a consensus of and , and will be absorbed by the corresponding consensus of and , guaranteeing absorption by a biclique in .
The runtime of OCT-MICA after iMBEA is .
We begin by noting that , so is .
Finding the bicliques in requires time for iMBEA (line 2); making them maximal (lines 3-4) is . The bicliques generated by the OCT stars (lines 6-8) can be found in . Sorting the initial set (line 10) incurs an additional . Since is , the total runtime for our initialization (lines 2-10) is .
The consensus-building stage of OCT-MICA contains nested loops over (line 14) and (line 15), which execute at most and times, respectively. The Consensus operation (line 16) executes in , and produces a constant number of candidate bicliques to check. Each execution of the inner loop incurs a cost of for MakeMaximal (line 17) and to insert the new MB in sorted order (lines 18-20). We note that the runtime of Consensus is dominated by the cost of the loop. Thus, the total runtime of consensus-building is , or .
This analysis leads to an overall runtime of , as desired. We note that for , OCT-MICA’s runtime degenerates to the of MICA. Additionally, the stronger results for incremental polynomial time described for MICA in  still apply; the proofs are similar and are omitted for space. For bipartite graphs (), OCT-MICA is effectively iMBEA, which was empirically shown to be more efficient than MICA on bipartite graphs .
In this section we describe several relevant implementation details and design decisions.
4.1 Algorithm Framework
We always (re-label and) store vertices as and maintain internal dictionaries as needed to recover original labels – e.g. when taking subgraphs. This allows us to leverage native data types and structures; vertices are stored as size_t.
For efficiency in subroutines, we utilize two representations of
. One representation is as adjacency lists, stored as sorted vectors (to improve union and intersection relative to dictionaries or unsorted vectors). This representation is essential in the performance ofConsensus in MICA/ OCT-MICA and MakeIndMaximal and AddTo in OCT-MIB or OCT-MIB-ii@. We also store the graph as a dictionary of dictionaries which is more amenable to taking subgraphs (as when finding MISs in OCT-MIB, OCT-MIB-ii@). Deleting a node requires time as compared to , where is the maximum degree, in the adjacency list representation.
The public implementation of MICA used in  is available at . However, this implementation is only suitable for bipartite graphs as it makes certain efficiency improvements in storage, etc. which assume bipartite input. As such, we implemented MICA from scratch in the same framework as OCT-MIB and OCT-MICA, etc., using the data structures discussed above. This is incompatible with the technique described in  for storing only one side of each biclique (since in the non-induced case, maximality completely determines the other side). We note this could improve efficiency of both MICA and OCT-MICA in a future version of our software, and should not significantly affect their relative performance as analyzed in this work.
5.1 Data and experimental setup
We implemented OCT-MIB-ii@, Enum-MIB, MICA, and OCT-MICA in C++, and used the implementation of OCT-MIB from . All code is open source under a BSD 3-clause license and publicly available as part of MI-Bicliques at .
For convenience, throughout this section, we assume and let . Our synthetic data was generated using a modified version of the random graph generator of Zhang et al.  that augments random bipartite graphs to have OCT sets of known size. The generator allows a user to specify the sizes of , , and (, , and ), the expected edge densities between and , and , and within , and the coefficient of variation (
; the standard deviation divided by the mean) of the expected number of neighbors inover and in over . The generator is seeded for replicability. We use the naïve OCT decomposition returned by the generator for our algorithm evaluation, but the techniques mentioned in Section 2 could also be used to find alternative OCT sets. Unless otherwise specified, the following default parameters are used: expected edge density , , and ; additionally, the edge density between and is the same as that between and .
To add the edges between and , the edge density and values are used to assign vertex degrees to , and then neighbors are selected from uniformly at random; this was implemented in the generator of . Edges are added between and via the same process, only with the corresponding edge density and values. Finally, we add edges within with an Erdős-Rényi process based on expected density (no value is used here).
In most experiments we limit to be , and use a timeout of one hour (3600s). Unless otherwise noted we run each parameter setting with five seeds and plot the average over these instances, using the time-out value as the runtime for instances that don’t finish. If not all instances used for a plot point finished, we annotate it with the number of instances that did not time out.
We began by running our algorithms on the same corpus of graphs as in  (see 5.2). As the new algorithms finished considerably faster than those in , we were able to scale up both and to create new sets of experiments, discussed in 5.3. We also ran our algorithms on computational biology graphs from , which have been shown to be near-bipartite; these results are in 5.4.
All experiments were run on identical hardware; each server had four Intel Xeon E5-2623 v3 CPUs (3.00GHz) and 64GB DDR4 memory. The servers ran Fedora 27 with Linux kernel 4.16.7-200.fc27.x86_64. The C/C++ codes were compiled using gcc/g++ 7.3.1 with optimization flag -O3.
5.2 Initial Benchmarking
We begin by evaluating our algorithms on the corpus of graphs used in . This dataset was designed to independently test the effect of each parameter (the expected densities in various regions of the graph, the values, , , and ) on the algorithms’ runtime. We observe that OCT-MIB-ii@ and OCT-MICA are generally the best algorithms for their respective problems, and include comprehensive plots of all experiments in the Appendix.
For Maximal Induced Biclique Enumeration, we observe that in general, OCT-MIB-ii@ outperforms OCT-MIB and Enum-MIB. This is the case when the varying parameter is the density within , the between and , the size of the OCT set , and the ratio between and , amongst other settings. In these “near-bipartite” synthetic graphs, Enum-MIB unsurprisingly is slowest on most instances. When and , Enum-MIB outperforms OCT-MIB when the density within increases above 0.05. This is likely due to the adverse effect of the number of MISs in the OCT set on OCT-MIB. The most interesting observation occurs when varying the edge density between and (left panel of Figure 1). In the case, OCT-MIB-ii@ is the fastest algorithm until the density exceeds 0.11, when OCT-MIB becomes faster. We believe this is likely due to OCT-MIB efficiently pruning away attempted expansions which are guaranteed to fail, while the number of MISs in does not increase. This behavior is also seen in the case where , though the magnitude of the difference is not as extreme.
In the non-induced setting of Maximal Biclique Enumeration, OCT-MICA consistently outperforms MICA on this corpus, typically by at least an order of magnitude. The more interesting takeaway is that both MB-enumerating algorithms run considerably faster than their MIB-enumerating counterparts (e.g. right panel of Figure 1), mostly because the number of MIBs is often one to two orders of magnitude larger than the number of MBs in these instances.
5.3 Larger Graphs
Given the much faster runtimes achieved in Section 5.2 we created a new corpus of larger synthetic graphs. For Maximal Induced Biclique Enumeration, we scaled up to 10,000 and varied in two settings, increasing the timeout to 7200 seconds. When the expected density was 0.03 and , OCT-MIB-ii@ outperformed OCT-MIB for all values of by at least an order of magnitude and finished on all instances, whereas OCT-MIB timed out on all instances with (left panel of Figure 2). However, when the expected density was 0.01 and , OCT-MIB was faster (right panel of Figure 2). We speculated that this was due to the sparsity of , allowing for a speed-up due to the efficient pruning of OCT-MIB similar to what was seen in Section 5.2. To test this theory, we increased expected edge density within to 0.05 while leaving the other parameters the same (right panel of Figure 2), and observed that once , OCT-MIB-ii@ outperforms OCT-MIB, confirming our hypothesis.
For Maximal Biclique Enumeration, we also designed a new experiment where and was scaled up to 1000 (left panel of Figure 3). OCT-MICA finished on all instances, whereas MICA finished on none when was 1000. We also tested how large we could scale the expected density between and (right panel of Figure 3). When , OCT-MICA finished on all instances with density at most 0.4, while MICA finished on two of five when density is 0.4. Neither algorithm finished in less than the timeout of an hour when the density was 0.5 or greater, exhausting the hardware’s memory in many cases. Thus OCT-MICA is able to scale to graphs with considerably larger OCT sets and higher density than both MICA and the MIB-enumerating algorithms.
We additionally created graphs with , which was not done in , and ran the algorithms for both MIBs and MBs (Figure 4). These graphs had values up to 4000 and for each value of , we used three values of ; and . The results were most interesting for the MIB-enumerating algorithms (Figure 4 top). OCT-MIB performed the worst of the three algorithms when , but outperformed Enum-MIB in the other settings. This verifies the analysis from  on the range in which OCT-MIB is most effective. In general, OCT-MIB-ii@ once again was the fastest algorithm and did best when was smaller. The impact of on OCT-MIB-ii@ and Enum-MIB appeared comparable. In the MB-enumeration case, OCT-MICA consistently outperforms MICA, and there is a distinguishable difference in the runtime based on the value of (Figure 4 bottom). The value of has far less effect on MICA, which does not finish on any graphs with .
5.4 Computational Biology Data
Finally, we tested performance on real-world data using the graphs from , which come from computational biology. These graphs have previously been exhibited to have small OCT sets , and we used the implementation from  of Hüffner’s iterative compression algorithm  to find the OCT decompositions. Computing the OCT decomposition for each graph ran in less than ten seconds, and often in less than one second. As can be seen in Table 1, OCT-MIB-ii@ performs the best of the MIB-enumerating algorithms and OCT-MICA is faster than MICA. Full results are in the Appendix.
We present a suite of new algorithms for enumerating maximal (induced) bicliques in general graphs, two of which are parameterized by the size of an odd cycle transversal. It is particularly noteworthy that the parameterized algorithms empirically outperform the general approaches even when their asymptotic worst-case complexities are worse. This highlights a weakness of standard complexity analysis, as many aspects of an algorithm get “swept under the rug”.
It is also interesting that even though Maximal Induced Biclique Enumeration and Maximal Biclique Enumeration are closely related problems, the MB-enumerating algorithms are often an order of magnitude faster than their MIB-enumerating counterparts. The reason for this can likely be attributed to two causes: the number of MBs is significantly less than the number of MIBs in sparse graphs, and that the stricter structure of MIBs requires more work to ensure. For , there is exactly one MB of the form in , but there can be many MIBs with this structure.
We implement and benchmark all of the algorithms on a corpus of synthetic and real-world computational biology graphs, and establish that parameterized approaches are often at least an order of magnitude faster than the general approaches. This remains true even when . It would be interesting to experimentally evaluate as increases, at what point the standard methods outperform those optimized for near-bipartite graphs. Finally, we note as in , the current implementations of the algorithms could be improved by replacing the MIS-enumeration algorithm with that of , and the M(I)B-enumeration on bipartite graphs with the implementation used in .
-  P. Agarwal, N. Alon, B. Aronov, and S. Suri, Can visibility graphs be represented compactly?, Discrete & Computational Geometry, 12 (1994), pp. 347–365.
-  T. Akiba and Y. Iwata, Branch-and-reduce exponential/fpt algorithms in practice: A case study of vertex cover, Theoretical Computer Science, 609 (2016), pp. 211–225.
-  G. Alexe, S. Alexe, Y. Crama, S. Foldes, P. Hammer, and B. Simeone, Consensus algorithms for the generation of all maximal bicliques, Discrete Applied Mathematics, 145 (2004), pp. 11–21.
-  M. Dawande, P. Keskinocak, J. Swaminathan, and S. Tayur, On bipartite and multipartite clique problems, J. of Algorithms, 41(2001), pp. 388–403.
-  V. Dias, C. De Figueiredo, and J. Szwarcfiter, Generating bicliques of a graph in lexicographic order, Theoretical Computer Science, 337 (2005), pp. 240–248.
-  D. Eppstein, Arboricity and bipartite subgraph listing algorithms, Inf. Process. Lett., 51 (1994), pp. 207–211.
-  M. Garey and D. Johnson, Computers and intractability: a guide to NP-completeness, 1979.
-  A. Gély, L. Nourine, and B. Sadi, Enumeration aspects of maximal cliques and bicliques, Discrete Applied Mathematics, 157(7), (2009) pp. 1447–1459.
-  T. Goodrich, E. Horton, and B. Sullivan, Practical Graph Bipartization with Applications in Near-Term Quantum Computing, arXiv preprint arXiv:1805.01041, 2018.
N. Gülpinar, G. Gutin, G. Mitra, and A. Zverovitch,
Extracting pure network submatrices in linear programs using signed graphs, Discrete Applied Mathematics, 137 (2004), pp. 359–372.
-  E. Horton, K. Kloster, B. D. Sullivan, A. van der Poel, MI-bicliques, https://github.com/TheoryInPractice/MI-bicliques, October 2018.
-  F. Hüffner, Algorithm engineering for optimal graph bipartization, International Workshop on Experimental and Efficient Algorithms, 2005, pp. 240–252.
-  W. Chang, Maximal Biclique Enumeration, http://genome.cs.iastate.edu/supertree/download/biclique/README.html, December 2004
-  Y. Iwata, K. Oka, and Y. Yoshida, Linear-time FPT algorithms via network flow, SODA, 2014, pp. 1749–1761.
-  M. Kaytoue-Uberall, S. Dupelessis, and A. Napoli, Using formal concept analysis for the extraction of groups of co-expressed genes, Modelling, Computation and Optimization in Information Systems and Management Sciences, 2008, pp. 439–449.
-  M. Kaytoue, S. Kuznetsov, A. Napoli, and S. Duplessis, Mining gene expression data with pattern structures in formal concept analysis, Information Sciences, 181 (2011), pp. 1989–2011.
-  K. Kloster, B. Sullivan, and A. van der Poel, Mining Maximal Induced Bicliques using Odd Cycle Transversals, Proceedings of the 2019 SIAM International Conference on Data Mining, 2019 (to appear).
-  R. Kumar, P. Raghavan, S. Rajagopalan, and A. Tomkins, Trawling the Web for emerging cyber-communities, Computer Networks, 31 (1999), pp. 1481–1493.
-  S. Kuznetsov, On computing the size of a lattice and related decision problems, Order, 18 (2001), pp. 313–321.
-  J. Li, G. Liu, H. Li, and L. Wong, Maximal biclique subgraphs and closed pattern pairs of the adjacency matrix: A one-to-one correspondence and mining algorithms, IEEE Trans. Knowl. Data Eng., 19 (2007), pp. 1625–1637.
-  D. Lokshtanov, S. Saurab, and S. Sikdar, Simpler parameterized algorithm for OCT, International Workshop on Combinatorial Algorithms, 2009, pp. 380–384.
-  K. Makino and T. Uno, New algorithms for enumerating all maximal cliques, Scandinavian Workshop on Algorithm Theory, 2004, pp. 260–272.
-  R. Mushlin, A. Kershenbaum, S. Gallagher, and T. Rebbeck, A graph-theoretical approach for pattern discovery in epidemiological research, IBM Systems J., 46 (2007), pp. 135–149.
-  A. Panconesi and M. Sozio, Fast hare: A fast heuristic for single individual SNP haplotype reconstruction, International workshop on algorithms in bioinformatics, 2004, pp. 266–277.
-  R. Peeters, The maximum edge biclique problem is NP-complete, Discrete Applied Mathematics, 131 (2003), pp. 651–654.
-  M. Sanderson, A. Driskell, R. Ree, O. Eulenstein, and S. Langley, Obtaining maximal concatenated phylogenetic data sets from large sequence databases, Molecular Biology and Evolution, 20 (2003), pp. 1036–1042.
-  J. Schrook, A. McCaskey, K. Hamilton, T. Humble, and N. Imam, Recall Performance for Content-Addressable Memory Using Adiabatic Quantum Optimization Entropy, 19 (2017).
-  S. Tsukiyama, M. Ide, H. Ariyoshi, and I. Shirakawa, A new algorithm for generating all the maximal independent sets, SIAM J. on Computing, 6 (1977), pp. 505–517.
-  S. Wernicke, On the algorithmic tractability of single nucleotide polymorphism (SNP) analysis and related problems, 2014.
-  R. Wille, Restructuring lattice theory: an approach based on hierarchies of concepts, Ordered sets, 1982, pp. 445–470.
-  M. Yannakakis, Node-and edge-deletion NP-complete problems, STOC, 1978, pp. 253–264.
-  Y. Zhang, C. A. Phillips, G. L. Rogers, E. J. Baker, E. J. Chesler, and M. A. Langston, On finding bicliques in bipartite graphs: a novel algorithm and its application to the integration of diverse biological data types, BMC Bioinformatics, 15 (2014).
Appendix 0.A MIB-Enumeration Framework Subroutines
We now provide algorithmic details and proofs of the complexity and correctness of MakeIndMaximal and AddTo.
Recall that MakeIndMaximal takes in , where is an induced biclique and , and either returns a MIB where , , , or returns . If it returns and then there is another MIB which contains and . We give pseudo-code of MakeIndMaximal in Algorithm 3.
MakeIndMaximal returns a MIB where , , , or returns .
Referring to the pseudo-code in Algorithm 3, it is clear that , as no vertices are ever removed from the input biclique . Furthermore, the only vertices added to are from , so and is the only biclique returned by MakeIndMaximal. Note that neither side of is empty and the only vertices added are independent from the side of the biclique which they are added to, so if we do not return the object returned is an induced biclique. If no node from outside of can be added to , then we will not return and thus is maximal.
If MakeIndMaximal returns and then there is another MIB in which contains and .
Note that at line 12. As MakeIndMaximal returns there must be a vertex which can be added to . Let be a MIB containing and , thus suffices to prove the lemma.
MakeIndMaximal runs in time.
Note that because is connected, . Setting and can be done in time. In each for loop, we can scan all of the edges incident to each in the iterated-over set and keep count of how many nodes from have been seen (checking for inclusion can be done in time with an initialization step). Thus, each edge is scanned at most once per for loop.
Recall that AddTo takes in where is an induced biclique and , and returns the induced biclique where is added to , is removed from , and is removed from if and otherwise. We give pseudo-code of AddTo in Algorithm 4.
AddTo returns the induced biclique where is added to , is removed from , and is removed from if , and otherwise.
Referring to the pseudo-code in Algorithm 4, it is clear that is added to and is removed from . Additionally ’s non-neighbors are effectively removed from by intersecting it with . If then and is returned. Otherwise since it includes and thus is a biclique. must be an induced biclique as , , and is an induced biclique and by definition.
AddTo runs in time.
Note that because is connected, . AddTo can be completed by scanning all of ’s incident edges in tandem with an preprocessing step to allow for constant-time look-ups when checking for inclusion in a set.
Appendix 0.B MB-Enumeration Framework Subroutines
We give a detailed description of the MakeMaximal and Consensus subroutines used in OCT-MICA, along with arguments of their correctness and complexity.
Extending a biclique to be maximal is different in the non-induced case from the induced case, since MBs are completely characterized by one side of the biclique.
MakeMaximal runs in time.
In order to form , we can scan the edges incident to each and keep count of how many nodes from have been seen (checking for inclusion can be done in time with an initialization step). The same can be done for , where instead we scan the edges incident to each . Thus, each edge is scanned at most twice in MakeMaximal.
The MICA section of OCT-MICA relies heavily on the Consensus operation introduced in  for finding new candidate bicliques. For each pair of bicliques, there are four candidate bicliques which form the consensus of the pair. Note that any of the four candidates may be empty and if so discarded. Consensus runs in time using standard techniques for set union and intersection.
Appendix 0.C Additional Enumeration Experiments