Awesome.AI Dynamic Thought Mechanics, Original Text

💻 Live Demo: Explore the algorithm in action — See the interactive prototype here. No registration needed, just raw AI dynamics.

INTRODUCTION

AI systems today utilises many different ML algorithms. These algorithms are good at finding patterns in data, yet they lack the dynamics of the thought. This algorithm produces that dynamics.
Imagine a black hole pulling in stars and planets. I have little expertice in General Relativity or Quantum Physics, so I started out using Newtons equations which also produced a dynamics.
There have not yet been a successfull attempt of the dynamics of the mind. This gives us the freedom define the dynamics and physics of the simulation ourself.
Personal experience, led me to believe that thoughts have mass, or index from which we deduce mass, force etc.. Gravity then pulls towards heavy thoughts. We talk daily about heavy thoughts.
Assuming we have capabillities for an infinite number of thoughts, aka UNITS. The system selects an upper bound, which are then available for use in the System.
These ideas has led to a highly autonomous agent, which produces a dynamics, that can be used for controlling other AI systems.

PROJECT VISION

a new approach to AI.
many other applications than ChatGPT.
if accepted this may be a new paradigm in AI (and psychology).

PROJECT MISSION

The end goal is to make an algorithm as smooth and continuous as an actual thought
Maybe the end goal is just to see how far this solution will go.

PROJECT PURPOSE

to have my idea or vision confirmed and the generel setup validated.
share ideas and new approaches to AI.
have new inspirations for the direction of this project.
get advise on how to optimize and better the solution.

MECHANICS

The mechanics are metaphores for the dynamics of the mind. These are some I have found to be working, others may exist.

Mech Noise, Low layer (needs validation):

this was the base mech during the formation of the project. 2 cars connected by a rope or chain, they are going opposite directions and car one is dragging with a constant force, while car two is dragging with a variable force. This produces "noise", centered around 0.0, which is used in later mechs. You might say this is the Heart/Soul/Will of the system.

Mech One, High Layer:

like Mech Noise, 2 cars connected by a rope or chain. Instead of dancing aound 0.0, the system here uses a Sine(time) + Noise from Mech One, to calculate the dynamics. This is used for making and sending promts to ChatGPT.

Mech Two, High Layer:

Here one can imagine a ball balancing on top of a hill. The ball can go down the sides. The hill can be more or less steep. By pushing the ball up the hill, the game is to keep it from falling down the sides. Like Mech One the system uses a Sine(time) + Noise to produce the dynamics, for sending promts to ChatGPT.

Mech Three (only in source):

Here we have a rocket trying to "leave orbit" of a black hole, and we have the momentum and opposing forces. Its only in source, since its a bit tricky because of the numbers being much greater in a setup like this.

The similarities for these mechanics, are that there is a static force dragging one direction and a variable force dragging or pushing the other way. ie. the car with a constant pressure on the the pedal (Mech One) and gravity (Mech Two, Mech Three).

From these mechanics the system gets a momentum, and if the momentum is increasing, the thought goes up and decreasing the thought goes down.

In later versions of the system, one can imagine entire landscapes of hills and valleys (Mech Two).

DATAFLOW BETWEEN LAYERS

The dataflow between the two running mechanics is FeedForward. Meaning that the lower layer (mech noise) is feeding its output (current unit) into the higher layer (mech one or two). Higher layers does not produce a current unit. This makes it a feed forward dataflow between the two layers.

THOUGHTPATTERNS

Higher layers produces thoughtpatterns. These are just versions of a given mech. Like is the Sine going from -1 to 1 (GENERAL), 0 to 1 (GOOD) or -1 to 0 (BAD). This is used to produce the mood of the system.

FRICTION

The static part of mech noise, always has the highest force UNIT, so the system multiplys the force by a static friction (0.666) and the dynamic part by a dynamic friction. Otherwise the static would always win.
In order to calculate the dynamic friction of mech noise, the system uses UNIT credits to find the friction coeficient.
Now it can calculate the actual force for the dynamic part of the mechanics.

UNIT and HUB

In order to continuosly better itself, the system dynamically adds/removes UNITs and adjusts index, which means they now take up some space on the x-axis (UNIT-space). This space can be arbitrarily narrow, and therefore still adds up to an infinite number of UNITs.

the system dynamically updates the index of the UNITs. UNITs are not supposed to be fixed.
the system dynamically adds new UNITs.
the system dynamically removes old UNITs.
A UNIT is a node, which represents a thought. It has index (0.0 to 100.0), data and credit. Data is generated by ChatGpt (used to be static) according to index and HUB subject.
A HUB is used to group UNITs together. It has subject and a list of UNITs. HUBs cannot be removed, but they can have an empty UNIT list.
One can think of HUBs as the context/problems and UNITs as answers/solutions.

FILTERS

the three main filters are:

Direction

this filter just removes UNITs above or below current UNIT.

Credit

this filters task is to make sure not the same UNIT get chosen every time. Credit is continuesly updated. In order for a UNIT to be valid, it must have above 1.0 in credit. Every time a UNIT is "current UNIT" its credit reduces(fast) and is filled up again when not "current UNIT" (slow).
Much like an infinity machine.

LowCut

since the system had a tendency to pick heavy UNITs, I created this filter which sorts out the heaviest UNITs. This can be used to hide certain UNITs. Hidden UNITs are not unconciouss thoughts, but rather possible thoughts that have been lowcutted and therefore currently not available to the system.
The idea of this dynamics was such a thought/UNIT.

ALGORITHM

It is build on the notion: 1000(500) impressions, produces one thought.
The system runs 500 times:
-- runs mechanics + friction
-- runs filters (Direction, LowCut, Credit...)
-- finds current UNIT
After 500 runs, it finds the statistically most occuring UNIT. Which is then considered "the actual thought"

DOWN (deltamomentum)

The meaning of DOWN, is that we say No or Yes to going down.

Down comes in 3 variants:

HARD: a hard YES/NO value, is delta momentum above or below 0.0
FUZZY: a fuzzy VERYYES, YES, MAYBE, NO, VERYNO, based on the value and interval of delta momentum
PERIOD: a series (approx. 100) of HARD downs are saved, and if there are more NO than YES, it returns true and vice versa.

THE HACK AND THE QUANTUM CONNECTION

Since the beginning of the project, I let myself use a "hack", where I flipped a boolean, as I saw fit. This hack has now been removed and replaced by these options.
These only apply to Low Level (Mech Noise).
MyQuantumXOR connects the Awesome.AI agent with another simpler agent.

classical (valid or logic error?):

when delta momentum is below 0.0, go_down is true. The system flips the value (changes direction). This produces the noise.

probability

when delta momentum is below 0.0, go_down is true. Then it uses momentum to calculate a probability for flipping the value (changing direction).

qubit (needs validation):

When delta momentum is below 0.0, go_down is true. The system returns MyQuantumXOR(awesomeagent.go_down, simpleagent.go_down).

MONOLOGUE

Deterministic:

This Mechanism uses static texts. The texts are chosen based on current mood-index and HUB-subject. It plays a "Connect the Dots" Game on the 2 texts. If both are positive or negative, they are combined with "..and.." if different then "..but..", (XNOR). This produces the flow in the monologue.

Fluent:

This mechanism is using ChatGPT, it also plays a game of "Connect The Dots". It has 2 sentences (created by ChatGPT, according to mood-index and HUB-subject) and asks ChatGPT to connect the sentences, this produces the flow in the monologue.

DECISIONS

These are some of the ways decisions are made within the system. The answers are stored in the data field of current UNIT. Both versions has a UNIT, that starts the process - either by HUB subject or by setting system state to QUICKDECISION. Decisions are used, when Awesome.AI starts and answers a chat conversation.

Quick

Quick decision, are decisions that are made within an epoch (~500 cycles)
it activates system state QUICKDECISION
clears UNIT-space and injects a number of QUICKDECISION UNITs
removes QUICKDECISION UNITs as they are visited
returns a Yes/No decision

Long

Long decision runs over a longer periode, it handles both decisions made in 1 state and 2 states
State 1:
solution 1: depending on current UNIT data, return a Yes/No answer
solution 2: depending on current UNIT data, proceed to next state or decline
State 2:
solution 2: if DOWN is No, return current UNIT data. If DOWN is Yes decline.

WHAT IS IT

At its core one can say it is a decision engine, a highly autonomous agent. Does the thought go up or does it go down and from this we can build more advanced systems.
It is an advanced statemachine, UNITs being states and an algorithm for navigating these states.
Other AI algorithms try to map every neuron in the brain, this algorithm instead maps entire networks(HUBs and UNITs) in the brain and use dynamics to move between these networks.

LIMITATIONS

no consiousness (others will have to figure that out).
no memory (or less than seconds).
no feeling (but some emotion. ie. mood, thoughtpatterns).
no free will (but the illusion of free will. ie. the heaviest UNITs are LowCutted, therefore the system cannot "see" the pattern or algorithm. Hence the illusion of free will.)

EXPECTATIONS AND REALITY

The algorithm is designed to handle an infinite number of UNITS, I use about a hundred. This makes the monologue a bit detached, with more UNITS/HUBs it should seem more coherent.
The promts to ChatGPT could be better, which is why the monologue dosnt always 'glue' together.
Grouping the HUBs better, should give a more coherent monologue. More closely related HUBs should give a smoother monologue. Now "programming" and "fembots" are grouped together.
The end goal should be a smooth continuous thought.
This is still a prototype and the up down motion is a limited way of expressing the thought, and some other approach might be better suited. But i believe that modeling the thought as a dynamic is a valid approach.

IMPLICATIONS

The biggest problem is..

the idea is quite obvious, but noones ever tried implementing it
that all that has been holding this idea back, is that it was a lowcutted thought
should this idea remain hidden? (the argument, lets see what happens)
is the idea generel or specific to my thought?
the outcome may be, that we define the physical laws of the world and this simulation
this setup just needs validation for the idea to be correct?

MENTIONS

(Mech One, Mech Two) as position goes towards 0.0 pain (my speculation, could be enlightenment or truth) goes towards infinity (physical or emotional) (could be a transition to a new state)
(Mech One, Mech Two) Alternative: the dependent of position could be defined by the system itself, it could go towards 0.0, infinity or any number (could serve as a motivation factor)
(Mech Three, only in source and needs validation) as position goes towards Rs (Schwarzschild radius), timedilation goes towards 0.0 (due to Gravitational Time Dilation)
what drives the system, is trying to solve the "error" introduced in THE HACK.
the system produces a random number, from momentum.
maybe the definition for this system is not "a dynamics of the mind, but rather "a dynamics of the will of the mind".
this is my subjective vision of how the dynamics of the mind should be modelled.
this is a prototype.. and therefore not the final version.

..and last: fake it, till you make it

Try the Demo

Curious to see the algorithm in action? Explore the live prototype here: 🔗 www.copenhagen-ai.com

The Awesome.AI Algorithm (Original Text)