The Classification Of Boolean Functions Using The Rademacher-Walsh Transform by Neil Arnold ...

132 Pages·2007·3.89 MB·English

by  Neil Anderson

The Classification Of Boolean Functions Using The Rademacher-Walsh Transform

by

Neil Arnold Anderson
B.Sc, University Of Lethbridge, 2004

A Thesis Submitted in Partial Fulfillment
of the Requirements for the Degree of

MASTER OF SCIENCE

in the Department Of Computer Science

 Neil Anderson, 2007
University of Victoria

All rights reserved. This thesis may not be reproduced in whole or in part, by photocopy
or other means, without the permission of the author.
ii
Supervisory Committee

The Classification Of Boolean Functions Using The Rademacher-Walsh Transform

by

Neil Anderson
Bachelor of Science, University of Lethbridge, 2004

Supervisory Committee

Dr. Jon C. Muzio, Department of Computer Science, University of Victoria
Supervisor

Dr. Jacqueline Rice, Department of Mathematics and Computer Science, University of Lethbridge
Supervisor

Dr. Micaela Serra, Department of Computer Science, University of Victoria
Departmental Member

Dr. David Wessels, Department of Computing Science, Malaspina University College
Outside Examiner
iii
Abstract

Supervisory Committee
Dr. Jon C. Muzio, Department of Computer Science, University of Victoria
Supervisor

Dr. Jacqueline Rice, Department of Mathematics and Computer Science, University of Lethbridge
Supervisor

Dr. Micaela Serra, Department of Computer Science, University of Victoria
Departmental Member

Dr. David Wessels, Department of Computing Science, Malaspina University College
Outside Examiner

When considering Boolean switching functions with n input variables, there are 22n
possible functions that can be realized by enumerating all possible combinations of input
values and arrangements of output values. As is expected with double exponential
growth, the number of functions becomes unmanageable very quickly as n increases.
This thesis develops a new approach for computing the spectral classes where the
spectral operations are performed by manipulating the truth tables rather than first
moving to the spectral domain to manipulate the spectral coefficients. Additionally, a
generic approach is developed for modeling these spectral operations within the
functional domain. The results of this research match previous for n!4 but differ when
n=5 is considered. This research indicates with a high level of confidence that there are
in fact 15 previously unidentified classes, for a total of 206 spectral classes needed to
represent all 22n Boolean functions.
iv
Table of Contents

Supervisory Committee...................................................................................................ii
Abstract..........................................................................................................................iii
Table of Contents...........................................................................................................iv
List of Tables.................................................................................................................vii
List of Figures...............................................................................................................viii
1 - Introduction...............................................................................................................1
1.0 Digital Logic And Boolean Switching Functions....................................................1
1.1 Motivation.............................................................................................................2
1.2 Overview...............................................................................................................4
1.3 Summary...............................................................................................................5
2 - Background................................................................................................................6
2.0 Introduction...........................................................................................................6
2.1 Boolean Switching Functions.................................................................................6
2.2 Binary Representation...........................................................................................7
2.3 Classification..........................................................................................................8
2.3.1 Definition Of Classification.............................................................................9
2.3.2 Algebraic Classification...................................................................................9
2.3.2.1 Permutation Of Input Variables.............................................................10
2.3.2.2 Negation Of Input Variables..................................................................10
2.3.2.3 Negation Of Output...............................................................................11
2.3.3 Spectral Classification...................................................................................12
2.3.3.1 Computing Spectral Coefficients............................................................14
2.3.3.2 Type 1: Permutation Of Input Variables................................................17
2.3.3.3 Type 2: Negation Of Input Variables.....................................................17
2.3.3.4 Type 3: Negation Of Output..................................................................18
2.3.3.5 Type 4: Variable Replacement With XOR............................................18
2.3.3.6 Type 5: Output Replacement With XOR..............................................19
2.4 Spectral Signature................................................................................................20
2.5 Other Function Groups.......................................................................................20
2.5.1 Threshold.....................................................................................................20
2.5.2 Unate............................................................................................................22
2.6 Rules...................................................................................................................22
2.7 Double Exponential.............................................................................................23
2.8 Linear Independence...........................................................................................23
2.9 The Problem........................................................................................................24
2.10 Summary...........................................................................................................25
3 - Related Work...........................................................................................................27
3.0 Introduction.........................................................................................................27
3.1 Alternate Representations Of The Hadamard Transform....................................27
3.2 Other Transforms................................................................................................28
3.3 History Of The Problem......................................................................................29
v
3.4 Summary.............................................................................................................30
4 - Approaches..............................................................................................................32
4.0 Introduction.........................................................................................................32
4.1 The Spectral Domain..........................................................................................32
4.2 The Functional Domain......................................................................................33
4.2.1 Pre-Filter.......................................................................................................34
4.2.2 Operations....................................................................................................36
4.2.2.1 Type 1: Permutation Of Input Variables................................................37
4.2.2.2 Type 2: Negation Of Input Variables.....................................................37
4.2.2.3 Type 3: Negation Of Output..................................................................38
4.2.2.4 Type 4: Variable Replacement With XOR............................................38
4.2.2.5 Applying The Rules...............................................................................40
4.2.3 The Canonical Function...............................................................................44
4.3 Summary.............................................................................................................44
5 - Results And Analysis................................................................................................46
5.0 Introduction.........................................................................................................46
5.1 The New Results.................................................................................................46
5.2 The Difficulties Of n ≥ 5......................................................................................48
5.3 Evidence..............................................................................................................50
5.3.1 Compared Functions.....................................................................................50
5.3.2 Number Of Coefficients Per Class And Group..............................................51
5.3.3 Calculations Of The Number Of Rules.........................................................54
5.4 Other Analysis.....................................................................................................56
5.4.1 Complexity...................................................................................................56
5.4.1.1 Brute Force............................................................................................57
5.4.1.2 Optimization..........................................................................................57
5.4.3 Prediction.....................................................................................................59
5.5 Results Confidence..............................................................................................61
5.6 Summary.............................................................................................................62
6 - Conclusion And Future Work...................................................................................63
6.0 Introduction.........................................................................................................63
6.1 Future Work........................................................................................................63
6.1.1 Implementation Analysis...............................................................................63
6.1.2 Theoretical...................................................................................................64
6.1.3 Improvements To The Approach..................................................................64
6.2 Conclusion...........................................................................................................66
Bibliography..................................................................................................................68
A - Implementation.......................................................................................................69
A.0 Introduction........................................................................................................69
A.1 Language............................................................................................................69
A.2 Program Structure..............................................................................................71
A.2.1 main.cpp......................................................................................................72
A.2.2 Prefilter Class...............................................................................................73
A.2.3 Classify Class................................................................................................74
A.2.4 Rules Class...................................................................................................75
A.2.4.1 Type 1: Permutation Of Input Variables...............................................75
A.2.4.2 Type 2: Negation Of Input Variables....................................................76
vi
A.2.4.3 Type 4: Variable Replacement With XOR............................................77
A.2.5 Transform Class...........................................................................................83
A.3 Optimizations.....................................................................................................85
A.3.1 Reducing The Problem................................................................................85
A.3.2 Programming Techniques............................................................................86
A.3.2.1 Dynamic Vs. Fixed Data Structures.......................................................86
A.3.2.2 Bitwise Operators..................................................................................88
A.3.2.3 Picking Data Types That Fit..................................................................89
A.3.2.4 Memory Vs. Clock Cycles......................................................................90
A.3.2.5 Object-Oriented Programming..............................................................90
A.3.2.6 Dividing The Problem...........................................................................91
A.4 Problems.............................................................................................................92
A.5 Summary............................................................................................................92
B - Classes.....................................................................................................................94
B.0 Introduction........................................................................................................94
B.1 Complete Spectral Class List For n = 5................................................................94
B.2 Transcription Of Hurst Printouts........................................................................98
B.3 Summary..........................................................................................................103
C - Source Code..........................................................................................................104
C.1 Main.................................................................................................................104
C.1.1 main.h........................................................................................................104
C.1.2 main.cpp....................................................................................................104
C.2 Prefilter.............................................................................................................105
C.2.1 Prefilter.h...................................................................................................105
C.2.2 Prefilter.cpp................................................................................................106
C.3 Rules.................................................................................................................107
C.3.1 Rules.h.......................................................................................................107
C.3.2 Rules.cpp...................................................................................................108
C.4 Classify.............................................................................................................113
C.4.1 Classify.h....................................................................................................113
C.4.2 Classify.cpp................................................................................................114
C.5 Transform.........................................................................................................117
C.5.1 Transform.h...............................................................................................117
C.5.2 Transform.cpp...........................................................................................118
C.6 Misc..................................................................................................................121
C.6.1 Misc.h........................................................................................................121
C.6.2 Misc.cpp....................................................................................................121
vii
List of Tables

Table 1 – Truth table for Figure 1...................................................................................1
Table 2 - Correlation between spectral coefficients and input variables for n = 3...........12
Table 3 – Truth table for Function 189.........................................................................15
Table 4 – The number of functions for n = 1 through 10...............................................25
Table 5 – Number of Functions for n = 3......................................................................36
Table 6 – Type 1 Rules for n = 3...................................................................................37
Table 7 – Type 2 Rules for n = 3...................................................................................37
Table 8 – Type 3 transformations for n = 3...................................................................38
Table 9 – Type 4 input variable lookup table for n = 4..................................................40
Table 10 – All possible combinations of input variables from lookup table in Table 9....40
Table 11 – Type 4 Rules for n = 3.................................................................................42
Table 12 – Previously unidentified classes for n = 5.......................................................47
Table 13 – Number of functions per class and group for n = 3.......................................51
Table 14 – Number of functions per class and group for n = 4.......................................52
Table 15 – Number of functions per class and group for n = 5.......................................53
Table 16 – Number of rules for n ≤ 6............................................................................54
Table 17 – Comparison between classes for n = 3,4,5....................................................60
Table 18 – Logical representation of lookup table for n = 4...........................................78
Table 19 – Decimal representation of lookup table for n = 4..........................................78
Table 20 – Lookup table generation for n = 5................................................................79
Table 21 – Complete spectral class list for n = 5............................................................98
Table 22 – Transcription of Hurst Printouts................................................................101
viii
List of Figures

Figure 1 – Digital Circuit.................................................................................................1
Figure 2 – a) AND b) OR c) XOR d) NOT.....................................................................6
Figure 3 – Truth table format..........................................................................................8
Figure 4 – Type 1: Permute input variables x and x .....................................................10
2 1
Figure 5 – Type 2: Negate input variable x ...................................................................11
2
Figure 6 – Type 3: Negate output vector values.............................................................11
Figure 7 – Spectral coefficients for n = 4........................................................................13
Figure 8 – Reordered spectral coefficients for n = 4.......................................................13
Figure 9 – Hadamard transformation matrix for n = 3...................................................15
Figure 10 – Example converting the output vector of Function 189 from Z to Y encoding
......................................................................................................................................16
Figure 11 – Calculate the spectral coefficients for Function 189.....................................16
Figure 12 – Type 4: Substitute x ⊕ x for input variable x ............................................18
2 1 2
Figure 13 – Type 5: Perform XOR between the output vector and x ............................19
2
Figure 14 – Threshold function for n = 2.......................................................................21
Figure 15 – Spectral output order for Hadamard (S ), Walsh (S ), Rademacher-Walsh
H W
(S ), and Walsh-Paley (S ) transforms........................................................................28
RW WP
Figure 16 – a) Original function b) Function a with x replaced with x ⊕ x ..................38
2 2 0
Figure 17 – True bits on the diagonal............................................................................39
Figure 18 – Transformation rule combinations (Details in Figure 19).............................41
Figure 19 - Details of Figure 18.....................................................................................43
Figure 20 – Implementation flow...................................................................................71
Figure 21 – Pseudocode for pre-filter logic.....................................................................73
Figure 22 – Pseudocode for classification logic...............................................................74
Figure 23 – Pseudocode for Type 1 rule generation.......................................................76
Figure 24 – Example of array item 4 (011).....................................................................76
Figure 25 – Pseudocode for Type 2 rule generation.......................................................77
Figure 26 – Pseudocode for lookup table creation..........................................................80
Figure 27 – Pseudocode for linear independence check for n = 3...................................81
Figure 28 – C++ code to check linear independence for any value of n.........................81
Figure 29 – Innermost for loop logic..............................................................................82
Figure 30 – Innermost loop logic for n = 2 (unfolded loops)...........................................82
Figure 31 – Pseudocode for rule generation...................................................................83
Figure 32 – Pseudocode for transformation logic...........................................................84
Figure 33 – All possible functions for n = 1....................................................................85
Figure 34 – Check if any bits are set to true...................................................................89
Figure 35 – Check if any bits are true using bitwise operators........................................89
Figure 36 – Addendum printout for Hurst Class 31 in 0/1 encoding...........................102
ix

Science, my lad, is made up of mistakes, but they are mistakes which it is useful to
make, because they lead little by little to the truth.
- Jules Verne
Chapter
1 - Introduction
1.0 Digital Logic And Boolean Switching Functions
In the field of digital logic, there are many techniques for representing circuits. One
representation is shown in Figure 1.
x
2
x
1
x
0

Figure 1 – Digital Circuit
Another representation is a truth table, which is used to tabulate the output for each
possible combination of input values. For n inputs, a truth table lists 2n possible results.
For example, the circuit in Figure 1 can be represented by the truth table in Table 1.
x x x
2 1 0
0 0 0 1
0 0 1 0
0 1 0 1
0 1 1 1
1 0 0 1
1 0 1 1
1 1 0 0
1 1 1 1
Table 1 – Truth table for Figure 1
Circuits with even a moderate number of input variables generate truth tables that are
very large. A more compact representation of the circuit can be achieved using a