Many people have asked me about how we might compute real, messy ethics which was the subject of my masters thesis in philosophy.
To get the ball rolling, let's think about a made-up function that does ethical analysis. Perhaps it tells which situation of two options would get something closer to the goal state. I will use a C or Java like notation for the function header example. I hope that’s not too technical.
float ethicsAnlys(situation goalState, situation opt1, situation opt2)Don’t read too much into that. I just made it up. But consider the inputs. What is the ‘situation’ class that is being passed in? Perhaps option1 and option2 describe a city with and without a particular law, respectively, and we want to know which one is best. But it depends on the goal state. If goalState describes a miserable, oppressed city we would get a different result than if goalState described a happy, thriving city.
There are three questions to answer:
How does the ‘situation’ class work?
Are there functions we can write that will do useful ethics analysis?
How can it know that some goalStates are unethical?
1: How does the ‘situation’ class work?
The situation class works by representing the way information flows. Consider: what if I have a bicycle that is upside-down. And imagine that you are in an adjacent room and can see only the rear wheel. If I begin to turn the pedals, you will see that the wheel begins to turn and you know that I am turning the pedals. That is, you are receiving some information about the pedals by observing the wheel. If we represent the world this way we have access to much more information than if we merely use symbols + logic. The new information is exactly what we need to do ethics analysis. For a more complete explanation see This paper. Or, check out the code (in the file ‘Proteus.lib.dog’). The ‘situation’ class is called ‘infon’ – as in “a piece of information”.
Here are some hints to help grok how it works:
Note that states and information are the same thing under a different unit. E.g.: 256 states = 1 byte of information.
In a deterministic system, the information (states) at time T is somehow the same as that at time T+n. That is, information is conserved. By tracing the information over time we model causality.
When we replace ‘material reductionism’ with ‘information reductionism’, something cool happens. To illustrate, suppose we map all the ways that information flows through a bike. And we have some mapping from the state changes of the pedals to the state changes of the rear wheel. Now we could also map the changes of the pedals to the changes of the chain and then map that chain-state to the wheel state. It should cohere with the higher level mapping. But we could also represent the chain as a series of steel links and model how information flows through the steel. It should still cohere. And if we want to model how information flows through the atom lattice of the steel it should still cohere. This illustrates that by modeling the world as information we do not have the problem of supervenience or the ‘levels of existence’ problem. And if we can calculate how systems at one level will have properties at a higher level we can determine whether one system will work better than another for a specific purpose. E.g., Would a bike chain made of tin be as good as one made of steel? The way information flows through tin is different than for steel. For example, certain pressures are manifested as deformations in tin that are manifested into the next link in steel. So under those conditions the tin chain will not cohere with the bike model.
Please ask if you want concrete examples of this.
2: Are there functions to do useful ethics analysis?
The key to answering this question is to understand that information by itself does not come with an interpretation. So our causal models are not absolute things, but overlays. Information coming in from the network could have the HTML overlay but we could also overlay the MP3 pattern onto it. One of these will produce syntax errors, but there is nothing to stop you from doing it.
Please bear with me. This will all make sense.
Suppose we take the model of a bike and apply it to a bike-with-a-tin-chain. The pattern will match, but not under every circumstance. Likewise, a bike-with-a-steel chain will fail to match the model if you try to ride it on the sun. Let us imagine a quality function that takes a model of the system you want and a model of a system you have and returns a value representing the quality.
float quality(infon want, infon have)A more useful function would generate a list of situations where the ‘have’ would not match the ‘want’. In other words, it would return an infon. But for simplicity, imagine we get a number back; say 0 to 100%
We are building more complex examples in order to get to the answer. In this story, suppose I need to remove a screw. If I had a good screwdriver it would be easy:
quality(generic-screwdriver, my-screwdriver) == 100%But suppose I don’t have one. Could I use a butter knife? In non-causal logic, probably not. Unless there was an assertion that sometimes a butter knife can remove screws. With causal models we can do:
quality(generic-screwdriver, butter-knife)We won’t get 100% but it might work. However, this call would return near 0%:
quality(generic-screwdriver, basketball)Now let us apply this function to people. Philosophers have long noted that Humans can make themselves into different things. For example, I have made myself into a software engineer, a philosopher and an AGI researcher. We can identify as whatever we want. Let’s look at some function calls:
quality(footballer, Bruce) // returns a low numberquality(software-engineer, Bruce) // returns a higher numberNow let us say that I want to calculate whether I should buy a super-fast laptop. I can measure my quality-as-software-engineer both with and without the laptop.
float Q1 = quality(software-engineer, Bruce-without-laptop)float Q2 = quality(software-engineer, Bruce-with-laptop)Now if I take Q2-Q1 I get an idea of the value the laptop would have for me. That is:
value = 'delta quality'With more complex models we can ask questions about laws before they are passed or we can evaluate various institutions for ethical behavior (do they add positive or negative value, and to which people or groups?)
3: How can it know that some goalStates are unethical?
Imagine that we are outside the universe with a god’s eye view. From that position the universe is pretty simple. It's going: state1, state2, state3, … We could divide that number up into some bytes and interpret it as a .wav file. That might not be ‘right’ but it isn’t ‘wrong’ either. From that position there are few rules.
If you will indulge me one more example to illustrate just how much categories are created by observing sub-systems and not somehow given. Suppose that ‘dark matter’ exists and that, while it doesn’t interact much with our matter, it does interact with other dark matter. Then there could be dark-matter planets with dark matter people. What to them is solid, heavy matter is, to us, almost nothing. Likewise, what is solid matter to us is dark-matter to them. So even the solidity of matter is relative to an observer. You can also make this example by considering self-aware NPCs in a 3D game. What to them seems like a solid table is actually, as we know, just information flowing around inside a computer.
But there is at least one system that is not arbitrary. If the god’s eye observer identified a sub-system that took in information, stored it in models and also had a model of itself to use, it would be factually incorrect to say that it was not such a self-aware system. And such systems make categories. So once you identify a self-aware system, the universe is suddenly categorized relative to that system.
As long as important ethical analysis includes all such systems that are relevant in the goalState, you won’t be able to convince it that, for example, the State is supreme and the people exist for the State. That is because it knows that the State is mearly a construct of entities that are not merely constructs. We can protect against people purposefully leaving relevant people out of the goalState by having distributed, decentralized systems that check each other and isolate bad models.