Abstract
Look around and you will see an evolution of forms going on. For
billions of years, those shapes are brushed against each other and
against nothing else. Some have managed to be present on this very
day. A hominid body is one example, a common rock's or a star's
shape are another. There are no guarantees however, how long they
will last in this constantly changing world.
What do we get, if we start the same process -- not inside the real
world -- but inside of an artificial world of digital bit strings, carved
into the computer memory?
The general law is the same. More prolific forms will fill the space.
We can manipulate the process by setting the initial conditions and
the law, by which one shape is more resilient to passing time, than
another one.
Critticall is such a humble simulation of a digital world, where
algorithms are created by a random change and where they survive
and evolve according to some simple criteria. Like how few steps
does it takes, or/and how few lines are needed to do the same thing, as
the original one does. Or even how small some variables become.
This way, any code segment is melted and driven through many
generations, till it may not be even recognizable any more. But still
giving exactly the same result, as the initial algorithm. Except it's
faster or with fewer lines.
From an algorithm, a more optimal one is usually evolved. Sometimes
never seen by a human eye before and never imagined by anyone.
Streamlining the architecture of an algorithm, not only it becomes
ever more optimized, it becomes what we consider as a new.
Critticall is a toy AI, with many serious and profound results.
45 characters description
Optimizes algorithms written in a C dialect. |
80 characters description
On the Evolution Algorithm based streamliner for "strict C" code segments.
|
250 characters description
Critticall is a digital environment, where an
input algorithm is a subject to a digital evolution. The fitness may be
the speed or the length of the code. Ever better algorithms are
surviving small random changes and are the output result.
|
450 characters description
Critticall runs Evolution (Genetic) Algorithm
on the program lines themselves. Any well defined code segment in
the "strict C" language, can potentially be significantly improved.
Often to a stage, never seen before. New sorting and compressing
algorithms may, and do come out in the form of a source code, ready
to compile. Even starting with an "empty" algorithm, just with a
desired result specified, a working algorithm can be found.
|
2000 characters description
Critticall is an automated way, to improve, or
even to invent a digital algorithm, or only a small segment of code.
Initially, the desired output for the input must be specified. By giving
the input and a known algorithm, or by specifying: if (input==0)
{output=0;}, if (input==1) {output=1;}, if (input==2) {output=4;}, ...
Critticall will improve this naive algorithm to something like
output=input*input; - eventually! By the default, among several
equivalent algorithms, those with a smaller computational complexity
are favored. Through thousands or millions of generations, faster and
faster algorithms are selected. Usually, the output is everything what
they share with the initial algorithm. There is more. You can specify,
that the number of lines should be minimized, regardless of how fast
the execution is. This may give you a glimpse, on what a complicated
code is in fact doing. Further, you can weight the commands by your
own choice. This is useful to substitute a heavy command with a
string of others. Additionally, you can penalize certain program
variable, instead of commands. This a powerful feature, which
enables a goal directed evolution, to a better and better predictor
program, for example. Everything what is expressible in the Critticall
language (which also expands), can be reshaped and studied with this
toy AI tool, which used properly, causes a havoc among ones
favorites program lines. But doing so, it gives you fast and efficient
practical solutions. With Critticall, you can do things, very much
beyond your algorithms devising power, no matter how high it may
be. Just subject your lines of code to Critticall, and watch what is
happening to them. You can investigate deep and broad among
fundamentals of the computing science.
|
|