I'll post the design a little at a time because of post length limits.


Everything in this file is licensed open-source GNU GPL 2+. Its AI designs and things that can be used as AI designs or have other uses. The non-computer uses of those things are not restricted by licenses.

This could possibly be an AI algorithm for exponential intelligence (arbitrarily high IQ of generated AI softwares?). I don't know. My Audivolv software is completely compatible with this because this only constricts the design (choices I had left open, just in case) and does not require any of the design be changed. I will take some years (dont know how many) to build the designs in Audivolv I've already written about, to build a framework for AIs that build AIs and music softwares etc, then build this new AI algorithm on top of that framework. Then we will see if its exponential intelligence or if it only becomes very intelligent. It will always be a musical instrument you play with the mouse, and it will get smarter to play better music, and later may do other things too.



Future versions of Audivolv will not have the good/bad training buttons and will use the realtime "permutation compiler" for instant partial evaluation (or partial compiling you might call it?) of new strings of Java code (only the subset of Java that Audivolv can create). The good/bad training buttons will be replaced by Audivolv predicting if you like it or not based on Audivolvs ability to predict your mouse movements more time ahead. My theory of psychology is that if you like the music you are playing, your mouse movements will be more predictable than if you do not like it. After that, add the connectionist AI evolution and evolution and use it to build AIs that build AIs and music softwares. After that, add what I created as the "USA Quantum Law Challenge" and an economy simulation as an AI algorithm on top of the Audivolv framework, which will be a framework for AIs that build AIs and music softwares, in the same code and data format so they are all compatible. The data format is called "node" below, and the code format is the audivolv.Func interface, and the audivolv.CodeTree interface which is an audivolv.Func. After that is working, do musical psychology tests and interactions with the people playing music with their mouse. Then add internet code to create the first open-source global AI network. Its too early to say, but this algorithm which started as the "USA Quantum Law Challenge" may lead me to a little more knowledge about Friendly-AI theory. I don't know.



I wrote a thread called "USA Quantum Law Challenge" at James Randi's forum: randi.org

It started as an idea for something to do in the Earth economy to increase the consistency and logicalness of many things at exponential speed and for only a few thousand dollars of money to start the process (then others would see a reason to donate the rest, donating more at each step and somebody else winning that by answering an even-or-odd question thats 2 times as hard as the last 1, which you could call a binary-search through a "quantum" intepretation of vague things on Earth to cause them to stop being vague then prove even or odd to make them completely specific, which you could call "collapsing the wavefunction", but its not physics. Its similar to physics.).

After I finished designing it, except for the social problems of how to get people to donate money into this system or think it will work, I realized I had created an artificial intelligence (AI) algorithm that can work with an economy simulation and a population of many AIs that creates AIs, pairing the ideas of "AI" and "person", and pairing "economy simulation" with "Earth economy", and pairing "charity" with "money account in the simulated economy", and pairing "even-or-odd questions about pencils or laws or whatever" with "even-or-odd questions about the math of the generated AI softwares".

===I wrote the following closer to the end of the randi.org thread, after I realized its also an AI algorithm===

I think this "USA Quantum Law Challenge", where people would donate and win money for even-and-odd questions of increasing difficulty, would work to improve many things on Earth, but there is too much uncertainty on Earth to predict it after it starts improving things at exponential speed, which it could do in theory.

For example, one of the harder money prizes could be won by proving that there are an odd (or even) quantity of pencils in USA, which could only be proven if there was enough consistency in pencil-related things to allow the pencils to be proven odd, or even.

I thought of a much better use for it: an artificial-intelligence (AI) algorithm, with a simulated economy between the various generated artificial-intelligence softwares, doing this same thing but counting things inside the AI softwares instead of pencils or laws. For example, one generated AI software may offer 5000 money units in the simulated economy, for answering even-or-odd quantity of the number 5 in all the other generated AI softwares in total. Because the other generated AI softwares probably are not consistently designed well enough to know how many of the number 5 is in them, without me writing code specificly to count that (its cheating if I help the AIs), the only way the generated AI softwares would be able to prove that the total quantity of 5s is even or odd would be to become more consistent and predictable, which leads to more intelligence as more kinds of things become cheaper and easier to predict, as more offers and questions are made and won as even-or-odd.

I don't know, but I think this, if combined with my existing AI designs that I have written but not coded, could possibly be an algorithm for exponential intelligence, like arbitrarily high IQ in the generated AI softwares, but I don't know. I'll have to build AI for some more years and see how this works.

I've generalized the "USA Quantum Law Challenge" so much that its an AI algorithm, and like my other work, it is licensed open-source GNU GPL 2+ if done in software instead of in Earth's economy.


===START: I wrote the following earlier in the randi.org thread, a summary of the "USA Quantum Law Challenge"===

It would be a series of charities, all called "USA Quantum Law Challenge". Basically each charity challenges anyone to count (even or odd) certain categories of laws or other things, and they win a money prize for proving that quantity is even or odd, and the indirect effects of that are important to the future of Earth.

Please read the informal plan for it at this URL, and/or read the summary below:

http://forums.randi.o...
(In the "Politics" section, thread title: "USA Quantum Law Challenge")


=============
===PURPOSE===

The purpose is to indirectly cause the USA government to become more self-consistent, logical, and efficient. Indirect effects of that would probably include the USA government saving trillions of dollars per year, less people going to jail for breaking laws that contradict other laws, more logical thinking about when to use nuclear weapons and other dangerous things, and generally better government. Because of USA's unique relationship with many other countries, these improvements would flow to most other parts of Earth too. Theoretically it could indirectly and gradually solve many of Earth's biggest problems.


==============================
===WHAT DOES THE NAME MEAN?===

The name includes the word "quantum", but no quantum math is necessary for it to work. Some of the ideas of quantum physics are very similar to the ideas that make the "USA Quantum Law Challenge" work, so its more of a description than a theory of physics.

http://en.wikipedia.o...

A quantum qubit for each category of "law" I will define. In a small way, it may be related to one of my theories about quantum physics and multiverses (read about it at that forum page), but its not necessary. There are simple logical reasons this will work. Most of those reasons are described at that forum page, but I will summarize below.

That forum is at the "James Randi Educational Foundation". James Randi created the "$1 Million Paranormal Challenge". Because of the similarity of how I am designing the "USA Quantum Law Challenge", I named it similarly. It does not challenge any laws. It only counts them and answers "even" or "odd" for that quantity.


=======================
===HOW DOES IT WORK?===

I will unambiguously (mostly in the style of lambda programming, with a few english words) define some categories of things. Those things may be laws, similar to laws, or anything else, but I will start with things most people would call a "law". I will avoid vague words like "law" because it would certainly lead to arguments over what counts as a law. It must be unambiguous.

For each category, the Lifeboat Foundation should add 1 charity account, where anyone can donate money. The money stays there until it is won by someone. That person wins all that money. Then, that same charity can be refilled and can be won again the same way, but only after the quantity of that category changes.

Each category has 1 question and 1 money prize (the charity). The question is always the following:

"Choose any arbitrary time in the future. Is the integer quantity of things in the category an odd number? Or is it an even number? Answer even or odd but not both, and prove it to the standards of published peer-reviewed science, and after 3 months, if the peer-review process proves no flaws in your proof, you receive the money prize."

A quantum physicist would say it this way: You won the money by observing the evenness or oddness to collapse the wavefunction, and it may not have been even or odd until you proved it. It may have been in superposition of simultaneous evenness and oddness.

My theory is that the USA government is so disorganized and confused about what itself is doing and thinking and planning that it would be very hard for it to count (and prove even or odd) most categories that we would define.

Other people could add categories later, but I will propose a few to start with. For each category, the first time it is won, and the money received by the winner, a new category should be created that is 2 times as hard to count (and prove even or odd). People may choose to donate to the old or new categories. As harder categories continue to be counted, confidence is gained in the "USA Quantum Law Challenge" as a working system, and more money will be donated and won, and more things counted and proven even or odd. The "purpose" I wrote above would eventually be accomplished that way.

================================================== ======
===These are the categories I recommend we start with===

USA Quantum Law Challenge - General funds can go to any category Lifeboat thinks is best.

USA Quantum Law Challenge - Quantity of letters in USA's Constitution. This one is very easy because the first one has to be easy to get it started. The harder it is, the bigger the money prize will probably become before somebody wins it.

USA Quantum Law Challenge - Even-or-odd-Quantity of federal laws

USA Quantum Law Challenge - Even-or-odd-Quantity of letters in all federal laws.

USA Quantum Law Challenge - Even-or-odd-Quantity of state laws, all states combined, including DC.

USA Quantum Law Challenge - Even-or-odd-Quantity of letters in all state laws, all states combined, including DC.

USA Quantum Law Challenge - Even-or-odd-Quantity of laws the president of USA must obey (no immunity).

USA Quantum Law Challenge - Even-or-odd-Quantity of laws Congress must obey (no immunity).

USA Quantum Law Challenge - Even-or-odd-Quantity of video-cameras in "Area 51".

USA Quantum Law Challenge - Even-or-odd-Quantity of video-cameras in the Whitehouse.

USA Quantum Law Challenge - Even-or-odd-Quantity of video-cameras in the Pentagon.

USA Quantum Law Challenge - Even-or-odd-Quantity of letters in the president of USA's police record.

USA Quantum Law Challenge - Even-or-odd-Quantity of government employees.

USA Quantum Law Challenge - Even-or-odd-Quantity of government employees that have ever been found guilty of a violent crime.


============================
===About those categories===

For all of those categories, prove the quantity is even or odd, and you win the prize. It is not possible for this to be a danger to "national security", even if it counts secret laws or secret things, because only "even" or "odd" has to be proven, and that can sometimes be done in math without proving the actual quantity. I do not know how to prove these things without knowing the quantity, but I do not know it can not be done either. Only requiring "even" or "odd" is an untouchable defense against "national security" accusations. I am not asking anyone to violate "national security", but it would be none of my business if they caused something to be declassified and to stop being "national security" and then counted it and said "even" or "odd". It has to be proven up to the standards of published peer-reviewed science (and the 3 month delay), but there are no limits on how to prove it other than that.

I'll give an example: If you prove that the quantity of laws the president of USA has to obey (no immunity) is an odd number, then indirectly he would have to obey laws more often. You can quantum-observe that into reality just by proving even or odd.

===END: I wrote the following earlier in the randi.org thread, a summary of the "USA Quantum Law Challenge"===

Similarly, you could cause more consistency in pencil-related things by paying a large amount of money to anyone who could prove there is an odd (or even) quantity of pencils in USA. Theres no other way to know if its even or odd. It would have to become more consistent.

Those categories need to be rewritten in a completely unambiguous way, like in the style of lambda, with as few english words a possible.

===Below, I will copy some of Audivolv's most important design summaries that this AI algorithm would be built on top of===

IN EXTREMELY TECHNICAL WORDS, MY LONG-TERM THEORETICAL GOAL FOR EACH AUDIVOLV PER COMPUTER: efficiently unify connectionist AI (the obs[] part of a audivolv.Func) (any recursive permutations of linear and exponential types) with evolution (the obs[] part of a audivolv.Func) and hypercube vector fields (the flos[] part of a audivolv.Func or any flo numbers recursively in permutations of linear and exponential connectionist array networks), represented in the same code and provably-predictable data format (arrays of arrays of arrays... allowing cycles and leaf nodes like audivolv.Func or numbers in hypercube range, with other constraints), code-string-firewalled for safety, so generated AI softwares can use other generated AI softwares as tools, starting from a few example AIs like bayesian (a type of exponential connectionist AI) and evolution, to play better mouse-music (a hypercube vector field that includes 1 dimension for each speaker and mouse x and y position).


THEORETICALLY: THIS PART COULD BE DONE ON 1 COMPUTER OR A GLOBAL AI NETWORK:
To an AI, mouse-music would look like an AI changing the data described above. To a person, mouse-music would sound like theres a person on the other end of the mouse helping with the music. A common language between people and AI, to use AI as a person emulator and people as an AI emulator. Its much easier to do both of those things together than only 1. Audivolv's long name is in quotes: "Audivolv - where Instruments Play The Musicians" and Musicians Play The Instruments, a theory of recursive intelligence, where Human thoughts and AI thoughts could be used interchangably in the same recursion, using mouse-music as "Human interface code" instead of normal "Human interface code" like windows, text, buttons, and menus. I know brains run much slower and more parallel than computers. There can be many speeds of recursion, some allowing more time to think at each step, some slow enough to flow across a global AI network, and others fast enough to process realtime audio. Recursive intelligence can be slow or fast, blurry or specific, and any combination of those, in theory.

Node

Node (Java type Object[]).

A Node is a constant-size ob array which contains certain types of arrays (depending on index in the Node) and whose sizes depend on other array sizes in the same array in terms of EQUAL, MULTIPLY, or POWER functions.

ArrayAlign

How evolved code will iterate over combinations of arraysThere are 5 main functions that array size can depend on:
* is multiply function. ArrayAlign_Multiply.
range is a function that gives a minimum and maximum size, which are equal for constant size. ArrayAlign_ConstantRange.
^ is power function. ArrayAlign_Power.
Each calculates required array size based on the sizes of 2 other specific arrays,
usually in the same node.
There is also ArrayAlign_PermutationCycle and ArrayAlign_Equal.

For example, a bayesian node's floating point array's size is 2^childArraySize,
and childArraySize may have a maximum of 7 to avoid a large floating point array.
It will not be possible to evolve nodes whose total array sizes can ever exceed
some user-definable limit, like 10000.

s means size of array.
i means current index during iterating.
xi*ys means ys quantity of xi. It does not mean xi quantity of ys.
(xs*ys)i means the current index of an iteration from 0 to xs*ys-1.
x --> y means x contains all information in y, but may not work as y --> x.

xs
ys
xi --> xs
yi --> ys
xs^ys --> xs
xs^ys --> ys
xs*ys --> xs
xs*ys --> ys
xi*ys --> xs^ys
(xs^ys)i --> xi*ys
xi*ys --> (xs^ys)i
(xs*ys)i --> xi
(xs*ys)i --> yi
(xs*ys)i --> xs*ys
yi*(xi*ys) --> (xs^ys)i
yi*(xi*ys) --> (xs*ys)i
yi*(xs^ys)i --> ys*(xs^ys)i
yi*(xs^ys)i --> yi*(xi*ys)
This is a description of a branch of math. Following this path, there must be things much more effective than bayesian-networks that can be written in a few lines. The most complex part of a bayesian-network is yi*(xs^ys)i

A bayesian-node's arrays would include an array containing BAYESFALSE and BAYESTRUE, size xs = 2,
Object array of child-bayesian-nodes, size ys, and floating point array of bayesian-weights,
size xs^ys, and floating point array of sums of weights for each child
(1 floating point for BAYESFALSE and one for BAYESTRUE, for each child), size xs*ys.
The function that processes a bayesian node would obey the iteration order defined by yi*(xs^ys)i,
or ys*(xs^ys)i would also work if you wanted to use ys quantity of floating points at a time.
yi*(xs^ys)i lets you use a constant quantity of floating points each iteration,
that does not depend on quantity of bayesian node childs. Variations of these iteration orders,
array sizes, types of arrays, etc will evolve, but for now I'm hard-coding a few of the
best artificial intelligence algorithms in a way that can evolve. I'm writing them
as data instead of algorithms. Javassist can optimize these long chains of logic
into a single Java class while Audivolv runs.

All evolved code implements this Java-interface which is simply an efficient way to write code at the stack level. The 4 parameters of the run function are used as a stack.
Example: Java code goes in a JCodeTree, a type of Func.
There may be a few more functions, but they will be for optimization, not for changing behaviors.

public interface Func{
public void run(double flos[], int f, Object obs[], int o) throws Exception;
public int flos(); //floating-point stack frame size. Never changes for the same Func. Start at flos[f].
public int obs(); //object stack frame size. Never changes for the same Func. Start at obs[o].
public boolean stateless(); //True if the run function is stateless
}

A recursive call into a child Func c would be c.run(flos, f+flos(), obs, o+obs()),
but to avoid slowness and infinite-loops caused by the Halting-Problem
(the logical impossibility of knowing if every program will halt or not),
evolved code will have a customizable maximum recursion depth (Example: depth 5).
One whole call tree has to finish before the next audio sample is needed 1/44100
of a second later. Letting evolved code choose to finish next week is simply not an option.
It IS an option to let evolved code save its work and continue later.


It will evolve Turing-Complete code. Recursion is a convenience,
not necessary for Turing-Complete. One call of a Func is not Turing-Complete,
but many calls on the same data, each time changing that data, is Turing-Complete.
The evolved code is stateless so that is easy.

Interaction with connectionist artificial intelligence algorithms
(like neural network or bayesian network) will be done on the obs[] stack.
Code that only plays sound will usually use the more efficient flos[] stack.
Most evolved flos (Java's 64-bit floating point type) will provably
stay in range -1 to 1, except for roundoff-error. If roundoff-error becomes a problem,
it can be completely avoided with Java's strictfp math type but that is much slower.

In Audivolv version 0.1.6, real audio evolution occurs
using only flos[] (not obs[]) and flos()==25.
f2, f3, and f4 mean the same as flos[f+2], flos[f+3], and flos[f+4],
which you can see in evolved Java code it saves on the hard-drive.

In that specific code, f2 is red, f3 is green, and f4 is blue, and f0 and f1 are
the left and right speaker amplitudes which change 44100 times per second for 44.1 khz
audio that reacts to mouse movements (not prerecorded).

Func is the core of Audivolv, and its just a Java-interface. It contains no code, only function names and parameter/return types. Its extremely flexible.

Type into Audivolv window{
green = green*.9999 + .0001*(-mousex);
double yellow = (red + green)/2;
left = Math.sin(yellow*5000);
}

First substitution{
f3 = f3*.9999 + .0001*(-f7);
double yellow = (f2 + f3)/2;
f0 = Math.sin(yellow*5000);
}

"void run(double flos[], int f, Object obs[], int o){
flos[f+3] = flos[f+3]*.9999 + .0001*(-flos[f+7]);
double yellow = (flos[f+2] + flos[f+3])/2;
flos[f] = Math.sin(yellow*5000);
//Recursion would run(flos, f+25, obs, o+5)
}"

SoundCard.play(Javassist compile "void run(d...");





Some of the CodeTree designs below are a little old, but not much different. Its still a Func and runs the Java code that way.
CodeTree is an easy way to permutate and var-rename and modify Java code without breaking it and be able to run that Java code in the same CodeTree object. The function names for renaming and describing vars will change, and the way descriptions (like RLRRRL) are defined may change. At this point, I'm only using them to know if single vars are Lvalue or Rvalue, so they are more flexible than I am using.


CodeTree

CodeTree is a type of Func which also has a string of code.
Optionally it can have multiple child CodeTree that are substrings of its code.

String of code in each CodeTree is immutable.
Its evolved score and links are in an EvolveData<CodeTree>. That data is mutable.

String code()
List childs()

List floVars(String regexDescriptionMatcher)
String describeFloVar(String floVarName)

Code:
temp = x;
x = x*3 + Math.sin(x);
y = x + .2;
x = temp;
Description of x: RLRRRL
Description of y: L
Description may change in later versions of Audivolv.

CodeTree floVarRename(String oldFloVarName, String newFloVarName)



ArrayAlign_ConstantRange

In a Node, an array size can be defined as in some constant range: a minimum and maximum int size.



ArrayAlign_Equal

In a Node, an array size can be defined as equal to some other array's size in the same Node.
Example: In a neural-net, each Node has an array of child Node and an array of flo weight the same size. There is 1 flo for each child.


Audivolv - ArrayAlign_Multiply

In a Node, an array size can be defined as the multiply of the sizes of 2 arrays in the same Node.
Example: If a Node has a flo array size 3 and an ob array size 14, then it could also have a Func array size 42 (3 multiply 14). When iterating over the array size 42, it is probable that an iteration over the other 2 arrays would be attached to the same loop, and they would be iterated together. For example, index 29 in the bigger array would align to index 2 in the size 14 array and simultaneously align to index 1 in the size 3 array, because 29 = 2*14+1.


ArrayAlign_Power

In a Node, an array size can be defined as x power y, where x and y are the sizes of 2 arrays in the same Node.

Example: In a bayesian-network, each Node has an ob array (each ob is a bayesian-Node) size y.
y is the list of child Nodes and also includes the parent.
The Node also has a flo array size 2 power y where all flos sum to 1.

There is no reason you can not create a variation of bayesian Node where its 5 power y,
or a variation where theres more than 1 list of childs and weights an of different types.
Node types will evolve.



ArrayAlign_PermutationCycle

ArrayAlign_PermutationCycle ( quantityOfIntArrays=X, sizeOfEachIntArray=Y ) {
An alignment of arrays in a Node.
The strangest type of array aligning. It only works on int arrays and it makes requirements on the ints in them.
It is only useful in combinations with other arrays.
There are X int arrays, each size Y, each containing ints range 0 to Y-1.
Each int value is index in the next array.
Cycles are always size X.
There are always Y cycles.
Example, where X is 2 and Y is 5: B=[2, 0, 4, 3, 1] and C=[1, 4, 0, 3, 2].
In B, index 2 has value 4, and in C, index 4 has value 2.
If X was 3, then B would point at C would point at D would point at B. B and C would not point at eachother.
The most common sizes of X are 1 and 2.
If X is 1, it simply counts up from 0, which is useful for describing math but usually not useful for efficiently running it.
If X is 2, it can be used to define reorderings of many arrays the same size without reordering them all. Instead reorder only 1 of the 2 int arrays.
}

HeapQueue

HeapQueue{
Normally goes in a Node as 3 arrays (int[], int[], and flo[]), often permutation-aligned to more arrays in the same Node.
int arrays: hqForward and hqBackward = ArrayAlign_PermutationCycle ( quantityOfIntArrays=2, sizeOfEachIntArray=Y ) ;
hqWeight = flo array size Y, aligned to hqBackward.
hqIdeaOfSorted = For every nonzero index x in hqForward, hqWeight[hqForward[round down x/2]] >= hqWeight[hqForward[x]].
TODO Choose between consistent design (all 3 arrays are the same size) and efficiency (1 of the arrays does not use index 0).
The 2 childs of index x are 2*x and 2*x+1, unless those are past the end of the array.
The only exception is the 2 childs of index 0 are 0 and 1. 0 is its own parent and child, for efficiency.
hqBackward[] and hqWeight[] are aligned to eachother and often other arrays in the same Node.
When any flo in hqWeight changes{
Approximately log(sizeOfEachIntArray)/2 quantity of ints in hqForward and hqBackward change.
Because hqForward and hqBackward point at eachother, they always change 4 at a time, swapping 2 pairs of int.
It changes to make hqIdeaOfSorted be true again. It runs recursively from the one that changed to its parent or a child.
}
Example{
Iterate over 1000000 Nodes in a neural-network, where activation-level of each Node is in a shared HeapQueue,
and for each Node, if it fires, update activation-level of all its child Nodes in the shared HeapQueue.
Each iteration starts with the Node index hqForward[0], the Node with highest activation-level.
Because that Node fires, its activation-level decreases, and hqForward[some other index] points at it instead.
}
}


flo

flo is Java's 64-bit floating point number type. In Java, it is written as double.

int

32-bit standard twos-complement integer.

ob

ob (Java type Object).
objects can be anything, but are most commonly arrays: flo[], ob[], Func[], or int[].


Low-level things should be Neat (100% predictable):
+ Testing.
+ Whitespace in strings of code.
+ Behaviors of compiled code, except speed.

High-level things should be Scruffy (IF it works, do it. Take chances if you're "feeling lucky".):
+ Speed of compiled code.
+ Evolving Java code.
+ Graphics.
+ Interaction with the user.
+ Strategy of keeping sound-card buffer just empty enough to not skip sound.

Brainwaves are easy to understand. Close your eyes, center your mind, and wait until light and dark blurry things flow across what you "see" at a rate of 2-6 per second. Those are brainwaves echoing across the visual part of your brain, and you can shape them into what your eyes see or dreams. I can build those in software.


Soon, mind-reading helmets will be sold for video-games. They do not work well, but in the next 10 years, they will become a common device on every computer.

Audivolv is theoretically compatible with most devices because it uses everything as multiple numbers between -1 and 1 that change quickly.
For speakers and microphone, those numbers are directly audio amplitudes that define the sound.
For mouse and game controllers, it is position of each axis, like mouse X and Y positions.
For mind-reading-helmets, it could be electricity amounts on the skin on your head, or other interpretations.
There are many ways to connect many devices, all as multiple numbers ranging -1 to 1.

A mind-reading helmet would be used the same way as Audivolv uses mouse movements X and Y, color R G and B, and speaker amplitudes LEFT and RIGHT. Thats 7 dimensions (X Y R G B LEFT RIGHT) that are used the same way. It works the same way for any number of dimensions. It learns them together. If such mind-reading-helmet gives raw electricity data from 10 places it touches the skin of your head, Audivolv would learn to interpret that as Human psychology (no need for other software to interpret the mind-reading-helmet) by adding those as 10 more dimensions to the existing 7 dimensions. Audivolv 0.1.6 uses 25 dimensions, but that can be changed simply by typing a different number of dimension in a few places. Add 10 more and you get 35 dimensions, which would still run fast.

Use Audivolv with mouse and speakers only, or wear a mind-reading helmet to take it to the next level and dream with AI (in later versions of Audivolv).

This AI design is licensed open-source GNU GPL 2+ and is copyright to Ben F Rayfield. When its built, it will be a musical instrument you play with the mouse that learns how you want it to sound, and an AI that learns to build smarter AI, a recursively-self-improving AI. I need to learn more about Friendly-AI before I build it.

===END AGI DESIGN==

Wow. OK. So, please, if you would, write a one paragraph explanation in plain, everyday grocery store english, of WHY you want to solve this even/odd prediction "problem".

All of my rhetoric alarms went off at once. I am fearful that you have a punch line and like it so much that you are wanting to produce a joke, to fit. Work backwards from the end state you hope for. Show your rhetoric, your desires, your pre-suppositions. Define your utopia and work backwards to your contest and software. This will expose and illuminate the reasons behind your work.

Randall Reetz

I'm not joking. This 30 kilobytes of text summarizes the first AGI design.

There are 2 main sections:

(1) The Audivolv designs I knew about last month, which include logical steps leading up to AI that can try to create more AI, but the AI it creates would probably be stupid or random because it lacks direction in its thoughts. All AIs in Audivolv will be defined in the same consistent code and data format si they can try to use eachother as tools. This is a framework to build AI and music softwares on. When this framework is built, specific AIs like bayesian networks, neural networks, evolution, and anything else you find in Wikipedia's AI section, will be able to be written in this framework and be evolved/used/designed together automatically.

(2) The part I created by accident recently. This is the part you are probably asking about: the "USA Quantum Law Challenge", or "even/odd prediction". Its purpose is more general than USA or laws. Its designed as a general system that operates in an economy to exponentially increase the consistency, logicalness, and efficiency of any system which lacks those things. Examples of systems that lack those things are "the USA government" and "specific AIs like bayesian networks, neural networks, evolution, and anything else you find in Wikipedia's AI section" as written in (1). I created it for the real economy then realized I could use it as an AI algorithm to give my AI a direction of thinking for it to design new AI code and data better.

By solving "even/odd prediction" (which has to be proven, not just predicted), each proof of an even-odd-question creates 1 more way that something is consistent. As a system becomes consistent in x quantity of ways, where those x ways are not similar to eachother, the total consistency of the system gets exponentially consistent: an exponential function of x. If written about the real economy, you would write "an exponential interest rate that starts low and ends exponentially high". If written about AI, you would say "exponentially high IQ or recursively-self-improving AI". This is all a theory, and I need to think about it and test it before saying for sure.


I'll write the sequence of thoughts that led me to this:
* the AI meetup group watched a movie, and me and Randall Reetz got into a debate.
* That debate continued in another thread on this forum, where I coined-the-phrase nihilistpanpsychism.
* The theory of nihilistpanpsychism is about physics and consciousness.
* I started reading more about quantum physics and multiverse theory on Wikipedia.
* When I started taking the theory of nihilistpanpsychism seriously, many ideas started aligning in my head that most people would say are unrelated. I started to have even more unusual theories about why things happened.
* Someone on KurzweilAI.net forum was talking about space-tethers and other technology, and I quickly responded that its extremely unlikely any species, that can not count its own population or its number of laws in any specific country, would be able to design and build a space-tether.
* I created a thread on KurzweilAI.net messageboard proposing a law that says taxes should increase when the president of USA can prove the quantity of laws is an even or odd number, and taxes should decrease if he can not.
* I went to James Randi's forum and created a thread called "USA Quantum Law Challenge" to expand on that idea.
* After figuring out more things about the "USA Quantum Law Challenge", I realized it is a general system and can work for a real economy or a simulated economy between AIs to make AIs more consistent too.
* I added a variation of the "USA Quantum Law Challenge" to my AI design, which upgraded it to an AGI design. It was the missing piece. No physics required. Its similar to physics.