"LI B R.AR.Y 
 
 OF THE 
 U N IVLRSITY 
 OF ILLINOIS 
 
 510.84 
 Kfcr 
 no. Z50-25fc 
 
 cop. ^ 
 
Digitized by the Internet Archive 
 in 2013 
 
 http://archive.org/details/patternarticulat253mcco 
 
t3 
 
 Keport JNo. d^i 
 
 M n I n 
 
 THE PATTERN ARTICULATION UNIT^OF ILLIAC III 
 HOMOGENEOUS BOOLEAN FUNCTIONS IN THE 
 ITERATIVE ARRAY* 
 
 by 
 
 Bruce H. McCormick 
 William J. Watson 
 Richard T. Borovec 
 
 January 8, 1968 
 
Report No. 253 
 
 THE PATTERN ARTICULATION UNIT OF ILLIAC III: 
 
 HOMOGENEOUS BOOLEAN FUNCTIONS IN THE 
 
 ITERATIVE ARRAY* 
 
 by 
 
 Bruce H. McCormick 
 William J. Watson 
 Richard T. Borovec 
 
 January 8, 1968 
 
 Department of Computer Science 
 University of Illinois 
 Urbana, Illinois 6l801 
 
 *Supported in part by Contract AT(ll-l )-10l8 with the U. S. Atomic Energy 
 Commission and the Advanced Research Projects Agency. 
 
1. INTRODUCTION 
 
 The Pattern Articulation Unit (PAU) of the Illiac III Computer is 
 a modular parallel data processor for visual information. The internal data 
 word is a plane having dimensions 32 x 32 bits. Planes are processed in 
 parallel by the execution of homogeneous (plane-wide) operations. This processing 
 is performed in an Iterative Array having an internal storage capacity of 9 planes. 
 These 9 planes of fast registers, which in many ways serve as multiple accumulators, 
 are augmented by U8 planes of core storage, the Transfer Memory of the PAU. (See 
 Figure 1 for the organization of storage in the PAU). 
 
 It will be the intent of this paper to describe (i) the homogeneous 
 Boolean functions evaluated in the Iterative Array, and (ii) the machine language 
 whereby instructions for homogeneous Boolean functions are transmitted to the PAU. 
 
 B. H. McCormick, "The Illinois Pattern Recognition Computer - ILLIAC III", 
 IEEE Transactions on Electronic Computers , Vol, EC- 12, No. 6, pp. 791-813, 
 December, 1963 
 
 -1- 
 
Transfer 
 Memory 
 
 ^ Iterative 
 Array 
 
 Figure 1 Planar Organization of the Pattern Articulation Unit 
 
 -2- 
 

 HOMOGENEOUS BOOLEAN FUNCTIONS IN THE ITERATIVE ARRAY 
 
 2.1 Description of the Functions 
 
 The unit data word processed is a plane (l02U-bits). Consider an 
 arbitrary cell in a plane P of the iterative array (Figure 2). Horizontal 
 neighbors cf cell are defined, for the rectangular representation, as those 
 cells which show a common edge or common vertex with cell 0. For reference 
 purposes, these cells have been numbered as shown in Figure 2, 
 
 Figure 2 
 
 A horizontal Boolean function may be defined as a unary mapping from a plane P 
 onto a plane P' , where for each bit position 0, the (new) value of the cell in 
 plane P' is determined from the logical values of cell and its immediate 
 neighbors in plane P. 
 
 As an example, consider the function 
 
 f(x) = (0) 
 
 (4) & (8) (2) & (6) 
 
 of a neighborhood in plane P, and assume that the value of the function will be 
 recorded in cell of plane P' . This mapping is illustrated in Figure 3. 
 
 -3- 
 
.P 1 (0) 
 
 Figure 3 
 
 In the figure, cross-hatched squares denote logical "ones" at those bit positions 
 In this example, the term (2) & (6) produces the '1' in plane P' . 
 
 This concept of a Boolean function for an arbitrary bit position is 
 
 then extended throughtout the plane. By means of this extension, the logical 
 
 2 
 value of every interior bit in plane P' is defined as a given Boolean function 
 
 of its corresponding neighbors in plane P. This concept of a homogeneous 
 
 Boolean function is illustrated in Figure k. 
 
 "It is recognized that the borders of the planes constitute a special case 
 which is not considered in this discussion. 
 
 -1+- 
 
Denotes undefined 
 border bits of P 1 
 since not all 
 neighbors in P are 
 defined. 
 
 f = (0)|(8)&(U) 
 
 Figure k 
 
 In this example, consider each interior bit, in turn, as being bit position 0, 
 The function is evaluated and recorded in plane P' for each interior bit 
 position, In this way, an arbitrary Boolean function of the nine horizontal 
 variables(i ,e. , self (0) plus eigtr neighbors) maps an entire operand plane P 
 into an accumulator plane P' , 
 
 The homogeneous Boolean function concept may be extended further. 
 Consider planes U, V and W, shown in Figure 5, as planes over which the 
 domain of the Boolean function may be extended. 
 
 -5- 
 
w 
 
 P ! 
 
 f = uo&vo&-?wo 
 
For the example of Figure 5, the Boolean function will be limited strictly to 
 the bits in the bit position vertical column (1 e , directly above each bit in 
 P'). By restricting the indicated function to vertical variables, the given 
 function may be readily computed and recorded in plane P' . Again, the function 
 should be considered as being homogeneous — i.e., holding for every interior 
 point in plane P' . 
 
 The homogeneous Boolean function may be generalized by establishing its 
 domain as both (a) all planes in the iterative array and (b) all neighbors 
 (including self). This is in contrast to the restrictive examples which have 
 preceded. These examples restricted the domain of the function to either (a) or 
 (b). Because the homogeneous Boolean function has been expanded to three 
 dimensions, it becomes convenient to introduce a notation whereby the function 
 may be succinctly expressed. 
 
 2.2 Notation for General Boolean Homogeneous Functions 
 
 In the introduction, it was mentioned that there are nine planes 
 of storage in the Iterative Array. One of these planes is reserved for special 
 use and is not available for inclusion in a general Boolean function. This 
 plane is designated as plane M- The other eight planes are denoted by the 
 symbols PO, PI,,,., P7 (Figure 6). For the remainder of this report the leading 
 P will be dropped- Thus PO will be represented by . 
 
 P7 
 
 P6 
 
 P5 
 
 PU 
 
 P3 
 
 P2 
 
 PI 
 
 PO 
 
 M 
 
 Figure 6, Planes in the iterative Array 
 
 -7- 
 
The horizontal neighbors, it will be recalled, are likewise designated by single 
 
 digits: 0, 1, 2, 8, where is the "self" bit. Based upon these digits 
 
 the general Boolean function is defined as F(00, 01, 02, , 08; 10, 11, 12, 
 
 , 18; ; TO, 71, 72, 78) where each two-digit number specifies a 
 
 particular neighbor in a particular plane. The first digit of a two-digit 
 pair denotes a plane, and the second digit denotes a neighbor in that plane. 
 For example, to evaluate the function 
 
 F =—1(12^(13) | (27)&(30) 
 
 a "one" must be stored (somewhere) for every bit position in the planar array 
 which has (a) (neighbor 2) = and (neighbor 3) = 1, both in plane 1, or_ (b) 
 (neighbor 7 in plane 2) = 1 and (neighbor in plane 3) = 1. To complete the 
 specification of the function, all that is required is the specification of 
 the plane in which the result is to be recorded. 
 
 Assume that, for the example given, the result is to be stored in 
 plane 7. The function will then be written 
 
 P7 =— i(12)&(13) (27)&(30) 
 
 meaning that plane 7 (P7) is to be replaced by the result obtained by evaluating 
 the given function over the entire plane. The notation, as developed thus far, 
 permits an arbitrary homogeneous Boolean function to be expressed which has 
 for its domain all planes of the array and all neighbors of a point. The 
 notation also designates which plane is to serve as the accumulator for the 
 evaluation of the function. It should be mentioned at this point that 
 
 neighbors in the accumulator plane are legitimate variables for inclusion 
 
 3 
 
 in the general function. 
 
 3 
 See Section 5*2 for an elaboration of this point 
 
 -8- 
 
THE POST FIX CANONICAL FORM FOR SPECIFYING 
 GENERAL BOOLEAN FUNCTIONS 
 
 3.1 Elementary Functions 
 
 An elementary function will be defined as any function meeting froth 
 of the following criteria: 
 
 (1) The domain of the function is restricted either to (a) any one 
 plane, or (b) the vertical column passing through hit position 0. 
 
 (2) The function is a simple Boolean sum (OR) or a simple Boolean 
 product (AND) of the individual (true and/or complemented) 
 variables . 
 
 For example, the functions 
 
 P6 = (10) & (11) & -»(l6) & (17) (horizontal, plane l) 
 
 P2 = — 1(20) I —1 ( 30 ) I (kO) 1-1(50) (vertical) 
 
 are elementary functions. 
 
 The functions 
 
 P3 = 21 I 31 | hi (criterion lb) 
 
 P5 = -i(10 I 11 | 12) (criterion 2) 
 
 PU = (10) & (21) & (11) & (12) (criterion l) 
 
 are not elementary functions because each fails to meet the indicated 
 criterion, In the canonical form, an arbitrary homogeneous Boolean function 
 will be written as a combination of elementary functions. 
 
 3.2 Secondary Operators 
 
 In order to write an arbitrary function as a combination of elementary 
 functions, the use of secondary operators will be introduced. These secondary 
 operators will be the conventional AND (&), OR ( | ), and negation ( I ) of 
 Boolean algebra, and they will operate upon elementary functions . For 
 example, let W, X, and Y be elementary functions. Then 
 
 P =-»( 'W)&(X)H(X)&(Y) ) 
 -9- 
 
is a function defined by elementary functions and secondary operators , where P 
 designates the final storage plane. 
 
 3. 3 Postfix Canonical Form 
 
 A function such as the one just previously given, can he written in 
 string form by using postfix notation as follows: 
 
 P = WX & X—l Y & | — | 
 
 where —7 is the string symbol for negation. This form will be slightly modified 
 and punctuated as follows : 
 
 F : W; X&; X-| ; Y&| — 1 ; P„ 
 
 In this representation, F is the function name. It should be noted that the 
 punctuation gives advance notice (assuming a left-to right scan of the string) 
 as to the nature of the next symbol. For example, to the right of the ( : ) 
 symbol, the first symbol defines an elementary function as does every symbol 
 which immediately follows a ( ; ) . Every symbol immediately following an elementary 
 function, or a secondary operator, if not a (;) is a secondary operator symbol. 
 The symbol P preceding the ( . ) is the final storage plane designator. This 
 latter form illustrates the canonical form for writing arbitrary Boolean functions. 
 
 The syntax of the canonical form may be formally defined as follows: 
 
 <function> : := <term string> ; P- 
 
 <term string> ::= <term> <term> ; <term string> 
 
 <term> ::= ^elementary function' <elementary function> <operator string- 
 <operator string> : := <secondary operator> <secondary operator> 
 
 <operator string> 
 
 An example will illustrate the canonical form. Consider the function 
 
 P7 = n (12)&(13) I (27) & (30) 
 
 -10- 
 
in the canonical postfix form in which the fundamental variables are elementary- 
 functions, this function may be written as follows: 
 
 let X = -1 (12)4(13) 
 
 Y = 27 V elementary functions 
 
 Z = 30 
 
 Then the required designation is of the form 
 
 F : X; Y; Z& | ; 7- 
 
 In this form, it is assumed that the symbols X, Y, and Z completely describe 
 their corresponding elementary functions. More explicitly, the function may be 
 written 
 
 F:[-i(12)&(13)];[27]j[30] &j; 7- 
 
 where square brackets [ ] are introduced to delimit the elementary functions. 
 This is a detailed example showing how a function is written in the canonical 
 postfix form. 
 
 An arbitrary homogeneous Boolean function must be written in the 
 canonical form before it is ready to be translated into machine code. 
 
 -11- 
 
k. "BOOLE" FORMATS 
 
 The general PAU instruction for specifying a homogeneous Boolean 
 function is named "BOOLE". The formats used for encoding the instruction 
 "BOOLE" will now be defined. 
 
 It is assumed that many of the PAU instructions will he based upon a 
 two-byte instruction word, where a byte contains eight data bits and one flag 
 bit. For the instruction "BOOLE" this format is as follows: 
 
 Q 
 
 D 
 
 t — n — i — i — r 
 J i i t i I 
 
 T — I — I — I | I 
 J ''''I 
 
 / 
 
 Mnemonic Byte Availability List 
 
 The availability list designates which planes of the array may be used for inter- 
 mediate (i.e., scratch-pad) storage in evaluating the "BOOLE" function. The 
 required number depends on the complexity of the function. (See Section U.2). 
 
 "BOOLE" control will begin to request auxiliary information after 
 decoding the two-byte instruction word. In the course of processing the instruc- 
 tion, information requests will continue, and must be honored by the controlling 
 taxicrinic processor until the information required for evaluating the function 
 has been completely transmitted. This auxiliary information will be presented 
 to the PAU in either of two formats. The two formats are: 
 
 Format X 
 
 Format Y 
 
 True Complemented 
 
 Address Variables Variables 
 ,-ss^, — „ w yK— _ ^ 
 
 r-i — i i i i i i 
 
 T-T- 
 
 J_JL 
 
 1 — 1 I I I I I I 
 III I I I 1 I 
 
 J—L 
 
 a fc> y 
 
 3 bytes 
 1 byte 
 
 0P(0 
 
 )\op(i)\ 
 
 0(0) C(l) 
 
 -12- 
 
The first auxiliary information to be furnished following the initial request 
 is in format X. From then on, the succeeding format is context dependent. 
 The meanings of the individual bits and fields are now described, 
 
 Format X 
 
 _a Meaning 
 
 (OR) operators connect the variables of the 
 
 elementary function 
 
 1 (AND) operators connect the variables of the 
 
 elementary function 
 
 6_ Meaning 
 
 a horizontal elementary function is specified 
 
 1 a vertical elementary function is specified 
 
 Meaning 
 
 if horizontal elementary function, operand 
 
 plane is as previously defined 
 
 1 if horizontal elementary function, operand 
 
 plane is redefined by address field 
 
 True Variables 
 
 This is a list of all true variables appearing 
 in the elementary function. 
 
 Complemented Variables 
 
 This is a list of all complemented variables 
 appearing in the elementary function. 
 
 Address 
 
 If 8 = and y = 1, the address field defines 
 a horizontal plane as follows (otherwise, the 
 field is ignored): 
 
 -13- 
 
ABC 
 
 
 1 
 10 
 Oil 
 10 
 10 1 
 110 
 
 111 
 
 Plane 
 
 
 1 
 2 
 3 
 h 
 5 
 6 
 7 
 
 Format Y (where s = 0, l) 
 C(s) 
 
 
 
 1 
 
 Meaning 
 Stop (i.e., period ) 
 Continue 
 
 0P(s) 
 
 If C(s) = 1 , the three-hit 0P(s) field 
 has the following interpretation: 
 
 N L P 
 
 Meaning 
 
 
 
 1 
 
 1 
 
 1 5 
 
 10 
 
 & 
 
 11 
 
 ft; 
 
 10 
 
 -1 
 
 10 1 
 
 -» ; 
 
 110 
 
 Forhidc 
 
 111 
 
 
 In other words, the individual bits have the following meanings 
 
 -Ik- 
 
N Meaning 
 
 a binary secondary operator is specified by 
 
 bit L 
 
 1 the operator is negation (unary ), unless ";" 
 
 L Meaning 
 
 if binary operator, operator is (OR) 
 
 1 if binary operator, operator is & (AND) 
 
 P Meaning 
 
 no punctuation follows operator 
 
 1 punctuation following operator is; 
 
 NOTE: The ";" when not preceded by an 
 
 operator is interpreted as meaning 
 "next format is of type X" regard- 
 less of whether it appears in 
 0P(l). 
 
 If C(s) = , the 0P(s) field bits (N,L,P) 
 are interpreted as the address of the final 
 horizontal plane: 
 
 N L P Plane 
 
 
 
 1 1 
 
 10 2 
 
 11 3 
 
 10 k 
 
 10 1 5 
 
 110 6 
 
 111 7 
 
 -15- 
 
In actual use, the complete set of auxiliary information required 
 to describe a function will consist of an initial format X group, followed 
 by a mix of data in formats X and Y. Format X is used when a new elementary 
 function is to be introduced, and format Y is used to introduce secondary 
 operators. The address in which the result is to be stored is given in the 
 final format Y byte. 
 
 -16- 
 
5. A BRIEF DESCRIPTION OF "BOOLE" EXECUTION 
 
 5. 1 Calculation of Elementary Functions 
 
 Physically, the Iterative Array is comprised of modules called 
 "stalactities" . Each stalactite contains nine bits of storage, one in each 
 plane Thus, a stalactite is a 1 bit by 1 bit by 9 bit column of the array. 
 In addition to storage capability, the stalactite contains selectable combina- 
 tional logic elements which give it computational capability. 
 
 There are twelve different types of elementary functions which must 
 be distinguished for evaluation by the stalactites in the array: 
 
 (1) Horizontal sum (OR), 
 
 (2) " " " , 
 
 (3) " " " , 
 (h) Horizontal product (AND 
 
 (5) 
 (6) 
 
 (7) Vertical sum (OR) , 
 
 (8) " " " , 
 
 (9) " " " , 
 
 (10) Vertical product (AND), 
 
 (11) " " " , 
 
 (12) " " " , 
 
 true variables only 
 complemented variables only 
 true and complemented variables 
 true variables only 
 complemented variables only 
 true and complemented variables 
 true variables only 
 complemented variables only 
 true and complemented variables 
 true variables only 
 complemented variables only 
 true and complemented variables 
 
 The eight types of elementary functions involving only variables of 
 one kind (i.e., true or complemented, but not mixed) can be evaluated by exe- 
 cuting a single micro-operation in the array. The four types involving both 
 kinds of variables require two consecutive micro-operations. In these 
 four cases, the M-plane is the intermediate storage plane in which the 
 partial results (from the first micro-operation ) are stored, When a complete 
 
 -17- 
 
(one or two micro-operations) elementary function has been evaluated, it 
 must "be temporarily stored. This problem will now be considered. 
 
 5 .2 Assignment of Intermediate Storage Planes 
 
 "BOOLE" control automatically assigns the required temporary storage 
 planes by selecting an available plane from the availability list. It will 
 be recalled that this list is contained in the second byte of the basic instruc- 
 tion word. For example, the availability list may appear as follows: 
 
 7 
 
 1 
 
 6 
 
 
 
 5 
 
 1 
 
 k 
 
 1 
 
 3 
 
 
 
 2 
 
 1 
 
 1 
 
 
 
 
 
 
 
 This means that planes 2, k, 5, and 7 are "available" for use as intermediate 
 storage. A status register in the PAU shows which planes are actually in use 
 as temporary storage planes at any given time. For example, in keeping with 
 the availability list example, the status register might appear (at some 
 given time during the processing of the function) as follows: 
 
 availability 
 
 7 
 6 
 
 5 
 h 
 3 
 2 
 1 
 
 
 1 
 
 
 
 1 
 1 
 
 
 1 
 
 
 
 1 
 
 1 
 
 
 
 
 
 1 
 
 
 
 
 
 o 
 
 
 
 o| 
 
 status register 
 
 -18- 
 
 
This means that of the planes which are available for temporary storage, three 
 are in use. There is, at this time, only one additional plane which is available 
 for intermediate storage, plane 2, The manner in which elementary functions are 
 combined will be discussed in the next section. 
 
 5. 3 Push-down Stack Structure 
 
 The canonical postfix form is a string representation of the Boolean 
 function to be evaluated. The "variables" of this string are elementary functions 
 and the operators are the Boolean | , & , and-i. The string is processed by 
 
 "pushing down" the variables (evaluated elementary functions) into a push-down 
 
 k 
 stack as they are scanned, and by executing operators as they are scanned. The 
 
 variable in the top cell of the stack (for unary negation) or those variables in 
 
 the top two cells (for binary operators) will be used in the execution. Lastly, 
 
 after the period is scanned and the final plane address has been read, the stack 
 
 is automatically checked to determine whether or not the result (i.e., top of 
 
 stack) is already in the required final location. If so, termination occurs. If 
 
 not, the result is moved to the designated plane prior to termination of the 
 
 '"BOOLE" execution. 
 
 The operation of the push-down stack may be clarified by tracing its 
 behavior through the execution of an example function that was previously given 
 (Figure 7): 
 
 F : [ -t(12)&(13 >J ;[27] ;[ 30] &| ;7. 
 
 M12)&(13)1 
 
 I 27) 
 
 L30] 
 
 L27]&[30] 
 
 [-i (12)&(13)]|[2T]&| 30] 
 
 
 [-»( i2)&: L3)J 
 
 L27] 
 
 l-r (12)&(13)] 
 
 
 
 
 L -»(12)&(13)] 
 
 
 
 time 
 
 Figure 7 Operation of the push-down stack 
 
 Last-in, first-out memory in which each "cell" is a plane, 
 
 -19- 
 
It should be noted that, for this example, the maximum required stack depth is 
 three cells . 
 
 As cells are added to the push-down stack, they are deleted (i.e. the 
 appropriate bits are set to one) from the status register, and as they become 
 available they are reinstated to the list of currently-free cells maintained in 
 the status register. 
 
 5 . k Requirements Imposed Upon the Programmer and/or Compiler 
 
 There are four fundamental restrictions imposed upon the function to 
 be evaluated by "BOOLE" that should be mentioned: 
 
 (1) The "arbitrariness" of the arbitrary Boolean function is restricted to those 
 planes which are not on the availability list. Conversely, any plane which 
 is on the availability list must not be included in the function. 
 
 (2) The final plane P may be on the availability list. It is not a requirement. 
 Likewise, the Boolean function may include P. Because the transferring of 
 
 a given result into plane P is a post-morten operation, plane P may first 
 participate in the description of a function and then, after the function 
 has been evaluated, be replaced by the result obtained from evaluating 
 the function. 
 
 (3) The number of intermediate planes required in the availability list depends 
 on the complexity of the function. For the stack example given, three 
 intermediate planes are required. In any event, the number of planes on 
 the availability list must be adequate for evaluating the given function; 
 otherwise, chaos will result, 
 
 (h) The auxiliary information must be ordered in the fast memory in a manner 
 corresponding to the symbol string order of the canonical form of the 
 function. (it should again be noted that it is possible to predict the 
 (n+1) format type from format (n), and this is precisely what is done by 
 "BOOLE" control). 
 
 -20- 
 
6. EXAMPLES WHICH ILLUSTRATE THE CODING 
 AND EXECUTION OF INSTRUCTION "BOOLE" 
 
 6.1 Purely Horizontal Logic 
 
 Consider the function 
 
 P6 = -i(-n(l0)&(l2)&(l6)| (20))| (3M&(38) 
 
 In the canonical form it is written (where 'F' is the name of the Boolean 
 function) 
 
 P: [-n(l0)Ml2)&(l6)];[20]|-i;[(3M&(38)]| ;6. 
 The code for this string is (Figure 8): 
 
 a 6 Y ADDR 
 
 
 
 D 
 
 
 
 : 
 
 oo 
 
 El 
 
 11110 00 
 
 E3 
 
 10 
 
 
 
 : 
 
 : 
 
 i 
 
 l 
 
 011 
 
 
 
 
 
 o o 
 
 
 
 11110 
 
 0P(0) 0P{-; 
 
 C(0) C(l) 
 
 
 
 10 10 1 
 
 — sr^ 
 
 TRUE 
 
 =TE 
 
 
 
 
 
 
 
 : 
 
 l 
 
 o[o|o 
 
 1 
 
 
 
 
 
 [— I(l0)&(l2)&(l6)j 
 
 COMPLEMENTED 
 
 
 
 E 
 
 E 
 
 [20] 
 
 ofo] [(3M&(38)] 
 
 ;6 
 
 Note: = Either '0' or '1 
 
 Figure 8 Code for Horizontal Logic Example 
 -21- 
 
It should "be noted that, in the encoding of an elementary function, the 
 elementary cannot be followed directly "by a ( ; ) . A total of twelve bytes 
 of auxiliary information is required for describing this function. 
 
 6.2 Purely Vertical Logic 
 
 Consider the example 
 
 P5 = (20)&(30) | — 1(60) 
 
 In the canonical form, it is written (where ' F 1 is the name of the Boolean 
 function ) 
 
 F:[(20)i(30)];[-!(60)]|;5. 
 
 The code for this string is (Figure 9): 
 
 corresponding 
 part of string: 
 
 [(20)&(30)] 
 
 a 6 y ADI)R 
 
 
 
 B [ 
 
 1 1 j 
 
 liiooooolol [o 0000000 
 J v L. ! v 1 
 
 TRUE 
 
 COMPLEMENTED 
 
 
 
 
 
 
 
 E 
 
 
 
 
 
 13 
 
 Oil 
 
 v— Z- — > 
 
 [-•(60)] 
 
 ;5. 
 
 0P(0) J. 0P(1) I 
 C(0) C(l) 
 
 Note: = Either '0' or '!' 
 
 Figure 9 Code for Vertical Logic Example 
 
 -22- 
 
6 . 3 General Three-Dimensional Logic 
 Consider the function 
 
 P7 = — »( — i(U0)&— 1(50)&-|(60) | (liU)'h(U5)) 
 A canonical equivalent is (where 'F' is the name of the Boolean function) 
 
 F: NU0)& -i(50)&-i (60)] ; [( UU ) |-|(1*5 ) ] h; 7- 
 
 The code for this canonical form is (Figure 10): 
 
 a 6 Y ADDB 
 
 
 
 1 
 
 
 
 1 
 
 : 
 
 1 
 
 . 
 
 
 
 I 
 
 
 
 : 
 
 
 
 oo 
 
 
 
 
 
 11 
 
 
 
 " 
 
 1 
 
 1 c 
 
 ) 
 
 
 
 
 
 I 
 
 \ 
 
 \ . 
 
 
 
 
 p( 
 
 o) 
 
 
 
 H 
 
 PI 
 
 1) 
 
 
 c(o) c(i) 
 
 0' 
 
 
 
 \T~ 
 
 TRUE 
 
 j\_ 
 
 
 
 corresponding 
 part of string: 
 
 
 
 [-i(i+0)&-i(50)&-i(60)] 
 
 v 
 
 COMPLEMENTED 
 
 
 
 
 
 
 
 
 
 oo [(W)|-^5)] 
 
 7- 
 
 Note: = Either '0' or '!' 
 
 Figure 10 Code for Example of General Three-Dimensional 
 
 Logic Having Both Horizontal and Vertical Components 
 
 -23-