KarNet: An Efficient Boolean Function Simplifier

TL;DR

KarNet leverages convolutional neural networks to efficiently simplify Boolean functions by solving Karnaugh maps, achieving faster computation times and high accuracy, thus improving upon traditional rule-based methods.

Contribution

This paper introduces KarNet, a CNN-based approach that models Karnaugh maps as images to simplify Boolean expressions more efficiently than existing algorithms.

Findings

KarNet's computation time is independent of minterm count.

Achieves nearly 100% accuracy, precision, and recall.

Faster than traditional rule-based methods by a factor of 10 to 100.

Abstract

Many approaches such as Quine-McCluskey algorithm, Karnaugh map solving, Petrick's method and McBoole's method have been devised to simplify Boolean expressions in order to optimize hardware implementation of digital circuits. However, the algorithmic implementations of these methods are hard-coded and also their computation time is proportional to the number of minterms involved in the expression. In this paper, we propose KarNet, where the ability of Convolutional Neural Networks to model relationships between various cell locations and values by capturing spatial dependencies is exploited to solve Karnaugh maps. In order to do so, a Karnaugh map is represented as an image signal, where each cell is considered as a pixel. Experimental results show that the computation time of KarNet is independent of the number of minterms and is of the order of one-hundredth to one-tenth that of the rule-based methods. KarNet being a learned system is found to achieve nearly a hundred percent accuracy, precision, and recall. We train KarNet to solve four variable Karnaugh maps and also show that a similar method can be applied on Karnaugh maps with more variables. Finally, we show a way to build a fully accurate and computationally fast system using KarNet.

Figures

Tables

Table 1. TABLE I : Comparison of various neural network based methods. Best performance metric is indicated in bold.

Arch.	Accuracy	Avg Precision	Avg Recall	Avg F1-Score	No. of Parameters
A1	40.79%	86.78%	86.35%	86.56%	15,470
A2	62.22%	90.85%	90.43%	90.64%	15,509
A3	74.14%	95.78%	96.23%	96.00%	3,72,368
A4	89.08%	98.25%	98.57%	98.40%	68,151
A5	93.72%	98.63%	98.53%	98.58%	19,60,066
KarNet-1	92.97%	98.97%	98.99%	98.98%	4,53,584
KarNet-2	93.84%	99.02%	99.04%	99.03%	4,53,584

Table 2. TABLE II : Accuracy on all 4x4 K-maps

Arch.	A3	A4	A5	KarNet-1	KarNet-2
Overall Acc.	74.10%	94.84%	96.59%	97.09%	98.09%

Equations

$$\displaystyle loss(\textbf{x},\textbf{y})=-\sum_{i=0}^{N-1}\Biggl{\{}y[i]*log((1+exp(-x[i]))^{-1})+$$

$$\displaystyle(1-y[i])*log\Biggl{(}\frac{exp(-x[i])}{(1+exp(-x[i]))}\Biggl{)}\Biggl{\}}$$

Full text

I Introduction

Numerous methods have been employed over the years in order to obtain simplified Boolean expressions of variables from sums of minterms or product of maxterms. For instance, Karnaugh map solving [1], Quine McCluskey algorithm [2] are some of the popular ones in this domain. These methods are based on a specific set of rules, and hence are hard-coded. Further, these problems have non polynomial (NP)-hard complexity [15].

One of the famous rule-based methods is the Karnaugh map solving [1] (abbreviated as K-map), in which, the minterms (or maxterms, as is the case) are marked as 1s (or 0s) in a square grid and don’t cares as Xs whose size is (number of variables) x (number of variables) and the cells are ordered according to the gray code. Other entries of the grid are marked as 0s (or 1s). An optimal grouping of the 1s (or 0s) in order to minimize the original expression, is shown in Fig. 1. Another popular method is the Quine-McCluskey Algorithm [2]. First, the prime implicants of the given function are found, and then, they are listed in the form of a prime implicant chart, as in Fig. 2 and Fig. 3. Prime implicant is an implicant that cannot be covered by a more general implicant, where an implicant is a covering of one or more minterms in the sum of products form of a Boolean function. However, on the downside, the time complexity of this algorithm increases exponentially as the number of variables increase.

Petrick’s method [3] is also a rule-based method based on the minimization of sum-of-products from the prime implicant chart. McBoole Method [4] uses efficient graph partitioning techniques to minimize the Boolean functions, where the Boolean function to be minimized is represented in the form of list of cubes, as shown in Fig. 4.

Recent works such as [14] include minimization of Boolean functions using a repetitive block diagram without using any auxiliary objects and achieves lower cost of development and computation compared to Karnaugh maps. In [16] an efficient realization of deep neural networks in terms of computation resource consumption, memory cost has been proposed using Boolean logic minimization. Neural Networks also have been used in the past to address Boolean logic simplification. For instance, [5] used modular neural nets in order to build an efficient learning architecture for Boolean algebra. Modular Neural Nets divide the task into various sub-tasks, each task being executed by a simple neural network. In order to control the weights of each of the neural net’s outputs, there is a gating network, which controls the training patterns of the sub-networks, as shown in Fig. 5.

In [6], a neural network is used to select a subset of prime implicants, which would be able to satisfy the function to be simplified for all possible input values with a minimal overall cost, where cost for a prime implicant could mean the number of literals associated with it.

All the rule-based methods described above and [6] have a computation time proportional to the number of minterms. Further, the method described in [5] has many parameters to be learned, since it involves multiple neural networks, thus increasing computational time.

In this paper, we propose KarNet, which learns Boolean simplification by itself. We give a Karnaugh map as an input, represented as an image signal, to a convolutional neural network (CNN). The CNN is designed using appropriate filters and padding, which maps the input to its simplified Boolean expression obtained as the output. KarNet has a computation time that is independent of the the number of minterms, which is much lower than the algorithmic methods. Moreover, we show that it achieves nearly hundred percent accuracy, precision and recall on all possible input four variable Karnaugh maps. We further show that KarNet can perform in cases of higher number of variables as well. Finally, we suggest a way to built a hundred percent accurate (like the algorithmic methods) and computationally fast system with KarNet.

The paper is organized as follows. The motivation behind the proposed solution is presented in Section II, and the approach is explained in Section III. The baselines and comparative experimental results are detailed in Sec. IV. Sec. V concludes the article.

II Motivation

Convolutional neural networks (abbreviated as CNNs) are widely used for image classification [7], localization [12] and segmentation tasks [13]. CNNs consist of various filters arranged in a hierarchical fashion doing convolution operations on the pixels of an input image. The filter coefficients are learned by the network from available training data. By repeated application of the convolutional filters, the network is able to extract learned features (filtered outputs) from the image data, with the filters at the beginning of the architectural hierarchy capturing the basic features and the filters in the latter part of the hierarchy capturing complex features. Thus the relationship between various pixel locations and values are captured along the said hierarchy. Inspired by the use of neural networks in the domain of Boolean algebra [5, 6, 16], we present a CNN based Boolean simplification method (KarNet), where the network is suited to learn the class mappings of input Karnaugh maps represented as image signals to get the product terms of the sum-of-products in simplified form.

III Proposed Method

Since, the method of grouping the cells in a Karnaugh map depends on the values and the locations of the pixels, we use a CNN based architecture, which would learn the pixel-wise relationships (treating each cell of a Karnaugh map as a pixel), and do the grouping of cells into product terms. Further, using locally connected CNNs instead of generic multi layer perceptrons, would require much less number of learnable parameters, and reducing memory requirement.

We first consider four variable K-maps in order to solve the problem of finding the minimum sum of products. As in Fig. 7, we use the Karnaugh map as a 4x4 image along with some padding as input . The desired output is provided in an one-hot encoded manner, in which, out of all possible product terms (say $AB$, $ACD$ etc., $A$, $B$, $C$ and $D$ being the variables) as the total number of output classes, the desired product terms are marked as 1. Since, solving Karnaugh maps involves making rectangular groups of $1$s, each group having number of terms in powers of 2, we take inspiration from the same. The architecture that we propose involves a padded $4$x$4$ Karnaugh map as input, on which, $8$ different sizes of convolutional filters are applied. The filter sizes are $1$x$1$, $1$x$2$, $2$x$1$, $1$x$4$, $2$x$2$, $4$x$1$, $2$x$4$, $4$x$2$ and $4$x$4$, with appropriate padding applied to the input according to the filter used, so that, all convolutional filters give output feature maps having shape same as that of the input. For one version of the proposed method (KarNet-1), we apply zero-padding. For another version (KarNet-2), padding of zeros is applied in addition to padding of the first row below and padding of the first column on the right, so as to learn the edge rectangular groupings in a more efficient manner, as shown in Fig. 6.

All feature maps obtained are then concatenated, flattened, and passed through two fully connected layers of neurons, and finally, the softmax activation function [8] is applied to estimate the probabilities of each of the classes as shown in Fig. 7.

For training KarNet, multi-label soft margin loss function is used. This loss function in (III) optimizes a multi-label one-versus-all loss based on max-entropy between the predicted output and the desired output [9].

[TABLE]

In the above expression, x refers to the vector of predicted class probabilities, y refers to the one-hot encoded vector representing the class(es) to which the input belongs to, and $N$ is the number of classes used for classification purpose. Final prediction from the output of the network is done by zero thresholding the intermediate output of the network just before applying the softmax function. The neurons for which the value is greater than zero correspond to the predicted classes which are then mapped to the product terms to obtain the minimum Boolean representation of the function in the sum of products form.

IV Experimental Results

IV-A Training Data

Here we elaborate on the data used to train KarNet. There are $2^{16}$ different K-maps possible for 4 variables, out of which, two of the Karnaugh maps are trivial, one having all $1$s, and the other having all [math]s and the total number of classes are 80. In order to extract the K-maps, we have used Quine-McCluskey Method, taking the minterms as the input, and giving as output the simplified equation. So, according to the minterms in the input, the corresponding positions would be 1 in the K-map, and the rest of the positions would be 0. The simplified equation is converted to one-hot encoded vectors, as has already been discussed in Section III.

IV-B Baseline algorithms

We consider a few baseline algorithms for comparison with KarNet, which are listed here. The input image signal is of size closer to the MNIST handwritten image data [17], which is of size $32$x$32$. Hence, we chose some of the state-of-the-art models of the MNIST data and some additional baselines to highlight some important factors which is explained in Section IV-D to benchmark the proposed method. The neural network architectures (earlier used on [17]) are as follows:

A1 - Conv2d((3, 3 x 3), stride=(1, 1), padding=(1, 1)) – ReLU() – Bilinear_Interpolation() – Fully

Connected(in_features=192, out_features=80).

A2 - Conv2d((3, 3 x 3), stride=(1, 1), padding=(1, 1)) – ReLU() – UpConv2d((3, 2 x 2), stride=(2, 2)) – Fully Connected(in_features=192, out_features=80).

A3 - Conv2d((12, 3 x 3), stride=(1, 1), padding=(1, 1)) – ReLU() – UpConv2d((72, 2 x 2), stride=(2, 2)) – Fully Connected(in_features=4608, out_features=80).

A4- This is based on LeNet architecture [11], in which, the input Karnaugh map is deconvoluted in order to increase the feature map’s size to $32$x$32$, following which, we apply the LeNet architecture, the only difference being that, in the last layer, we use the number of neurons equal to the number of classes in our case, which is 80.

A5- Deep columnar CNN architecture [10] with the input Karnaugh map deconvoluted to $28$x$28$.

In these baselines, the minimum representation of the Boolean function in the sum of products form is obtained in a similar fashion like the proposed method by zero thresholding the intermediate output and mapping the positive activations to the product terms.

IV-C Training Parameters and Hyperparameters

We did a train:validation:test split as 70:20:10, stratified on the basis of the number of classes corresponding to each input. Adam optimizer with a learning rate of $5$x$10^{-4}$ is used. Training is done on batches, with a batch size of $64$, and is continued for $600$ epochs. The model used for testing is the one saved at the epoch with the highest validation accuracy.

IV-D Evaluation and Results

We used accuracy, average precision, average recall and computation time on the test set as the evaluation metrics. For the architectures A1, A2, A3, A4, A5, and the two versions of the proposed method discussed above, Table I contains evaluation results.

As can be seen from Table I, KarNet performs better than all the baselines. This is because in KarNet, filter sizes are such that they correspond to the shapes of the rectangular groups of $1$s which is in accordance with the method of Karnaugh map solving. Among the two versions of the proposed method, the second one performs better than the first one, which may be due to the padding in the second method that allows the filters to learn even groups of $1$s across opposite edges.

In the baseline algorithms, having the deconvolutional layer in A2 instead of having a bi-linear interpolation function in A1 gives better results, as due to the introduction of deconvolutional layer, the total number of trainable parameters increases, thus being able to learn the complex mapping function more effectively. However, DC-CNN and LeNet baselines performs much better than the other 3 baselines. For LeNet baseline, this might be due to the number of features increasing by 64 times initially using a deconvolutional layer. DC-CNN has the highest number of parameters among all the baselines, and this might be the reason for it performing the best among all baselines.

Generalizability of KarNet -

K-maps with higher number of variables: Here, we show that KarNet is applicable to cases of K-maps with higher number of variables. As an example, without loss of generality, we applied a KarNet on K-maps having 5 variables. For this demonstration, we used a part of the $2^{32}-2$ K-maps data, taking $51,05,504$ K-maps, having $115$ classes. The sampling of these K-maps was done in a stratified fashion, based on the number of classes to which each input belonged to. An accuracy of $92.34\%$, precision of $98.32\%$, recall of $97.82\%$ and F1 score of $98.07\%$ was achieved using KarNet-1, whereas the best baseline, A5 gave an accuracy of $90.25\%$, precision of $98.26\%$, recall of $98.25\%$ and F1 score of $98.25\%$. This shows that KarNet can be trained to solve K-maps with higher number of variables achieving accuracies close to that obtained for the four variable case in Table I.

K-maps with don’t care: Here, we show that KarNet is applicable to cases of K-maps with don’t care cells. We extracted all possible 4 variable Karnaugh maps with the help of Quine Mccluskey Method for don’t care terms, which had at least one don’t care cell and at least one cell with value $1$. There are $42850116$ such K-maps in total, with the total number of classes being $80$. In order to convert the K-maps to images, the don’t care cell was filled with $0.5$, since, it had an equal probability of being occupied by either [math] or $1$. Performing stratified sampling over all samples based on the number of classes of each input, we sampled $800000$ inputs. Subsequently, following the same train:validation:test split, optimizer and learning rate, a batch size of $4096$, and applying KarNet-1 on the input, we achieved an accuracy of $85.58\%$, precision of $98.14\%$, recall of $98.32\%$, and a F1 score of $98.23\%$ on the test set.

The accuracy in case of five variables and don’t care K-maps can be increased by using more data for training, but it should be noted that in both the generalization cases, even by using only a small fraction of relevant data, more than 90% accuracy is achieved on the overall data.

Computation time - To highlight our most important contribution, we present here the time to process one set of given minterms to get the reduced Boolean expression for four methods - Karnaugh map solving method, Quine McCluskey Method, Petrick’s Method, and KarNet. This was performed for varying number of minterms in the input. The time taken is plotted against the number of minterms, as shown in Fig. 8.

This graph suggests two important things - one being that, the computation time of K-map, Quine McCluskey and Petrick’s methods are almost 10-100 times higher than KarNet, and the other being that, with an increase in the number of minterms, computation time of the rule-based methods increases, while for KarNet it is nearly independent of the number of minterms. The time of inference per input for KarNet is independent of the number of minterms. This is because KarNet treats each input to be simplified as an image, and the feed-forward time is independent of the pixel values of the input. Whereas, for the Karnaugh map solving method, the time taken is proportional to the number of groups of $1$s formed in K-map representation, which is in turn proportional to the number of minterms. For the Quine McCluskey and Petrick’s methods, all prime implicants are to be listed and minimal subset satisfying the truth table corresponding to the minterms of the input is to be found, which is proportional to the number of minterms present in the input. Hence, KarNet clearly has much lesser computation time when compared with conventional rule-based methods of Boolean function minimization.

100% Accurate Method (using a combination of KarNet and Quine McCluskey Method) - Many applications necessitate that Boolean function simplifier are 100% accurate, and here we suggest a way to achieve that using our computationally fast KarNet. The results of the overall accuracy obtained on inference performed on the whole data corresponding to 4x4 Karnaugh maps are tabulated in Table II. For the part of the data used for $5$ variable and don’t care K-maps, the overall accuracies are $97.33\%$ and $90.2\%$, respectively.

Now for the $4$ variable case, if we consider KarNet-2, of $65534$ K-maps, $1250$ K-maps have been predicted wrong. Hence, we can build a $100\%$ accurate Boolean minimization engine having very less computation time by using Quine McCluskey Method to predict the outputs where KarNet-2 would be inaccurate (stored as a prior knowledge) and use KarNet-2 on the rest of the samples. The computation time as a function of the number of minterms for this method has been plotted in Fig. 8, which is just marginally more than that of the KarNet.

V Conclusion

Through our proposal KarNet, we have shown that the simplification of Boolean expressions can be performed with the help of neural networks like CNNs with increased efficiency. The computation times of the rule-based methods like Quine-McCluskey and solving K-maps are based on the number of comparisons and are found to increase exponentially with the number of minterms. On the other hand, it is found that more number of minterms does not affect the computation time in case of KarNet. We get close to 100% accuracy in case of four variable K-maps and with a similar accuracy using a very small fraction of the data in case of five variable K-maps we demonstrate generalizability of KarNet. Applicability of KarNet on K-maps with don’t care conditions is also shown. A fully accurate and efficient system is demonstrated using a combination of KarNet and Quine McCluskey method. Given the existing potential, the work shall be extended in future, to solve K-maps with larger number of variables, so as to achieve 100% accuracy within a significantly less computation time.