A Dude's Musings

Something I've wanted to do years ago was to take a cellular automata, probably Conway's Game of Life, and do a particular set-up with it. First, take a very large but finite board, non-wrapping, with spaces outside the board treated as dead. Then, once every X ticks, with X being some number preferably larger than 3, but easily larger, the whole board is shifted in one direction, let's say down so it's like they're falling, by one cell, with the cells at the top being filled in randomly and the ones at the bottom simply being discarded.

Then, you have a system where patterns can only remain on the board if they move in the opposite direction of the shift, at the same speed! Given that, I would like to try having the shift be large enough to allow for larger/more complex ships. Then, as the iterations continue, there would be a continued input of new patterns into an environment with a clear selective pressure, which to me seemed comparable in concept to simple genetic algorithms, so I figured this would somehow lead to more sophisticated patterns developing over time.

However, at the time I somehow wasn't able to really invest myself in wrapping my head around scripting for Golly, so I let the idea sit there for a while. Recently, though, I saw a video on chemical evolution ( https://www.youtube.com/watch?v=mRzxTzKIsp8 ). The model of chemical evolution, with fatty acids accumulating in water due to neither floating or sinking, reminded me of the idea of having a CA setup that selects for patterns that neither rise nor sink on a board that constantly scrolls.

Also, I'm now slightly better/more experience dealing with scripting, and think I might be able to pull this off now! So I'll want to try it out soon, though I'd also like to keep writing all these ideas I've mostly kept in my head for a while.

To continue writing down ideas I ought to have written: I like the idea of making computer parts from scratch, impracticable as it may be for producing a machine which meets contemporaneous performance expectations. I like the idea of reversible computing. As well, I also enjoy playing with the idea of analog computing. These things entwine together in a series of thoughts that begin with observation the observation that a Fredkin gate, in addition to being reversible, outputs the same number of each value as it receives as input.

This means that even if the two values are represented by a phenomenon which embodies different energy levels, the output can embody the same amount of energy as the input. Further, it can do so without the output using different energy levels for each value than the input! If there were a continuous version of this, I figured it'd be pretty handy for designing analog computers.

The reason I thought this was that I was already looking into ways to make reversible analog computers, as I wanted to see if the reversibility would result in substantially reduced noise in the system and thus a higher precision of results for a given level of quality of components. That in turn just seems generally useful for making computers from scratch.

So, the first thought I had was that what I'm doing would have something to do with affine transformations, as earlier research and discussion called my attention to the fact that affine transformations are both reversible and continuous functions. Specifically, rotation seemed like a good option, since if I'm taking the two inputs to be swapped as the X and Y coordinates, and the controlling input as rotation, then rotating 90 degrees should do something like swap them? More like invert them both, really.

At the moment, I was more interested in getting around the part where I don't want a circular arc, since that clearly wouldn't preserve the part where the sum of the outputs match the sum of the inputs. So I tried looking a thing where, before rotation, perform a transformation where I take the Chebyshev distance of the point and turn it into a point with the same angle from the origin but with Euclidean distance, and reverse the transformation after.

This ended up making the function for the X/Y coordinate inputs over the rotation input equivalent to what I'll call trapezoid waves, since that's what they look like, and a simpler way to implement the result is to just make a triangle wave and then use min and max functions to clip off the distance. However, I notice then that this still doesn't actually conserve the sum-invariance property I wanted! So then I thought, hey, if I rotate it 45 degrees normally first, then just do a the triangle waves without clipping them, I'm now going around the edge of a Manhattan distance circle instead of a Chebyshev distance one!

So that actually worked, but only if I presume the signal values can be negative, which might not be true of whatever computing media I go with. Otherwise I'm stuck in the upper right corner. I guess I could just use a different offset for the triangle waves so the function for any given X/Y input just covers the diagonal line where X+Y is constant. Maybe that actually would work? Something about it just didn't feel right to me, though.

So, I decided to make a function that takes X,Y, and Z inputs and well as the control/rotation, and does a function that for each input is just a triangle wave clipped at the bottom, but for all three of them ends up tracing the perimeter of a triangular wafer cut from a cube. So there we go! Maybe some time I'll try using it for a thing. Also, here it is on a web-based graphing calculator: https://www.desmos.com/calculator/rslh0cvwrk

Edit: Just realized I could generalize this to rotating arbitrary points by having each input other than the control ran through the function alongside its two neighboring inputs. Though also, it seems that I'm wrong about this version of the function doing what I want at all, as actually checking (I1+I2+I3)-(O1+O2+O3) shows that it in fact not produce a function f(r) that only produced an output of zero? So I'll need to keep working on this I guess.

Edit2: Oh, nice, I managed to fix the thing I was making! Working cube slice gate function: https://www.desmos.com/calculator/15wnxj923y

When reading about tax systems and the reasoning behind them, sometimes I like to try my hand at making up my own approach to them. Recently I told my dad about one that I think could be nice as a substitute for tariffs, and he said I should write it down somewhere, so I guess I'll try doing a series of posts on various tax ideas I have. Not that I think these are necessarily the best way to go based just on my personal guesswork, but maybe they're interesting enough to be worth talking about and critiquing.

Anyway, as far as tariffs go: The idea is that such a tax protects local businesses when imported goods manage to be cheaper, to preserve the ability to produce things internally. And it would seem that currently, a major contributor for prices of imports being low would be the workers who make those imported goods having lower wages. I'm wondering if it would be useful to have something that's like a tariff, but proportional to the difference in minimum wage between countries. And instead of the government keeping this tax, it would be distributed directly to the workers who make those products.

If actually actually keeping track of where the money needs to go is feasible, it'd be nice in that it'd fulfill the goal of a tariff domestically, which is to keep the prices of locally produced things competitive, while in the countries targeted by it, it'd result in increasing the purchasing power of their own domestic market, reducing their economy's reliance on exports to begin with. This benefit to the foreign country's economy would hopefully make this form of tax less of a problem in terms of international relations.

Something I've been playing with is the idea of computer programs which produce other computer programs via probabilistic selection. Basically similar to the idea of Markov chain generated text or procedurally generated images, but with code.

The previous instance I created in SmileBASIC for the 3DS, which was lost when the 3DS broke and I replaced it. For output, I only got it to print numbers, which were calculated by a series of randomly generated math expressions. Constant values were added, and later variables, with a simple naming scheme of [variable type][index number] so as to easily keep track of what variable names were in use by simply counting the number of each variable type created.

To begin with, though, I was testing the control flow system with calls to the RND in place of expressions. Each time a code block deliminator was selected, it would then be decided whether to go one nesting level up or down, based on the length of the program and the current nesting level depth. The type of code block was chosen when starting it, and remembered in a stack for when it was exited. When exiting a nesting layer was chosen when there were none left, the program end was written.

This produced amusing enough results for a while, though now that I'm starting over I think I'll try things a little differently, and as I'm making it a little more complex I figure I'll write down my thoughts somewhere before I go far in it, which is why I'm doing exactly that here. I'm using javascript this time, mostly so I can easily upload it to link to various people I know without them having to get a particular 3DS program to run it. As such, I'll be making some use of objects and whatever other elements of javascript that seem handy.

While I could have done so on the 3DS, I think this time I'll make an effort to focus on graphics, and try imposing a simple control structure to generated programs, working towards something that could possibly make things vaguely game-like with a much higher probability. I'm thinking at the very least setting up distinct input, process and output phases for the main game loop, plus maybe a setup and maybe a menu system. I'd like it to veer a little more towards inscrutable nonsense than not though, so aside from that I don't think I'll be hard-coding anything like lives or objectives, maybe not even a particularly designated object to be a player character.

Might want to limit the number of draw functions their are though, to help give things a more unified graphical style per generated game despite the chaos of it. I do know that I'll want output phase functions to operate on specially designated variables that don't get read outside that phase and are blanked at the start of it, to better separate the processing in it from the actual process phase. A sort of arbitrary designation, but it's something I thinking could be useful in organizing my manually made javascript games, and it just seems like I'd be more interesting in the kind of quirks created by such a system than by one that makes graphics randomly throughout the program.