Fractal Logic 

Consider a pair of binary operations F_{0}(x,y) and F_{1}(x,y), each constructed from two lower level binary operations using feedback as shown below: 





The symbol _{} denotes the "past value" of F contained in the feedback loop. Now suppose each of the four lowerlevel operations is similarly constructed from two operations on a still lower level, and so on, recursively. The general expression by which an operation at one level is expressed in terms of operations at the next lower level is 

_{} 

where the subscript *i signifies any binary string of zeros and ones (the same for each appearance in the expression) followed by the index i, and the index _{} denotes the 2's complement of i. Every recursive expression is applicable with each subscript in the expression prefaced by the string *, so hereafter we will omit this preface. Also, instead of writing the expressions with the generic complementary subscripts i and _{}, we will use 0 and 1, with the understanding that each expression remains valid under exchange of these two symbols. Hence the above expression will be written as 

_{} 

For example, if the lower level functions ending with the subscript 1 are logical ORs, and those ending with the subscript 0 are logical ANDs, the top level operations written in Boolean notation are 

_{} 

Returning to the general case, we can use the recursive formula to express any operation in terms of operations two levels down as follows 

_{} 

By construction, the "past values" of successive levels are linked by the relations 

_{} 

Consequently we can replace the past value of F_{01} with the past value of F_{0}, and the preceding expression can be written as 

_{} 

To illustrate, let us again define the lowestlevel operations as simple logical functions. This time we define the 3rdlevel functions whose subscripts end in 0 as logical ORs, and those whose subscripts end in 1 as logical ANDs. (This is the reverse of how we defined the 2ndlevel gates in the previous example.) In Boolean notation the top level operations then reduce to 

_{} 

These are the very same logical operations that we found when we assumed the recursion went only to the 2nd level and imposed logical definitions on the secondlevel operations. Obviously if we proceed to the next level, and define the 4thlevel functions as we did in the 2ndlevel example, we will arrive again at the very same logical operations. In fact, we can define the top level events recursively down to any arbitrary level, and impose the logical function definitions on the operations at that level (transposing OR and AND depending on whether the level is odd or even), and the result will be the same two toplevel operations. (Of course, if we don't transpose AND/OR on successive levels, the two toplevel operations are themselves transposed for successive levels.) This is reminiscent of the story about mythological belief that the world is carried on the back of a turtle, and when the believer is asked what the turtle is standing on, he says "another turtle", and "it's turtles all the way down". It also reminds me of how the rest mass of a particle can be regarded as consisting of the rest mass of a smaller set of subparticles with a large amount of kinetic energy to give them a greater effective "relativistic mass". And then the rest mass of the smaller particles can likewise be regarded as mainly kinetic energy of a set of even smaller particles, and so on. Extending this to a complete infinity would suggest the somewhat puzzling notion that there is no essential rest mass at all, and the entire toplevel rest mass consists of nothing but recursive modes of kinetic energy of... lower lowerlevel modes of energy. 

For what sets of fundamental operators (like AND and OR) do we arrive at a "convergent" toplevel operation? This is certainly not always the case. For example, if we define the lowestlevel operations as NAND and NOR functions, then the toplevel operations based on just the first recurrence are 

_{} 

Going to the next level of recursion, the top functions are 

_{} 

Notice that the feedback loops represent "memory", so in general there is another element of memory for each level of recurrence, and presumably an infinite recurrence would represent infinite memory. 

This type of "fractal" (i.e., selfsimilar) function is not limited to logical operations. For example, it's interesting to consider the result of defining the lowestlevel functions in the above recurrence as MIN and MAX selection operators. Typical results for just the second order recursion level are illustrated below. 


The blue and green lines are the sample input functions and the red line is the toplevel output function. We can also imagine other patterns of nested selfsimilar operations, such as the trinary construction illustrated below. 



For another example of “fractal logic”, consider the three most common "means" of two variables x,y 

_{} 

We can construct another binary "mean" function by combining these three common means as follows 



Let this function be denoted by AGH(x,y). By permuting A, G and H we can construct six such functions, but since the first two components are symmetrical we have only three distinct functions, which we will call AGH, AHG, and GHA. The function z = AGH(x,y) implies that z (if not zero) satisfies the cubic 

_{} 
which, in the special case x = y, factors as 

_{} 

Therefore, if z = AGH(x,x) then either z = x (as one would expect) or else z equals one of the two quadratic roots 

_{} 

If we consider the HGA mean we find z = HGA(x,x) implies that either z equals x or else z equals one of the values 

_{} 

Interestingly, for the third mean, AHG, we find that AHG(x,y) = G(x,y). 

So, given the three original twoinput functions, we have constructed another set of three twoinput functions. These can be combined in the same three distinct ways to produce yet another set of three functions, and so on. At each level (above the lowest) the three functions have precisely the same structure in terms of the three lowerlevel functions. What is the limit of these functions at the nth level as n goes to infinity? 
