duality

Is it me, or is it you? Is it false, or is it true? Many things can be explained by a bimodal or binary system. Everything, from boolean logic to art, any system whose goal is to make a prediction.

My hypothesis is that whenever someone believes something, the opposite belief is equally valid. In order to demonstrate, let me introduce:

The theory of duality is self deconstructing and self constructing in the same way via self reference. If the opposite stance is valid, that means that not believing in duality is valid, but that also is a data point that confirms our hypothesis.

We're also describing duality using a dual framework here, which is another pretty interesting thought.

Logic is a self affirming structure, and that might give you the clue that it is also self destructing. Nevertheless, one of the axioms of logic is:

This statement filters for binary, or as I would call it, dual mode frameworks, and gets around the principle of explosion. We have an intuitive understanding of truth and falsehood, and we can use those general terms whenever there is a mutually exclusive divide. In short, you can view the logical framework as an abstraction of all other dual frameworks. I propose that you can do analysis on all dual frameworks in much the same way group theory does analysis on groups. Mathematics in general has the same recursive binary structure to it, because it is based on a couple of axioms and utilizes logic as an extrapolation mechanism. By , everything that utilizes mathematics is also an inherently dualistic structure.

Of course, there is logic in programming, but that is kind of boring. What I am going to explain here is a recursive, binary structure known as the binary tree. It seems like you can model a lot of things in this way as well; John Conway's surreal numbers are a manifestation of this phenomenon.

class BinaryTreeNode:
    def __init__(self, value):
        self.left = None
        self.right = None
        self.value = value
    def insert(self, value):
        if value < self.value:
            if self.left is None:
                self.left = BinaryTreeNode(value)
            else:
                self.left.insert(value)
        else:
            if self.right is None:
                self.right = BinaryTreeNode(value)
            else:
                self.right.insert(value)
    def print_node(self, level=1):
        print(f"level {level}: {self.value}")
        if self.left is not None:
            self.left.print_node(level + 1)
        if self.right is not None:
            self.right.print_node(level + 1)
root = BinaryTreeNode(5)
root.insert(3)
root.insert(10)

root.print_node()

level 1: 5
level 2: 3
level 2: 10

Currently, all that this binary tree has is an insert method, but that is all that is needed in order to see the recursion in the structure. Each node "height" is self similar, and it works of a dual-mode sorting algorithm. That is, smaller values go on the left side, and bigger values go on the right side. It is the binary tree model in my view that unites the concept of duality with the concept of recursion. Duality is self similar at every abstraction level, and the duality is crucial for subdividing processing power in order to break a big task into small tasks, which is needed for recursion to be finite.

This is a good question, and one that I've still yet to answer completely. However, I would still like to try my hand at this, because there are things that make the number two specially suited for the task of subdividing.