How to Model Problems in General

• I’m generally unhappy about the time I usually go to bed
• (O) I usually lie down in bed at about 2am
  • (O) (P) My higher-level reasoning thinks that this is too late; better would be midnight [J: "better would be midnight" is an inference your brain made. We could more explicitly state it in observation form: "My higher level reasoning expects that it would be better to go to bed at midnight"]
    • (O) but when it is midnight, I don’t actually want to go to bed
  • (Pred) the thing is, I think I could fall asleep early if I just would lie in bed earlier
  • my evening structure is usually like this:
    • 19:00 to 20:00 dinner
    • (O) directly after dinner, I either
      • do some work
      • talk to Chao/watch an episode or half a movie with her
    • (O) starting at 22:30 or so, I decide to do something relaxing
      • most of the time I read fiction
      • sometimes I watch videos
    • at 01:40 I decide to get ready for bed
  • (O) when I was in Berkeley for MATS, I thought I had the perfect opportunity to fix this
    • because I would be starting out with my circadian rhythm shifted very early
    • and I actually had an office to go to in the morning
    • I decided to have my alarm always set to 8:30
  • (O) but even having a consistent alarm in the morning was not enough to make me go to sleep early enough
• (O) additional observations
  • if I do a lot of physical activity during the day, I think I go to bed earlier
• (O) Sometimes, when going to bed, I have the impression that I’m going to bed too late. The quality of my tiredness seems different somehow then. I think I know the kind of tiredness that will let me fall asleep quickly, but sometimes my tiredness is beyond that point.

Inferences (O) Sometimes I feel very tired in the evening, and still don't go to bed. AND in the moring I then feel tired. -> It would have been good to go 1h earlier to bed.

Inferences Johannes: "the thing is, I think I could fall asleep early if I just would lie in bed earlier." This is imprecise. It's unclear what this is. If you mean "In the past I sometimes did lay down earlier and each time I had no trouble falling asleep", then it would be an observation. But it cloud also be a prediction. In this case you probably make a hidden inference somewhere. Your subconscious/conscious reasoning might have been "usually I don't have trouble falling asleep so just laying down earlier would work, because I would not have trouble falling asleep."

Thomas: I think I made an implicit inference (the second thing).

Trying things is like doing experiments. It seems good to write down the motivation for the experiment, as well and the observations, and the interpretation of those observations.

• Do you have a specific time when you want to be in bed?
  • Thomas: (No) I have not thought deeply about this. But I guess midnight.

Johannes Reasoning: If you don't have a target time it feels like a major problem intuitively.

I tried to identify a property of the world such that if that property holds, it would exclude the possiblity of solving the problem, as long as the property holds.

Starting by going through all such properties seems good, because they are easy to generate. They are in a sense the obvious things. It's usually quite hard to just notice the obviously good things.

Also if you find a property that obviously can't be changed (with reasonable efford), then it tells you that a solution is impossible (or would take too much efford).

Here are a few observations I have made when it comes to going to bed on time.

You can make such an argument tree. However, how do you know when it is complete? Maybe all the issues are real, but are outweight by the advantages? How could we notice this.

The above argument tree is actually using logic, and when making arguments we are using logic. But it seems like we are not proving anything.

It seems like if we have proposition we want to evaluate, we generate two sets of predicates . Each predicate in takes in a world state, and returns true or false. True means that "the argument" applies to the world state.

It's bad to jump out of the window infront should return false if I am in the ground floor. Having predicates that take in world states allows us to not make a fixed argument, but a method to evaluate propositions based on the context.

For each we have a constant value . If is positive then supports , if is negative then it disputes .

To compute whether is true for a world state we do:

This gives us a number between 0 and 1.

Example reasoning:

• Research X is good to publish
  • Against
    • It could be exfohazardous 1000
    • Takes a lot of time 4
  • For
    • People can give feedback 3-6
    • Find collaborators 5-8

Where X is a parameter that needs to specifyied. E.g. X = World state graph post.

Note that this argument doesn't say what to do, because you can't evalute the predicates for the world easily and accurately! Is X exfohazardous? You probably don't know, and might have no way to figure it out.

Let's consider a toy bitstring world. .

• The list 3 digits are 1
  • For
    • , weight: 1
    • , weight: 1
    • , weight: 1
  • Against
    • , weight: -1000
    • , weight: -1000
    • , weight: -1000

This exhaustively lists the arguments for and against. If one of the last digit is false then the whole thing is false. We encode this by having large negative weights.

So far we have only described what the datastructure for an argument is, and how to compute the conclusion of the argument. Open problems are:

• How do you generate the arument in the first place?
• What is missing (does this actuall capture the intuition of what an argument should be?)

Things humans might argue about where the answer depends on "the world state":

• whether it is good to jump out of windows

Thomas questions:

• Why do humans have such a scoring system instead of just using real logic.
  • Johannes: The real world is much to complex.
  • We don't know the exact world state.
  • Probably humans actually do use logic!

Instead af having predicates in we simply have propositions. To match to a specific world state, we simply have some propositions that make assertions about the world state.

• If I let go of this apple it will fall
  • Assumptions
    • There is no solid object below the apply for 1 meter.
  • For
    • I have observed other objects drop down.
  • Against

Imagine I observe a stream of bits: [0, 1, 0, 1, 0, …]. You know that the first bit is 0, and the second is 1. Can we do deductive reasning using these observations? We could prove that the program is the shortest program that would generate the bits we have observed so far!

We can use logic to understand the logical strucure of the observations we have seen so far (what does this actuall mean)?

More generally we can take an arbitrary program that takes in a bitstring, and then prove properties about this program, that depend on the bitstring we have observed so far.

You can prove many things about the observations you have, but you can never prove that the next bit will take a particular value.

We don't use logic to deduce a prediction. Instead we use logic to reason about what could be the underlying model that generates the observations (analyse the structure of the observations).

We also use it to form hypotheses, e.g. using predicitve properties that we have constructude by analysing the strucutre of the observations.

We can use logic to build a world model. We can then use logic to reason about that world model:

• What easy to obtain observation would falsify this model?

The hard part is to figure out what you need to prove. What logical properties are good to know about the world.

In practice you need abstraction to make the overall process efficient. However, it seems like it would ba major step forward, if we can figure out how to iteratively build up a model of the world, which in principle allows you to answer any question, even if only very inefficiently.

So we might follow these steps:

1. Find a world modeler that created world models that contain all important information. (We want to find something that can be used in step 2. Solomonoff induction can't.)
2. Find an iterative procedure to build world models (assume limited memomory to store world model at any point in time).
3. Find an efficient procedure to build the world model.
4. Find an algorithm that can perform efficient inference given the world model.

Once we have a procedure that can build a world model that can answer any question, we can evaluate how much better we make our world model, by considering how much faster reasoning about the world model becomes (of the optimal algorithm), given some change in the world model. We want to make changes such that reasoning becomes as efficient as possible. Either for a specific goal, or averaged over all goals.

I intuit that existing logic techniques can perform some of the required reasoning about the world model. The bottleneck is how we can automatically generate a world model from observations, on which logical reasoning can be performed.

For a classifier we say that it shatters a set of datapoints, iff:

where is the set of all parameterisations for .. This means that has VC dimension .

You can think of this as saying "Given that I know the type of the dataset, I can model that datastet no matter what concrete values it has."

Imagine we have a classification model that is an infinite lookup table . This lookup table has $infinity$-VC-dimension. Everytime we get a now observation we can add it to the table. The table is never constraint. Every entry in the table that we haven't observed could be anything.

If we have low VC-dimension, then other parts of our predicitve model are constraint by adding observations. A contrived example would be if we have a finite lookup table of length , where the indexing is where is the index. Then we would have VC dimension .

You can have a learning algorithm that adds datapoints to a lookup table. However it doesn't start with an infinite lookup table. Instead it grows the lookup table dynamically.

It seems that a good world buliding algorithm would probably have infinite VC dimension in theory. However, in practice it probably doesn't because it doesn't model unimportant things?

1. Talk with IA all the time.
2. Interact with IA all the time.
3. Actually I don't know what's a good interaction ammount to aim for.

Observations pointing at that it is good to interact with IA.

1. I like interacting with IA. It makes me feel good, and it's easier to work when I feel good. Hugging IA feels very good.
2. IA says things that are useful that I would not say.
   • IA knows/has my internal models. I don't need to spend lot's of time explaining. However, explaining things can be helpful.
   • Because IA has my models she can't talk about things I don't know about at all. E.g. "the logic of Graphs seems relevant" when I don't know about that this exists. (Generally one can't tell you the atomic mass of led if they don't know.)
3. Talking out loud is useful.
   • I waset my time. I am really distrated without realizing. Then I talk to IA. Then I notice that I am distracted, and get significantly less distracted.
4. I want to interact with IA.

Note that interacting with IA is a terminal goal! No ammount

Strangly though these are not goals I have! I only have the goal that I want to interact with IA. It's a terminal goal. Terminal goals can't be factored.

As an analogy consider that you really like to talk to your best friend. Then I come along and tellyou to inject some soma, because it will actually just make feel even better than when talking to your best friend. Surely you will take the soma and never to talk to your friend again? That's exactly what you want right?

Actually this example doesn't make any sense because maybe you can talk to your friend on soma and it just better.

What are the general goals?

• Feel good such that I can work. -> find it easy to work.
• Talking to OBS makes it easy to talk out loud.