You : Do this simple thing.
DS : Okay, ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ..., but No, wait, but okay and ..., but wait ! No, cause ..., so ..., but perhaps ... ot maybe ...
So ! You need to use the following method to do it by your self.
1. Prepare all the nessecary things in order to solve the problem.
2. Mentally prepare to apply a good solution.
3. Actually solve your problem by solving it.
4. Done !
I'm happy to help you ! If have any other question or request, I'm here for helping you and it's my great pleasure.
the easiest way to trigger an hilarious overthinking is to ask a nonsense question as a riddle.
> Here is a riddle : "How can you have any pudding if you don't eat your meat?"
or
> The riddle is : "Why'd you leave the keys upon the table?"
honestly, it really demonstrates there is no actual reasoning happening, it's all a lie to satisfy the end user's request. The fact that even CoT is often mispoken as "reasoning" is sort of hilarious if it isn't applied in a secondary step to issue tasks to other components.
It looks like it's reasoning pretty well to me. It came up with a correct way to count the number of r's, it got the number correct and then it compared it with what it had learned during pre-training. It seems that the model makes a mistake towards the end and writes STRAWBERY with two R and comes to the conclusion it has two.
I think the problem is the low quantity/quality of training data to identify when you made a mistake in your reasoning. A paper recently observed that a lot of reasoning models tend to try to pattern match on reasoning traces that always include "mistake-fixing" vs actually identifying mistakes, therefore adding in "On closer look, there's a mistake" even if it's first attempt is flawless.
Makes sense. So the model has bias the same way as they sometimes think the question is some kind of misleading logic puzzle when it actually isn't. So the model is in a way "playing clever".
Yeah, it thinks you want it to make mistakes because so many of the CoT examples you've shown it contain mistakes, so it'll add in fake mistakes
One interesting observation about this ability to properly backtrack (verification of each step + reset to a previous step) is that it also seems to be an emergent behavior similar to ICL itself and there may be some sort of scaling law governing their emergence based on parameter size and training examples (tokens), however the MS paper has recently show that small models with post training have also demonstrated both of these behaviors, so it may also be a matter of the type of training
I think the issue is with transformers themselves. The architecture is fantastic at tokenizing the world’s information but the result is the mind of a child who memorized the internet.
I'm not so sure about that, the mechanistic interpretability group for e.g. have discovered surprising internal representations within transformers (specifically the multiheaded attention that makes transformers transformers) that facilitates inductive "reasoning". It's why transformers are so good at ICL. It's also why ICL and general first order reasoning breaks down when people try linearizing it. I don't really see this gap as an architectural one
Transformers absolutely do have a lot of emergent capability. I’m a big believer that the architecture allows for something like real intelligence versus a simple next token generator. But they’re missing very basic features of human intelligence. The ability to continually learn post training, for example. They don’t have persistent long term memory. I think these are always going to be handicaps.
I mean, most people have mindboglingly pathetic reasoning skills so... No wonder AIs don't do well or at it or, there isn't much material about it out there...
We also (usually) don't write down our full "stream of consciousness" style of reasoning, including false starts, checking if our work is right, thinking about other solutions, or figuring out how many steps to backtrack when we made a mistake. Most of the high quality data on, for e.g., math we have are just the correct solution itself, yet rarely do we just magically glean the proper solution. As a result, there's a gap in our training data of how to solve problems via reasoning.
The general hypothesis from https://huggingface.co/papers/2501.04682 is:
1. Many problems exist without an obvious single solution that you can derive through simple step by step breakdown of the problem (though the # of rs in strawberry is one of these)
2. Advanced LLMs seem to be able to do well on straightforward problems, but often fail spectacularly when there are many potential solutions that require trial and error
3. They attribute this phenomenal to the fact that we just don't have a lot of training data demonstrating how to reason for these types of harder problems
I think the opposite. This actually reminds me of a lot of the biases humans have where we work backwards to justify our biases, or where we get confused by riddles and things with conflicting connotation.
Nope, this shows reasoning. The only problem you are having is that you expect regular human reasoning achieved through human scholarship. That's what it is not.
This is basically what reasoning based on the total content of the internet is like.
A human brain simply has more neurons than any LLM has for params.
A human brain simply is faster than any combination of GPU's.
Basically a human being has a sensory problem where the sensory inputs overload if you try to cram the total content of the internet into a human brain, that is where a computer is faster.
But after that a human being (in the western world) basically has 18 years of schooling/training, where current LLM's have like a 100 days of training?
Basically what you are saying is that we haven't in the 10 years that this field has been active in this direction (and in something like 100 days training vs 18 years training) achieved with computers the same as nature has done with humans in millions of years
Even animals can reason. Animals have mental models of things like food and buttons. We can teach a dog to press a red button to bring food. We cannot teach a LLM that a red button will bring food.
LLMs cannot reason because they do not have working mental models. LLMs only knows if a set of word is related to another word.
What we have done is given LLM millions of sentences with red buttons and food. Then when prompt it "Which button gives food?" we hope the next most likely word is "red"
We are now trying to get LLMs to pretend to reason by having it add to its own prompt. We hope if the LLM creates enough related words it will guess the correct answer.
If an Deepseek was capable of reasoning, it would understand what it was saying. If it had working models of what it was saying, it would have understood after the first or second check counting that it already answered the question.
Recent research suggests that LLMs are capable of forming internal representations that can be interpreted as world models. A notable example is the work on Othello-playing LLMs, where researchers demonstrated the ability to extract the complete game state from the model's internal activations. This finding provides evidence that the LLM's decision-making process is not solely based on statistical prediction, but rather involves an internal model of the game board and the rules governing its dynamics.
I'm sure information/models are encoded in LLM parameters. But LLMs internal representations are not working functional models.
If it had functional models LLMs wouldn't make basic mistakes like saying 9.11 > 9.9.
And LLMs wouldn't have the [Reversal Curse](https://paperswithcode.com/paper/the-reversal-curse-llms-trained-on-a-is): when taught "A is B" LLMs fail to learn "B is A"
___
Its like training a dog to press a red button for food. But if we move the button or change it's size the dog forgets which button to press.
We wouldn't say the dog has a working model of which color button gives food.
9.11 can be greater than 9.9 if you are referring to dates or version numbers.
Context matters. LLMs have different models of the world than we do (shaped by their training data), so the default answer for “is 9.9 > 9.11?” for an LLM might easily be different than a human’s (tons of code and dates in their training data, we will always default to a numerical interpretation).
Is the LLM answer wrong? No. Is it what we expect? Also no. Prioritizing human like responses rather than an unbiased processing of the training data would fix this inconsistency.
If you change the meaning of the question, then any response can be correct.
If there was a sensible reason behind the answer, like it interpreting it as dates, the LLMs would say that in their explanations.
However in its reasoning afterwords it gives more hallucinated [nonsense](https://media.licdn.com/dms/image/v2/D4E22AQHwg_YHJQTJlg/feedshare-shrink_800/feedshare-shrink_800/0/1721910451328?e=1740009600&v=beta&t=Xm1ojGK8RBPq016f4B5woIoz3GD1beHdG4RWAvZwXPY) like ".9 is equivalent to .09 when rounded"
You can hand-wave away this singular example. But AI hallucination where it makes basic mistakes is a fundamental problem which doesn't even have a hypothetical proposed solution.
>However in its reasoning afterwords it gives more hallucinated [nonsense](https://media.licdn.com/dms/image/v2/D4E22AQHwg_YHJQTJlg/feedshare-shrink_800/feedshare-shrink_800/0/1721910451328?e=1740009600&v=beta&t=Xm1ojGK8RBPq016f4B5woIoz3GD1beHdG4RWAvZwXPY) like ".9 is equivalent to .09 when rounded"
I tested the same question multiple times on Llama 3.1 405B in deepinfra API and it gor the answer correctly 100% of the time. What provider are you using ? It seems that particular model is quantized to hell or is malfunctioning in some other way. Llama 405B should be able to handle simple number comparison like that correctly, and in my own testing it did without errors.
Try using better provider, or if you are self-hosting try a different/better quantization.
This was a very popular problem like the "r's in strawberry" test that multiple models failed.
The fact that they updated models on this specific problem is not evidence that it is solved because we have no idea why it was a problem and we don't know what other 2 numbers would create the same error.
It was just one example of AI hallucinations, you can find many others.
You miseed the point. According to your screenshot the model you are using is Llama 3.1 405B, correct ?
In my tests that same model succeeded in the described task 100% of times I tested.
Either the model has been damaged by quantization or there is a bug in your inference pipeline.
Tldr: you are having an issue you should not be having if your model was functioning correctly. You are complaining about something that doesn't exist...
https://www.google.com/search?q=which+is+greater+9.11+or+9.9
This was a problem with multiple LLMs.
I didn't personally encounter this problem. I just found it on the internet because many people reproduced this error with multiple LLMs.
_____
> You are complaining about something that doesn't exist...
More importantly do you think if all those models worked 100% to specification it would not have basic hallucination errors?
Do you think that basic AI hallucinations, (the thing I am complaining about) has ever been a solved problem for any language model ever?
>More importantly do you think if all those models worked 100% to specification there would be 0 basic hallucination errors?
>Do you think that basic AI hallucinations, (the thing I am complaining about) has ever been a solved problem for any language model ever?
While Large Language Models (LLMs) have shown significant improvement, their tendency to confidently hallucinate remains a challenge. This issue is multifaceted:
"I don't know" is difficult to teach. Training LLMs on examples of "I don't know" as a valid response backfires. They learn to overuse this answer, even when they could provide a correct response, simply because it becomes a frequently observed pattern in the training data.
LLMs lack robust metacognition. Current architectures struggle to facilitate self-evaluation. While reinforcement learning with extensive datasets holds potential for teaching LLMs to assess their own certainty, the necessary techniques and data are currently insufficient.
Internal consistency remains a hurdle. LLMs are trained on massive datasets containing contradictory information (e.g., flat-earth theories alongside established science). This creates conflicting "truths" within the model, making its output context-dependent and prone to inconsistency. Training on fiction further exacerbates this "noise" by incorporating fictional world models. While improvements have been made by prioritizing data quality over quantity, this remains an active area of research.
That being said, I tested the original numbers comparison on multiple locally hosted models on my own pc, and did not encounter a single wrong answer. All models responded that 9.9 is larger than 9.11. These were all small models wit 8B or less parameters. The smallest model I tested was 3B parameter starcoder2 with Q4K_M quantization, and even it got the answer right, despite being a very small model and relatively old on the scale of LLMs.
I would not rule out user error or faulty quantization in cases where people encounter this error, especially when top-tier models like Llama 405B are considered.
You're right, 9.11 could be greater than 9.9 depending on the context, like dates or version numbers. This is further complicated by the fact that a comma is often used to separate decimals in some regions, while a period (point) is more common for dates and version numbers. This notational difference can exacerbate the potential for confusion.
This highlights a key difference between human and LLM reasoning. We strive for internal consistency based on our established worldview. If asked whether the Earth is round or flat, we'll consistently give one answer based on our beliefs.
LLMs, however, don't have personal opinions or beliefs. They're trained on massive datasets containing a wide range of perspectives, from scientific facts to fringe theories. So, both "round" and "flat" exist as potential answers within the LLM's knowledge base. The LLM's response depends on the context of the prompt and the patterns it has learned from the data, not on any inherent belief system. This makes context incredibly important when interacting with LLMs.
You actually pointed out a difference that didn’t occur to me - international notation for these things is different too. For places that use a comma for decimals, the other interpretations are even more reasonable.
Turns out the commenter we were replying to is using a broken model. I tested the same number comparison on same model (llama 405b) on deepinfra, and it got it right on 100% of attempts. He is using broken or extremely small quants, or there is some other kind of malfunction in his inferencong pipeline.
LLMs don't need perfectly accurate world models to function, just like humans. Our own internal models are often simplified or even wrong, yet we still navigate the world effectively. The fact that an LLM's world model is flawed doesn't prove its non-existence; it simply highlights its limitations.
Furthermore, using math as the sole metric for LLM performance is misleading. LLMs are inspired by the human brain, which isn't naturally adept at complex calculations. We rely on external tools for tasks like large number manipulation or square roots, and it's unreasonable to expect LLMs to perform significantly differently. While computers excel at math, LLMs mimic the human brain's approach, inheriting similar weaknesses.
It's also worth noting that even smaller LLMs often surpass average human mathematical abilities. In your specific example, the issue might stem from tokenization or attention mechanisms misinterpreting the decimal point. Try using a comma as the decimal separator (e.g., 9,11 instead of 9.11), a more common convention in some regions, which might improve the LLM's understanding. It's possible the model is comparing only the digits after the decimal, leading to the incorrect conclusion that 9.11 > 9.9 because 11 > 9.
My point is LLM's current level of intelligence is not comparable to any state of human development because it does not operate like any human or animal brain.
Its thought process has unique benefits and challenges that make it impossible to estimate its true intelligence with our current understanding.
This is old research by LLM standards, and notably very little seems to be done to try and create those world models in LLMs. There's an assumption that they will appear automatically but I don't think that's actually true.
Most animals don't (and can't) reason. They simply learn via conditioning. Even animals capable of reasoning mostly don't use reasoning except in extremely limited circumstances.
> A calculator can reason about math because it has a working model of numbers as bits. We can't get AI reason because we have no idea how to model abstract ideas.
Whilst not saying LLM's can reason or not, I don't think this example applies here as much as you think it may because if the programming of the calculator had a mistake in it where for example 1 > 2 and then it start giving you dumb answers just because it's initial rules of working were incorrect, which is what the LLM here showed with it's dictionary word from it's training data having a misspelled version of strawberry.
All logic and reasoning can be corrupted with a single mistake. Calculators and human logic follows a deterministic path. We can identify what causes mistakes and add extra logic rules to account for it.
LLMs sometimes fail at the basic logic because it randomly guesses wrong. Instead of correcting the logical flaw like in humans we retrain it so it memorizes the correct answer.
I mean this isn't really too different from how reason isn't it? One thing leads to the next, with some words or some conditions leading to the result that normally happens.
The difference is trust. We can trust animals with very poor reasoning abilities to very reliably do what they were trained. Animals have reliable models of the very few things they can reason about.
We cannot trust an AI on things that even a guide-dog would do because it still makes basic mistakes. And we have no idea how to make it stop making these errors.
I think most people are slowly starting to realize that.. transformers won't get us there, this generation is not even close to "actual reasoning" and it won't matter how many hacks we try. CoT is a hack trying to bruteforce it but it is not working.
This example here kind of shows that. But the reasoning won't converge. It's not impossible for future LLMs to be trained on characters instead of tokens. Or maybe some semantic, lower level stuff. The tokenizer, as it is today, is an optimization.
humans can do this just fine. nobody is thinking in letters unless we have a specific task where we need to think in letters. i'm not convinced that LLMs do "reasoning" until MoE can select the correct expert without being pretrained on the question keywords.
It says "visualizing each letter individually". Clearly it is not really reasoning here because it is not even "aware" of having no vision and not admitting that the actual thing that would help is the tokenization process to split the word into letters, making every letter a separate token. That's what helps it, and not "visualizing each letter individually". So it's still just roleplaying a human and following human thinking.
Literally just have it write a python program to count the number of R's in any word and hard code the word to strawberry. Done.
But, the lack of simple logic following in one of the supposedly greatest models we've seen yet is sadly not great. (I haven't used this model yet I've only heard a bit of hype about Deepseek and seen some sample output)
I'm guessing it was trained on Chinese language quite a bit and this could have more to do with it not being so sure about English. Idk
Yes that's my problem in v3 and r1, I let it calculate perfecting hashing in a 7-set, and it was trapped in an endless loop, deepseek should let itself stop thinking at some point
How many letters in "Hi"
High parameter models be like: proceeds to write an entire essay as to why it's two letters and goes in greater detail explaining why.
Low parameter models be like: word "Hi" has 7 letters.
I absolutely love the part where it analyzes the word letter for letter, realizes there are actually 3 rs, but then it immediately recalls something in its training about it having "two rs", then it analyzes the word again, counts 3 rs again, gets even more confused because "it should have 2 rs", develops another analysis method (using syllables this time), again determines there are 3 rs, and then it convinces itself again that it "must have 2 rs" when recalling its training data again (in this case dictionary entries), analyses the word again, again finds 3 rs and then just finds a way to ignore its own reasoning and analysis in order to be in harmony with its training data.
It's fascinating honestly, not only it developed four methods to correctly determine that the word has 3 rs, but then somehow some of the values in its training forced it to incorrectly reach a way to determine it "has 2 rs" so its conclusion could be in harmony with the data it recalls from its training.
The next logical step in order to make AIs more reliable is making them rely less and less in their training and rely more on their analytical/reasoning capabilities.
Not quite.
There are situations where there might be a mistake in the reasoning and so it needs to be able to critically evaluate its reasoning process when it doesn't achieve the expected outcome.
Here it demonstrates a failure to critically evaluate its own reasoning.
So a reasoning model for its reasoning? And how many times should its reasoning conflict with its training data before it sides with its reasoning vs its training data?
There's no correct answer to that.
The problem is that if the AI is making a mistake it can't fact-check by cracking open a dictionary.
What it should be able to do it think: okay, I believe "strawberry" is spelled like that (with 3 Rs). However, I also believe it should have 2 Rs. I can't fact check so I can't resolve this, but I *can* remember that the user asked me to count the Rs in "strawberry" and this matches how I thought the word should be spelled. Therefore, I can say that it definitely has 3 Rs.
If the user had asked it to count the Rs in "strawbery" then it might reasonably provide a different answer.
It’s reminiscent of flat earthers testing their hypothesis with real experiments in the documentary “Behind the Curve”.
For some reason the training data (or prompt) has convinced the model the answer must be two no matter what the evidence suggests.
Even better if ithe AI was also given access to tools and reality so it can ground its reasoning, like using a dictionary and ctrl-c ctrl-v'ing the word into a program to count it, and if the result was still not satisfactory then the Ai should do it with other words to see that the method was right all along, but as you said the Ai should be able to accept the results of research (like also looking about it online) and experiments...
What are you talking about? In early 20th century people couldnt write. They barely had language at that stage of development. Im surprized they could walk at all...
not really. what they wrote formal proof for is basics of all math starting from what numbers are, summing, equality etc, once those were done then on page 379 (not 1000) of principia mathematica they get to say that based on all that 1+1=2 (as an example of a sum of any two numbers).
May be because.of the attention mechanism treating extra r in the strawberry as irrelevant? Someone probably can confirm this by counting letters in languages like indonesian where the writing system is simpler and no unnecessary double letters used.
I think it might be because it's written with two **consecutive** "R"s, maybe the models get confused and forget about the consecutive part. Also there's a potential contamination effect with more recent models, they probably have stories and examples about ChatGPT and LLMs in general struggling to count the Rs in strawberry, and since they're LLMs, they're supposed to struggle with that.
Yeah, we could expect some spelling Q&A in the internet like "Is it strawbeRy or strawbeRRy? Remember, the strawberry is written with 2 r's, because beRRy and ..."
100% its this. its just finding Q&A for "how many rs in strawberry" in its training set, which humans naturally respond to with 2 because we understand why the other human was asking.
This is basically a Turing test.
Yeah that's what a.i agents will be doing. Posting weird clickbait blog posts that go into deep conspiracies about how many strawberries r's really have lol
I watched the explaination of this in youtube(Sorry I forgot the name and link) and it explain that it is due to how fundamentally it see's the words per tokens instead of actual words so strawberry is = straw"berry" and only the berry is being counted on that question iirc
When it counted the individual letters it found three. There, each letter is represented as a separate token for the model, while strawberry probably only two or three tokens. This actually shows that this CoT reasoning has the capability to compensate for training inherent errors. This is just a very special case that seems very trivial but is actually extremely difficult for the model.
I wish people would stop asking this question and ask questions involving open-ended reasoning with no clearly defined answers to gauge a model's reasoning (and creativity).
In my experience, we're still missing an order of magnitude of reasoning/planning ability. I find the models say reasonABLE things when presented with those types of challenges, but don't really come up with creative ideas or a solid plan for finding them. Maybe that's still more the domain of multi-agent-based systems.
The training data needs a good generic answer to stupid questions. It freaks out if you ask about a topic a mile away from gambling, but can't reply that it can't count.
i really hope they won't add a huge dataset just to get an extra point in some stupid benchmark.
Honestly this is a great example of one of the fundamental weaknesses of current reasoning models, and why there will need to be advancements before we truly reach anything resembling AGI.
They are able to reason about the problem, and the problem solving process they come up with to do so is pretty good, but they aren’t very good at handing results that contradict their training data, and will gaslight themselves into making errors that validate their biases. Which is something people do all the time too but current gen Chatbots take it to the extreme because they don’t actually trust the process they came up with, or even truly understand it for that matter.
That doesn’t mean we’ll never get there, I’m pretty hopeful for the future of AGI, but it’s also clearly not here and not very close.
It's just nonsense. Deepseek's logic is horrible. I think it's just a placeholder we're seeing to make us feel like it's a great model, and not really much there
This leads me to two observations:
\- why do most models tend to make the same mistake of counting too few r's? I don't recall seeing a response with 4 r's. Here the LLM even claims that "common usage" is two r's. Why so? Did it start from the very first mistake in the synthetic data of GPT4, or are there any other reasons?
\- it says "visualizing each letter individually". Clearly it is not really reasoning here because it is not even "aware" of having no vision and not admitting that the actual thing that would help is the tokenization process to split the word into letters, making every letter a separate token. That's what helps it, and not "visualizing each letter individually". So it's still just roleplaying a human and following human thinking.
I think it's because of the tokenizer. Because the tokenizers that the LLMs use, breaks words into subwords maybe because of that the LLMs are unable to get the full picture of the word and hence it miscalculates the frequency. One thing that I am wondering is whether models that will be built on Meta's new Byte Latent Transformer will be able to solve this or not.
Is anyone else profoundly bored with this topic? Yes, models can't spell strawberry. It's a quirk of how tokens work, there is literally nothing meaningful or interesting about this as a benchmark or measure of intelligence/performance.
The scam is how this is presented. This is most likely working because increasing the prompt context increases the likelihood that it guesses the correct answer. It is not doing multi-step 'reasoning'. LLMs cannot 'reason' because it has no understanding of what it is saying.
[The Reversal Curse: LLMs trained on "A is B" fail to learn "B is A"
](https://paperswithcode.com/paper/the-reversal-curse-llms-trained-on-a-is-b)
If it can't do the most basic reasoning "A=B therefore B=A" , then all of this complex reasoning is an illusion
Unless it is using individual letters as tokens, it literally can't see how many letters are in the word strawberry. It would be like asking you how many atoms are in a strawberry.
Worked for me first try with “How many “r”s in strawberry?“
### Step 1: Understanding the Problem
The question asks, “How many ‘r’s are in the word ‘strawberry’?” To answer this, I need to:
1. **Identify the word in question**: “strawberry.”
2. **Count the number of times the letter ‘r’ appears in this word.**
### Step 2: Breaking Down the Word
First, I’ll write down the word to visualize each letter:
```
S T R A W B E R R Y
```
Breaking it down, the letters are: S, T, R, A, W, B, E, R, R, Y.
### Step 3: Identifying the Letter ‘r’
Now, I’ll go through each letter one by one to identify the ‘r’s.
1. **S**: Not an ‘r’.
2. **T**: Not an ‘r’.
3. **R**: This is the first ‘r’.
4. **A**: Not an ‘r’.
5. **W**: Not an ‘r’.
6. **B**: Not an ‘r’.
7. **E**: Not an ‘r’.
8. **R**: This is the second ‘r’.
9. **R**: This is the third ‘r’.
10. **Y**: Not an ‘r’.
### Step 4: Counting the ‘r’s
From the breakdown:
- The letter ‘R’ appears three times in “strawberry.”
### Step 5: Verifying the Count
To ensure accuracy, I’ll recount:
1. First ‘R’ at position 3.
2. Second ‘R’ at position 8.
3. Third ‘R’ at position 9.
No more ‘R’s are present beyond these.
### Step 6: Conclusion
After carefully analyzing each letter in “strawberry,” I’ve determined that the letter ‘r’ appears **three times**.
**Final Answer:** There are **3** ‘r’s in the word “strawberry.”
Been using it today and its been able to basically one shot my first 3 phases of my programing project when provided with a action plan and enabling deepthink. My new favorite AI at the moment. Been using claude 3.5 but keep running into context issues. Deepthink is nice because it basically reduces the need for follow up quesitons
You got quite unlucky with the order DS got it right 9/10 times i tried with thinking on.
You can very well see the reasoning methods get it right like 5 times.
"but I recall strawberry has usually 2 r's"
the remembering the trainingsdata gives it two.
and a quick check gives it also 2 because of token issues.
The reasoning models will also help identifying many issues model have.
Also Qwen just released their SRM. Step reasoningmodel which can evaluation each reasoningstep.
So next up minimax 4M content window + SRM = O1 quality? 🔥
I wonder why it trailed off for so long instead of concluding that maybe its memory was wrong and just confirming Strawberry has 3 letters or something like that.
Reminds me of something I heard recently which is that the actual mathematical proof showing that 1+1 =2 was written by a machine and is so long no human could read it in a lifetime even if they never slept and spent their entire lives just reading it.
It’s basically so long that mathematicians treat it as true.
Well that's not true. You might be misremembering the fact that it took god-knows-how-long for Russell and Whitehead to prove 1 + 1 = 2 in Principia Mathematica. But strictly speaking those two weren't machines, and humans can *just about* parse their proof.
But (1) Principia Mathematica is only of historical interest - there are much better ways of doing what PM was attempting to do.
And more fundamentally (2) there's no such thing as *the* proof of 1 + 1 = 2, we can only talk about the proof within a given formal system. One perfectly good example of a formal system is Peano arithmetic (plus some choice of deductive system for first order logic - there are many to choose from). The proof will only be a few lines long.
You can feel the "No, no, no I know this is wrong, this can't be happening! NOOOOOOOO! Shit shit shit I need to make something up so it fits, uhhhhhhh yeah this'll do. Perfect. Nailed it."
I've noticed DeepSeek has a tendency to doubt itself a lot. Qwen does the same. There's a lot of "if you think you have the answer, question yourself just in case" going on behind the scene and they'll probably get much better in the next iteration.
Gemini Thinking seems to have the most confident thoughts so far:
https://preview.redd.it/395jqjdg58de1.png?width=691&format=png&auto=webp&s=4fb84e4cbad3603651182d906e5fe33eb51a40f1
v1 "if you think you have the answer, question yourself just in case"
v2 "if you think you have the answer, question yourself just in case. But not too much, you know. Have some confidence."
I really enjoyed this one from the other day:
https://preview.redd.it/p3qre8sx58de1.png?width=619&format=png&auto=webp&s=5e839762458a8d357358da4785f3b7fe2ce0599d
This is another great example — notice the difference. Gemini always seems to think very top-down and develops a methodical game plan, whereas DeepSeek meanders from thought to thought:
https://preview.redd.it/dl1ux5zc78de1.png?width=718&format=png&auto=webp&s=263d43c100a2ff8c24877331f775dd11f6d32285
this is gold. this also mimics how people tend to believe what they already think is true, looking for facts that support their ideas and ignoring ones that contradict them, instead of changing their beliefs
This issue with these thinker models is that they're fine tuned to get things wrong at first and then start rambling about the question before then actually answering correctly. There are right ways to do this but they built these ones wrong
209 Comments
Remarkable-Ship-2856@reddit
OrganizationFast9063@reddit
PotaroMax@reddit
PurpleWinterDawn@reddit
NihilisticAssHat@reddit
LCseeking@reddit
plocco-tocco@reddit
possiblyquestionable@reddit
Alarming_Manager_332@reddit
ArkhamDuels@reddit
HumpiestGibbon@reddit
possiblyquestionable@reddit
rand1214342@reddit
possiblyquestionable@reddit
rand1214342@reddit
possiblyquestionable@reddit
Cless_Aurion@reddit
Themash360@reddit
alcalde@reddit
SolumAmbulo@reddit
Cless_Aurion@reddit
Ok-Protection-6612@reddit
Cless_Aurion@reddit
possiblyquestionable@reddit
Cless_Aurion@reddit
AR_Harlock@reddit
UnlikelyAssassin@reddit
M3GaPrincess@reddit
Former-Ad-5757@reddit
CeamoreCash@reddit
Dramatic-Zebra-7213@reddit
CeamoreCash@reddit
Top-Salamander-2525@reddit
CeamoreCash@reddit
Dramatic-Zebra-7213@reddit
CeamoreCash@reddit
Dramatic-Zebra-7213@reddit
CeamoreCash@reddit
Dramatic-Zebra-7213@reddit
Dramatic-Zebra-7213@reddit
Top-Salamander-2525@reddit
Dramatic-Zebra-7213@reddit
Dramatic-Zebra-7213@reddit
CeamoreCash@reddit
ASpaceOstrich@reddit
LetterRip@reddit
Tobio-Star@reddit
major_bot@reddit
CeamoreCash@reddit
TenshouYoku@reddit
CeamoreCash@reddit
West-Code4642@reddit
Tobio-Star@reddit
Helpful_Excitement50@reddit
LotusTileMaster@reddit
Minute_Attempt3063@reddit
Admirable-Star7088@reddit
Minute_Attempt3063@reddit
Top-Salamander-2525@reddit
Minute_Attempt3063@reddit
PeachScary413@reddit
gavff64@reddit
Code-Useful@reddit
ivarec@reddit
pmp22@reddit
ivarec@reddit
arvidep@reddit
martinerous@reddit
ControlProblemo@reddit
Nyao@reddit
Admirable_Count989@reddit
YourNetworkIsHaunted@reddit
Code-Useful@reddit
Equivalent_Bat_3941@reddit
TheThirdDuke@reddit
E_mc420@reddit
sala91@reddit
sala91@reddit
Charuru@reddit
Comfortable-Prior626@reddit
Fancy_Run_8763@reddit
SouthAsianAlterEgo@reddit
Used-Carry5712@reddit
sebo3d@reddit
Arcosim@reddit
Keblue@reddit
eiva-01@reddit
Keblue@reddit
eiva-01@reddit
Top-Salamander-2525@reddit
esuil@reddit
121507090301@reddit
AppearanceHeavy6724@reddit
CharaISTB@reddit
PeachScary413@reddit
AppearanceHeavy6724@reddit
KattleLaughter@reddit
Mart-McUH@reddit
Live_Bus7425@reddit
cptbeard@reddit
Minute_Attempt3063@reddit
Eritar@reddit
FutureFoxox@reddit
EnviousLemur69@reddit
hayarms@reddit
Life_Ad_7745@reddit
GraceToSentience@reddit
Loui2@reddit
flowstoneknight@reddit
NewGeneral7964@reddit
stddealer@reddit
YearnMar10@reddit
rubute@reddit
arvidep@reddit
Psychonominaut@reddit
xXPaTrIcKbUsTXx@reddit
DeviantPlayeer@reddit
shabusnelik@reddit
dibu28@reddit
armaver@reddit
LogicalLetterhead131@reddit
Cruxius@reddit
Runnzi@reddit
Admirable-Star7088@reddit
Inaeipathy@reddit
fauxpasiii@reddit
R3PTILIA@reddit
Key-Contact-6524@reddit
alcalde@reddit
alcalde@reddit
jameshung-1219@reddit
B4N4N4RAMA@reddit
Substantial_Way8470@reddit
spartan421@reddit
lxe@reddit
MarekNowakowski@reddit
PeachScary413@reddit
Exact_League_5@reddit
Appropriate-Sort2602@reddit
RogueZero123@reddit
EastZealousideal7352@reddit
Confident-Ad-3465@reddit
PraiseThePidgey@reddit
lammatthew725@reddit
nodeocracy@reddit
Alex_1729@reddit
TBMonkey@reddit
Switchblade88@reddit
Alex_1729@reddit
tabspaces@reddit
AppearanceHeavy6724@reddit
tabspaces@reddit
AppearanceHeavy6724@reddit
martinerous@reddit
crazycomputer84@reddit
UniqueAttourney@reddit
thecowmilk_@reddit
Sad-Nefariousness712@reddit
Monoryable@reddit
Switchblade88@reddit
realkorvo@reddit
matadorius@reddit
GrennKren@reddit
Pryani4ek@reddit
op4@reddit
grtgbln@reddit
maddogawl@reddit
BigDaddyPrime@reddit
Blasket_Basket@reddit
TenshouYoku@reddit
Strict_Counter_8974@reddit
esuil@reddit
CeamoreCash@reddit
ColorlessCrowfeet@reddit
roger_ducky@reddit
National_Cod9546@reddit
kac487@reddit
shadows_lord@reddit
SuuLoliForm@reddit
Secret_Ad_6448@reddit
Comms@reddit
ericbigguy24@reddit
ReadyAndSalted@reddit
exilus92@reddit
thatkidnamedrocky@reddit
alby13@reddit
tengo_harambe@reddit
Utoko@reddit
qroshan@reddit
SkyGazert@reddit
ServeAlone7622@reddit
DisillusionedExLib@reddit
sleepydevs@reddit
Massive_Robot_Cactus@reddit
MoffKalast@reddit
Recoil42@reddit
ares623@reddit
Recoil42@reddit
Recoil42@reddit
Recoil42@reddit
Ok-Engineering5104@reddit
Anthonyg5005@reddit
SithLordRising@reddit
thetaFAANG@reddit
Irisi11111@reddit
Journeyj012@reddit
bgighjigftuik@reddit
Admirable-Fox-7221@reddit
Born_Fox6153@reddit