I have been working on a model of the universe, language, blockchain and their intersection in the mathematical space of storage. The question is why? The answer is simple, there is no toolset that does what I want. Programming languages are based on the premise that you must memorize a whole set of new information. English language appears to be compatible with a programming language, why not test that theory to see if we can make something useful?

So why Ci? what does that mean to us? Ci is after “A’ splits to aa, then classes an instance(i). We first class “A”, the start of time calculation, then we eventually instance a, these are small instances of something running in the background. There’s a data stream coming from a, refracted through B, there are rules about what can be refracted and to where. We stop specific propagation events we know lead to problems, bottlenecks, programming issues, etc. We write answers with long lives that change the running architecture of the program itself. Ci is a calculation of when to write.

Ci is a calculation based on notation/color setting in a series of images. Imagine a bitmap which is 1 pixel by 10000 (A). Next we convert this image to 100x100 (b8). Next we convert this to 10x10x10 then 10x10x3x3. That’s four images, some which have depth, some have depth and a possibility of 3 states. Now we start at 1, 1x1, 1x1x1, etc. We are moving to the edge, furthest away from the start, calculating a running tally of whatever colors we hit. When we hit a threshold, we set a flag Ci.write(true).

Here’s some code as an example (python):

cl(U)

A.read(U)

a,a2 = start_aa(ii,U)

a.calculation_of(c)

a2.calculation_of(c2)

t = start_communication_grid(systems_ev,c,c2)

p = start_P(grid)

array_of_movement = []

for x,y in [Z.read(t)]:

- — array_of_movement.push(x,y)

images = [on,tw,th,fo,fi]

def Ci.calculate_distance(array_of_movement):

— — distance_from_epoch = final_tally(on,tw,th,fo,fi).calculate_score(array_of_movement)

— — -return distance_from_epoch

def calculate_score(arr):

— #defined in post

Next let’s define “systems computation autocompiler”

system computation autocompul

— ew drops e object from ci

— — compute

— —sort

— — — lists

- — files

— — — headers only

— —code

— — best known line

ai

- ap

- at

- an

- — as

This runs against Ci, computes it’s own running state, by first defining what it is that we’re going to be executing. “ew” is a classification event, learning system, built to find new answers to common issues/tasks, e is dropping information related to what “ew” learned, then eventually if writable by ci the data in e will drop, (dr op, from dragon to pb).

Ai is an instance of A, a program written in es. After that completes, we’ll run “ap,at,an”, then when all three are complete “as” which is an instance of a ran in a “S” enclosure, that’s where we drop “e” originally before it reaches the c network.