Causal Mathematical Logic - Project Plan

February 2013. Last update: May 12, 2013.

This is a proposal for an on-line open-source project for developing causal logic. Modules of work and interfaces among them should be defined. The presence of clearly defined interfaces is what allows modular work with multiple weakly-connected contributors. Below, five core parts are defined. Each one of them can, in turn be divided into many more specialized parts. The general idea is to provide a core of code with minimal features and then release it so interested parties can build their specialized applications around the core.

I expect considerable interest from Neuroscience, General Intelligence, and Computer Science. With time, some interest from Physics and Biology are to be expected, but currently there is little. This project is scientific and we are all volunteers, but the possibility to create a “cash cow” by allowing a startup to develop some commercial products should be left open. Also, working in group, it will be easier to apply for grants in some future. In both cases, we must first show something working. As for me, I wish to remain with the theory.

The first step for any work to be possible is to develop specialized hardware that implements the virtual CML machine in Section 4 of Pissanetzky 2012B. Currently, the machine is implemented on a personal computer, and is too slow for productive work, particularly if other projects depend on it. Super-computation has not been tried yet, but a significant improvement is not expected. The correct way is to produce a stackable unit with, say, 100,000 or 1 million neurons, the size of a USB flash drive or a small electronic board. This unit emulates CML the same way the brain does, but will work much faster, because electronics is much faster than wetware. A quick estimate is as follows: it takes the brain about 0.5 sec to recognize an image on wetware. Assuming that hardware runs 1 million times faster,  it should take in the order of a microsecond for the causal processor to do the same.  These units are inexpensive and stackable, and they are massively parallel, so execution time will not depend on the number of units, although some communication latency should be expected.

This project is currently (Feb 2013) being discussed on Facebook by some members of the group Strong Artificial Intelligence.

Required Reading: see Reasoning with computer code.

A core implementation of causal logic needs 5 parts:
Part 1. Input to causal set.
Part 2. Causal set to least-action permutations.
Part 3. Least-action permutations to block system.
Part 4. Block system to hierarchy.
Part 5. Hierarchy to output.

Working examples are available in SciControls.com under Supporting files, where two cases are illustrated: the European Example in Java, which is complete, and the Point Separation example for input from a camera, which is incomplete. The Euler Equations example has been recently added.

Part 1 should include several modules for different types of input, for example from text files with a format to be established, from a camera, from a program written in some language (Haskell? C++? Java?), manual. As of March 2013, I have a version for text file input, another for C, and another for cameras. All are primitive, but will work as a seed. In all cases, the output is a standard causal set. An example of a causal set is available. Various forms of input should be part of the GUI. Part 1 should also include code for separating the resulting causal set into connected components. I have this code and it works very well, it’s the algorithm on page 104 of SMT.

Part 2, I have seed code for causal sets, but it needs to be adjusted before I release. It is written in C++.

Part 3 needs to be addressed. This is a well-know problem in group theory. I understand that free code is available on-line, but someone needs to choose the best version and make sure it works with the standard interfaces.

Part 4 is open. Once part 3 works, part 4 should be easy, but someone needs to do it.

Part 5 should include at the least visualization and output to files. I always output to files, but have trouble trying to visualize the meaning of the results. Various forms of output should be part of the GUI.

Special hardware is necessary for part 2 to work properly. This hardware is described in Section 4.3 of the required reading. It can be implemented perhaps on an FPGA or a GPGPU. Without it, execution will be slow. There should be an option to extract the causal set in a file and send it to a supercomputer, and then re-enter the output from the supercomputer. But even then there will be limitations.

There should be several modes of operation, such as batch mode, where a job is accepted and executed in full, and learning mode, where an initialization file is kept and the system is allowed to learn indefinitely. Let’s do the batch mode first.