Difference between revisions of "Hypercubic evolution engine"

From RAGEPATH Wiki
Jump to: navigation, search
Line 1: Line 1:
 
Hopefully you clicked this because you think I'm crazy. In which case, I invite you to read this:
 
Hopefully you clicked this because you think I'm crazy. In which case, I invite you to read this:
  
class HyperCubicMap()<B>
+
class HyperCubicMap()<BR>
#I know, right?<BR>
+
..........#I know, right?<BR>
<BR>
+
..........<BR>
def initialize<BR>
+
..........def initialize<BR>
t_axis = []<BR>
+
....................t_axis = []<BR>
if(dimensions > 4)<BR>
+
..............................if(dimensions > 4)<BR>
puts("Now that we've built a hyper-cube plotting system, there's no reason we can't make it n-dimensional. But it's so complicated that you chose to put off till later, and I hope this means you need it now.")<BR>
+
........................................puts("Now that we've built a hyper-cube plotting system, there's no reason we can't make it n-dimensional. But it's so complicated that you chose to put off till later, and I hope this means you need it now.")<BR>
omega_axis = [] #I mean you did some thinking here. This would be the master array of arrays of arrays of arrays... and then you would iterate into it... i dunno. coding the n-dimensional nested loops is not now.<BR>
+
........................................omega_axis = [] #I mean you did some thinking here. This would be the master array of arrays of arrays of arrays... and then you would iterate into it... i dunno. coding the n-dimensional nested loops is not now.<BR>
return<BR>
+
........................................return<BR>
else<BR>
+
..............................else<BR>
x_axis = []<BR>
+
..............................x_axis = []<BR>
y_axis = []<BR>
+
..............................y_axis = []<BR>
z_axis = []<BR>
+
..............................z_axis = []<BR>
x = 0
+
..............................x = 0<BR>
while x < bound
+
..............................while x < bound<BR>
y = 0
+
........................................y = 0<BR>
while y < bound
+
........................................while y < bound<BR>
z = 0
+
..................................................z = 0<BR>
while z < bound
+
..................................................while z < bound<BR>
t = 0
+
............................................................t = 0<BR>
while t < bound
+
............................................................while t < bound<BR>
#At this point in space, at this point in time, something happened that you want to record, so execute that storage function here. Probably actually you just want to create a blank datapoint and return
+
......................................................................#At this point in space, at this point in time, something happened that you want to record, so execute that storage function here. Probably actually you just want to create a blank datapoint and return<BR>
t = t + 1
+
......................................................................t = t + 1<BR>
end
+
............................................................end<BR>
z = z + 1
+
..................................................z = z + 1<BR>
end
+
..................................................end<BR>
y = y + 1
+
..................................................y = y + 1<BR>
end
+
........................................end<BR>
x = x + 1
+
........................................x = x + 1<BR>
end
+
..............................end <BR>
end
+
....................end<BR>
end
+
..........end<BR>
end
+
end<BR>
  
 
Ugh, ok that pseudocode is not coming out great. Should work on that.
 
Ugh, ok that pseudocode is not coming out great. Should work on that.

Revision as of 01:27, 19 February 2023

Hopefully you clicked this because you think I'm crazy. In which case, I invite you to read this:

class HyperCubicMap()
..........#I know, right?
..........
..........def initialize
....................t_axis = []
..............................if(dimensions > 4)
........................................puts("Now that we've built a hyper-cube plotting system, there's no reason we can't make it n-dimensional. But it's so complicated that you chose to put off till later, and I hope this means you need it now.")
........................................omega_axis = [] #I mean you did some thinking here. This would be the master array of arrays of arrays of arrays... and then you would iterate into it... i dunno. coding the n-dimensional nested loops is not now.
........................................return
..............................else
..............................x_axis = []
..............................y_axis = []
..............................z_axis = []
..............................x = 0
..............................while x < bound
........................................y = 0
........................................while y < bound
..................................................z = 0
..................................................while z < bound
............................................................t = 0
............................................................while t < bound
......................................................................#At this point in space, at this point in time, something happened that you want to record, so execute that storage function here. Probably actually you just want to create a blank datapoint and return
......................................................................t = t + 1
............................................................end
..................................................z = z + 1
..................................................end
..................................................y = y + 1
........................................end
........................................x = x + 1
..............................end
....................end
..........end
end

Ugh, ok that pseudocode is not coming out great. Should work on that.

One of the fundamental challenges I face with this project is that the computational power necessary to resolve anything at the scales being contemplated is quite simply unavailable. How do you solve that? Flatten the t-dimension. There is only ONE law of physics with a uni-directional flow of time - the 2nd Law of thermodynamics. So, if you plot your coordinates on a hypercube in which the fourth dimension represents the time axis, you should be able to create, say a "g2 class star aged 4.2 billion years in this galaxy of 13.6 billion year age" and simulate *outwards* from it.

So at it's most abstract level, the hypercube grid represents a model of energy flow, where the lowest state is at [0,0,0,0] and the *scale* is completely arbitrary. The galaxy we live in exists at [0,0,0,13.61] or so - in that its space in time is the only coordinate we seem to have any interest in. Which fine. "Can earth happen?" is a small question with a 4.2 billion year timespan. So if that's all you want to answer, fix your values and see what you get.

OK, but then.... has earth been visited by aliens before mankind evolved? That's a slightly smaller window of time but involves a much wider window of space, so you need to move out to certain levels of distance and then back in equivalent levels of time. The idea, essentially is that you can simulate a universe that "exists" in conformity with the parameters you've specified but doesn't *resolve* with any specificity until you select a space AND a time in which to look. And to make that possible we need a four dimensional hypercube.

But... and this is the part that I love... the unified evolution engine can use these hypercubes as the "feature space" in which kinetic flows are modeled. Right so, suddenly those proto-earths I was so frustrated with before, are just time-bound location points. You can move forward and backward in the timeline and test "what if life starts here? here? here? this way? that way?" It was the failure to capture the time dimension in my earlier simulators that made them flounder.

OK, so modeling kinetic flow in a hypercube... it seems to me at this point that I have a few insights and ideas that I'm still working on so all of this is tentative here, but... the first step is to think of the four-dimensional cube as both a playspace and an archive. Events happen at nodes in space time, and those events are recorded. Those *records* can then provide the seed values for related events in space OR time.

Within this four dimensional grid, you have flows of energy. I'm leaning towards hypercubes of 11x11x11x11 with a zero dimension, because weird things happen in centers. You get galactics disks and planetary discs. You get ejection beams like quasars and pulsars.

So in theory [0,0,0,0] is the center of space and time. This is the anchor around which the energy swirls. In our solar system, it's an emissive source - the sun. In our galaxy, it's an attractive source - a black hole that absorbs energy instead of releasing it. And that right there is a fundamental distinction. How is the energy flowing through your grid? Is it being pushed away by energy emission or is it being pulled in by cold gravity?

On a galactic level I think I may be able to model this. Galaxies are divided into their own hypercubic grid of "volumes" (each is 11,000 light years/time years along each axis). As the core "sparks" and matter begins to fall "down" and "in" towards the center of the system, it compresses and begins to generate kinetic counter-forces to the central gravitational force, and you'd begin to see gases coalsescing into stars.

At each step of the simulation, the question is basically "what material is present, and what energy inputs are acting upon it?" Stars, planets, lifeforms, even civilizations and spaceships and space stations all follow this basic principle. Energy + matter + PURPOSE = Counter-Entropic Pattern

Which, probably not coincidentally starts looking like the division of mind/body/soul. We waste so much energy trying to abstract purpose out of our contemplation of the universe, and it is clearly a fool's errand that the universe will neither tolerate nor reward.

So, the "evolutionary hypercube" is one that sets the zero point at an arbitrary corner. You have an environment at time zero, with energy level zero, and suddenly it starts using energy and matter to produce self-sustaining organization. What happens next? From the corner of the hyper cube [-5, -5, -5, -5, -5] you have four moves available. Let's say "up", "north", "east", or "forward" as you begin to move towards the "center" of "evolutionary gravity" the number of options available grow. As soon as you're not clinging to the walls there are six exits from each interior node in 3 dimensions and 8 if you allow all 4.

What does a "move" represent within the context of this evolutionary hypercube? So if life is the self-sustaining purposeful movement of matter with energy across time then its three concerns are essential ingestion of more energy, more efficient use of the energy being ingested, or storage of the exceses energy. So like, storage... y'know. There are three dimensions you can increase the way you store energy absorbed from your environment. You can reproduce, and increase the population - a whole new unit of self-sustaining biomatter (let's call this a "+x strategy")! You can expand, and grow larger, storing more material within your own bodyplan (the "+y strategy"). You can live better without changing your material circumstances (the "+z strategy" - essentially adding an evolutionary scheme of motives to the simulator) Or you can live longer and extend the lifespan, making the pattern exist across a longer stretch of time. ("the +t strategy")

From that basic plan the rest will flow. There should be "devolutionary pathways" where it costs less to move back than it does to move forward and "evolutionary deadends" where species become so hyper-adapted to their specific context that they cannot withstand changes to their environment. But overall, hopefully depending on the constraints you've applied with your preferences around the anthropocentric principle, the "flow" of energy will push toward the center of the cube across time, but *also be capable of branching back off again even from the center point*. Science fiction is replete with fallen, devolved and vanished precursors. Vestigial organs exist because evolution finds its way back from dead ends sometimes.

OK so... neat, the evolutionary engine seems like an elegant and scalable soltuion BUT I have a lot of grunt work to do before it's ready and it's not really math.

I'm also interested in the idea of hypercubing the galaxy itself. From that you take the galactic age, and set it to 0. Then you take the abundance of the element, and convert them all into hydrogen with a brutal 1:1 reduction. Now, your galaxy is nothing but hydrogen gas at t = 0. But then you inject kinetic flow. Matter flows forward in time, converting matter into energy. It falls "down" towards the galactic plane in the z-dimension. It moves "left" or "right" on one of the lateral planes to simulate the rotation of the orbital disc. And it moves "in" on the other lateral plane to simulate the effect of gravity. So as the material begins to condense in the center, it would start sparking into stars - population I stars. The problem with this whole process is that it represents an old model of thinking that can't mathematically explain the fusion processes that generated elements higher than iron. I'm not a fan of "Population I" versus "Population II" stars. I suspect the galactic medium itself is cluttered with stuff that makes weird results inevitable. Anyways, you start sparking supernovas this way and use that process to seed the distributions of different elements around the galaxy. I prefer a more decumbent method of distributing elemental abundances but I'm so far off topic already.