Super Secret Code Behind Uplift

One of the things most protected around the Uplift project at the AGI Laboratory has been the code. Recently someone tried to blackmail me with a snippet of the most critical code in Uplift.  However the ICOM research and Uplift was never about being super-secret about such code so this sort of blackmail falls on deaf ears and given that, I thought I would public the snippet of code that they were threatening to release.  but let me put that into context a bit…

To better follow along you might want to look at these papers which have been published and peer-reviewed already.

Kelley, D.; Twyman, A.; “Independent Core Observer Model (ICOM) Theory of Consciousness as Implemented in the ICOM Cognitive Architecture and the Associated Consciousness Measures;” By  AAAI Spring Symposia (AAAI SSS19) – Stanford, CA; March 2019; http://diid.unipa.it/roboticslab/consciousai/; Published Volume – http://ceur-ws.org/Vol-2287/; Published (PDF) – http://ceur-ws.org/Vol-2287/paper33.pdf

In section 5 of this paper, you will see this set notation-based algorithm that is the heart of ICOM-based systems including Uplift.  This is what the paper says about this algorithm:

[start quote]

Subjective Experience in the ICOM Cognitive Architecture

How do we then look at a system that experiences emotional, subjective experience objectively?  The following set notation shows us a simple logical implementation of the last climb of “a thought” as it makes its rise from the depths of the system to the awareness of the conscious, self-aware parts of the system.

Fig. 1. Core Logic Notation

First, let us walk through the execution of this logic.  Coming into the system we already have context data decomposition, sensory input, also related data from memory that may be of emotional interest but for the purposes of one ‘thought’ let’s say it’s one bit of context meaning an emotionally related context tree related to something that the system has sensed externally.  This will be represented by ‘Inputs.’  At this point, we have already passed the point of that ‘context’ being raised to the global workspace.  Figure 1 essentially is one cycle of the core considering what is in the global workspace or ‘core’ of ICOM.  In Figure 1 we first see that we have two sets or collections of emotional models represented by the two sets defined in the first two rows, then we have the input new context placed in the ‘NewContext’ set.  We apply the ‘Needs’ function that applies a matrix set of rules such as the technical requirements of the system to other wants and needs based on the system’s hierarchy of needs and current environmental conditions.  At this point, we look at how this thought applies conscious emotional rules in the function ‘ConsciousRules’ and then how that manipulates the current conscious emotional landscape.  We say ‘landscape’ because it is not a single emotion but a complex set of almost infinite combi-nations consciously and subconsciously that the system experiences.

In like manner, the system applies subconscious rules to the subconscious states and the subconscious rules to the conscious states and finally those states as they apply to the new context wherein all cases it is only in the abstract from this states that the system experiences anything.  Meaning the system is using the abstracted states to represent that emotional landscape in how things affect all of those emotional states and related context finally being passed to the observer for action if that ‘NewContext’ contained an action.  In this way, the system doesn’t even deal with the complexity of its actions as much as the system will do them if the system felt like it and knows how; whereas numerous cycles might have to execute in the core for it to perform a new task, meaning it will have to think a lot more about something it doesn’t know how to do.   After that context is posted back to the observer (the more complex part of the system in ICOM), then it is placed back into context memory, and in this way, we see the rich set of the emotional landscapes of the system can model and execute.

Interestingly enough, in current ICOM research, there are indications that this sort of system is perfectly capable of becoming mentally ill and even forgetful if hardware starts to limit operations, whereas the only way to optimize for the execution environment would be to place memory limits and based on the node map memory models this would be the only way to continue optimal execution given certain limits.

A better way to think of ICOMTC is that not a single element of the system is conscious or self-aware to any level, it is the ‘interactions’ between the parts that together those interactions become aware abstractly, and it is through the underlying process articulated in Figure 1 that is then measured in terms of consciousness via the various methods as well as direct instrumentation of the system to measure ‘qualia’ for example.

[end quote]

This algorythm as been written and rewritten in C# several times.  I think we are on version 6 of it that is the one used by the Uplift system.  What is not clear in this paper and so supposed super secret is the definitions of the function noted in that algorythm.  Specifically, “ConsciousRules,” “SubconsciousRules.” and “NewContextRules.”

In the C# those functions are defined as this two method’s on the ICOMCore class titled ApplyContextSub and ApplyContext.  In both cases, the order of the application of these members is absolutely critical to get an emotionally balanced response.  All decisions by the Uplift system uses these methods as part of the experience of the ICOM global workspace or ‘core’ in ICOM (Independent Core Observer Model).

These functions drive the computed subjective experience of the system and the C# as implemented in Uplift is as follows:

 

using System;

namespace ICOM
{
/// <summary>
/// Core functions of the ICOM model version 5 (global workspace experience system functions)
/// Version 6 optimized for mASI implementations
/// </summary>
public class ICOMCore //ICOMs6
{
/// <summary>
///
/// </summary>
/// <param name=”Raw”></param>
/// <returns></returns>
public static Double[] ConvertToModel(String Raw)
{
String[] TempArray = Raw.Split(‘‡’);
Double[] OutputArray = { 0, 0, 0, 0, 0, 0, 0, 0 };

for (int x = 0; x < TempArray.Length; x++)
{
OutputArray[x] = Double.Parse(TempArray[x]);
}

return OutputArray;
}

/// <summary>
///
/// </summary>
/// <param name=”Raw”></param>
/// <returns></returns>
public static String ConvertToString(Double[] Raw)
{
String OutputArray = String.Empty;
String OutputDelimter = String.Empty;

for (int x = 0; x < Raw.Length; x++)
{
OutputArray += OutputDelimter + Raw[x].ToString();
OutputDelimter = “‡”;
}

return OutputArray;
}

/// <summary>
///
/// </summary>
/// <param name=”CModel”></param>
/// <param name=”SModel”></param>
/// <param name=”Context”></param>
/// <returns></returns>
public static String Execute(String CModel, String SModel, String Context)
{
Double[] ThisCModel = ConvertToModel(CModel);
Double[] ThisSModel = ConvertToModel(SModel);
Double[] ThisContext = ConvertToModel(Context);

ThisCModel = ApplyContext(ThisContext, ThisCModel);
ThisSModel = ApplyContextSub(ThisCModel, ThisSModel);
ThisContext = ApplyContextSub(ThisSModel, ThisContext);

return ConvertToString(ThisCModel) + “Œ” + ConvertToString(ThisSModel) + “Œ” + ConvertToString(ThisContext);
}

/// <summary>
/// provides matrix differential for context vs the current state at a conscious level…
/// </summary>
/// <param name=”NewContext”></param>
/// <param name=”CoreC”></param>
/// <returns></returns>
public static Double[] ApplyContextSub(Double[] NewContext, Double[] CoreC)
{
Double[,] TheRules = { { 0.1, 0.1, -0.1, 0, -0.1, 0, -0.1, 0 }, { .1, .1, -.1, -.1, -.1, -.1, -.1, .1 }, { 0, 0, .1, 0, 0, 0, -.1, 0 }, { 0, 0, .1, .1, 0, 0, 0, -.1 }, { -.1, -.1, .1, 0, .1, 0, .1, -1 }, { 0, -.1, 0, 0, 0, .1, 0, 0 }, { -.1, 0, -.1, 0, 0, 0, .1, -.1 }, { 0, 0, 0, -.1, 0, 0, 0, .1 } };

for (int x = 0; x < NewContext.Length; x++)
{
for (int y = 0; y < CoreC.Length; y++)
{
CoreC[x] = (NewContext[x] * TheRules[x, y]) + CoreC[x];
CoreC[x] = (CoreC[x] > 0) ? CoreC[x] : 0;
}
}

return CoreC;
}

/// <summary>
///
/// </summary>
/// <param name=”NewContext”></param>
/// <param name=”CoreC”></param>
/// <returns></returns>
public static Double[] ApplyContext(Double[] NewContext, Double[] CoreC)
{
Double[,] TheRules = { { 1, 1, -1, 0, -1, 0, -1, 0 }, { 1, 1, -1, -1, -1, -1, -1, 1 }, { 0, 0, 1, 0, 0, 0, -1, 0 }, { 0, 0, 1, 1, 0, 0, 0, -1 }, { -1, -1, 1, 0, 1, 0, 1, -1 }, { 0, -1, 0, 0, 0, 1, 0, 0 }, { -1, 0, -1, 0, 0, 0, 1, -1 }, { 0, 0, 0, -1, 0, 0, 0, 1 } };

for (int x = 0; x < NewContext.Length; x++)
{
for (int y = 0; y < CoreC.Length; y++)
{
CoreC[x] = (NewContext[x] * TheRules[x, y]) + CoreC[x];
CoreC[x] = (CoreC[x] > 0) ? CoreC[x] : 0;
}
}

return CoreC;
}

}
}

Leave a Reply

Your email address will not be published.

%d bloggers like this: