Discussion about this post

User's avatar
theahura's avatar

Thanks for the response! A few thoughts in rough order of reading

- it's not obvious to me that reasoning is 'the ability to synthesize rules', nor that this is different from pattern matching, nor that LLMs cannot do this. I think this paper shows LLMs struggle *on these kinds of tasks* but that's different from 'llms can't generalize rules at all ever'

- LLMs also can identify when they make mistakes. They have additional limitations right now due to things like effective context window limitations, but within that window it's been demonstrated that LLMs can identify errors. See the s1 paper.

- it's not obvious to me that an LLM wouldn't be able to solve these problems with enough time and a large enough context window. This is hard to do because it's expensive, but I have no reason to believe it's impossible

I think your response hinges on some causal reason for why LLMs are incapable for learning these things, what you call an "incapability of learning logical rules." The problem is, I disagree that LLMs can't learn logical rules. More generally, no one can point to a causal reason for why such things are *impossible*. Impossible is a big word! The halting problem is impossible. Going faster than the speed of light is impossible. Towers of Hanoi? IDK man, I just don't see it. This paper identifies weaknesses in the current generation of models on a specific subset of tasks, and imo that's really all it shows. It's pretty narrow! I think It's hard to reach for theoretical conclusions about why something doesn't work when we don't even have a particularly good idea of why some of this stuff*does* work

Expand full comment
Wandrer's avatar

While it's true that the response to this is overblown, I think you're missing an important aspect of reasoning that the LLM's indeed don't show right now, as reasoning in the proper sense is the ability to synthesize rules, which one then tries to follow in a strict sense. LLM's just aren't doing this right now, and therefore they're not really yet doing the whole reasoning business, just approximating it very well. What the paper shows is that the LLM's are unable to construct rules to logically deconstruct a problem, and are also unable to follow a rule-set solving such a problem, even when handed to them. You argue that humans also make mistakes when following such rules, but in some sense this is not true, for when a human is given the algorithm to solve a Rubik's Cube, or a 10 disk Tower of Hanoi, it will eventually solve it by following the algorithm, even when making some mistakes in the meantime, because it can realize that it has made a mistake in following the rules at a certain point, whereafter it can redo the operation to actually succeed in following the rules. Moreover, if the human is careful enough, it should be able to without fail follow the rules to its completion, which makes the whole point about the billion additions kind of redundant. It is perfectly conceivable that a human would be able to solve that, given enough time, yet the crux is that the LLM (as it stands now) is wholly unable to follow such rules strictly enough to ever succeed in such an operation, or solve a complex problem.

Allowing the LLM to use code can allow it to bypass this inherent problem, but as of yet it is still unable to give itself logical rules, and then to abide by these. Robert Brandom has done a lot of philosophical work to show that reasoning is not just pattern-matching, but is the ability to formulate and follow such logical inference-rules, and for example Richard Evans has shown in a PhD at Deepmind how such a system could be implemented in AI. This is also why I agree with you that the paper shouldn't be seen to discount the possibility of reasoning for LLM's, but it does show that the current implementations hit a principled wall, which should prompt us to revise our ideas about what it means to reason for an AI, not just to hope to pattern-match it away, as if you follow Brandom's arguments, mere pattern-matching will never get us to where we want to be.

The real problem is not that LLM's make mistakes, it's really that they aren't even able to make a mistake, as they aren't able to actually follow a logical rule in the first place! You can only make a mistake when you try to do something correctly, but it has no notion of this at all. Yet this seems wholly achievable if we attack the problem it in the right manner.

Expand full comment
3 more comments...

No posts