Comparison of Parallelization Techniques for Boolean Reasoning-Based Binary Biclustering

Abstract

Biclustering is a two-dimensional data analysis paradigm that aims to identify subsets of rows and columns in a data matrix whose intersection forms a submatrix satisfying predefined properties. In the case of binary data, a bicluster is typically defined as a submatrix containing exclusively ones or exclusively zeros. Numerous approaches to binary biclustering have been proposed over the last several decades. Among them, a distinctive line of research relies on Boolean reasoning, transforming the biclustering task into the problem of finding prime implicants of a data-dependent Boolean function. From a theoretical perspective, it has been shown that every prime implicant of the data-dependent Boolean function corresponds to an inclusion–maximal bicluster in the original dataset, and vice versa. Here, inclusion maximality means that no additional row or column can be added without violating the bicluster property. For discrete datasets, the corresponding Boolean function can be represented in Conjunctive Normal Form (CNF), where clauses contain up to three variables, reducing the general biclustering problem to an instance of the 3-SAT problem. Furthermore, the computational complexity of discrete-data biclustering can be reduced to the analysis of binary matrices. In this case, the associated Boolean functions consist of clauses containing at most two literals, yielding monotone 2-CNF formulas. This paper focuses on improving the efficiency of computations required to derive a disjunctive normal form (DNF) representation composed exclusively of prime implicants. Since the extraction of prime implicants constitutes the computational core of the Boolean biclustering framework, accelerating this process directly enhances the scalability and practical applicability of biclustering methods based on Boolean reasoning.

1. Introduction

Modern data analysis increasingly deals with complex systems that are naturally represented in a matrix form, where rows correspond to objects, and columns to their attributes. Classical clustering techniques aim to identify homogeneous groups of objects based on global similarity across all attributes. However, in many real-world scenarios, such global assumptions are overly restrictive, as meaningful relationships between objects often occur only within specific subsets of features.

Biclustering, also referred to as co-clustering or two-way clustering, addresses this limitation by simultaneously grouping subsets of rows and subsets of columns in a data matrix. In contrast to traditional clustering, which produces global partitions, biclustering identifies local patterns represented by coherent submatrices, allowing the discovery of relationships that are context-dependent and potentially overlap each other [1]. This shift from global to local modeling provides a significantly richer description of structured data.

The importance of biclustering was first highlighted in the context of gene expression analysis, where the assumption of global similarity across all experimental conditions is rarely valid. In their seminal work, Cheng and Church showed that genes can behave coherently only under particular subsets of conditions, motivating algorithms that identify such localized submatrices [2]. This insight opened a new direction in data mining, emphasizing the need to analyze subspace-specific relationships rather than entire datasets.

Since then, biclustering has evolved into a versatile framework that can be applied across a wide range of domains. In bioinformatics, it enables the identification of functional gene modules and condition-specific regulatory mechanisms, while in other areas, such as text mining, recommender systems, and environmental data analysis, it facilitates the discovery of latent patterns between entities and their features. Recent surveys confirm that biclustering has become one of the key approaches to pattern discovery in high-dimensional and heterogeneous data, supporting both descriptive and predictive analytical tasks [1,3].

Conceptually, biclustering reflects a broader paradigm shift in data analysis: rather than asking whether two objects are similar in general, it seeks to determine under which conditions such similarity holds. This perspective aligns with the growing recognition that complex systems rarely exhibit uniform behavior and that valuable knowledge is often embedded in localized and context-specific structures. As data complexity continues to increase, methods capable of uncovering such patterns are expected to play an increasingly central role in modern data science.

Recently, a new approach for searching for biclusters was developed [4,5] and is based on the so-called Boolean reasoning [6]. Such an approach reduces the problem to checking the satisfiability of the Boolean function. A variety of patterns that could be found this way [5,7] were proposed and with each kind of pattern a mathematical theorem (and its proof) was also presented. In general, for each kind of pattern, two theorems were provided: the first is called “strong” and the second is called “weak”. The weak theorem binds the implicant of a data-dependent Boolean formula with the bicluster in the data, which satisfies the required pattern properties. This means that any implicant corresponds to a bicluster and vice versa. The strong theorem binds the prime implicant of the abovementioned Boolean formula with inclusion–maximal pattern in the data: a corresponding bicluster cannot be extended with any row or any column without violating conditions that a pattern should satisfy. The weak theorems allow prime implicant approximation techniques to search for patterns that are not inclusion–maximal but can be found more quickly. On the other hand, strong theorems guarantee finding inclusion–maximal patterns; however, such a task (searching for all prime implicants of the Boolean function) is characterized by very high computational complexity.

In this paper, we focus on the second approach: the searching for all prime implicants of the Boolean function that encodes the binary data. We present several strategies on how to perform the calculation in a parallel way and compare the total computation time.

In the literature, several alternative approaches have been proposed for prime implicant enumeration and related dualization problems. Classical examples include the quasi-polynomial dualization algorithm of Fredman and Khachiyan [8], methods for identifying all minimal transversals of hypergraphs [9], and more recent output-sensitive algorithms for large-scale hypergraph dualization [10,11]. Since prime implicant enumeration, monotone Boolean dualization, minimal transversal generation, minimal hitting-set enumeration, and minimal vertex-cover enumeration are closely related problems, advances achieved in one area are often transferable to the others. In contrast, the present study does not propose a new prime implicant generation algorithm. Instead, it focuses on the computational aspects of the classical clause-by-clause CNF-to-DNF transformation process and investigates how different parallelization strategies can accelerate this procedure in the context of Boolean-reasoning-based exact biclustering. Therefore, the contribution of this paper should be viewed primarily as an investigation of parallelization techniques for Boolean-formula processing rather than as a proposal of a new exact bicluster enumeration framework.

This paper does not propose a new exact biclustering algorithm. Instead, it studies parallelization techniques for an existing Boolean-reasoning-based exact biclustering framework. This paper is organized as follows: The next section provides a theoretical background related to biclustering, Boolean reasoning, and its application in biclustering; then discusses the nature and some notable issues related to processing the Boolean formula from its CNF to DNF; and finally describes the possibilities of concurrent processing of such formulas with reference to the form of the Boolean function that encodes the binary data. The section that follows provides a description of some artificial binary datasets on which the experiments were carried out as well as a discussion of the results obtained with these experiments. The paper concludes with suggestions of possible future studies in this area.

2. Theoretical Background

2.1. Biclustering

Biclustering, also known as co-clustering or two-way clustering, is an unsupervised learning paradigm that simultaneously groups rows and columns of a data matrix to reveal hidden patterns, known as biclusters [1,12]. Formally, given a data matrix $X\in {\mathbb{R}}^{n\times m}$, a bicluster is defined as a pair $(I,J)$, where $I\subseteq \{1,\dots ,n\}$ and $J\subseteq \{1,\dots ,m\}$, such that the induced submatrix $X_{I,J}$ satisfies a certain criterion. These criteria vary depending on the application and can include constant values, coherent patterns, low variance, or correlation structures.

In contrast to classical clustering methods, which identify global partitions of either rows or columns, biclustering discovers local patterns that hold only across subsets of rows and columns. This ability to model context-dependent relationships is particularly important in high-dimensional data analysis, where global similarity assumptions often fail [1,12]. A graphical explanation of the difference between clustering and biclustering is presented in Figure 1.

Having two-dimensional data (“Original Data”), we may be interested in finding similar rows (subfigure A: two groups of rows), similar columns (subfigure B: two groups of columns) and finally, submatrices that may even overlap each other (subfigure C: two $3\times 3$ have common cells, denoted by xs).

The origins of biclustering can be traced back to the work of Hartigan [13], who introduced the concept of direct clustering of data matrices. However, biclustering gained significant attention with the work of Cheng and Church [2], who proposed a practical algorithm based on the minimization of the mean squared residue (MSR) criterion and demonstrated its effectiveness in gene expression data. This study established biclustering as a key tool for discovering co-regulated gene sets under specific experimental conditions.

Later, a wide range of biclustering algorithms have been proposed. One of the first categories includes greedy and heuristic methods, such as the Cheng–Church algorithm [2], which iteratively refines submatrices by excluding rows and columns that increase the MSR score. Similar strategies have been used in other approaches, such as the iterative signature algorithm (ISA) [14] and xMotifs [15], which also aim to identify locally coherent patterns in gene expression data. Although effective in practice, these methods are often sensitive to noise and may require careful parameter tuning [12].

Another important class consists of enumeration-based methods, particularly for binary data. In this setting, biclustering can be formulated as the problem of finding maximal bicliques in a bipartite graph [12]. The Bimax algorithm [16] adopts this formulation and applies a divide-and-conquer strategy to compute all inclusion–maximal biclusters. Although such approaches guarantee exact solutions, they are computationally expensive due to the combinatorial nature of the search space.

Spectral approaches provide an alternative perspective by leveraging matrix factorization techniques. The method proposed by Kluger et al. [17] employs singular value decomposition (SVD) to detect checkerboard patterns in data matrices, revealing biclusters corresponding to coherent structures. These methods benefit from strong mathematical foundations and scalability, although they often assume specific data structures.

Probabilistic and generative models constitute another major line of research. The plaid model [18] represents the data matrix as a superposition of biclusters, where each bicluster contributes additively to the observed data. This framework has been extended with Bayesian formulations, enabling the incorporation of prior knowledge and uncertainty modeling [19].

Due to the inherent combinatorial complexity of biclustering, many formulations of the problem are computationally intractable in the general case. Consequently, metaheuristic approaches, including evolutionary algorithms and swarm intelligence, have been developed to efficiently explore the search space [20]. These methods provide flexible optimization frameworks, but do not guarantee optimality.

Biclustering has found widespread applications in various domains, including bioinformatics [3,21], text mining [12], recommendation systems [22], and industrial data analysis [1]. Its ability to uncover local and overlapping structures makes it particularly suitable for complex datasets where traditional clustering methods are insufficient [1].

2.2. Boolean Reasoning

Boolean reasoning [6,23] is a paradigm for computational problem solving in which a given problem is encoded as a Boolean formula. The solution process is then reduced to the transformation or evaluation of this formula, and the obtained results are subsequently decoded to yield solutions to the original problem. This encoding–solving–decoding scheme enables the application of well-established logical inference mechanisms, including satisfiability checking and formula transformations.

This approach has been widely applied in Rough Set Theory, where Boolean reasoning is used to compute reducts and decision rules through logical representations of information systems [24,25,26]. It has also been used successfully in decision tree induction, where logical expressions can be used to represent and simplify decision rules derived from data [27].

Beyond these classical examples, Boolean reasoning has found applications in several other areas of computer science. In formal verification, Boolean encodings enable analysis of system properties through model checking and satisfiability techniques [28]. In artificial intelligence, logical representations are used for knowledge representation and automated reasoning tasks, including planning and inference [29]. Furthermore, Boolean formulations constitute the foundation of SAT-based methods, which have become an effective framework for solving a wide range of combinatorial and optimization problems.

2.3. Boolean Reasoning and Biclustering

As was already mentioned in the Introduction section, it is possible to express the task of searching for biclusters in terms of Boolean reasoning [4,5], on the basis of two theorems: weak and strong. To apply Boolean reasoning to this issue, a Boolean function definition is needed. The definition of the function varies depending on the properties of the bicluster change and the nature of the input data [4,5,7,30]. In this paper, only a simple case—searching for biclusters of ones in binary data—will be discussed and pursued. However, this only influences the data encoding step, while the initial form of the Boolean function is always a CNF: Conjunctive Normal Form. The Conjunctive Normal Form of a Boolean formula is a logical conjunction of logical disjunctions of simple literals (Boolean variables). For the task of searching for inclusion–maximal biclusters of ones in binary data, the Boolean function is defined as follows. Let X be a binary matrix of n rows ($\mathcal{R}=\{r_1,\dots ,r_n\}$) and m columns ($\mathcal{C}=\{c_1,\dots ,c_m\}$). Let us introduce a row (column) label corresponding Boolean variables that will be denoted in the same way as the row/column label (we know the meaning of the symbol from the context where it is used). Then, the formula has the following form:

$$f_X=\bigwedge (r_i\vee c_j)$$

(1)

where $r_i\in \mathcal{R}$ and $c_j\in \mathcal{C}$ such that $X_{r_i,c_i}=0$. In other words, we build the formula that encodes the coordinates of all cells of the matrix containing zero.

The weak theorem says that each implicant of the above defined Boolean function encodes a bicluster of ones in such a way that the bicluster is built from these rows and columns, whose corresponding Boolean variables are not literals of an implicant. The strong theorem says that each prime implicant of the above defined Boolean function encodes an inclusion–maximal bicluster of ones in the data (maintaining the same way as that of prime implicant interpretation). The proofs of both theorems can be found in [4].

Consider the following binary matrix $X^1$ as presented in

Table 1. The binary matrix $X^1$.

	$c_1$	$c_2$	$c_3$
$r_1$	1	0	1
$r_2$	1	0	0
$r_3$	1	1	1

.

Following the definition in Equation (1), we have to encode the coordinates of three cells containing zero into the following Boolean function:

$$f_{X^1}=(r_1\vee c_2)\wedge (r_2\vee c_2)\wedge (r_2\vee c_3)$$

(2)

Multiplying the last two clauses we get:

$$f_{X^1}=(r_1\vee c_2)\wedge (r_2\vee (c_2\wedge c_3))$$

(3)

and after another multiplication (the brackets are kept to distinguish implicants from each other)

$$f_{X^1}=(r_1\wedge r_2)\vee (r_1\wedge c_2\wedge c_3)\vee (r_2\wedge c_2)\vee (c_2\wedge c_3)$$

(4)

Application of an absorption law for the second and fourth clauses brings us to the DNF of the function consisting of only prime implicants (no other application of absorption law can be performed):

$$f_{X^1}=(r_1\wedge r_2)\vee (r_2\wedge c_2)\vee (c_2\wedge c_3)$$

(5)

Following the strong theorem, there are three inclusion–maximal biclusters of ones in the data as there are three prime implicants of the Boolean function (

Table 2. Prime implicants of $f_{X^1}$ and corresponding inclusion–maximal biclusters of ones in $X^1$.

Prime Implicant	Bicluster
$r_1\wedge r_2$	$(\left\{r_3\right\},\{c_1,c_2,c_3\})$
$r_2\wedge c_2$	$(\{r_1,r_3\},\{c_1,c_3\})$
$c_2\wedge c_3$	$(\{r_1,r_2,r_3\},\left\{c_1\right\})$

).

For a better understanding of the prime implicants and inclusion–maximal biclusters corresponding to them, let us visualize them (Figure 2).

Now it is clearly visible (although it comes directly from the strong theorem) that each bicluster contains only ones (we have no zeros in blacked cells), and they cannot be extended without introducing a zero.

3. The Nature of Boolean Formula Processing in Biclustering

As was already mentioned, the application of Boolean reasoning usually leads to the secondary task of satisfiability of the Boolean formula. Although such calculations are characterized by very high computational complexity, fortunately, in some contexts the number of clauses in CNF of the original formula can be easily reduced with so-called absorption laws. They are presented below (the brackets for the second one are not necessary but help in comprehending the idea):

$$a\wedge (a\vee b)=aa\vee (a\wedge b)=a$$

(6)

For example, in the Rough Set Theory [24], one of the most crucial tasks related to information system analysis is the search for reducts. Having a set of attributes of this information system, we build a Boolean formula which is in CNF, and each clause is a disjunction of Boolean variables corresponding to a subset of information system attributes. This means that it is very easy to point out which clauses are subsets of others (in terms of the inclusion of the set of literals). Taking into account the following set of attributes $\{a,b,c,d,e,f,g\}$, it is possible to obtain the Boolean formula of the following form (after removing the repeating clauses):

$$(c\vee d\vee e\vee f\vee g)\wedge (a\vee b\vee c\vee d\vee e)\wedge \left(a\right)\wedge (d\vee e\vee f\vee g)\wedge (a\vee c)\wedge$$

$$\wedge (c\vee d\vee e\vee f)\wedge \left(b\right)\wedge (a\vee b)\wedge (a\vee b\vee c)\wedge (a\vee b\vee c\vee d)$$

Single literal clauses like $\left(a\right)$ or $\left(b\right)$ easily shorten the formula as they “consume” each clause that contains at least one of these literals:

$$(c\vee d\vee e\vee f\vee g)\wedge \cancel{(a\vee b\vee c\vee d\vee e)}\wedge (a)\wedge (d\vee e\vee f\vee g)\wedge \cancel{(a\vee c)}\wedge$$

$$\wedge (c\vee d\vee e\vee f)\wedge (b)\wedge \cancel{(a\vee b)}\wedge \cancel{(a\vee b\vee c)}\wedge \cancel{(a\vee b\vee c\vee d)}$$

thus bringing the formula to the following form:

$$(c\vee d\vee e\vee f\vee g)\wedge (a)\wedge (d\vee e\vee f\vee g)\wedge (c\vee d\vee e\vee f)\wedge (b)$$

Also, each of the four literal clauses may absorb the first one, so the shortened (with absorption laws) formula has the following form:

$$(a)\wedge (d\vee e\vee f\vee g)\wedge (c\vee d\vee e\vee f)\wedge (b)$$

which is much less complex for further processing: the clause multiplication.

Unfortunately, in the considered task of binary biclustering, we cannot expect any input formula simplification: each clause is related to a specific cell of the input matrix, so it has no possibility to contain repeating clauses as well as clauses including each other in terms of a set of literals.

The above example shows that apart from the general possibility of application of the conjunction absorption law, it is impossible to apply it in the discussed context of Boolean reasoning-based binary biclustering. However, the second one is almost always applicable, especially when longer and longer clauses are multiplied by each other. Let us consider the following two clauses in the CNF to be multiplied:

$$C_1=(a\wedge b)\vee (c\wedge d\wedge e)\vee (f\wedge a)C_2=(a\wedge c\wedge d)\vee (b\wedge e)\vee (c\wedge d\wedge e\wedge f)\vee (b\wedge f\wedge a)$$

The direct multiplication all-by-all gives the following result (repeating literals within the clause were already removed):

$$\begin{array}{ccc}\hfill C_1\wedge C_2& =& (a\wedge b\wedge c\wedge d)\vee (a\wedge b\wedge e)\vee (a\wedge b\wedge c\wedge d\wedge e\wedge f)\vee \hfill \\ & & \vee (a\wedge b\wedge f)\vee (a\wedge c\wedge d\wedge e)\vee (b\wedge c\wedge d\wedge e)\vee \hfill \\ & & \vee (c\wedge d\wedge e\wedge f)\vee (a\wedge b\wedge c\wedge d\wedge e\wedge f)\vee (a\wedge c\wedge d\wedge f)\vee \hfill \\ & & \vee (a\wedge b\wedge e\wedge f)\vee (a\wedge c\wedge d\wedge e\wedge f)\vee (a\wedge b\wedge f)\hfill \end{array}$$

The clause $(a\wedge b\wedge e)$ absorbs four clauses as well, and so we have a repetition of clause $(a\wedge b\wedge f)$:

$$\begin{array}{ccc}\hfill C_1\wedge C_2& =& (a\wedge b\wedge c\wedge d)\vee (a\wedge b\wedge e)\vee \cancel{(a\wedge b\wedge c\wedge d\wedge e\wedge f)}\hfill \\ & & \vee (a\wedge b\wedge f)\vee (a\wedge c\wedge d\wedge e)\vee (b\wedge c\wedge d\wedge e)\hfill \\ & & \vee (c\wedge d\wedge e\wedge f)\vee \cancel{(a\wedge b\wedge c\wedge d\wedge e\wedge f)}\vee (a\wedge c\wedge d\wedge f)\hfill \\ & & \vee \cancel{(a\wedge b\wedge e\wedge f)}\vee \cancel{(a\wedge c\wedge d\wedge e\wedge f)}\vee \cancel{(a\wedge b\wedge f)}\hfill \end{array}$$

So, finally,

$$\begin{array}{ccc}\hfill C_1\wedge C_2& =& (a\wedge b\wedge c\wedge d)\vee (a\wedge b\wedge e)\vee (a\wedge b\wedge f)\vee (a\wedge c\wedge d\wedge e)\vee \hfill \\ & & \vee (b\wedge c\wedge d\wedge e)\vee (c\wedge d\wedge e\wedge f)\vee (a\wedge c\wedge d\wedge f)\hfill \end{array}$$

In conclusion, with this section, we wanted to highlight some specific issues related to the naive processing of a Boolean formula from its CNF to DNF (containing only prime implicants). As we have shown, in the case of absorption laws, only the second one seems to have potential to be used in Boolean reasoning-based binary biclustering. We will take this into account by presenting the possibilities of the parallel processing of the formula in the next section of the paper.

4. The Potential of Parallelization

Taking into account the original form of a Boolean function for the considered task (Equation (1)), one of the intuitive solutions for parallel processing is to build a queue of clauses to be multiplied. As long as the queue length is at least twice as long as the number of available computation cores, we obtain a maximal parallelization of computations. The main idea is presented in Figure 3.

Here, we have (on the left side) a list of clauses to be multiplied and a set of computational nodes on the right side. For the sake of simplicity, only two of them are shown, but it is easy to consider many more possible ones. Each node takes two clauses from the beginning of the list (and removes them), while the result of multiplication is added to the end of the queue of clauses. The process ends when there is only one clause in the list.

However, it is worth considering the situation whereby the last two clauses have to be multiplied—so we need only one computation node for that purpose—and all other nodes will be not used. This means that parallel processing of a single two-clause multiplication is necessary. So, let us consider the following two formulas in DNF:

$${\mathrm{\Phi }}_1=(a\wedge b)\vee (b\wedge c\wedge d)\vee (c\wedge e)\vee (a\wedge d\wedge f)$$

(7)

$${\mathrm{\Phi }}_2=(b\wedge d)\vee (a\wedge c\wedge e\wedge f)\vee (c\wedge d\wedge e)\vee (a\wedge b\wedge f)$$

(8)

To facilitate the multiplication of ${\mathrm{\Phi }}_1$ and ${\mathrm{\Phi }}_2$, we can build a matrix of one-by-one simple multiplications (Figure 4).

In such a case, we see that we have 16 independent multiplications. It is possible to split each formula into two smaller ones:

$${\mathrm{\Phi }}_{1,1}=(a\wedge b)\vee (b\wedge c\wedge d)$$

(9)

$${\mathrm{\Phi }}_{1,2}=(c\wedge e)\vee (a\wedge d\wedge f)$$

(10)

$${\mathrm{\Phi }}_{2,1}=(b\wedge d)\vee (a\wedge c\wedge e\wedge f)$$

(11)

$${\mathrm{\Phi }}_{2,2}=(c\wedge d\wedge e)\vee (a\wedge b\wedge f)$$

(12)

The graphical explanation of such a division is presented in Figure 5.

So, in fact, it is possible to split the multiplication of ${\mathrm{\Phi }}_1$ and ${\mathrm{\Phi }}_2$ into four independent tasks that could be performed concurrently (Figure 6).

This split of multiplied formulas makes it possible to run this subtask on separate computation nodes, including the phase of application of absorption laws (Figure 7).

However, it is very important to remember that these results should be merged and the absorption law should be applied to the sum of these results.

$$\begin{array}{ccc}\hfill {\mathrm{\Phi }}_1\wedge {\mathrm{\Phi }}_2& =& (a\wedge b\wedge d)\vee (a\wedge b\wedge c\wedge e\wedge f)\vee (b\wedge c\wedge d)\vee \hfill \\ & & \vee (a\wedge b\wedge f)\vee (b\wedge c\wedge d\wedge e)\vee \hfill \\ & & \vee (b\wedge c\wedge d\wedge e)\vee (a\wedge c\wedge e\wedge f)\vee (a\wedge b\wedge d\wedge f)\vee \hfill \\ & & \vee (c\wedge d\wedge e)\vee (a\wedge b\wedge c\wedge e\wedge f)\vee (a\wedge b\wedge d\wedge f)=\hfill \\ & =& (a\wedge b\wedge d)\vee \cancel{(a\wedge b\wedge c\wedge e\wedge f)}\vee (b\wedge c\wedge d)\vee \hfill \\ & & \vee (a\wedge b\wedge f)\vee \cancel{(b\wedge c\wedge d\wedge e)}\vee \hfill \\ & & \vee \cancel{(b\wedge c\wedge d\wedge e)}\vee (a\wedge c\wedge e\wedge f)\vee \cancel{(a\wedge b\wedge d\wedge f)}\vee \hfill \\ & & \vee (c\wedge d\wedge e)\vee \cancel{(a\wedge b\wedge c\wedge e\wedge f)}\vee \cancel{(a\wedge b\wedge d\wedge f)}=\hfill \\ & =& (a\wedge b\wedge d)\vee (b\wedge c\wedge d)\vee (a\wedge b\wedge f)\vee (a\wedge c\wedge e\wedge f)\vee (c\wedge d\wedge e)\hfill \end{array}$$

and only that formula can be added to the end of the queue of clauses to be multiplied.

In conclusion, it is easy to provide two main techniques of parallel processing of a Boolean formula from its CNF to DNF. The very first strategy just builds a queue of clauses to be multiplied, sends a pair of them to the node (to be multiplied), and the result is put at the end of the queue (this will be called a queue approach). The second one assumes having just one node performing the multiplication of two clauses; however, the multiplication of long clauses is parallelized and the result has to be merged before it is put into the queue (this will be called a parallel absorption approach). Both aspects were presented with the above examples. However, it is also possible to consider a mixed mode: while clauses are short, the processing is parallelized on the level of a pair of clauses; later, when clauses are very wide, the parallelization means splitting the multiplication in a matrix form, as presented in Figure 6 (this will be called a mixed approach).

5. Experiments on Artificial Data

In Figure 8, artificial binary data are presented. They were obtained as a binarization of discrete data originally presented in ref. [31].

A brief description of each of the abovementioned datasets is presented in

Table 3. A more detailed description of binary datasets.

Dataset	Size	Number of Ones	Number of Clauses (CNF)
#0	$100\times 100$	1415	8585
#77	$100\times 100$	1327	8673
#237	$100\times 100$	2148	7852

.

The one and only goal of these experiments was to observe how the total computation time changes when parallel processing strategies are applied. There is no necessity to compare the quality of results, as—with the strong theorem—obtained prime implicants of the data–dependent Boolean formula are the same, whichever strategy of getting all of them was used.

The nature of the calculations is deterministic, so we expect exactly the same results after any processing run. However, the experiments were carried out on the real machine (mobile workstation GP76 Leopard with 16 logical processors), where other processes were carried out also, and there was no possibility of providing the computational time and resources only for biclustering related tasks. For that reason, experiments on each dataset and each computation strategy were carried out 10 times. The raw results of all experiments are presented in

Table 4. Comparison of methods over different datasets (computation time in seconds).

	Sequential App.			Queue App.			Absorption App.			Mixed App.
Iteration	#0	#77	#237	#0	#77	#237	#0	#77	#237	#0	#77	#237
1	15	<1	611	1	<1	78	3	<1	44	1	<1	40
2	15	<1	607	1	<1	81	3	<1	43	1	<1	38
3	15	<1	557	2	<1	145	3	<1	43	1	<1	38
4	15	<1	616	1	<1	89	3	<1	43	1	<1	38
5	15	<1	495	<1	<1	74	3	<1	43	1	<1	38
6	15	<1	554	2	<1	96	3	<1	43	1	<1	38
7	15	<1	633	1	<1	69	3	<1	44	1	<1	38
8	15	<1	621	2	<1	45	3	<1	44	1	<1	38
9	15	<1	564	<1	<1	34	3	<1	42	1	<1	39
10	15	<1	502	2	<1	44	3	<1	43	1	<1	41
mean	15.0	<1	576.0	1.2	<1	75.3	3.0	<1	43.2	1.0	<1	38.6
std. dev.	0.0	<1	47.0	0.7	<1	30.3	0.0	<1	0.6	0.0	<1	1.0

.

As we may observe, the set #77 was quite easy to be biclustered even in a sequential processing (less than a second), so the results of application of parallelization techniques will not be discussed.

The first intuitive conclusion that comes from the data is that in most of the cases the total time of computation was rather stable.

Let us focus on the average time and its standard deviation for each set; however, the columns will be organized in another way, a set related (

Table 5. Aggregated (mean and standard deviation) time of computation (mm:ss) for different methods and datasets.

	#0				#237
	Sequential App.	Queue App.	Absorption App.	Mixed App.	Sequential App.	Queue App.	Absorption App.	Mixed App.
mean	15	1.2	3.0	1.0	576	75.3	43.2	38.6
std. dev.	0.0	0.7	0.0	0.0	47.0	30.3	0.6	1.0

).

As expected, the average data processing time has decreased significantly. The effect is much more visible for the dataset #237. In case of #0 saving up to 14 s per experiment may not seem particularly spectacular, whereas the reduction from almost 10 min to less than 1 min is noteworthy. However, the relative level of the decrease in computation time follows the number of computational nodes used during the experiments: 16. This shows two things: first, it is possible to decrease the total computation time of Boolean reasoning-based biclustering with parallelization techniques, and second, the level of reduction may strongly depend on the number of computational nodes.

6. Conclusions and Further Work

This paper focuses on accelerating the computational process underlying Boolean reasoning-based binary biclustering. In this framework, the problem of identifying inclusion–maximal biclusters is reduced to finding all prime implicants of a Boolean function derived from binary data, which requires transforming a formula from Conjunctive Normal Form (CNF) into Disjunctive Normal Form (DNF).

The primary challenge addressed in the study is the high computational complexity of the CNF-to-DNF transformation, which becomes the main bottleneck of the overall biclustering process. Due to the structure of Boolean formulas generated from binary data, classical simplification techniques (such as absorption laws) have limited effectiveness, making direct sequential computation inefficient.

To overcome this limitation, the article investigates several parallelization strategies that aim to reduce execution time. Three main approaches are proposed: (i) a queue-based strategy that distributes clause multiplications across multiple computational nodes, (ii) a parallel absorption strategy that parallelizes the internal multiplication of large clauses, and (iii) a mixed strategy that dynamically combines both mechanisms depending on the intermediate formula structure.

Experimental results on synthetic datasets show that all proposed parallelization techniques significantly speed up the computation compared to the sequential approach, while producing identical results due to the deterministic nature of the method. The most substantial improvements are observed for more complex datasets, where the execution time is reduced from several minutes to under one minute. These findings confirm that parallelization effectively mitigates the computational bottleneck inherent in biclustering based on Boolean reasoning and enables its practical applicability to larger problem instances.

Our future work will focus on publishing our software as a publicly available Java package. The core of the package will focus on general Boolean-formula processing; however, the UI will allow the user to use the package directly for Boolean reasoning-based biclustering issues.