Code center > Darwinbots3
Mutation protection
jknilinux:
--- Quote from: Numsgil ---It's either a property of the codon itself, (multiple codons, with different possible mutation probabilities, might code for the same amino acid), or it might be regulated by a regulatory protein which sits on the strand of DNA itself, like a glob of clay stuck on my string of beads analogy.
--- End quote ---
Either way, the DNA still governs it's own mutation rate. Having an exon make a protein to protect another peice of DNA by sitting on it is just like saying
x .protect10 store
Or "protect the next X bases by giving them a 10% mutation rate". Whether it's done through proteins or not doesn't matter. Ultimately, in real biology, the DNA is protecting itself, and therefore does contain metadata.
Numsgil:
No, it's quite different. That protein might have come from anywhere in the genome. It get's created, floats around a bit, finds its target, and latches on. If its target moves, so does it. If its target doesn't exist, it doesn't bind. If there are multiple targets, multiple proteins may or may not bind to the site. The protein may be encoded somewhere in the DNA, so in that regard you're right that the DNA includes it somewhere in itself, and thus regulates itself, but the actual mechanism is not embedded next to thing it wants to protect, which is my point.
Mind you this idea (that organisms can control their mutation rates voluntarily) are new in biological thinking. They're not quite as dogmatic as some of the more central tenants of evolutionary theory.
jknilinux:
--- Quote from: Numsgil ---No, it's quite different. That protein might have come from anywhere in the genome. It get's created, floats around a bit, finds its target, and latches on. If its target moves, so does it. If its target doesn't exist, it doesn't bind. If there are multiple targets, multiple proteins may or may not bind to the site. The protein may be encoded somewhere in the DNA, so in that regard you're right that the DNA includes it somewhere in itself, and thus regulates itself, but the actual mechanism is not embedded next to thing it wants to protect, which is my point.
Mind you this idea (that organisms can control their mutation rates voluntarily) are new in biological thinking. They're not quite as dogmatic as some of the more central tenants of evolutionary theory.
--- End quote ---
I see your point. However, it sounds like it would be difficult to implement and difficult for evolution to take advantage of (since each "protect codule1" instruction must tie to a certain "codule1" exon, etc...).
How about having the protection instruction that Eric and I were talking about act like a protein, so it can be "glued" to the exon? That way, if one instruction in the exon moves, then the entire codule (including the mutation protection "protein" instruction) moves. You could also have multiple mutation protection protein instructions (MPPIs) for the same codule, like having
10 .protect5 store
9 .protect50 store
in which case the two MPPIs could "compete" for protecting the next exon within the next nine/ten lines***, just like how you said two or more proteins could be assigned the same exon to protect. Here, maybe one of the mutation rates could be randomly chosen out of the two, because the other MPPI couldn't bind to the exon before the first one did.
Or, the 9 .protect50 store could apply it's mutation rate to only the next nine bps, but let the 10 .protect5 store govern it's (the 9 .protect50 store's) mutation rate. This way, you can never 100% protect a certain exon (since even a 10 .protect0 store is subject to the outside mutation rate, so it could change to 10 .protect200 store) but you can get really close, just like real biology.
The only problem with this idea is that the protected exon must be directly behind the MPPI, like Numsgil pointed out. However, since the MPPI acts like a protein (it's basically an exon that makes a protein that attaches to the parent exon and the next x bps), this is still just like real-world biology. Besides, the fact that the MPPI is right before the exon it protects is not a big deal. Why make code somewhere else that protects code at another place? This does the same thing, evolutionarily speaking. Also, come to think of it, having code at one place protect code at another place sounds like a DB version of goto. Nesting them is a debuggers' nightmare.
Just one instruction, so it's easy to implement and easy for evolution (and coders) to use, but it also has most of the features Numsgil wanted (like binding specifically to one exon, and binding-site competition).
Plus, it can decrease or increase mutation rates, like by having 10 .protect200 store, which would double the mutation rate for the next 10 bps.
Everyone happy?
***- With this method, an MPPI could protect lines of code not directly behind it.
Numsgil:
I don't like the idea of any sysvar or command influencing mutation rates (of a subset of the DNA anyway). Having it use the stack and sysvars is not an improvement over just using a command.
What I'm thinking, in the short term, is something like this:
--- Code: ---[x0]
cond
*.nrg 5000 >
start
50 .repro store
stop
[/x0]
--- End code ---
The [] tags would let you specify meta data, that applies for all base pairs until you find the matching closing [/] tags. (In this example, the x specifies a mutation multiplier, with 0 meaning mutation rates for this section get multiplied by 0). It would get "compiled" into something like this:
--- Code: ---(type: flow logic) (value: 1) (mutation multiplier: 0)
(type: sysvar) (value: 236 (or whatever .nrg is)) (mutation multiplier: 0)
etc.
etc.
--- End code ---
That is, right now the DNA is stored in memory as a pair of numbers: one describes the type, the other describes what it actually is (cond, start, stop, else share a type but have different values). To that tuple I would add a float that describes a mutation multiplier. It defaults to 1.0, but can be modified by special tags. If we really want, we could have these multipliers subject to mutations as well. I'm not sure I like the idea (it would get really messy with evolved DNA), but I wouldn't be against it either.
It's not what I'll probably do for DB3, but I think it addresses both Eric and my concerns, with the added benefit that it can be done right now. Not sure if it addresses your concerns, though.
bacillus:
--- Quote from: jknilinux ---
--- Quote from: bacillus ---I don't like the idea of changing the rate of mutation too much; if anything, it should be treated like internal slime eg. higher protection lasts for a less period of time, and wears down in relation to the amount of protection offered, and the amount of DNA protected.
--- End quote ---
But that's nothing like real-world Biology. An organism doesn't get increased mutation rates after it lives a long time. Photosynthesis doesn't wear down if a tree lives for a thousand years, because an organism's mutation rate is not dependant on time, amount of DNA, or anything else.
--- End quote ---
Actually, more than you think. Internally, DNA is tended to by having enzymes which 'remember' certain assigned parts of DNA; if an error is found in these, eg. the sequence doesn't match, it is replaced by the version the enzyme is carrying. This doesn't mean that DNA is immutable though, the backup copy can always mutate. More protection simple means more backups.
Navigation
[0] Message Index
[#] Next page
[*] Previous page
Go to full version