Daylen's Journey

[daylen]

1. I do not really know how to describe this perfectly but language has increasingly become like a proxy in my mind for construction. Mostly I rely on simulation from basic sensory processing units (i.e. like features of the sensorium, mostly visual transformations). Simulations run on some finite set of rules. Some simulations are more complete or cover more fields/objects of study, some are more challenging to run, some are simpler to explain, etc. (a trade-off or optimization space emerges). More fit simulations get selected to join the model ecosystem, so to speak. When my mind was more like a grassland with a few subconscious shrubs here and there the early succession process took hold and started this simulation project. It was some time later that I started analyzing these transitions to the point of developing a simple visual model of how my mind works and it has served as a fairly stable tree-like addition to the ecosystem that I can use to gain vantage points over the landscape of developing models or simulations.

2. The Drawing Agency thread highlights the general idea of the core model: viewtopic.php?p=247731#p247731

Here is a simplification that has tended to be most helpful that has three stages of complexification: 1) agents and vegents as finite open sets that move or do not move on some manifold (i.e. like a sphere or ring) 2) add in closed structural sets that cover agents and vegents on the outside and add in points of convergence to the inside of agents and vegents 3) add in open map sets that cover some agents and vegents and add in open frame sets that cover some points inside agents and vegents.

This chart shows a single agent enclosed in a single map within a single structure that has within them a single frame with a single point. It's an agent since I am not sure the MBTI or PPPP mappings project into vegent-mind space very well:



Now, several different "kinds" of rule sets can be interpreted from this basic picture with the help of group theory (or by presuming causal symmetries). At stage 1 with no outside or inside world, life just is what it is (agents and vegents on a manifold). Stage 2 involves introducing an open or closed causal loop between an outside thing/process/system/universe/etc. and an inside thing/process/system/cell/etc.. Stage 3 involves introducing an open or closed causal loop between an outside representation/model/simulation/etc. and an inside representation/model/simulation/etc..

So, the drawing is self-referential and so must sorta be raised to the "level" of a "meta-model". Which is just a map within a map and a frame within a frame.. it's a bottomless bucket of recursion that might waste a lot of cycles, or at least it use too, but seems to do a pretty good job now at constraining or freeing any other processing in the brain. Making it easier to steer through the state space.. or does it? I don't really know anything or maybe I do but I have forgotten.. but sometimes I re-remember in a different forest or desert.

[daylen]

What if instead of a simple arena with complex agent-based modelling there was a complicated, fractal-based arena with somewhat simpler agent-based models embedded within?

Let a civilization be a koch curve on any degree polygon that is relaxed to allow for any degree polygon insertions inwards or outwards. So, an octagon with triangular bioregions with square cities with hexagon districts with triangular agents with pentagon organs.. for instance. The depth of the fractal updates leading to a dynamically evolving ontology or world. Updates can be locally rolled back or flattened to indicate systemic collapses.

Part of the curve can be cut out and projected onto a closed polygon retaining the sides. Allowing moving agents or unmoving vegents to be distributed into an arena (the inside of the parent koch curve). Gents all the way down.. but how can a balance of top-down and bottom-up causation be achieved?

[daylen]

As per the agent model above, a circular agent is an idealized limit towards an infinite edged polygon. A finite representation being of N edges and allowed to fractalate inwards towards the central point, black hole, or garbage collector of the agent and outwards towards the universal structure beyond the agent. More edge allows for more interaction between what is in and out. Gent bodies invite sub-gents that gradually or punctually dissolve the gent identity. Maps and frames approximate the boundaries across scale of this fractalation process. Or at least this is one way to map/frame it.

[daylen]

Gents all the way down.. but how can a balance of top-down and bottom-up causation be achieved?

Or gents emerge from the bottom and complexify to introduce middle-out causation. In functional terms that are agent-relative, the convergent perception and judgement axes (Ne-Si and Fe-Ti) invert into the divergent perception and judgement axes (Se-Ni and Te-Fi).

This invites the exploration of various n-ary operators between fully connected sections of the overall fractal.

[daylen]

Started thinking about how knots could be brought into the fractal picture since both mathematical knots and koch curves are closed loops that can be represented easily in 2D. The koch curves could be cut, entangled, and glued to diverge from the default of the unknot. Then I started thinking about quantum information theory again and considering bringing communication between agents to the forefront. This is on a similar track as moving from agent-based models to fractal-based models that operate in some space other than physical space where movement and collisions time agent interactions. Knotting on a fractal might be associated with non-aligned communication between agents that are embedded in the fractal. So, one agent's "up" may be another agent's "down" along with the inverse, corresponding to a knot or over/under crossing. Perhaps each level of granularity or zoom into the fractal could represent sets of communicable agents with various alignments. High alignment and low noise between two agents allowing for a high density of information transfer. The simulation may get knottier as it volves through discrete states that entangle agents or otherwise become unknotted through disentanglement.

Knots are additive so are easily constructed, though an arbitrary knot is difficult to tell apart from the unknot or any other knot. Two knots can be proven to be the equivalent by using Reidemeister moves but proving two arbitrary knots are different is impossible(*). This may lend itself to some kind of asymmetry in computation that lends itself to a puzzle for the user/guide/player/steward of the simulation to solve or otherwise manage. At this point, I am basically searching a very large space of possible mathematical structures for interesting proofs that can be systematized and associated with some kind of dynamical process of entropy accumulation and complexity flux. With little idea of where it all leads yet enjoying the endless thought experiments along the way.

(*) Though possible in limited cases using p-colorability which is invariant to Reidemeister moves.

[daylen]

Still working on Volution but now it has shifted more towards agent-based modeling within a cellular automata. Here is a possible high-level implementation, but the design is always changing.

Using Godot, a TileMap corresponds to the Arena and Area2D's correspond to agents. The arena is generated through an automata that locally determines tile changes. The three types of tiles being unassigned (grey), sources (white), and regions (black). Starting with a small seed or pattern of black and white, the arena expands into the grey overtime to fill a valley or hill. Valley's and hill's discovered through different 2D noise functions of variable parameters truncated above or below zero: https://auburn.github.io/FastNoiseLite/

Agents can move into regions but not sources or unassigned tiles. Agents scale from small populations to large populations by sourcing alpha. Matching something like a logistics curve where slowly alpha builds population until population explosion, then tapering off near 255. That is, each agent has a particular color (rgb: 0-255) and transparency (alpha: 0-255), and the source available to convert into rgba flow is increased by agentic regions having an edge with source tiles. Higher alpha agentic regions siphoning source at a faster rate. The colors corresponding to blue-water, green-organics, and red-inorganics, and the stocks/flows of which emerge into an economy of trading/arbitrage/imbalance between regions. Each region occupied by an agent has a particular rgba (red, greed, blue, alpha) value that can change from turn to turn. The simulator is turn-based where the agents each take their turns followed by the arena updating automata then agents taking turns again and so forth.

The simulation will probably be more of an open-ended sandbox game that allows players to cooperate or compete across multiple different scales. Dense agentic regions with high-alpha move slower, hit harder, and source faster; whereas sparse agentic regions with low alpha move quicker, hit softer, and source slower. Agents have only so much source per turn to spend on actions. Actions vary in required source and usually involve moving color and alpha around (i.e. drawing). Dense agentic regions requiring more source for more impactful actions. Agentic regions can be distributed over a larger area or consolidated into a smaller area, requiring actions that will span more turns the higher the overall alpha of the agent.

Other actions include regional awareness and attention in trade-off. That is, the further you see the less you see around you and vice versa. As agents distribute, they expand awareness and attention to include more of the arena allowing for increasing depth of strategy. Agents can go to war and trade simultaneously if they want (attacking, defending, trading, and sharing information in the same turn perhaps). A spy or scout can be created as a low-density region disconnected from the agent's center of density and in antagonistic and/or friendly regions. Regional awareness pauses the cellular automata on the respective regions allowing for the agent to build out their own geometry of high-density centers or cities connecting as a source flow network over discrete time.

Looking for other systems or rules that mesh in with these causes/constraints to add more depth. Relative proportions of rgba could lend itself to an action tree that unlocks with progression, or something like that. Not entirely set on rgb mapping to inorganics, organics, and water.

So, what you basically end up with is a population density map with deep history doubling as a colored drawing that can be exported as a picture/state each turn. Allowing for an exploration of divergent and convergent volutions. AKA a fractal rainline, rainbow, rainring, rainspiral, etc.

Developing an AI is essential for solo experimentation and for off-loading cognitive demands to automated agendas as your agent scales up to require more active decisions per turn.

[daylen]

Code for arena so far (will probably upload project to github at some point):

Code: Select all

extends TileMap

var time = 0
var turn = 0.1
var offset_speed = 5
var noise = FastNoiseLite.new()

# initialize
func _ready():
	build(2,3) # regions within sources
	# noise parameters
	noise.seed = 333
	noise.noise_type = 1
	noise.fractal_type = 1

# grow
func _process(delta):
	zoom()
	offset()
	# update
	time += delta
	if time > turn:
		automata()
		time = 0

# tiles { unassigned: -1, source: 0, region: 1 }
# sectors { southeast: (+,+), northeast: (+,-), northwest: (-,-), southwest: (-,+) }

func build(region: int, source: int):
	var x = 0
	while x <= source:
		var y = 0
		while y <= source:
			if x <= region and y <= region:
				set_cell(0, Vector2i(x,y), 1, Vector2i(0,0))
				set_cell(0, Vector2i(-x,y), 1, Vector2i(0,0))
				set_cell(0, Vector2i(x,-y), 1, Vector2i(0,0))
				set_cell(0, Vector2i(-x,-y), 1, Vector2i(0,0))
			else:
				set_cell(0, Vector2i(x,y), 0, Vector2i(0,0))
				set_cell(0, Vector2i(-x,y), 0, Vector2i(0,0))
				set_cell(0, Vector2i(x,-y), 0, Vector2i(0,0))
				set_cell(0, Vector2i(-x,-y), 0, Vector2i(0,0))
			y += 1
		x += 1

func zoom():
	if Input.is_action_just_released("zoom_in"):
		$Camera.zoom += Vector2(0.1,0.1)
	elif Input.is_action_just_released("zoom_out"):
		if $Camera.zoom.x >= 0.1:
			$Camera.zoom -= Vector2(0.1,0.1)

func offset():
	var speed = offset_speed/$Camera.zoom.x
	if Input.is_action_pressed("offset_east"):
		$Camera.offset += Vector2(1,0) * speed
	if Input.is_action_pressed("offset_north"):
		$Camera.offset += Vector2(0,-1) * speed
	if Input.is_action_pressed("offset_west"):
		$Camera.offset += Vector2(-1,0) * speed
	if Input.is_action_pressed("offset_south"):
		$Camera.offset += Vector2(0,1) * speed

func automata():
	var updates = []
	for cell in get_used_cells(0):
		var sources = 0
		# grow and count sources
		for neighbor in get_surrounding_cells(cell):
			if get_cell_source_id(0, neighbor) == -1:
				if noise.get_noise_2dv(neighbor) > 0:
					updates.append([neighbor, 0])
			elif get_cell_source_id(0, neighbor) == 0:
				sources += 1
		# source to region (death)
		if get_cell_source_id(0, cell) == 0 and sources == 0:
			updates.append([cell, 1])
		elif get_cell_source_id(0, cell) == 0 and sources == 4:
			updates.append([cell, 1])
		# region to source (birth)
		elif get_cell_source_id(0, cell) == 1 and sources == 2:
			updates.append([cell, 0])
		elif get_cell_source_id(0, cell) == 1 and sources == 3:
			updates.append([cell, 0])
	for update in updates:
		set_cell(0, update[0], update[1], Vector2i(0,0))

Way zoomed-out automata state after many steps, sharp edges indicate more exploration to be done by the automata (agents will add color when integrated):



Will probably end up building interface for arena setup to experiment early with different 2d noise parameters and automata rules. Only using 4 sides instead of 8 like Conway's game of life for now. A high degree of dynamism can be achieved with only 4 so I may stick with it.