Rationality as Computation

I first published these thoughts on X. Here, I expand a bit. All code published under the MIT license.

Here’s the thing about the formation of rational preferences. Once you really grok its computational nature, you understand that people have things backwards.

They want to their method of forming a rational preference to be complex. And they want to express it using only or mostly natural language.

But I think it’d be far better if they had a simple method expressed entirely in code.

Take for example the method: ‘Between two given ideas, as written, I will always prefer the one with the most instances of the letter i.’ Translated into code, this method reads:

# idea1 and idea2 are assumed to be strings
def prefer_by_i_count(idea1, idea2)
  [idea1, idea2].max_by do |idea|
    idea.downcase.count('i')
  end
end

Or: ‘I will always prefer the idea with the fewest words.’

def prefer_by_word_count(idea1, idea2)
  [idea1, idea2].min_by do |idea|
    idea.split.size
  end
end

Or: ‘I’ll always prefer the idea with the most uppercase characters.’

def prefer_by_uppercase_count(idea1, idea2)
  [idea1, idea2].max_by do |idea|
    idea.count('A-Z')
  end
end

Those are obviously nonsensical methods in content. But purely methodologically, they’re a fine start! That’s because…

1. They’re trivial to program. And…
2. You can tell exactly when you stray from them. If you ever pick an idea with more words than another, say, you’re being irrational (according to that standard).

Those are two crucial properties non-computational epistemologies lack. And their adherents have a hard time being rational as a result.

Some people have an aversion to this line of thinking. Their heart’s in the right place: they want to point out that rational decision-making can’t possibly follow something like a math formula, say. There needs to be room for creativity. After all, rational decision-making involves the creation of new options rather than just choosing between existing options using a fixed formula.

But my stance isn’t at odds with creativity. Our code can simply prompt the user for creative input. Easy! That’s where the ideas come from in the first place.

Also, we never have infinite time to create new options. The inspiration phase doesn’t last forever. There comes a time to act. At that point, you have to choose from a finite set of options.

A key question in moral philosophy is, how do you do that? That’s where code comes in.

Not to mention, creating a new moral code (which should literally be computer code) for every decision would be paralyzing. It would be too hard. Man needs a clear moral code, easily programmable, so he can figure out what to do. (This is analogous to the legal code: imagine having to come up with a new legal code anytime somebody commits a crime. It wouldn’t work. One couldn’t even know it was a crime without such a code in the first place.)

Occam’s razor is interesting in this regard. It says to prefer the simplest idea. This approach is similar to the second method above, of preferring the idea with the fewest words. Though false in content, it’s not bad methodology! It’s easy to follow. It’s easy to know when you stray from it.

But it’s not clear how to write a program that can tell which of two ideas is simpler in content. I think that would be my main reason for rejecting Occam’s razor. It’s underspecified, ill-defined. I think that’s also the major flaw with David Deutsch’s epistemology around ‘hard to vary’.

Some people may object and say it’s not realistic to expect everyone to be able to code. I agree. Though coding isn’t that hard (IMO), expecting everyone to know how to code is unrealistic, if only because some people just aren’t interested in it. And there’s division of labor, of course.

This is where moral philosophers come in. Their main job isn’t to write books. Their job is to write code, to create beautiful user interfaces that help the average non-coder make rational decisions.

This is why, as I always like to stress, serious epistemologists are programmers.

Some people don’t like this job description of moral philosophy. They don’t know how to code, and they don’t want to learn. To them, this job description seems like gate keeping.

I don’t know what to tell them. Jobs have prerequisites. Those prerequisites change over time. And there are plenty of free resources to study online.

You can’t be a productive thinker without knowing how to code. It’s almost as big a handicap as not knowing how to read. You can’t form good opinions on matters like consciousness, thought, creativity, animal consciousness, rationality, etc, without knowing how to code. For example, a thorough understanding of rationality involves graph theory and recursion.

21st-century moral philosophers are programmers and product designers.

For a real-world implementation of an actual method to form rational preferences, head on over to veritula.com. It’s a product I built. It helps you make rational decisions and be confident that your actions are right.

Here’s the actual method Veritula uses to form rational preferences:

def should_adopt?(idea)
  pending_criticisms(idea).none?
end

def pending_criticisms(idea)
  criticisms(idea).filter { |c| should_adopt?(c) }
end

def criticisms(idea)
  children(idea).filter(&:criticism?)
end

In short, it says an idea is rationally preferable/adoptable if and only if it has no pending criticisms. Pending criticisms are criticisms that have no pending criticism in turn. Nine simple lines make the core of my moral philosophy.

For more details on this method, see my technical paper ‘The Structure of Rational Thought’, available on academia.edu and philpapers.org.