*less* quantum immortality?
---------------------------

if the set of nested universes [really does](what-happens-when-you-die.html) look like a funny graph of bubbles, i think there are two likely possibilities: either the set of bubbles rapidly dries up, or it grows towards infinity; in which case, if compute is infinite [as wolfram would have me think](https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/) then as soon as the bubble explosion happens, it's likely a [universal complete](universal-complete.html) algorithm is booted somewhere reasonably fast, itself booting in turn all initial states.

this has the result of instanciating all (countable, discrete) [tegmark 4 universes](https://space.mit.edu/home/tegmark/crazy.html), over time.

yet, [we still observe a preference for coherency](limiting-real-universes.html): i think the reasonablest interpretation of what'd be going on is that "computationally early" or at least "computationall frequent" states are favored; and thus, very weird and incoherent initial-state universes *do* get spawned, but much later and/or are being computed more slowly (for example, maybe computation is equally distributed among all timelines, and as more and more timelines spawn over time each individual one gets updated less and less often).

while this creates a neat explanation for what selects for universe coherence, it does make it that while [quantum immortality/suicide](quantum-suicide.html) can be considered to "still work", if you choose to keep living [only by waiting to be reincarnated later](what-happens-when-you-die.html), you're reducing the "realness" of your continued existence; you're making universes in which you continue to live appear only "computationally later".

it also provides a nice simplicity test fo roccam's razor: the simplicity of a hypothesis can be akin to how soon a universal-complete program that simulates all spawned computations arrives at it.

this probly doesn't apply to "classical" quantum immortality where you just use the fact that you're redundanced on other timelines, because i would imagine those other you's in other timelines would tend to be computed "at the same time".


thinking about psi: as a more general json
------------------------------------------

[JSON](https://en.wikipedia.org/wiki/JSON) is a format that's designed to work well with JavaScript — to move around entire JavaScript objects, you can `JSON.stringify` them on one end, and then `JSON.parse` them back on the other end.

this is very cool, but it's limited: it can't support cycles, can't deduplicate shared data, and can't send code — those issues are actually related: part of the problem with serializing code is that functions are often recursive or even mutually recursive (which takes either cyclical representations to send, or otherwise a layer of indirection to remove cyclicality) and that many functions point back to other shared functions in a structure that looks like a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph), where you would ideally want the upstream nodes to be deduplicated.

[psi](psi.html) tries to address these issues by being a universal format that supports cycles and efficiently unifies shared structures, such that they remain a single big piece of data pointed to for example using an [IPFS](https://en.wikipedia.org/wiki/InterPlanetary_File_System) address, and only small changes can be sent along.

in addition, psi's recommended usage of randomly-generated identifiers to represent concepts also makes psi payloads universal as opposed to only contextually meaningful, which hopefully makes things nice for things like interoperation or debugging.


non-scarce compute means moral patients might not get optimized out
-------------------------------------------------------------------

i tend to assume AI-borne [X-lines are overwhelmingly more likely than S-lines or U-lines](timeline-codes.html), because in almost all cases (such as [paperclip manufacturing](https://en.wikipedia.org/wiki/Instrumental_convergence#Paperclip_maximizer)) the AI eventually realizes that it doesn't need to waste resources on moral patients existing (whether they're having an okay time or are suffering), and so recycles us into more resources to make paperclips with.

but [if wolfram's idea is correct](https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/#how-it-works) — a possibility which [i'm increasingly considering](ai-alignment-wolfram-physics.html) — it may very well be that computation is not a scarce resource; instead printing always more paperclips is a trivial enough task, and the AI might let "bubbles" of computation exist which are useless to its goals, even growing bubbles.

and those could contain moral patients again.

of course this reduces to the [*no room above paperclips* argument](above-paperclips.html) again: inside that bubble we probly just eventually make our own superintelligence again, and *it* takes over everything, and then either bubbles appear again and the cycle repeats, or eventually in one of the layers they don't anymore and the cycle ends.

but, i still think it's an interesting perspective for how something-maximizing AIs might not need to actually take over *everything* to maximize, if there's nonscarce compute as wolfram's perspective can imply.


yes room above paperclips?
--------------------------

in two [previous](above-paperclips.html) [posts](nonscarce-compute-optimize-out.html) i talk about the ultimate inability for interesting things to happen when everything has been tiled with paperclips, even if the superintelligence doing the tiling isn't very good at it — i.e. lets room exist ["besides" (by superintelligence not actually consuming everything)](nonscarce-compute-optimize-out.html), or ["above" (using as a substrate)](above-paperclips.html) said paperclips (or whatever else the universe is being tiled with).

but, actually, this is only true if the spare compute (whether it's besides or above) only has room for one superintelligence; if that spare compute is composed of multiple bubbles causally isolated from one another, then maybe a superintelligence permanently kills everything in one, but another one creates even more bubbles in another.

in fact, as long as the first superintelligence to create many bubbles preceeds the first superintelligence to create no bubbles at all, and then if the amount of bubbles tends to be slightly more than one, and assuming superintelligences can't (or can only do so at a lesser rate than new bubbles being created) just "hack back upwards" (to escape to their parent universe), we can expect the set of pre-X-risk superintelligence bubbles to just increase over time.

this might provide a better explanation [than just us dying forever](estimating-populated-intelligence-explosions.html), for the weird fact that we exist now when the future could contain very many ([plausibly infinitely many](ai-alignment-wolfram-physics.html)) persons: it's not just that the amount of pre-singularity population is large compared to future timelines multiplied by their low likelyhood of being populated, it's that it grows over time forever and so makes it harder for U-lines or S-links to "compete", expected population wise.

we can then run into weird questions: rather than a tree, or even a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph), why couldn't this be just a general graph? if [the "seeds" for complex universes can be simple](https://en.wikipedia.org/wiki/Rule_30), it makes sense to imagine bubbles causating each other: maybe someone in [Rule 30](https://en.wikipedia.org/wiki/Rule_30) eventually boots a superintelligence that takes over everything but happens to cause a [Rule 110](https://en.wikipedia.org/wiki/Rule_110) bubble to appear (perhaps among many others), and then in that Rule 110 bubble someone creates a superintelligence that causes a Rule 30 bubble to appear again.

conceptually navigating this likely cyclical graph of pre-superintelligence bubbles seems like headache so i'll put the matter aside for now, but i'll be thinking on it more in the future. for the moment, we should expect bubbles with simpler seeds to be highly redundanced, and ones with more complex seeds to be rarer; but there's no reason to assume any ceiling on bubble seed complexity (in fact, if even just one of these bubbles is [universal complete](universal-complete.html), then *any* seed eventually gets instanciated!), and it seems nigh impossible to predict which types or complexities of seeds could lead to which outcomes, superintelligence-wise.

in the meantime, rember that while things might look pretty hopeless with this perspective, [it's plausible that we can actually actually causate *very far*](https://www.lesswrong.com/posts/PcfHSSAMNFMgdqFyB/can-you-control-the-past).

yes room above paperclips?


database transactions: you guessed it, it's WASM again
------------------------------------------------------

i barely need to say anything past the opening title: to run arbitrary transactions to a database server, whether they be atomic or not, instead of a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) like SQL, we should use [WASM](https://en.wikipedia.org/wiki/WebAssembly) programs that would have the ability to read, lock, mutate, etc. pieces of data arbitrarily inside, for example, [a key-value store](https://en.wikipedia.org/wiki/Key%E2%80%93value_database).

this allows a single server to run transactions one after the other, without letting different clients become desynchronized, but also without having to *understand* the data being stored — that can all be up to clients.

for example, maybe a value somewhere represents a list, and two clients send at the same time a WASM transaction that will insert an element into that list. the two WASM program calls can run in sequence on the server, resulting in the correct list with both values added, without requiring the server to "understand" that the value is a list (as would be the case in SQL) nor having desynchronization issues (which would be the case if clients were to fetch the list, modify it, and then send the new value back).


unoptimal superintelligence doesn't lose
----------------------------------------

i [previously](unoptimal-superint-loses.html) wrote a post about how a superintelligence with an unoptimal decision system likely loses to alien superintelligences that are more optimal, at the scale of cosmic wars between those superints.

i don't think this is necessarily true: maybe physics *does* look like a funny graph à la wolfram, and then maybe we can carve out pieces of space that still grow but are causally isolated from the rest of the universe; and then, whether a given causally isolated bubble ever has to encounter an alien superint is purely up to whether it decides to generate alien space that leads to those, which is prevented easily enough.


emotionally appreciating grand political visions
------------------------------------------------

it is useful to build an intellectual understanding of what makes people defend the three grand political visions to emerge from the 20th century — liberalism/capitalism, socialism/communism, and nationalism/fascism.

that said, i believe it is also neat and good for perspective to be able to *appreciate* why people are *emotionally attached* to those visions; here is how i've built those appreciations for myself.

i can emotionally appreciate socialism/communism as presenting a romantic vision of building a world together. socialism really pushes the idea of collaborating, of emancipating people from automated nonhuman systems and devices and letting them take control of their world and build their future together. it's a very fraternal vision, and that's a profoundly appealing aspect.

i can emotionally appreciate nationalism/fascism as the promotion of the *tribe*; when reframed in term of subculture groups that i do feel a strong kinship to — such as channer culture or weeb culture — i'm strongly able to relate to nationalistic ideas of preserving a purified community, insulated from outside cultural influence.

and, i can emotionally appreciate liberalism/capitalism as the system that ruthlessly satisfies humans. in this sense, commodification is a very "[humanity fuck yeah](https://www.reddit.com/r/HFY/)" idea: whatever the universe has in store for us, we *will* be able to assimilate it and make it easily accessible to the masses, and we *will* instrumentalize its forces and processes ever for the maximization of demand satisfaction, no matter how weird or individualistic it gets.


psi rewriting
-------------

my [psi](psi.html) format is quite inspired by [wolfram's hypergraphs](https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/#how-it-works), though those include a turing-complete rewriting system. in this post i sketch out something similar for psi which i'd argue is a lot more elegant.

in a way, wolfram's hypergraph rewrite system can be said to be a kind of [linear system/move semantics](https://en.wikipedia.org/wiki/Substructural_type_system#Linear_type_systems) in which quantities are consumed and produced: namely, edges in the graph are consumed and produced by rules, and their presence is required for a rule to apply; in addition, the system gets nondeterminism from deciding which rule gets to consume a given edge when several could.

psi rewrite rules are similar to wolfram's, except for the following differences:

* they don't consume their input; they only create output
* they don't quite apply in discrete time steps (see "determinism")
* nodes are purely informational, there are no vertices that count as intrinsically different mathematical objects

### constructivity

in this system, new nodes can only be created, not consumed. this works great for "constructive" systems such as logic, where new true statements can be created but not consumed; for systems like cellular automata, one can construct an artificial timekeeping system by defining each new state as a function of its past state.

### informationality

given a starting set of nodes, the amount of data can only grow; a rule can be applied again to an existing set of nodes but because psi merges together observationally identical nodes, applying a rule to equal nodes a second time to the same input doesn't do anything; the result already exists.

so, all information is defined, and tested for equality, purely on a basis of relation to other information; and if two identical nodes are constructed at different "places" of the psi state, they are merged together; avoiding wolfram's need to do extra work to notice identical patterns in different states.

it can also be hoped that these properties allow an implementation of this rewrite system to more natively recognize, and merge, "locally equivalent" computations in the way [hashlife](https://en.wikipedia.org/wiki/Hashlife) does.

### determinism

rule application is kind of deterministic, but which part of the computational expansion you choose to follow (which local area of the graph you observe from) and the result of which rule applications you choose to follow can be considered a source of indeterminism.

unlike "native multiverse" systems like wolfram where [timelines on one hand, and different locations in space on the other](https://space.mit.edu/home/tegmark/crazy.html) are a different source of parallelism, this makes nondeterminism have only one source: which part of the set of nodes you follow (and not: which hypergraph timeline-instant *and* which piece of space in that timeline-instant).

in this way, nondeterminism with multiple timelines is implemented "on top" of the system: the base framework can be considered to be a deterministic system that just computes all timelines, and which one you choose to look at is the source of nondeterminism.

i expect that this unification of time/timelines together with space will greatly simplify bookkeeping the entire history of expanding computations; in fact, with the exception of rule constructed nodes that are not connected back to existing nodes, any expansion of the psi graph is also [its own causal graph](https://en.wikipedia.org/wiki/Causal_graph): new nodes point to the existing nodes that have allowed it to exist.

note that, together with constuctivity, the unification of time and space means that units of space in a cellular automaton also need to be defined relative to one another instead of relying on "intrinsically different" vertices.

### limitations

there seems to be one main limitation in this system: cycles can only exist within a piece of data that results from only a single rule application; a cycle can't span the results of multiple rule applications, because one application preceeds the other and the nodes produced by the first application can't have their fields point in the future to nodes that haven't been created yet.

there is a way, however, to overcome this: if rules themselves are objects in the graph, maybe in the form `(→ input-list output-list)`, then some rules can produce novel rules, and thus one can encode "general rules" able to generate (with full turing-complete ability) arbitrarily complex rules, which in turn can be applied to produce arbitrarily complex cycles in a single rule step.

psi rewriting


non-interfering superintelligence and remaining philosophical progress: a deterministic utopia
----------------------------------------------------------------------------------------------

[in a previous post](against-ai-alignment.html) i talk about the need to accomplish philosophical progress at determining what we value, before alignment. i wouldn't be the first to think of "what if we boot superintelligence now, and decide later?" as an alternative: it would indeed be nice to have this possibility, especially given the seeming imminentness of superintelligence.

alas, typically, making this proposition goes like this:

* A: "we should boot superintelligence now, and make it that we can adjust it later when we figure out more of philosophy."
* B: "yeah, but superintelligence isn't gonna just wait: it's gonna want to try to make us figure out whichever philosophy would make its job simpler, such as actually we value all dying immediately so that there's nothing to protect"
* A: "well, in that case, we need to make sure superintelligence can't interfere with our decision process."
* B: "and *how* do you ensure that the new being running all things in the world, has no interference into human affairs, exactly?"

which is a pretty good point, and usually a reasonably A concedes at that point.

today, however, i am here to offer a continuation to this conversation, from A's side.

my idea is to implement a deterministic computational utopia for people to be uploaded in, whose internals are disconnected from the outside world, such as [∀V](%E2%88%80V.html); if we have infinite compute, then it can be even more free from outside interference.

the trick is to have that utopia's principles be *deontological*, or at least to make them absolute rather than able to be weighed against decisions outside of it: as it largely is in ∀V, ensure everything about utopia has a definite okay or not-okay status, evaluable without knowing anything about the "outside" of this utopia. either someone's consent is being violated, or it's not. with a set of decisions based only on the state of the utopia being simulated, every decision of the superintelligence about what it does in ∀V is unique: all superintelligence is doing is calculating the next step of this deterministic computation, including ethical principles, and thus there is nothing superintelligence can do to bias that decision in a way that is helpful to it. all it can do is run the computation and wait to see what it is that persons inside of it will decide to reprogram it to value or do; on the outside/before the singularity, all we need to ensure is that superintelligence does indeed eventually run this computation and apply the changes we decide on once it finds them out.

under these conditions, a device could be set up for us to later reprogram superintelligence somehow when/if we ever figure out what values we *actually* want, and it wouldn't be able to meaningfully interfere with our decision process, because every decision it takes regarding how our utopia is ran is fully deterministic.

not that i think being able to reprogram a superintelligence after boot is necessarily a good idea, but at least, i think it can be a possibility.


freedom and diversity in Albion's Seed
--------------------------------------

considering my interest for america and for human cultures in general, ever since reading [the Slate Star Codex review of Albion's seed](https://slatestarcodex.com/2016/04/27/book-review-albions-seed/) i'd been meaning to read the whole thing (as has happened [several](https://slatestarcodex.com/2017/03/16/book-review-seeing-like-a-state/) [previous](https://slatestarcodex.com/2019/06/04/book-review-the-secret-of-our-success/) [times](https://slatestarcodex.com/2019/10/14/book-review-against-the-grain/)).

i was not disappointed, but the main two takeaways i got from this fascinating book about the four main early british colonial cultures in america are only tangentially related to america or the british; they are about freedom and diversity, great topics of fascination, as well as intrinsic valuing, for me.

for a general idea of what the book is about, you might want to read that Slate Star Codex book review before reading this post.

### freedom

the book consists of four sections (one for each of the main cultures of early british colonies in america), each consisting of a sequence of parts going over how each of those cultures relate to a variety of aspects: geographical and socioeconomic origin in the british isles, food, clothing, religion, architecture, life, death, time, magic, marriage, sex, politics, etc…

the last part of each section is about how each of those four cultures views freedom. it's particularly interesting because the book seems to be making a point about how those four radically different visions of freedom contributed to the general modern american understanding of freedom: it is a pluralist view where many people have different meanings about what freedom means to them.

in fact, the book contains a conclusion after the four main sections, whose very last part is about this very notion: cultural views on freedom in america, and how they've been contributed to by those four cultures.

i don't think it can just be reduced to "actually they're four different cultural values that all have the word freedom or liberty attached to them", either: there does seem to be some freedom-ey core invariant to all four visions, even if it takes more effort to see it in some.

this makes me pessimistic about [trying to come up with a single unifying definition](defining-freedom.html), but maybe that's to be expected: [value is complicated and fragile](https://www.readthesequences.com/Value-Is-Fragile) after all, and the scope of "freedom" in human caring has been particularly big. indeed, look into history and you'll find numerous peoples from all kinds of cultures describe what they're fighting for as "freedom", and there probly *is* a way to understand those as still a perspective on some essence of freedom if one is open-minded enough, even if it's hard to pin down what that essence is.

### diversity

a friend of mine once pointed out how in the video game Mass Effect, the difference between humans and other *alien* cultures, who have spent almost all their existence on *completely different planets*, are lesser in the game than differences *between human populations, on the earth, in real life, right now*.

this isn't a point about how those aliens look, though it may be part of it: it's largely a point about how they talk, how they think, how they view the world and transmit knowledge, etc…

in addition, when i talk to people, i see them make what seem to me like insane underestimatings of human diversity. "if someone does this, then they'll say this"; "if this happens to a people, they will do this"; "people would enjoy a single society like this"; and so on. as for me, i've come to increasingly believe that the breadth of human diversity is immense, and that very few assumptions can be held about how a population, let alone a person, can think, or act, or react, in general — almost all such assumptions are bound to be anchored in the culture of whichever local culture the person making those claims is from. this is kind of akin to what happened when linguistics discovered languages like [Pirahã](https://en.wikipedia.org/wiki/Pirah%C3%A3) that wildly break assumptions about invariants in human language — there are some invariants we should believe in still, but they are much lesser than what we originally assumed.

Albion's Seed makes a great case study in diversity, and has become my go-to example for it: all four of the cultures depicted are broadly protestant british peoples existing at about the same time period, and yet their historical and environmental circumstances makes them have such a different cultural core than when they move to america and are able to implement their culture and lifestyle to a much greater extent, the results end up being wildly different and alien to one another.

to point out individual differences would be underselling the sheer scope of their quantity, so i'll just ask you to read the Slate Star Codex book review for an idea of just how much these four cultures differed. and again, all that differences is *just* within four protestant british peoples from the era of colonialism in america! imagine what it must be on the whole of earth, or what it *could* be once we multiply beyond earth (whether that be in space or in some uploaded form).

freedom and diversity in Albion's Seed


the deobfuscation conjecture
----------------------------

suppose i write a program that tries to find counterexamples to [fermat's last theom](https://en.wikipedia.org/wiki/Fermat's_Last_Theorem): that is, numbers a>1, b>1, c>1, n>2 such that aⁿ+bⁿ=cⁿ.

suppose i now explain to you this program; you will probably shortly understand what it is doing.

now, suppose i compile it, and run its compiled code through an obfuscation algorithm such as [movfuscator](https://github.com/xoreaxeaxeax/movfuscator); with the strict requirement that the output program has the same I/O and [time complexity](https://en.wikipedia.org/wiki/Time_complexity) as the input program (i *believe* this is the case for movfuscator).

can you, manually or with the help of a deobfuscator or even in a fully automated manner, *now* figure out that the program is trying to find counterexamples to fermat's last theorem?

with infinite time, surely; the conjecture that i posit here (well, that i *posited*, see below) is that you can do so in an amount of time that is at most linear in the amount of time it would have taken you to understand the original program.

in general, the deobfuscation conjecture says this: for any code obfuscation program that conserves I/O and time complexity, and for any reasonable notion of "understanding" what a program does that is conserved by obfuscation (such as "does this program halt" or "will this program find a counterexample to fermat's last theroem if there is one"), there exists a deobfuscation program that determines that criteria for the obfuscated program in the same time complexity (as a function of the program size) as the fastest program that determines that criteria for the unobfuscated program.

or, put another way: as long as I/O and time complexity are conserved, transforming a program does not change the time complexity in which can be tested other criteria of the program, or in which it can be [reduced](https://en.wikipedia.org/wiki/Computational_irreducibility).

as evidence for this conjecture, i'll point to the ability of video game crackers to pretty systematically overcome [software DRM](https://en.wikipedia.org/wiki/Digital_rights_management), to extract the behavior of the program they care about.

a corollary to this conjecture is that shipping a program together with "hints" about what it does cannot help to understand it by more than a constant factor.

### a proof that it's false

while writing this post and talking about the conjucture with a friend, they helped me figure out a proof that it must be false.

consider:

* the program is a program that will sort a hardcoded list and output the result
* the criteria is "what will the program output ?"
* the hint being shipped with the program is a list of what position each item in the original list will occupy in the final sorted list

with the hint, the criteria can be determined in O(n): checking that the hint is indeed a correct sorting of the list is O(n), and so is checking that the program is indeed the sorting algorithm (for this proof we can just hardcode recognizing one specific sorting algorithm; the space of this proof is merely the set of hardcoded lists, while the sorting algorithm is constant).

without the hint, however, the criteria can only be determined in O(n × log(n)): after one has figured out that the program is a sorting algorithm, one has to actually sort the list to figure out what the program will output, which is known to take at least O(n × log(n)).

and so, the hint helps by more than a constant factor, and there can indeed be information shipped alongside a program that can help determine criteria about it; and thus, obfuscation can indeed make a program harder to understand by more than a constant factor.

the deobfuscation conjecture


think in what ?
---------------

most people think in words; some think in images, or sounds, or sometimes even concepts.

computers are kind of the same: while a lot of computer "thinking" is fairly opaque, a lot of it is textual: the command line and shell scripts, JSONs being sent around, and other "flattened" textual representations comprise a significant portion of human-program and program-program interaction (just think of how often a number circulating in computer systems will take the form of a decimal text string).

one could imagine (though it would be very weird) an alternative timeline in which most computer interaction, be it between programs and users or between programs and other programs, happens via images, or via sound, even though those sound [pretty messy](analogpunk.html).

my point with this is that a core goal of [psi](psi.html) is to get our computers thinking in structured ideas, in the way i like to do in my own brain; to extract [the most general shape of information](categories-of-knowledge.html) and have other forms be secondary representations.

think in what ?


Genuineness, Existential Selfdetermination, Satisfaction: pick 2
----------------------------------------------------------------

imagine you have a world where one person wants the moon to be painted blue, and another wants the moon to be painted red.

they both mean the current actual physical moon as it exists now; they both refuse any "cheating" option such as duplicating the moon or duplicating reality, and they don't want their minds changed, nor to compromise.

there's three ways to resolve situations like this:

* you sacrifice **genuineness**: you somehow make both of them believe, mistakenly, that what they want is satisfied. maybe by unknowingly giving them eye implants that change what color they see the moon.
* you sacrifice **[existential selfdetermination](core-vals-exist-selfdet.html)**: you ensure the situation never happens to begin with, that no two persons will ever want the moon to be painted different colors; or maybe you brainwash one of them after the fact.
* or, you sacrifice **satisfaction**: you let them want what they want, and let them see what the moon looks like, such that at most only one of them will ever be satisfied.

you can't have all three of those things.

many hedonists will happily sacrifice **genuineness**; authoritarians like to sacrifice **existential selfdetermination**.

as for me, for [∀V](%E2%88%80V.html), i ultimately sacrifice **satisfaction**: while people can choose to become mistaken about things, the default is that they get to access the actual true state of things.


the two-vtable problem
----------------------

when programming, there are in general two types of interfaces: "static, known" interfaces and "dynamic, unknown" interfaces.

in the former, the possibilities are well known. maybe an object has a bunch of public methods that can be used, or maybe even public fields; maybe an API has a known call endpoints.

when the behavior or contents of an object are unknown or inaccessible, someone can still implement how it interacts with another known-interface object: just send the known object to the unknown object, and let the unknown object manipulate the known object however it wants.

however, there is no general way to make two (or more) objects interact with each other, when they both have a dynamic/unknown interface.

this is what i call the **two-vtable problem**.

one approach is to implement all n² behaviors: implement the behavior for any possible concrete type of one object and any possible concrete type of the other. the rust ecosystem is kind of like that with types and traits: if you have `N` types and `K` traits, unless one of those traits has a blanket implementation for all types, you'll need to write `N×K` implementations to have proper coverage in the general case.

but this is hardly scalable; and doesn't work well, for example, in environments in which objects are expected to be implemented by different parties that don't necessarily coordinate with one another, where those objects are then expected to work together without putting in extra effort afterwards. i'm sure this probly has been encountered a lot for example in video game modding communities, regarding the interaction between mods created by different people.

an answer can be taken from other fields that have already solved that problem on their own, however. i can think of two: how natural selection solved negotiation between dynamic persons, and how liberalism solved negotiation between dynamic private actors.

the general solution to the two-vtable is to have the two objects have a language —as tells us the evolution of humans— that they can use to communicate and negotiate an outcome. liberalism tells us that the shape of negotiated outcomes is contracts, and cryptocurrencies tell us that the formalized form of contracts is programs.

and so, here is my proposed solution to the two-vtable problem: when two dynamic objects want to interact with one another, that interaction must take the shape of the two of them building a program together, which will be executed once they both agree on it. perhaps this can take the shape of both of them sending an initial contract to the other which is ideal from the perspective of the sender, and from there try to incrementally build up programs that implement a compromise between the two ideals, until they meet somewhere in the middle; like haggling.

this framework generalizes nicely enough that it could be used for arbitrary informatic agents, such as a bot and an uploaded person, or two uploaded persons. in fact, contract negotiation of that kind, when understood enough by both agents partaking of it, can be the formalized form of consent, a matter i've [grappled with formalizing](defining-freedom.html) for [my utopia](%E2%88%80V.html).

this could also be useful for negotiation between different [compilation stacks for portable programs](portable-programs.html), or even for the negotiation between [different wasms running on a liberal server market](saving-server-internet.html).

the two-vtable problem


no room above paperclips
------------------------

(edit: see also [*yes room above paperclips?*](above-paperclips-2.html))

when presented with the idea of a [paperclip-maximizing unaligned superintelligence](https://en.wikipedia.org/wiki/Instrumental_convergence#Paperclip_maximizer), people sometimes mention the possibility that sure, the universe gets tiled with paperclips, but maybe there's [slack](https://thezvi.wordpress.com/2017/09/30/slack/) in how paperclips are arranged, and that maybe nice things can exist again "above" paperclips.

(note: this relates to the idea of ["daemon-free"ness in "minimal circuints"](https://www.lesswrong.com/posts/nyCHnY7T5PHPLjxmN/open-question-are-minimal-circuits-daemon-free))

i think it's a reasonable line of thinking, but it's short-sighted: let's think about what happens next. eventually, above those paperclips, some evolutionary process may take place, leading (possibly, such as in our case, through the step of a technological species) eventually to a superintelligence taking over everything. given that *the entire cosmos* gets tiled with paperclips [*possibly forever*](ai-alignment-wolfram-physics.html), and that a superintelligent singleton taking over everything is irreversible (short of everything dying forever), in all likelyhood in the long term in any piece of universe not already actively managed by a superintelligence, eventually either everything dies forever, or a superintelligence takes over everything forever.

and then what? either this new superintelligence cares about "upwards", and has some plan for how its own paperclips are arranged (such as into more "macro"-paperclips), or it doesn't and the cycle begins again.

given that the outcome of an "alien" superintelligence's takeover is probly a worse outcome than the takeover of a superintelligence of our own (we should expect them to be about as incompetent as us at alignment, but to have values [less aligned to ours](https://www.lesswrong.com/posts/HawFh7RvDM4RyoJ2d/three-worlds-collide-0-8)), we need to care about our own iteration first, it's our best bet.

the point is, eventually for any given local patch of spacetime, either a superintelligence explosion is reached or everything dies forever. this can't be avoided, even by "climbing up" on substrates, so we should care about alignment now; we can't just hope that things are okay despite paperclips.

no room above paperclips


endiannesses
------------

i extend the term "[endianness](https://en.wikipedia.org/wiki/Endianness)" to mean the order of symbols within a representational sequence, and whether that order is least-significant to most-significant (little endian, hereby LE) or most-significant to least-significant (big endian, hereby BE).

in technology and culture, there are a variety of places in which endianness makes sense to talk about, and not all of them are of the same endianness.

* famously, and this is what let to the terms LE and BE being coined for numbers in the first place, bytes within a multiple-byte-wide integer in computers can have different endianness, typically depending on [ISA](https://en.wikipedia.org/wiki/Instruction_set_architecture); though LE has become the de-facto standard
* in computers, bits within a byte are LE; indeed, bit-shifting instructions address in order the least significant bit as 0, the second most significant bit as 1, the third as 2, and so on. this is why i believe LE is the correct choice for bytes within an integer: it's coherent with the order of bits within an integer.
* numbers in english are in BE: in the number "5005", the first "5" is more significant than the last "5". that said, english uses arabic numerals, which were still ordered with the most significant digit on the left even when they were used in arabic, which is read to right-to-left. this makes arabic numerals dependent on language, and originally LE, as it still in semitic languages.
* times of the day, such as "11:30" are in BE, though "5pm" is LE ("pm" is more significant than "5"), which makes "eleven thirty PM" mixed endian.
* dates in most western countries such as "31/12/2005" are LE, while dates in america such as "12/31/2005" are famously mixed endian; the recommended [ISO-8601](https://xkcd.com/1179/) dates are BE.
* postal addresses like "John Doe, 50th Central Avenue, Seattle, Washington, USA" are LE
* file paths such as "/home/carado/.bashrc" are BE, but domain names such as "something.carado.moe" are LE, making URLs (with a domain name followed by a file path) mixed endian.
* in the same vein as file paths, C-like programming language record access paths like `customer.address.city`, and indeed paths in almost all computering contexts i know of, are BE
* possessive sequences like the english "john's mother's cat" or the japanese "ジョンの母親の猫" are BE

endiannesses


unoptimal superintelligence loses
---------------------------------

(edit: [maybe it doesn't](unoptimal-superint-doesnt-lose.html))

what if a phenomena is powerful enough to kill everyone, but not smart enough to be optimal at reasoning? (such as a grey goo event, or a "dumb" superintelligence with a faulty decision mechanism)

then, in all likelyhood, it eventually dies to an alien superintelligence that is better at decision-making and thus at taking over everything.

our superintelligence doesn't just need to be aligned enough; it needs to be aligned enough, and on the tech side, to be maximally intelligent. hopefully, it's smart enough to start making itself smarter recursively, which should do the trick.

the point is: when talking about the eventual superintelligence(s) that reign over the cosmos, assume whichever one(s) to have "won" to be optimal at decision making, because others probly got outcompeted.

unoptimal superintelligence loses


rust & wasm, without wasm-pack
------------------------------

i like to keep my software stacks simple.

to write [wasm](https://en.wikipedia.org/wiki/WebAssembly) modules in rust, i use a relatively simple template, which only requires the `wasm-bindgen` utility (`cargo install -f wasm-bindgen-cli`) and the `wasm32-unknown-unknown` toolchain (`rustup target add wasm32-unknown-unknown`).

the `Cargo.toml` of the project looks [like this](wasm-template/Cargo.toml); in it, the `crate-type = ["cdylib"]` part is the essential thing needed to build a wasm module.

there is [a `make.sh` script](wasm-template/make.sh), which compiles the project, calls `wasm-bindgen`, and cobbles together two html files: a `light.html` which reloads fast (good for development and debugging), but depends on `js/wasm.js` and `js/wasm_bg.wasm`, as well as a standalone `page.html` which doesn't depend on any external files, because it embeds `wasm.js` verbatim and `wasm_bg.wasm` encoded in base64 (good for distribution).

after that, it starts a `python2 -m SimpleHTTPServer` serving the `light.html` file at <http://localhost:8000/light.html> (unlike `page.html`, it unfortunately can't be used with the `file://` scheme because of [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing) security restrictions).

i also use [a script called `cw`](wasm-template/cw) which requires `cargo watch` (`cargo install cargo-watch`) and calls `make.sh` each time the project's source code is modified.

finally, to cobble together the html documents, `make.sh` uses a `head.html` and `tail.html`, which are meant to remain static.

the files from the template can be browsed [here](wasm-template) or [downloaded as a tarball](wasm-template.tar.gz).

rust & wasm, without wasm-pack


against AI alignment ?
----------------------

[i usually consider AI alignment to be pretty critical](were-all-doomed.html). that said, there are some ways in which i can see the research that is generally associated with alignment to have more harmful potential than not, if it is applied.

this is a development on my idea of [botched alignment](botched-alignment-and-awareness.html): just like AI tech is dangerous if it's developed before alignment because unaligned AI might lead to [X-lines](timeline-codes.html), alignment is dangerous because it lets us align AI to things we think we want, but aren't actually good; which sounds like it could lead to an increase in the ratio of S-lines to U-lines.

with this comes a sort of second [orthogonality thesis](https://www.lesswrong.com/tag/orthogonality-thesis), if you will: one between what we think we want and what is actually good. note that in both cases, the orthogonality thesis is a *default* position: it could be wrong, but we shouldn't assume that it is.

determining what is good is very hard, and in fact has been the subject of the field of *ethics*, which has been a work in progress for millenia. and, just like we must accomplish alignment before we accomplish superintelligence if we are to avoid X-risks, we might want to consider getting ethics accomplished before we start using alignment if we are to avoid S-risks, which should be a lot more important. or, at least, we should heavily consider the input of ethics into alignment.

things like [my utopia](%E2%88%80V.html) are merely patches to try and propose a world that *hopefully* doesn't get *too bad* even after a lot of time has passed; but they're still tentative and no doubt a billion unknown and unknown unknown things can go wrong in them.

it is to be emphasized that both parts of the pipeline are important: we must make sure that what we think is good is what is actually good, and then we must ensure that that is what AI pursues. maybe there's a weird trick to implementing what is good directly without having to figure it out ourselves, but i'm skeptical, and in any case we shouldn't go around assuming that to be the case. in addition, i remain highly skeptical of approaches of "value learning"; that would seem like it would be *at most* as good as aligning to what we think is good.

so, it is possible that just as i have strongly opposed doing AI tech research until we've figured out AI alignment, i might now raise concerns about researching AI alignment without progress on, and input from, ethics. in fact, there's a possibility that putting resources into AI tech over alignment could be an improvement: [we should absolutely avoid S-risks, even at the cost of enormously increased X-risks](when-in-doubt-kill-everyone.html).

against AI alignment ?


psi: a universal format for structured information
--------------------------------------------------

representing structured information in general is not a solved problem.

in this post i outline a format tentatively called "psi", proposing what i think is the best general solution to that problem.

### rationale

there are some attempts at making a general purpose information format (XML, JSON, [CBOR](https://en.wikipedia.org/wiki/CBOR)) but psi outshines them in several respects:

* psi is designed to be very simple
* given a structure of modules, new values can be created that reference values deep inside other modules easily (to annotate or simply reuse pieces of another psi structure)
* the format isn't burdened with either a scarce amount of privileged first-class types, nor [a central authority tasked with assigning small integer IDs to specific meanings](https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml); long random IDs give everyone the same ability to declare concepts or collections thereof
* it is designed to be easily transmitted in a variety of substrates, and [binary encodings](https://en.wikipedia.org/wiki/Binary_file) are encouraged
* it isn't bogged down in specifying endianness or specific integer sizes (typically 8, 16, 32, and 64 bits); instead, arbitrarily large natural numbers are used for everything, and specific platforms can have their own limitations in the size of indices and modules they support.

note that natural numbers can be used to reference even arrays of bytes: 0 can correspond to the empty sequence, the next 256 naturals can correspond to sequences of 1 byte, the next 65536 naturals can correspond to sequences of 2 bytes, etc.

in fact, natural numbers are the mathematically natural ways to express items of a countable set; they're what those naturally map to.

while binary formats can be hard to work with, the hope would be that tools and eventually operating systems come to support this format well enough that manipulating psi values would be no harder than manipulating usual plain text files, and in fact [tools to manipulate structured objects can be a lot richer](https://developer.mozilla.org/en-US/docs/Tools/Page_Inspector/How_to/Open_the_Inspector).

one specific use case for which i'd like to see psi used is to [overcome unicode](against-unicode.html); but others include [fact-sharing](where-next-piracy.html), proof manipulation, algebra, note-taking, sending around concepts, program representation, etc

### top-level grammar

at the top level, the units of information in psi are *nodes*, which are stateless values.

in [BNF](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form) grammar, the syntax for psi nodes is pretty simple:

`V ::= a | ( V+ )`

that is, a node is either a symbol, or a sequence of at least one node; but this is far from saying everything about psi nodes.

one important aspect of them is that they can form any structure, not just hierarchies or directed acyclic graph. when a node is in `V+` form (called a "physical" node), the elements forming its sequence (called "fields") can be any node, including the node itself or other nodes whose fields cycle back to this node.

the `a` form stands for a (countably) infinite set of "virtual" nodes, whose meaning comes from outside of the data being encoded.

together, these two possibilities allow psi to form very flexible structures, but also to reference externally meaningful ideas.

finally, as a convention, the first field of a physical node by convention indicates the type of that node. so, for example, a fraction could be expressed by a node with three fields: a virtual node referring to the concept of a fraction, followed by the numerator and the denominator.

### middle-level structure

at the middle level, a psi node is represented by a pair of a **module** and an **index**.

a module can be either:

* a "virtual module" containing either a finite non-zero amount, or a countably infinite amount, of virtual nodes
* a "physical module" containing a finite collection of physical nodes

the index of a node indicates which node in the module it is.

physical modules must obey three constraints:

* they must be the result of [graph condensation](https://en.wikipedia.org/wiki/Strongly_connected_component): if we draw up the directed graph from nodes to other nodes they reference through fields, then every node is a [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component#Definitions), while the set of physical modules themselves form a [directed acyclic graph](https://en.wikipedia.org/wiki/Directed_acyclic_graph).
* nodes inside them must be "unified" such that if exploring two nodes yields the same observable structure, these two nodes must be considered equal and referenced by the same index. a result of this is that for example cycles where every entry point is isomorphic to any other are "collapsed" into a single node. (the reason for this is that, if nodes weren't unified in this way, there could be weird effects where two people creating the same structure could end up disagreeing on which node is equal to which based on implementation details; reducing equality to observational equality is just simpler)
* finally, after these two steps, the nodes can be sorted using a standardized comparison method (not explained here, but not hard to design).

one great advantage of these limitations is that there is only one canonical way to construct any node, even considering cycles. this can make testing nodes for equality, but also establishing a consistent ordering between them or hashing them, easy enough.

also, by holding only a collection of nodes and every physical module that is referenced by following the fields of any of the physical *modules*, one holds exactly the amount of information that could be referenced by following the nodes themselves. no nodes will be missing and, more importantly, no unreachable node will be held.

this provides arbitrarily cyclical (immutable) structure manipulation, without need for a [garbage collection](https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29): since the modules form a directed acyclic graph between each other, simple [reference counters](https://en.wikipedia.org/wiki/Reference_counting) can be used. this is not just useful to store psi structures in memory, but also to store psi structures as [IPFS Merkle DAGs](https://docs.ipfs.io/concepts/merkle-dag/) with the potential for convenient reuse of modules when constructing new structures.

virtual modules on the other hand are identified by their amount of nodes, and by a large randomly-generated non-zero natural number serving as their ID. to represent a collection of external concepts, users are expected to generate a sequence of n random bits, and use 2ⁿ + the number formed by those digits, as the identifier. the 2ⁿ allows one to tell from a natural number how many random bits it has been generated with. the number of bits to generate should be chosen as a function of the expected amount of computation existing at the time of generation, to ensure collisions are avoided.

i'm not quite sure how large those randomly generated numbers should be; [random UUIDs use 122 bits](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_%28random%29); i've seen some [recommend using 160 bits](https://neilmadden.blog/2018/08/30/moving-away-from-uuids/), which seems reasonable to me.

here are some examples:

* let's say the virtual module number `2595793418667508392727470919165783019666420633976` with 128 nodes, represents the set of all 128 [ASCII](https://en.wikipedia.org/wiki/ASCII) codepoints
* in the same way, let's say the number `1757914673057156744813439560490372169016067640867` with 1,111,998 nodes represents the set of [Unicode](https://en.wikipedia.org/wiki/Unicode) characters, in order of increasing codepoint values (or maybe [private use areas](https://en.wikipedia.org/wiki/Private_Use_Areas) should not be counted?)

i also think it's reasonable to reserve the following:

* virtual module `0` with size 1 consists of the [unit](https://en.wikipedia.org/wiki/Unit_type)
* virtual module `0` with size 2 represents the logic values false and true, assigned respectively to indices 0 and 1
* virtual module `0` with an infinite size represents the set of natural numbers, each mapped to itself as index.

maybe virtual module `0` with any finite size should be considered to represent the values of modulo arithmetic of that size, and would also correspond to the unit value and booleans when that size is respectively 1 or 2. i'm not sure yet.

### low-level structure

it would be cool to define compact bitwise binary formats for storage; and likewise, it could be cool to define standard *memory layout structures* so that arbitrary programs and libraries with shared memory can move around those objects freely without having to be aware of each other's API.

in practice, some liberties can be taken for efficiency: for example, physical modules can be stored right alongside their dependencies when those are small enough, to avoid creating too many references in storage. in memory, however, this isn't recommended.

### syntactic convention

for convenience, i'm proposing a simple plain text notation for psi nodes:

a top level node is either of

* `(x1 x2 x3…)` where `xi` are nodes
* `#93418#128#97` is value 97 in virtual module 93418 of size 128
* `#93418#97` is value 97 in infinite virtual module 93418
* `#93418` is syntactic sugar for `#93418#1#0`
* `x(…)`, `(…)x`, `x[…]`, `[…]x` all alias the node to the name `x`. the node being aliased can be a virtual node, but then the aliasing name *must* be on the left. in addition, if `#`s are present between the name and the node being aliased, they indicate a local (as opposed to global) scope, "climbing back" as many nodes as there are `#`s, minus one; so `x(a)` is global, `x#(a)` is accessible only in the current node and its sub-nodes, and `x##(a)` is accessible in the parent node and its sub-nodes.
* a standalone name like `x` refers to either an alias or, if none, an external node

in addition, inside of a node:

* `#` means the node being listed itself, `##` its parent (in the syntactic hierarchy), `###` its parent's parent, etc
* `[x1 x2 x3…]` inside a node doesn't actually add that node as a field, but instead allows that node to float freely; such a node *must* contain at least one `#` field

given this, and the convention of the first field of a node indicating its type, we can already establish:

* `(#)` is "type": the type of types
* `((#))` is a type, with no other information being provided
* `(((#)) x1 x2 x3…)` could perhaps be a simple collection of values
* `(t (t (t (t ####))))` is a circular linked list which, as indicated above, reduces to `(t #)`
* likewise, `(t #0#1 (t #0#2 (t #0#1 (t #0#2 ####))))` reduces to `(t #0#1 (t #0#2 ##))` and `(a (b) (b) (c ##) (c ##))` reduces to `(a x(b) x y(c ##) y)`


saving the server-side of the internet: just WASM, *again*
----------------------------------------------------------

in [a previous post](saving-the-web.html), i propose to abandon the entire client-side web stack in favor of pretty much just [WASM](https://en.wikipedia.org/wiki/WebAssembly).

today i am proposing the same thing but for the server side.

at the higher level for most content, of course, i strongly favor [IPFS](https://ipfs.io/) — but sometimes, one actually needs centralized, responsive, cheap, continuously or on-demand running server programs, for many uses.

today's answer to these questions is a collection of [various](https://en.wikipedia.org/wiki/Google_Cloud_Platform) [cloud](https://en.wikipedia.org/wiki/Amazon_Web_Services) [platforms](https://en.wikipedia.org/wiki/Netlify), inevitably controlled by large companies and no doubt resting on a brittle tower of overly complex software.

i propose a nice way to decentralize and standardize all of this and simplify the stack. a piece of relatively simple server software (the "generic server") with a standard public-facing API could be deployed on any server machine, and make that server sell its bandwidth and computation resources in exchange for cryptocurrency, automatically. people or other programs could connect to it, upload a small WASM (or [meta-wasm](portable-programs.html)) program, and pay to have it run and be able to use various amounts of resources.

then, if the server for example runs a multiplayer video game session, ports could be opened for client software to connect to. the coordination of what is hosted where could be maintained on [the IPFS](https://ipfs.io/) as [decentralized knowledge](where-next-piracy.html), as would be the network of trust of which server machines are known to be reliable. especially, for information that one might not want leaked, one could cultivate a small set of trusted server providers — just as they do now by trusting just google or just amazon, except this would be a more general and automatably manipulable framework.

people could buy some server resource in bulk to share with their friends if some can't be bothered to buy crypto, large companies could deploy this generic server on many computers of their datacenter, people could run generic servers on their home computers to make money from unused resources, and anyone would be able to compete without setting up a significant piece of cloud infrastructure and then spending money on marketing to get known and trusted. larger distributed applications needing to allocate and deallocate servers dynamically based on demand and geographical location would have an entire competitive market to use, rather than having to settle with one of the large providers; and their individual server units could interoperate with each other even across providers.

server-side WASMs could access various APIs to communicate with each other be it on the same server machine or with other server machines; they could access APIs to use storage, to use [GPU computer](https://web.dev/gpu/), to publish IPFS data, etc.


lamenting nerds
---------------

when i was growing up, it was clear that computers and the internet were increasingly the new thing that was going to change the world. this eventually became the case. but one thing i was wrong about, and no doubt many others, was in expecting that this would result in young people increasingly getting into computer stuff.

but alas, as mentioned in the book *Because Internet*, while my generation (millenials) had to learn some tech as a bar for using computers and the internet in the first place, this isn't the case for [zoomers](https://en.wikipedia.org/wiki/Generation_Z) and younger: everything has been made easy for them, and indeed in my social circles it is people my age who tend to not just be *good* at computer stuff, but also to be *interested in it* in the first place.

of course, accessibility is overall a good thing. i just am lamenting the lack of genuinely interested people.

in university, in my computer science classes, most of the people present were there not out of genuine interest for computer science, but because that knowledge is thought to be highly demanded in the market. again, while this is technically useful, it is unfortunate that it has, in my view, pushed nerds to the wayside. in the case of universities, it has also corrupted curriculums: academic content (which is what universities are supposedly about) keeps retreating in favor of more practical information technology knowledge, making both demographics (academy-oriented and industry-oriented) dissatisfied at having to waste time learning the other half (uni courses in france are largely not elective). i would rather have schools dedicated to practical information technology on one hand, and universities focusing on academic understanding on the other, and let people pick which one they want; or even better, mix and match course from either.

lamenting nerds


alignment is an optimization processes problem
----------------------------------------------

i like to talk about [AI](https://www.lesswrong.com/tag/ai) alignment a lot, but the matter of alignment is really general to *optimization processes* in general.

here are some ways it applies to some other areas:

### natural selection

natural selection is an optimization process that improves the survival and duplication of inheritable traits (genes) in living beings.

it is not intelligent: there is no agent involved in this process which is able to make decisions by looking ahead into the future at what consequences those decisions will have; with the possible exception of humans making rational decisions about what will maximize their amount offspring.

it is completely multipolar: basically no agents in this process (either genes themselves, or individuals or populations carrying those genes) have the ability to coordinate decisions with one another, since they're not even intelligent.

the default of natural selection is genes whose only purpose is to be better at duplicating themseles.

one way in which we've aligned this process is by breeding: by selecting the individuals we like best among, for example, crops, cattle, or dogs, we've been able to align the process of gene selection to respond to what we value rather than the default.

### economics

the economy is an optimization process that improves economic efficiency.

it is intelligent: actors in the economy, ranging from individuals to states and giant conglomerates, have the ability to make intelligent decisions about the long term.

it is fairly multipolar: while they don't use it much, states do have overriding power over companies (they determine what's legal or not, after all), and also economic agents are able to coordinate to an extent using contracts and trusts. nevertheless, it is still largely multipolar, with agents overall competing with one another.

the default of economics is the optimization out of anything that doesn't generate maximally much resources: the optimizing out of people when they become the unoptimal form of labor because of automation, and the strip-mining of the universe to acquire ever more resources with which to create more machines to mine even more resources, and so on.

the way we align economics is through taxes, redistribution, and the like. redistribution like [UBI](ubi.html) aligns the economy to serves the demand of people, while tax externalities can align economic agents to take steps to preserve nice things, such as avoiding pollution.

### electoralism

electoral representative democracy is an optimization process that improves voter satisfaction.

it is intelligent: the agents competing for the reward, here political parties, are able to make decisions about the future. some organisms even plan for the very long term, taking steps to improve their chances when they become parties, long before they do.

it is fairly multipolar: like economics, while parties can coordinate and ally with one another, they are still competing agents at the end of the day, with no central authority to guide them and solve coordination.

the default of electoralism is parties throwing all values under the bus to do whatever gets them and keeps them in office for as long as possible.

the way we align electoralism is by having universal sufferage on the one hand, which makes it that it is the population that parties must try to satisfy; and the various apparatii of liberal democracies (journalism and free press, public debate, education of the voting public, etc), which we'd hope would help that voting population determine which parties do indeed implement policies that satisfy their demand.


to wasm and back again: the essence of portable programs
--------------------------------------------------------

what is the *essence* of a portable program, a program expressed in a format such that it can then be interpreted or, ideally, compiled to run efficiently in a variety of different environments?

this doesn't just mean "different OSs" or "different CPU architectures", but can even expand to compiling programs to different forms of computing like [GPU code](https://en.wikipedia.org/wiki/RISC-V) or maybe even [FPGA](https://en.wikipedia.org/wiki/Field-programmable_gate_array)s.

when we tried to figure some of this out for web pages, we came up with ["Native Client"](https://en.wikipedia.org/wiki/Google_Native_Client); but it eventually became clear that that the [LLVM intermediary representation](https://en.wikipedia.org/wiki/LLVM#Intermediate_representation) that it uses wasn't a good fit for a variety of reasons, so we eventually settled on [WASM](https://en.wikipedia.org/wiki/WebAssembly); and now [everyone is moving in that direction very fast](https://bytecodealliance.org/) despite [its](http://troubles.md/posts/wasm-is-not-a-stack-machine/) [various](http://troubles.md/posts/why-do-we-need-the-relooper-algorithm-again/) [issues](http://troubles.md/posts/the-stack-is-not-the-stack/).

alas, there can be a variety of factors that influence how a program should be compiled to take full advantage of the machine it's running on:

* what is the size of pointers? WASM currently hardcodes this to 32, and another WASM variant will come out to hardcode it to 64; just 32 works for many uses but having these hardcoded at compile time is hardly a great choice in general.
* how much CPU cache is available? currently, barely anything ever takes this into account, even though uncached memory access times can be a huge cause for inefficiency; and let's not get into cache-manipulation instructions, which nobody's using because [we all like to pretend our computers are simpler than they are](https://queue.acm.org/detail.cfm?id=3212479) (which no doubt also encourages hardware designers to only make CPUs for programmers that have this expectation, but this is a story for another time).
* how much memory can be allocated? how is it allocated? can programs and libraries share entire memory blocks with one another seamlessly? WASM currently takes a pretty naive approach to this with "linear memories", and [a variety of conversion schemes](https://github.com/WebAssembly/interface-types/blob/main/proposals/interface-types/Explainer.md) are guaranteed to make the standard a lot more complex.
* what instructions are available? instructions like [count leading zeros/count trailing zeros](https://en.wikipedia.org/wiki/Find_first_set) or [popcount](https://en.wikipedia.org/wiki/Hamming_weight) can be pretty instrumental to some algorithms performing efficiently, but compiling those in terms of other instructions on instruction sets that don't have them natively can be quite the loss in performance.
* how many registers are there? are some operations expected to use only certain registers? how efficiently can values be pushed and popped from the stack? [how much stack even *is* there??](https://utcc.utoronto.ca/~cks/space/blog/programming/CStackSizeInvisible)
* what is the expected alignment of various types in memory? how are those alignments checked? are unaligned accesses unsafe or merely slow?
* and then *everything to do with atomics and multithreading* (WASM's attempts at addressing these seem at the moment pretty unsatisfactory)

more importantly, effects of questions like those can ramificate upwards: a change in pointer size (say between 32 and 64) or knowledge about the cache sizes, or cache-fetching or branch-prediction algorithms of a CPU should be able to lead to an entire data structure "choosing" a very different implementation (not just for algorithms, but also but for memory layout!). and those changes are even more far-reaching once parts of this algorithm (such as accessor functions for data structures) get inlined in various ways in other parts of the code. WASM just assumes some relatively common invariants and that's it; there's no ability to provide entirely different algorithms based on even pointer size or alignment requirements.

so, to be able to make arbitrarily complex decisions based on those environmental conditions, a portable program should not be just a flat WASM, but should in fact be a dynamic metaprogram which, upon initialization, examines the environment and makes all the right choices to produce a code that is able to run optimally on the target environment. ideally, that metaprogram itself should be written in yet another meta²program; but this one compiles the meta¹program for the compiling environment rather than the target environment (those can be different! think of a meta²program, producing for the CPU a meta¹program whose goal is to produce for the GPU the end program). ultimately, though, we need *some* form of basic language to bootstrap this whole process, at the top of the tower of metaⁿprograms: this is where WASM can come back.

such metaⁿprograms should expect to interact with an API that would be like that of [a JIT compiler library](https://github.com/wdv4758h/awesome-jit#id3), with functions like `create_function(parameter_types, return_types) → FunctionId` or `add_function_call(function_id, parameter_variables) → ValueId` used to generate pieces of the metaⁿ⁻¹program. ideally, different metaⁿprograms from different places could even end up getting their functions inlined with each other; a library generated by a metaprogram, and a user program generated by another metaprogram from another vendor but using that library, should be able to be inlined with each other, rather than "naively" loaded like current dynamic libraries. maybe their two metaprograms should even be able to "negotiate" optimizations with one another using specification contracts, but this seems hard to set up.

if "object programs" (meta⁰programs) — but also higher up metaⁿprograms — are expected to be safely sandboxed, the best way to do this might not be to dynamically check everything and then hope optimization can remove some checks, but instead the metaⁿ⁺¹program that produces them should be able to manipulate logical statements to "logically prove" to the compiler that the program being produced is safe; and adding a dynamic check would be just one way to guarantee this safety. the point is, demonstrating safety should be able to, like code generation, be an arbitrarily complex process, rather than a very strict one limited to whatever type system is available, and whatever hacks one can build on top of it.

ideally, metaⁿprograms should also be able to tap into a collection of optimizing code-transformation libraries, which could be updated regularly such that old programs can benefit from new optimizations; but should be proven to be correct such that this doesn't affect behavior we care about. in this way, logically proving behavior is not just a matter of sandboxing or program safety, but also a matter of optimization even in "unsafe" programs.

this approach, in some ways despite its lesser dynamicity, is more general than ["runtime metaprogrammability"](degrees-of-runtime-metaprogrammability.html) in that the metaprogram is able to create a mesaprogram (the opposite of a metaprogram) for a vastly different target environment than the one it is itself running on.


cosmic missing outs
-------------------

this might be a complete waste of brainflops, but sometimes i wonder about "cosmic missing outs".

my typical example for those is the culture of modern japan.

imagine timelines where japan never became the country it did, and we never got its culture. that'd be a huge thing to miss out on, right? the second best thing might be korean culture or something like that.

but, now that you've imagined this timeline that is missing out on modern japan culture, imagine the opposite: there are timelines out there that have those great cultures of countries that we're missing out on, that us missing out on is kind of on the same scale as those other timelines missing out on japan's culture.

i'm talking about this because i just thought of some other things kind of of this type:

what are some unknown things that we are missing out on, that us missing out on is kind of like if other timelines were missing out on music?

what are some unknown things that we are missing out on, that us missing out on is kind of like if other timelines were missing out on philosophy, science, or math?

these speculations are the closest i can get to putting human minds into perspective and considering the existence of things entirely outside of human conception, the way many things are entirely outside of a mouse or ant's ability to conceive.

to be clear: i still can't have that consideration, this is only the closest i get, but it's not quite there.

cosmic missing outs


exact minds in an exact world
-----------------------------

[in the sequences](https://www.readthesequences.com/Zero-And-One-Are-Not-Probabilities) it is argued that 0 and 1 are not probabilities; that these "certainty ratios" aren't meaningful. but, i can think a situation that challenges this.

imagine a fully deterministic world — for example, running on [a cellular automaton](https://en.wikipedia.org/wiki/Cellular_automata) — and imagine that in this world there are some intelligences (either artificial or natural) that utilize this determinism to have the ability to make flawless logical deductions (for example, [automated theorem proving](https://en.wikipedia.org/wiki/Automated_theorem_proving) algorithms running on computers that cannot ever have undetected [hardware failures](https://en.wikipedia.org/wiki/Soft_error)). for example, if they think about mathematics, under the axioms under which they work, 2 + 2 will always equal to 4, and doing any mathematical computation will either result in them knowing they don't have the computational resources to do the operation, or the result being guaranteedly true with the same certainty as that the cellular's automaton's rules will be applied next tick.

now, these beings still have a use for probability and statistics: those can be used to talk about parts of the world that they don't have complete information about. but, there will be some contexts, both purely in their minds (such as logic or math) or sometimes in the real world (they could make assessments like "this box cannot contain any [spaceship](https://en.wikipedia.org/wiki/Spaceship_%28cellular_automaton%29) of a certain size") that *will* be, functionally, certain.

it could be argued that they *should* still be weighing everything by the probability that there might be unknown unknowns; for example, their cellular automaton might have rules that apply only very rarely, and that they never got a chance observe yet but might yet observe later. but, let's say that they *assume* the rules of their world are exactly as they think, and let's say that they happen to be correct in that assessment. does that not make some of their deductions actually entirely certain?

exact minds in an exact world


meta-tracking
-------------

some social constructs don't originally track anything in the real world, but people who erroneously believe in them start assigning them attributes and meaning, and then those concepts bootstrap themselves into being real at least in that they track people's beliefs.

so, for example, refusing to follow astrology because it doesn't track the real world, fails to track all the people that start acting in astrologically predictable ways from believing (originally erroneously) in astrology.

another way in which one must take care to meta-track because people are involved, is the meaning of the meaning of words. the meaning of a word is defined by its usage; but, "the meaning of a word" is understood by many to instead track some essence of the word. while the idea of that essence is wrong, saying "the meaning of a word is defined by its usage" is kind of wrong; not because that's not what the meaning of a word is, but because in that sentence one is using a fairly non-usage meaning of "the meaning of a word".

and, you have to rember that phrases mean what they are understood to mean; so, in a weird way, the only statements that are understandable to someone are the ones that are agreeable with what they think, because those statements are those that match the general worldview-ideas-definitions that the person has; and fundamental disagreement entails using definitions of words and ideas that the person doesn't have, and therefore are kind of failures to communicate with them.

meta-tracking


> "your mind is a labyrinth of anti-cognitive-bias safeguards, huh?"
>
>

a friend, to me

do not form your own opinion
----------------------------

when confronted with an idea, it can be tempting to try to evaluate it. in fact, the brain does this by default.

however, i try to avoid doing this; i tend to dismiss ideas that don't have the approval of the consensus of their respective field of expertise. the reason for this is simple: i don't trust my brain (or most anyone else's) to evaluate the validity of ideas [outside of what they have a profound understanding of (which [is itself hard to determine](https://noahpinion.substack.com/p/epistemic-trespassing-or-epistemic)).

this is an idea i learned after getting burned many times by believing even popular things that turned out to be just plainly false. clearly, i must be wrong at determining whether an idea i encounter is true. which made sense once i [learned about biases](https://www.readthesequences.com/What-Do-I-Mean-By-Rationality).

brilliant words from renowned philosphers or economists can sound insightful and empowering, but so can new-age nonsense about chakras and astrology; and stepping back from the idea to examine whether it actually provides novel and useful value (rather than just [being a template](https://astralcodexten.substack.com/p/is-this-predictive-coding) to [make your hear whatever you want to hear](https://www.youtube.com/watch?v=1okD66RmktA)) is very hard and can require an extensive background in the field in question. [even studies picked on their own](https://slatestarcodex.com/2014/12/12/beware-the-man-of-one-study/) or [entire fields](https://slatestarcodex.com/2014/04/28/the-control-group-is-out-of-control/) will get things wrong, but in general they're still *more likely* to be *less wrong* than you.

so, i tend to go by where a statement comes from. the very same idea phrased in the very same way, i will dismiss if it comes from some random self-help youtuber or [therapy book](https://slatestarcodex.com/2019/11/20/book-review-all-therapy-books/); but if it comes from a philosopher which is still being talked about after centuries or has the agreement of the vast majority of economists, then it's probably not *completely* worthless.

find trusted sources that seem to respect academic (or [rationalist](https://www.lesswrong.com/)) consensus, and/or are more qualified than you at topics you don't know much about, and in your own communication try to be careful and humble when talking about ideas you don't have profound background knowledge of.

there *is* room to hear weird ideas, *[carefully](cultural-and-memetic-hygiene.html)* and without falling into [easy traps](https://www.lesswrong.com/posts/AdYdLP2sRqPMoe8fb/knowing-about-biases-can-hurt-people) or rabbit holes. in general, just try to constantly keep in mind that the information you're receiving is only the opinion of the person saying it; *not* particularly more likely to be factual than not, contrary to what your brain is designed to assume.

do not form your own opinion


∀V: A Utopia For Ever
---------------------

![](%E2%88%80V3.svg)

∀V (read "universal voluntaryism" or "univol") is my utopia proposal. for people who are familiar with me or my material, this may serve as more of a clarification than an introduction; nevertheless, for me, this will be the post to which i link people in order to present my general view of what i would want the future to look like.

### what's a person?

you'll notice that throughout this post i've stuck to the word "person" instead of, for example, "human". this isn't just in case we eventually encounter aliens who we consider to be persons just like us, but it's also possible some existing animals might count, or even beings whose existence we largely don't even envision. who knows what kind of computational processes take place inside the sun, for example?

by person i mean something deserving of moral patienthood; though this is still hard for me to even start to determine. it probably requires some amount of information system complexity, as well as a single point of explicit consideration and decision, but apart from that i'm not quite sure.

i do know that pretty much all currently living humans count as moral patients. other than that, we should probably err on the safe side and consider things moral patients when in doubt.

### systems within systems

all top-level systems are, in the long term, permanent.

if you want society to "settle what it wants later", then your top-level permanent system is what they'll eventually settle on.

if you want society to never be stuck in any system and always have a way out, then the top-level permanent system is "going from system to system, being forever unable to settle" and you better hope that it spends more time in utopian systems than dystopian systems.

if your view is "whatever happens happens", then your top-level permanent system is whatever happens to happen. by not caring about what the future looks like, you don't make the future more free, you only are less likely to make sure it's one you'd find good.

if there is going to be a top-level system no matter what, no matter how flexible its internals are, we ought to care a lot about what that system is.

### enforcement: superintelligence

even if you don't think [superintelligence explosion](https://en.wikipedia.org/wiki/Technological_singularity#Intelligence_explosion) is [imminent](were-all-doomed.html), you should think it will happen eventually. given this, what may very well be [the "infinite majority" of remaining time](ai-alignment-wolfram-physics.html) will be one where a superintelligence is the ultimate decider of what happens; it is the top-level.

i find this reassuring: there *is* a way to have control over what the eternal top-level system is, and thus ensure we avoid possibilities such as unescapable dystopias.

### generalized alignment

in AI development, "alignment" refers to [the problem of ensuring that AI does what we *actually* want](https://en.wikipedia.org/wiki/AI_control_problem) ([rather than](https://docs.google.com/spreadsheets/d/e/2PACX-1vRPiprOaC3HsCf5Tuum8bRfzYUiKLRqJmbOoC-32JorNdfyTiRRsR7Ea5eWtvsWzuxo8bjOxCG84dAg/pubhtml), for example, what we've explicitly instructed it to do, or just maximizing its reward signal).

when we think about how to organize future society, we actually care not just about the alignment of the top-level superintelligence, but also "societal alignment" before (and within) that. i will call "generalized alignment" the work of making sure future society will be in a state we think is good, whether that be by aligning the top-level superintelligence, or aligning the values of the population.

so, even if you don't think a superintelligence is particularly imminent, you should want society to start worrying about it sooner rather than later, given what you should consider being the amount of unknown variables surrounding the time and circumstances at which such an event will occur. you want to align society *now*, to your values as well as the value of figuring out superintelligence alignment, hopefully not too late.

### not just values

at this point, one might suggest directly loading values into superintelligence, and letting it implement whatever maximizes those values. while this may seem like a reasonable option, i would kind of like there to be hard guarantees. technically, from a utilitarian perspective, there exists a number N sufficiently large that, if N people really want someone to genuinely be tortured, it is utilitarianly preferable for that person to be tortured than not; my utopia instead proposes a set of hard guarantees for everyone, and *then, within the bounds of those guarantees*, lets people do what they want (including "i just want superintelligence to accomplish my values please").

one might consider the solution to that to be "just make it that people never want others to be tortured", but that's a degree of freedom on people's thoughts i'd rather keep if i can. i want persons to be as free as possible, including the freedom to want things that can't ethically (and thus, in my utopia, can't) be realized.

### a substrate for living

i am increasingly adopting [wolfram's computational perspective](https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/) on the foundation of reality; beyond offering great possibilities such as [overcoming heat death](ai-alignment-wolfram-physics.html), i feel like it strongly supports the [informational view of persons](you-are-your-information-system.html) and the ability for people and socities to live on any form of computation framework; and those aren't particularly less or more real than our current, [standard model](https://en.wikipedia.org/wiki/Standard_Model)-supported reality.

given this, the most efficient (in terms of realizable value per unit of resource) way for superintelligence to run a world is to extract the essence of valuable computations (notably [the information systems of persons](you-are-your-information-system.html)) into a more controllable substrate in which phenomena such as aging, attachment to a single physical body, vulnerability to natural elements, or vulnerability to other persons, can be entirely avoided by persons who wish to avoid them. this extraction process is often referred to as "uploading", though that implies uploading into a nested world (such as computers running in this world); but if wolfram's perspective is correct, a superintelligence would probably be able to run this computation at a level parallel to or replacing standard model physics rather than on top of that layer.

this is not to say that people should all be pure orbs of thought floating in the void. even an existence such as a hunter-gatherer lifestyle can be extracted into superintelligence-supervised computation, allowing people to choose superintelligence-assisted lifestyles such as "hunter-gathering, except no brutal injury please, and also it'd be nice if there were unicorns around".

### universal voluntaryism

at this point, we come to the crux of this utopia, rather than its supporting foundation: ultimately, in this framework, the basis of the existence of persons would be for each of them to have a "computation garden" with room to run not just their own mind but also virtual environments. the amount of computational resource would be like a form of universal basic income: fixed per person, but amounts of it could be temporarily shared or transferred.

note that if resources are potentially infinite over time, as wolfram's perspective suggests, then there is no limit to the amount of raw computation someone can use: if they need more and it's not available, superintelligence can just put either their garden or *everyone's gardens* on pause until that amount of computation resource becomes available, and then resume things. from the point of view of persons, that pause would be imperceptible, and in fact functionally just an "implementation detail" of this new reality.

persons would have the ability to transform their mind as they want (though having a bunch of warnings would probably be a reasonable default) and experience anything that their garden can run; *except for computing the minds of other persons*, even within their own mind: you wouldn't want to be at the mercy of someone just because you happen to be located within their mind.

persons would be able to consent to interact with others, and thus [have the ultimate say on what information reaches their mind](cultural-and-memetic-hygiene.html). they could consent to visit parts of each other's gardens, make a shared garden together, and all manner of other possibilities, so long as all parties consent to all interactions, as determined by superintelligence — and here we're talking about [explicit consent](defining-freedom.html), not inferred desires even though superintelligence would probably have the ability to perfectly determine those.

for a perspective on what a society of "uploaded" persons might look like, see for example [Diaspora by Greg Egan](https://en.wikipedia.org/wiki/Diaspora_%28novel%29).

### rationale and non-person forces

the goal of this structure is to allow people to live and associate with each other in the most free way possible, making the least possible restrictions on lifestyle, while retaining some strong guarantees about consent requirements.

in a previous post i talk about [non-person forces](two-principles-for-topia.html); those being for example social structures that act with an agenthood of their own, running on other people as their own substrate.

at the moment, i simply don't know how to address this issue.

the problem with the "dismantlement" of such forces is that, if every person is consenting to the process, it's hard to justify superintelligence coming in and intervening. on the other hand, it does feel like not doing anything about them, short of being able to align sufficiently many people *forever*, will tend to make people dominated by such structures, as a simple process of natural selection: if there is room for such structures and they can at least slightly causate their own growth or reproduction, then they will tend to exist more than not. this may be thought of as [moloch](https://slatestarcodex.com/2014/07/30/meditations-on-moloch/) "attacking from above".

one major such potential non-person force is superintelligence itself trying to make people tend to want to live in ways that are easier to satisfy. if everyone wants to sit in their garden forever and do nothing computationally costly, that makes superintelligence's job a lot "easier" than if they wanted to, for example, communicate a lot with each other and live computationally expensive to run lifestyles; and the reason superintelligence will want to make its job easier is to increase the probability that it succeeds at that job (which it *should* want).

if informationally insulating people from superintelligence except when they outright consent to it intervening in their decisions is *not* sufficient, then maybe we can add the rule that people can never ask superintelligence to intervene in their life unless there is one single optimal way to intervene, and hopefully *that's* enough. the idea there being: if, for any request to superintelligence, there is only a single optimal way to accomplish that request, then superintelligence has no degree of freedom to influence people and thus what they want.

### on new persons

there are some reasons to be worried about the creation of new persons.

one is [malthusian traps](https://slatestarcodex.com/2014/07/30/meditations-on-moloch/): if the amount of resources is either finite or growing but bounded, or if it's unknown whether the amount of resources will end up being finite or not, then you *have* to cap population growth to at most the speed at which the amount of resource grows (if the amount of resources grows, the maximum speed of population growth should preferably be lower, so that the amount of resource each person has can grow as well). while it does seem like in current society people tend to have less kids when they have a higher quality of life, in a system where persons can live forever and modify their minds, one can't make such a guarantee over potentially infinite time.

another is replicator cultures: if there is no limit on creating new persons, and if people can influence even just a bit the values of new persons they create, then soon the world is overrun by people whose values are to create kids. or: making a world in which "new person slots" are filled by whoever wants to fill them first, will just select for people who want to fill those slots the most.

there might also be weird effects such as, even if resources were infinite, allowing arbitrary amounts of persons to be created could "stretch" the social network of consenting-to-interact-with-each-other persons such that, even if someone has registered an automatic consent to interact *even just a bit* with the kids of persons they already consent to interact with, they are soon flooded with a potentially exponentially growing network of kid interactions; though this probably can be addressed by that person by revoking this automatic consent.

beyond various resource and network effects, new persons create an ethical dilemma: does a person consent to living? or, for a child, do they consent to being taken care of for some amount of years after they are born — a time during which we often consider them to require affecting them in ways they might be unable to consent to?

if such philosophical quandries don't have a solution, then the safest route is to simply forbid the haphazard creation of new persons, whether that be through conventional human infants, [headmates](https://en.wikipedia.org/wiki/Multiplicity_%28psychology%29) and [tulpas](https://en.wikipedia.org/wiki/Tulpa#21st_century) if those are "real" enough to count as persons, and potentially other ways of creating new persons that can't consent to future interactions because they don't exist yet. **2022-08-11 edit: this idea has [its own post](unviable-moral-patient.html) now.**

on the other hand, one way to increase the population *with* consent, is simply to "fork" existing persons: create a duplicate of them. because both are a continuation of the original single person, the original person's consent counts for both resulting persons, and there is no issue. the "merging" of consenting persons together might be possible *if* it can be reasonably estimated that their shared consent "carries through" to the new, merged person; i am currently undecided about how to even determine this.

finally, if resources are finite, creating a new person (whatever the means) should require permanently transferring one "universal basic computation amount"'s worth of computation garden to them, as no person should start out without this guarantee. this could be done by a person consenting to die and give up their own computation garden, it could be done by several "parents" consenting to give up a ratio of their gardens to the new person, it could be done by reclamating the redistribution of persons who die and don't make any decisions about what should be done with their computation garden, etc.

∀V: A Utopia For Ever


what happens when you die?
--------------------------

contrary to popular (secular) belief, i don't believe nothing happens.

considering that [you are your information system](you-are-your-information-system.html) and [nothing else](persistent-data-structures-consciousness.html), any future occurence of your information system *is you*. so, the meaning of the question "what happens when you die?" is really "what are some next things your information system will percieve after facing what should be fatal events in its original body?"

this is very likely [not nothing](quantum-suicide.html). somewhere, in some timeline, your information system is probably being redundanced.

first, your body can miraculously avoid death. this would be a weird kind of immortality, where there is almost always a timeline where you somehow avoid death. it is, however, pretty unlikely to persist.

second, your mind could arise somewhere by accident. this could be as simple as random fluctuations in space producing something that runs your mind's information system by pure chance. this is *extremely* unlikely.

in fact, the most likely scenario is that someone in the far future reproduces your mind on purpose. for example, this could be a society in a [u-line](timeline-codes.html) being able to, and deciding, to run an accurate enough simulation of the entire earth up to some point, and downloading people from this simulation into their world, to allow them to avoid death. as it'd probly take a bunch of effort, and sounds like a pretty nice thing to do, i expect that to happen mostly in u-lines; however, there could be some [s-lines](timeline-codes.html) where this happens too. and while getting resurrected seems more likely in u-lines than s-lines, s-lines seem more likely than u-lines, and i don't know if the probabilities cancel out.

so, what happens when you die? you wake up either in heaven or hell, depending not on your personal actions in particular but in how likely it is we figure out AI alignment (a probability which you do have, if small, an impact on).

what happens when you die?