Live Parsers and Quines
An unusual mathematical-leaning definition of a living thing.
(Or, to be more precise… a potential living immortal? A replicon? Whatever.)
A self-replicating physical entity with...
3 Core Components:
Quine: Contains the code to produce itself
Parser: A parser for that code
Code includes instructions for the parser; ideally, compressed instructions
Power: Actively running (probably on some substrate)
Not actively running is death, although for some the death is temporary.
Access to resources may be a subcomponent of this?
Additional components:
Substrate: A material that can be converted into more self
Possibly a multi-step process
Access to resources is probably a component of this
Translator: Converts quine into power, or vice-versa
Not always necessary; sometimes a quine is held as power, not substrate
Parser and Code: the information can actually be stored on either; you can extract the correct complex signal from complete randomness using an arbitrarily-complex parser chosen for that purpose. There are analogies that can be drawn in the other direction, too: a fairly dumb parser can make fairly complicated things, given enough instructions. (Something something Turing Machines)
Ideally, though, they’re well-paired and the compression method is something sensible, to reduce complexity.
A quine by itself has only a partial life; it is just its own code, it requires a parser to replicate.
(If you allow for arbitrarily complex parsers, any code could be a quine, if you were willing to search for the right parser.)
Compilers are… parsers? (Or translators?)
It is possible for what was “code” information to be embedded into the parser. I think this is part of what happens when you completely integrate parts in IFS.
Examples
Example replicons: A bacterium, a cell, a clonal organism, a pair of opposite-sexed humans (but not a single), self-contained repeating Game of Life automata, the eventual goal of RepRap (a 3D printer fully producing a copy of itself)
Viruses: Sometimes quines, sometimes pre-quine and translator
The distinctive thing about Lisp is that its core is a language defined by writing an interpreter in itself. It wasn’t originally intended as a programming language in the ordinary sense. It was meant to be a formal model of computation, an alternative to the Turing machine. If you want to write an interpreter for a language in itself, what’s the minimum set of predefined operators you need? The Lisp that John McCarthy invented, or more accurately discovered, is an answer to that question.
-- What I Worked On, Paul Graham
Related: Self-Reference, Post-Irony, Hofstadter’s Strange Loop, Turing Machine, Automata (less-so), deconstruction (less-so)
Is a cryonics’d human a quine? (wrt future technology)
The definition of parasite used in Nothing in evolution makes sense except in the light of parasites is literally quines.
(Complex multi-step life-cycle in the T5 case, though?. The quine produced a bare-bones quine-compiling “spawner” when it interacts with the wild-type, and then replicates on that. Almost analogous to CS viruses that infect the compiler, and any future compiler compiled by that compiler.)
Process is Art: Is art that demonstrates how to craft the art, a quine on a human compiler?
Some connection to: Compartmentalization (Black Box Testing, unit tests, separation of software components) and the “swappability” of keeping things general and non-embedded, with clearly-marked and limited interface-surfaces (APIs). Generates pressure against having “arbitrary compilers” in practice.
It’s sorta non-obvious. I kinda poked at this for hours, at some point? It took a while for me to settle on a model I liked for this.
Here’s the full notes for what I came up with.
Physics: Feels close. Hm… biological life as a self-compiler on a physics substrate?
DNA or gametes seem really close to a “quine” for this: plug it into the right part of an active compiler, and it outputs many instances of its own code + a customized compiler. Although it crashes/gets rejected if the compiler is too different (ex: plant & animal have different regulatory markers & different sugar-related protein modifications).
I don’t have a fixed word for the “custom compiler” thing yet (“optimized compiler”? “coopted compiler”? “spawner”? “Q-spawner”?). I have seen analogous stuff in other places, and I’m tempted to call it a somewhat common pattern, though. (ex: vertically-transmitted CS compiler corruption, or viruses producing tumor micro-environments that are more favorable to replicating the virus)