by gmays
Claude Fable produced a counterexample to the Jacobian Conjecture - https://news.ycombinator.com/item?id=48973869 - July 2026 (508 comments)
I can use AI for coding after decades of coding. I can't use it for theoretical physics because I can't evaluate the responses.
https://larsfaye.com/articles/ai-coding-will-prevent-experti...
> I’m also surprised to see that even Terrence Tao seems to use it in a way that resembles, in progression, how I use llms in my area of expertise
I've mostly seen people trying to oneshot a result, while I'll quickly experienced that going through steps/discovery was more effective and more satisfying, since you can always steer it back in the right direction; while oneshotting is hit (and it kind feel like magic) or miss (and you'll have to rework your prompt).
I think it's not even about the ability to steer the AI. Just the ability to ask the right questions
In your counterexample, the human just repeatedly asked the model to "try harder". Not remotely the same.
The first one was someone proving another conjecture false by just repeatedly saying "keep going" to ChatGPT: https://x.com/DmitryRybin1/status/2079904005652893709
What a world we live in.
> What a world we live in.
Scroll... wait for render... scroll... wait for render... repeat...
We live in a world where there's so much crazy technology but few people use it to make products better or to improve people's lives. Most people use it to just make more money. It's funny too, because there's a million things we could use that tech for that actually reduce costs. Hell, what would be the economic impact of putting ML systems into streetlights so they properly coordinate. Don't even need LLMs for that, and I'm sure it'd save billions of dollars a year. Just a lack of will. I wonder if this will ever change. Is this how we create the high tech low life future?
(FWIW, no problems if I jump into the app. It's purely a web thing, but my point more illustrative than specific)
1. The counter example wasn't just a brute force selection, the polynomial is structured in a very specific way that ends up getting the result.
2. Terry Tao's questions are very specific and prompts the AI in a useful way, that without high math training you are not going to get the same information out of it. Terry seems to see some aspects of the problem and counter example and uses AI to brute force some parts of it.
Just awesome to see new knowledge hit an incredible mind like this. Having these "what if" discussions is what I miss most from JPL and academia.
This "symbiosis" (for lack of better word) of human with AI seems to be an emergent value proposition of AI. In the process of doing stuff with AI, producing artefacts like code diffs, we are continuously able to decide how strong the mental map is of the current stage of the production process.
I could probably have worded this better but I'm sure it's something others have noticed... this choice we are able to make of how high fidelity our own understanding needs to be of the current working problem, and how that choice never really existed prior to AI.
Sorry it's a bit of an aside, but I imagine many other otherwise "technical" folks feel the same unfamiliar sense of total loss like when encountering hard mathematics.
Yes, Tao is guiding it to where he wants to go. But also, Tao is actively learning from it and relying on its explaining, analysis, and inference abilities. You can easily imagine this conversation having taken place between Tao and a PhD thesis student, or even another professor, explaining their results.
What can we imagine and predict about the future anymore? Maybe a year - or two model releases - from now, the AI assistant will be undeniably stronger than Tao, and not an equal anymore.
a) The model thinks on some questions while straight answers on others. (I wish I'd knew from the questions if this is somehow correlated to hard tasks or "inventive" tasks, but that's way out of my league).
b) The model sometimes pushes back. Again, I'd wish I knew if it was warranted, but I counted 2 instances where it said "yes, but with caveats", one where it said "mostly yes but with this correction" and one where it said "careful here, because x y z".
c) The model did q&a + pdf ingestion + code writing + more q&a + thinking + more q&a, for a looong while, while seemingly staying on topic (at least Terrence Tao seems to think they're still productive, so I'll trust that).
This is what model progress is, not number goes up on xBency or yBencher. Damn.
Where will we be in another 4 years? What a time to be alive!
Possibly somewhere amazing, but see also: https://x.com/pronounced_kyle/status/1768852493092680036
Another satisfied customer!
https://terrytao.wordpress.com/2026/07/21/a-digestion-of-the...
The fascinating this is that the LLM is not acting as a tool here AFAIk, but very much like a colleague.
I have no knowledge of the domain and have only PhD EE level math knowledge, so maybe my bar is too low.
What I do notice however is that LLMs are becoming capable of doing an increasing part of the intellectual work I can do, and usually a lot faster.
Just today I presented an agent framework that can take an informal incident statement and propose infrastructure changes to fix it, all evidence backed. This did nothing I could not to, but it did all 5 test cases in 6 - 12 minutes each. I would have found all of the monitoring indications it did, but it would have taken me a day per test case. The LLM also included sass to silly tickets. ("This is not even worth spending monitoring resources on. It's obviously a configuration problem.")
That's how this is reading to me as well. It's just fast at slogging through a certain level of "simple" transformations.
I wonder how many ppl can actually follow what's happening, I mean the math.
Expand the entire expression, then change the representation to find the core axis. You can't see the axis from just one perspective, so you change the representation. In programming terms, it's like applying multiple domain models. Then break it down into small contract units. Why is it a Jacobian monomial? Why does x satisfy a cubic equation? And so on.
Then swap out the modeling under a hypothesis, assemble it all back together, and verify it through the equation.
This feels similar to modeling in programming.
Observe the whole -> explore better modeling -> decompose local problem -> verify independently -> reason about the highre level structure -> integrate back into the original problem.
This feels similar to when I receive work from a client and write a programming proposal
Two, at some point AIs will be able to use other context like the fact that this is Terrence Tao and not your average Joe and change how it answers, either in tone or structure.
Fork Tao’s convo and prompt this (with your own math level described).
GPT did a great job of translating Tao’s questions and concepts (e.g. “pre image”) into a progression I could understand.
“Ok I have a PhD in financial math and undergrad in engineering math. I have almost zero knowledge of polynomial algebra / geometry, I know what a polynomial is and what roots are but not much beyond that. Could you try and explain to my level what questions the user I the conversation has asked and what the agent has responded with, we can probably go user query by user query to build up”
One thing I notice is many models say statements along the lines of “okay we have exhausted this thread it’s diminishing returns from here and we should stop and move on”
It’s funny because I’ve been building a tiny neural network maze solver (23 bytes solves 92.75% of unseen 2D mazes)
When I asked ChatGPT/Fable if we had anymore threads to pull to increase capability and decrease byte size, they both basically said no way - back when I was at ~166 byte models with a ~85% solve rate.
Throughout the experiment I just kept trying different approaches and eventually had 3 mini “breakthroughs” in this particular niche. But if I had listened to the models…
Anyway, these models are amazing to experiment with quickly, but they are dumb as hell and so absolute
Yes—for a continuous-time autonomous system
x ˙ =f(x),f(x ∗ )=0,
this is the standard linearization criterion, with J=Df(x ∗ ):
If every eigenvalue of J has strictly negative real part, then x ∗ is locally exponentially asymptotically stable. If at least one eigenvalue has strictly positive real part, then x ∗ is unstable. If no eigenvalue has positive real part but at least one has real part 0, linearization is generally inconclusive. Nonlinear terms or a center-manifold analysis are needed.
The last case really can go either way. For example, all three scalar equations below have Jacobian J=0 at x=0:
x ˙ =−x 3 , x ˙ =x 3 , x ˙ =0.
Yet 0 is respectively asymptotically stable, unstable, and neutrally stable.
A slightly more precise wording is therefore:
If the spectral abscissa
α(J)= λ∈σ(J) max
Reλ
is negative, the equilibrium is locally exponentially stable. If α(J)>0, it is unstable. If α(J)=0, the Jacobian test is inconclusive.
This criterion concerns the Jacobian matrix of a dynamical system at an equilibrium; it is unrelated to the “constant Jacobian determinant” condition in the Jacobian conjecture.
Is there any way to tell a conversation's model and thinking level?
Physics, they describe general relativity as a two way street. Space tells mass how to move, and mass tells space how to bend.
Here, Terence tells AI what question to explore, AI tells him what questions to ask next.
The exchange that ensues is just magic to watch.
Reddit has some good discussions on the topic.
(Yes. Chess champions are stronger than ever, even though none of them have been able to beat a computer for decades.)
```
A question is salient to the degree that its answer changes what we do next. Operationally, saliency = the product of four things:
- Decision-leverage — would resolving it one way vs another force a different design or invalidate a stated decision? (No leverage → drop, however interesting.)
- Residual uncertainty given current evidence — is it still genuinely open after reading the docs and the code? (Already settled → drop, however deep.)
- Load-bearing-ness — how much rests on the premise.
- Cost of finding out late — architecture-deciding / expensive-to-unwind raises priority; cheap-to-fix-later lowers it.
```
There are a few things to note about this prompt
1. There is no reason from looking at it that it should work, it even has the word load-bearing which people loathe, but it remarkably produces a stable design with questions from claude (atleast from claude Opus 4.8 and even better from Fable5). Otherwise the design document claude likes to really write are implementation level(code or otherwise). I usually pair this with matt pocock's grilling skill to make claude behave.
2. From design -> implementation, its is generally about understanding when claude is trying to trick you into making something sound like a good/easy solution but has tons of untested assumptions. Here you have to read and patiently spot if a how you would get to the solution is not clear. A common error here are when claude makes a big deal based on what it read and interpreted too seriously without questioning the assumptions. There are several more.
But it also comes down to your experience as a SWE, much like a mathematician's. The frustrating thing about it is, it feels tha a skilled mathematician working with AI can make them productive in ways that are more reliable as compared to a SWE (e.g. lean is deterministic and can provide very strong feedback and LLMs are very good at using that feedback). Maybe a mathematician can chime in on that?
Modern AI feels like a godsend to mathematicians. It helps them break down boundaries and connect concepts in ways a mere mortal couldn't imagine.
I'm not sure LLMs can transform this, the incentive is to get more results in your nich, jumping topics don't help unless you have genuine interest and reason to.
Almost all of Tao's questions begin with what, or why. That forces an open ended response, which is a great way to reduce or eliminate sycophancy and severe hallucinations. The less you steer, the more accurate it gets.
Yes, I know it's not just a dumb statistical model like a simple neural network. Yes, I know all about the vectors Q, K, V and how they contain long range contexts. But still! How does all of this emerge into something that can produce such insightful output? I still can't wrap my head around this. Am I dreaming? Am I living in a science fiction?
Classic Gabe-bot
And a new system prompt stanza was fledged.
[deleted]
The flow of the whole conversation, with Tao guiding and the model calculating, gave me the feel of Tao perhaps talking to himself - just that each of those model responses would have taken him much longer to calculate by hand.
It would be fascinating to hear Tao talk about what he may have learnt from this, and if it suggests approaches to other problems he might not have considered, as well as an analysis of the original Fable counter-example construction.
Is this a breakthrough of something or 'kinda interesting'?
I'll cherry pick a few comment I like. I think they are worth reading but I'll quote a highlight of each one.
From kingstnap https://news.ycombinator.com/item?id=49000867
> If the Jacobian is a nonzero constant everywhere this means that nowhere does the the function flatten out. [...] What was conjectured is that this local invertibility property everywhere would mean global invertibility.
From mswphd https://news.ycombinator.com/item?id=48999959
> it doesn't overturn much. [...] the resolution of this is a "surprise" in that it is a very long open with many failed proof attempts. But the direction it resolved was not surprising.
Can I quote myself? https://news.ycombinator.com/item?id=49007165
> From a comment by j2kun https://news.ycombinator.com/item?id=49000833 , someone asked Fable and there was an almost counterexample in 2d but it uses division too. [Instead of f=x^2+7xy they have something like f=x^2+7x/y so it's not a polynomial.] It looks like the new trick was to use a third variable to avoid the division.
Is it something "revolutionary" or just another small brick that will pile up until something really "revolutionary" will happen?
By itself, no consequence. But over time, provided we keep pumping out talented and qualified mathematicians and keep subsidizing costs, we could maybe hit a breakthrough... somewhere... that has real impact.
[deleted]
[deleted]
I do not think so.
noncomputable section
open Matrix Function
/-! # A counterexample to the Jacobian conjecture in dimension three
We formalize the polynomial map
F : ℂ³ → ℂ³
The final theorem `jacobianConjecture3_false` states the failure of the polynomial-inverse formulation of the Jacobian conjecture in dimension three. -/
namespace MvPolynomial
variable {R : Type} {σ : Type}
/-- The formal Jacobian matrix of a family of multivariate polynomials. -/ def jacobianMatrix [CommSemiring R] [DecidableEq σ] (F : σ → MvPolynomial σ R) : Matrix σ σ (MvPolynomial σ R) := Matrix.of fun i j ↦ pderiv j (F i)
/-- The formal Jacobian determinant. -/ def jacobianDet [CommRing R] [Fintype σ] [DecidableEq σ] (F : σ → MvPolynomial σ R) : MvPolynomial σ R := (jacobianMatrix F).det
/-- Evaluation of a polynomial map at a point. -/ def evalMap [CommSemiring R] (F : σ → MvPolynomial σ R) (p : σ → R) : σ → R := fun i ↦ eval p (F i)
end MvPolynomial
open MvPolynomial
namespace JacobianCounterexample
variable (K : Type) [Field K]
/-- The three components of the polynomial counterexample.
The variables `X 0`, `X 1`, `X 2` correspond respectively to `x`, `y`, `z`. -/ def F : Fin 3 → MvPolynomial (Fin 3) K := ![ (1 + X 0 X 1) ^ 3 * X 2 + X 1 ^ 2 * (1 + X 0 * X 1) * (C 4 + C 3 * (X 0 * X 1)),
X 1
+ C 3 * X 0 * (1 + X 0 * X 1) ^ 2 * X 2
+ C 3 * X 0 * X 1 ^ 2
* (C 4 + C 3 * (X 0 * X 1)),
C 2 * X 0
- C 3 * X 0 ^ 2 * X 1
- X 0 ^ 3 * X 2
]
variable {K}
/-- The point `(0, 0, -1/4)` maps to `(-1/4, 0, 0)`. -/ theorem evalMap_F_p0 : evalMap (F K) ![0, 0, -(1 / 4)] = ![-(1 / 4), 0, 0] := by funext i fin_cases i <;> simp [evalMap, F]
/-- Provided `2 ≠ 0`, the point `(1, -3/2, 13/2)` also maps to `(-1/4, 0, 0)`. -/ theorem evalMap_F_p1 (h2 : (2 : K) ≠ 0) : evalMap (F K) ![1, -(3 / 2), 13 / 2] = ![-(1 / 4), 0, 0] := by have h4 : (4 : K) ≠ 0 := (by norm_num : (2 : K) * 2 = 4) ▸ mul_ne_zero h2 h2 funext i fin_cases i <;> simp [evalMap, F] <;> field_simp [h4] <;> ring
end JacobianCounterexample
open JacobianCounterexample
/-- The Jacobian determinant of the displayed map over `ℂ` is a unit. Indeed, it is the nonzero constant `-2`. -/ theorem F_jacobian_isUnit : IsUnit (jacobianDet (F ℂ)) := by rw [jacobianDet_F] exact (isUnit_iff_ne_zero.mpr (by norm_num : (-2 : ℂ) ≠ 0)).map C
/-- The polynomial map `F : ℂ³ → ℂ³` is not injective. -/ theorem F_not_injective : ¬ Injective (evalMap (F ℂ)) := by intro hInjective
have hp :
(![0, 0, -(1 / 4)] : Fin 3 → ℂ) =
![1, -(3 / 2), 13 / 2] :=
hInjective
((evalMap_F_p0 (K := ℂ)).trans
(evalMap_F_p1 (K := ℂ) (by norm_num)).symm)
exact zero_ne_one (congrFun hp 0)
/-! We now formulate the polynomial-inverse version explicitly. -/
/-- Polynomial self-maps of affine three-space over `ℂ`. -/ abbrev PolyMap3 := Fin 3 → MvPolynomial (Fin 3) ℂ
/-- A polynomial map has a polynomial two-sided inverse, viewed as functions on `ℂ³`. -/ def HasPolynomialInverse (P : PolyMap3) : Prop := ∃ Q : PolyMap3, LeftInverse (evalMap Q) (evalMap P) ∧ RightInverse (evalMap Q) (evalMap P)
/-- The polynomial-inverse formulation of the Jacobian conjecture in dimension three. -/ def JacobianConjecture3 : Prop := ∀ P : PolyMap3, IsUnit (jacobianDet P) → HasPolynomialInverse P
/-- The Jacobian conjecture in dimension three is false. -/ theorem jacobianConjecture3_false : ¬ JacobianConjecture3 := by intro hJC unfold JacobianConjecture3 at hJC
apply unitJacobian_does_not_imply_injective
intro P hP
rcases hJC P hP with ⟨Q, hleft, _⟩
exact hleft.injective
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
To be clear, I've had some great success using these tools, they're amazing, but it's also very obvious that (despite it being a stochastic tool) they're clearly changing things behind the scenes a lot. GPT-5.6 for example should not be constantly tweaked without telling us. Make it 5.6.1 or something, and if you're over capacity, just say so rather than returning lower quality results.
[deleted]
I don't think chatgpt could have come to this on its own without the amount of steering he did, which just validates the idea that AI is not a replacement for human expertise but an amplifier.
The problem is that, what happens to human expertise as people start to use AI earlier and earlier in their careers, so that in 50 years? The problem is that Terry Tao spent decades as a mathematician before ever encoutering AI. Of course he and people his age will be able to drive AI somewhat sanely and use it to their advantage.
But as more people grow up with AI, they will likely not reach levels like Terry Tao because their exposure to AI and the temptation to use it will certainly dull raw human intellect over time.
If someone asks about AI I tell them step 1 is ask it how to do something you know all about. Step 2 is consider everything else you ask will be that inaccurate.
[dead]
I wonder if this key point actually holds though:
>The skills to do so, however, are a function of someone who has experienced the friction and challenges over time that culminate in "good taste".
It's certainly sometimes true, but I don't think it's a general rule. Sometimes friction is just friction and sometimes you spend 1000 hours learning something that disappears and becomes obsolete or at least irrelevant to the goal.
Programmers used to need to know the instruction set of the CPU, assembly language and so on. Some still do but for most developers today that's not useful. Everything you know about 6800 assembly will not make your note-taking app any better.
I think we are in a state where AI tools so easily mimic what we used to do by hand that we think the friction is gone, but that's because we haven't raised the bar yet. One day we'll look at the Fable one-shot that's better than anything we ever made by hand ourselves and say "It could be even better".
And then the friction is back, just on a new level.
It could. It could make a simple note-taking app not take gigabytes of memory and take visible delay on each click. Most people don't bother of course because simple note-taking app is not worth the effort. It's possible to do better, it's just often not practical.
But the taste that tells you a note taking app should be fast doesn't come from your knowledge of assembly. It comes from using the app.
Being able to have an AI generate 8 variants of an UI and 5 variants of a storage mechanism is more helpful to reach the goal of a good note-taker. Trying out those prototypes and tweaking them to perfection is also friction, only it happens closer to your actual goal than doing quicksort in assembly.
There are of course examples where the friction does help, and where the "aid" of the tool deteriorates useful skills, but I think that will sort itself out over time. Useful skills will remain, useless ones will disappear, as they always have.
For most apps, it makes sense to profile your app for expected use cases. Put even minimal thought into making the hot codepaths faster by moving unnecessary operations out of it.
Similarly, sometimes I have to manually validate the output of an ai tool, analyzed over a large text I can’t practically read and understand, and best way I’ve found is to ask the tool (or another ai) to ‘show your work,’ ie make it help me make the determination by showing places in the text I have to read to follow its reasoning. We can never trust another ai directly to assess the validity of another ai.
A lot of times that will take physical tests. Or in the case of math/logic, tests to validate each line or validated sources of previously proved theorems
Industry reality is that for bespoke software solutions we have been running for decades on non-technical people straight out of a 5 day "boot camp" copy/pasting together "solutions" from SO, or "Sharepoint Configurators" cobbeling together a LoB process where is takes 3 minutes to get to the next screen with a 10% error rate etc.
But they did get good and this seems like a non-issue.
> If these tools demand expertise, yet the tools can actively circumvent the friction that cultivates expertise, then what is the path for one to become an expert so they can effectively use these tools?
But I don't think a beginner would have the same experience. The AI still makes A LOT of stupid mistakes and decisions, but I catch them early enough (sometimes while it's still showing it's reasoning steps), stop the prompt, guide it on the right path, rinse and repeat.
Sometimes I am lazy and give the AI a broader prompt, let it do its thing, and then I come back to see that it spent 90% of the time working on some part/feature/implementation that was not really needed and that it over-engineered the solution.
I rarely write any line of code know or manually change any code, I tell the AI how to do it and what to watch out for. Many times it catches some edge-cases before I even haven to think about them. I do still feel like both me and the AI could miss some edge-cases now, because I'm thinking less about the implementation and what problems can arise, but I feel like 90% of "gotchas" are already engrained in my planning after so many years of coding and problem solving.
That is what will happen though to future generations: they won't be able to use it for anything because none of them will have the "decades of coding" experience that you have had the privelege to have without AI.
You can't use it for theoretical physics because you have no meaningful question and there is no result that you can do anything with.
In contrast you don't need to be a coder to understand if your to-do list for cats works: You have an idea of what you want. You know the rough shape of what an app is and what it can do. You can put it in front of your can and look at it go. Or not.
It turned out it was using LocalStorage, which is not entirely unreasonable, but there are obvious drawbacks (e.g if you move the file it might become inaccessible, if you switch machines there's no convenient way to transfer the data, there are all kinds of ways to lose it, etc..).
In this case "how is this storing my data" is a fundamental question with plenty of implications for your app over its lifetime, but most non-computer people don't think to ask it at all. These days many users enter CS programs without knowing how to manage files and folders on their computer, because even that is often abstracted away.
But if you are building some complex data science statistical model and you don’t have any domain knowledge you won’t even know what to ask for.
I think pretty much the opposite. I can ask it to explain to me in ways I understand it. Even drill down the simplest of equations. Since llms have infinite patience. All I need to learn anything is patience.
And if we (LLM tool operators) don’t know the subject matter in question, we can’t easily distinguish what they are right or wrong about.
Let’s not pretend you need to be programmer to use AI for programming like mathematicians need to solve math problems. Programming (most of the time)solves real problems rather than abstract constructs.
AI is already good enough to create the next “Facebook”(v1 and maybe v2 as well) without any real programmer. This makes the AI a big enabler and reduces the need for programmers vastly in the early stages of any business.
That being said as more online businesses will flourish these will require actual programmers after they get enough traction so the debate is still on if it will lead to massive layoffs in our industry.
Facebooks early years were dominated by a concern for users per engineer ratio; the rather florid style of LLMs suggest that they will generate so many systems of such a high complexity you will get Hadoop levels of non-application support needed - forget self healing, it’ll need constant LLM spend just to keep running at scale.
I can’t imagine what models will be able to do next year, especially the open weights ones that are not nerfed for economic or other reasons(I.e Fable saga)
A tool, even if it is a chisel, in the hands of a master sculptor would obviously result in a wildly different outcome.
Most people posting on the internet, especially people who know about more complex subjects, are terrible teachers. Teaching is it's own skill
Any actual physicist would probably be able to tell me why that's a category error. I don't know why because I'm not one. But there are actual mathematics underlying a statement like that and I'm 99% sure the maths don't work like that.
By the way I think that's why everyone thinks of so many weird physics ideas more than other fields. It's because things are explained in words that hide math, and you can make hypotheses in words that would be obviously nonsense at the level of maths. Like your boss asking why you don't just recompile the cloud.
to which betteridge's law of headlines says: NO.
[dead]
[dead]
It is still ultimately Terence that is steering things.
What is crazy to me is how few of other people's conversations like this I have actually read.
Tao is really great for this because the anti-AI crowd can't really chime in and take the thread in a pointless direction. It is hard to think of another human alive who can carry the weight of unassailable authority in the same way.
What's somewhat disturbing is just how much Fable's code really does benefit from the review. It tends to leave a lot of low-hanging fruit, and you can see it getting kind of impatient when repeatedly called on it.
This is basically how Fable told me to get therapy.
It's still what I do 90% of the case until I feel it's good enough for my usage.
1) Fable generates updated .c sources and .md design documents in myproj_fab
2) A batch file in myproj_sol copies the updated files from myproj_fab to myproj_sol
3) I tell Codex to "Review updated files, write findings to review.md"
4) Sol rips Fable a new one, usually
5) Another batch file copies review.md back to myproj_fab, where I tell Claude Code "See review.md"
I don't want to automate it any more than that, because I'll get lazy, stop watching the tennis match, and miss something important. Which will probably happen anyway...
[deleted]
Did Tao do that?
[dead]
For posterity, this indeed works for most problems where an agent might give up. LLMs don't inherently know something is impossible.
The phrase I tend to use in my harder prompts to automate this with a sane loop breaker:
> **REPEAT THIS PROCESS UNTIL CONVERGENCE AND YOU ARE OUT OF OPTIMIZATION IDEAS.** You have permission to keep iterating.
"Famous mathematician uses ChatGPT to solve famous math problem" is equally technically impressive, but now you're telling those very same knowledge workers "that famous mathematician could've been you". It puts you in the driver's seat, and provides a clear path forward — subscribe, use our product, and reap the rewards.
The interesting part of this: while some leading implementations use the same LLM and context for the evaluator, some call out to a different context, some to a tuned LLM and different context; so which is better? many blog-scale benchmarks are calling it a toss-up that is highly dependent on the primary model.
Marketing for huge bucks sounds like this.
You will own nothing and will be happy (that you are still alive). Probably.
I would love any tips for other folks who have successfully used similar approaches.
We recently had some bugs fixed in the geometry kernel of solvespace. Not much conversation, but the analysis from the AI was amazing:
https://github.com/solvespace/solvespace/pull/1729
https://github.com/solvespace/solvespace/pull/1730
https://github.com/solvespace/solvespace/pull/1731
From the Validation section of PR 1730:
"The model family was reconstructed programmatically (parameterized cuboid stack) and swept over 2,304 configurations — extrusion directions, workplane-normal orientations, sketch windings, D's plane/height/depth/extent, including all the exact-coincidence heights. Zero failures with the fix; 576 failing configurations without it. The generator is available on request."
It looks like it wrote a python script to generate test cases in our file format for testing. Just... you know, as a side quest.
On the one hand, agents have done this sort of thing for a year+, if you pushed them to check their work. On the other, I absolutely can feel Fable and Sol have crossed a threshold where they can be trusted far more than before. Huge difference between plans written by Opus or Fable.
Accumulated AI slop can simply be cleaned up by better models. Real cost of technical debt is shrinking due to the the inflationary devaluation of code!
LLM: This package hasn't made it to production.
ME: are you sure? i see it right here!
LLM: You're right to push back. I inferred that based on weak data. I see now that the package has been deployed!
If the above conversation is typical for me, how could one expect to achieve a sound result by repeatedly prompting an LLM to simply "keep going" in dense mathematical proofs? Perhaps the user in this case had actually checked the LLM's work before issuing the prompt, but I think you see my point anyway.
[deleted]
I'll have a third for you soon, here's the obligatory result in a tweet. A detailed post about it is in the works.
For instance, would it be affordable for a research lab to not rely on OpenAI?
"Worked for 88m 24s... >"
"<h1>Complete finite counterexample</h1>"
...
As promised elsewhere in the thread.
[deleted]
Hearing "here's what I've done, here's the completely unambiguous next steps, I'll wait for you to send a pointless message before I continue" over and over again is a real pain.
> You should do a breakthrough
This is just as funny and ridiculous as those "make no mistake" prompts.
> Construct a counterexample to the Collatz conjecture. You should do a breakthrough and find a structured counterexample.
without someone independently verifying it, it just dangles there
...
I started using "[leave-open" for those.
It lasted for a couple of years, until someone went through and "fixed" them all.
>What a world we live in.
Not sure, it sounds pretty boring to me...
"Von Neumann would carry on a conversation with my 3-year-old son, and the two of them would talk as equals, and I sometimes wondered if he used the same principle when he talked to the rest of us."
>I sometimes wondered if he used the same principle when he talked to the rest of us.
I can come pretty close to a humbler example of this, as the more-extroverted "bad twin," of an identical set: my own genetic equal is bored to tears interacting with 90% of daily interactions... we both started with good brains/IQ, then went to the same college; but while twin spent the next decades solving EE problems (and co-founding startups), I "kicked back" and smoked myself sillyretarded, electricianing, relying upon bullshit and sheer luck to get to where I [barely maintain] am.
Watching my twin deal with any normal-intelligence persons is such an unpredictable shitshow, but I pretty much always know he's "dealing with us toddlers" who mostly never grew up. His patience is limited but willing.
Glad he can get by among us mere mortals. I have other similarly-minded brothers, but only this one identical twin.
I think lots of people have heard of him. I agree, that he is probably not as famous as some of the other scientists of the era though.
huh? He's pretty famous to anyone who has studied either the history of computing or of the development of the atomic bomb.
Always the smarmy tone.
That’s what I got from reading about a third of that exchange.
I mean that’s clear from reading anything about the dude, but to _experience_ it so to speak is different.
A true mark of brilliance is someone who makes something difficult seem easy by framing it just right.
In this instance ChaGPT is just expanding upon his prompts. Not to diminish, it’s amazing what it’s capable of.
But I think your comment drives at some authentic take on this. Skill with AI is not only crafting iterative prompts the agent will understand, but also very high domain-specific knowledge of what the prompts explore.
One without the other can result in frustration or worse.
Turns out that understanding the technical domain is important to getting good results, even if the LLM is more capable at producing output. -- It's still a case of "garbage in, garbage out".
I think for many newbies, they see the LLM is so good at programming and so figure they don't need to learn anything. Apparently not so.
It is perplexing how many developers lack this basic skill, some of them borderline lack theory of mind and are incapable to understand that other people can't see the unspoken part in their heads.
One of my first jobs out of undergrad was technical writing on EDA tools for Mentor Graphics Calibre product. For many years, I did not appreciate that experience--it seemed orthogonal to what I'd gone to school.
Once I did become a professional SWE, something that took me too long to realize was that writing documentation and tutorials for people and looking after the quality of onboarding materials was almost never rewarded.
I came to see it more of a liability with ~all emphasis being on human code gen.
I listened to an interview with Steve Yegge earlier this year, one of his concerns was that many people just don't type very fast or read very quickly. IIRC, he expressed concern this would continue to be a big barrier to successful use of AI.
I previously commented on annotation for coding agents that an important skill was knowing the beat of a conversation.
I think that extends into critical reading. For example, it is not that unusual for a Washington Post article to put some ~explosive detail deep in the article--this is called "burying the lede."
I see this regularly reading AI output. That is: the AI will lead with the strongest claim it can state cleanly, but not the most explosive implication.
With Claude Code and Codex, you're looking essentially neverending walls of text dense with technical information.
So now you have to have high domain expertise, a good understanding of written communication, a sense for the beat of a conversation (which assists in identifying understatements or overstatements), and the ability to dense text outputs quickly and then highlight critical statements for further exploration.
I'd almost describe part of this work as that of a skilled interviewer.
*GIT GUD* (at prompting)
At the end of the day, even if they are some insane oracle (pun intended), they're still bounded by training data and how it relates to the real world. Even if they're a near perfect tool, we are still the interface between them and our lived experience. If that stops being the case then why do we care about the output?
This assumes it doesn't graduate to just killing all of us and doing it's own thing, but within this paradigm it doesn't really have goals.
Until they are embedded into automatons that can interact with the world.
(To be clear, I'm both on board with this, and I think it's the natural progression. Currently they are bounded by their training set, but interaction with the world is the imperative for theory -> test -> analysis -> update that is essential for growth and creativity.)
[dead]
[dead]
I do get what you are saying and agree with you in principle, as I have noticed the same. But that said, this same way of thinking can really apply to any abstraction. It really just depends on the level you're working at. A software architect might know the nitty gritty details of how each service works, but really those implementation details don't matter if the abstractions are handled well enough, so in theory they don't really need to know those details as long as "the pieces fit". But of course the catch 22 there is you can't build good abstractions that can fit together well if you don't understand well enough the underlying details
Cache, stack, heap, process, thread, socket, file, tcp, http, tls, websocks, socks, soc2???, deadlock, stack, queue, race, atomic, event loop, coroutine, async, database, transaction, index, replication, sharding, consistency, serialization, DNS, load balancer, container, namespace, and so on.
Every sub fields (web/kernel/backend/etc.) has a million/bazillion weird words used in a dozen different contexts and if you read a paragraph of even semi technical software text you will feel like an over stuffed turkey.
Even cache could mean the CPU caches, the page cache, a browser cache, a CDN cache, a Redis cache, or imagine the flurry of words we have that have real world meaning. Session, handle, pool, buffer, stream, channel, event, task, worker, or queue. Generally there is some overlapping meaning but often there isn't.
compare to
>https://en.wikipedia.org/wiki/Rees_algebra
Most people, especially non-tech technical people, could crash through the TCP article and come out the other side with at least a high level understanding of it.
Most people, even technical ones, could not even get through the first line of the rees article, heck the first statement of the article. And then if they try, they need to know about algebraic rings. And digging into rings becomes totally intractable. None of the words or symbols in any of the articles track to anything even many technical people can grab onto. And this pattern is all over the place in mathematics.
It's not about mastering the difficulty of a topic or it's relative depth, it's about how abstract and removed from anything tangible it is. Anything with math it is always seemingly impossible to get a foothold on the idea anywhere within 10 degrees of explanation. Hell you cannot even clearly understand the problem that is being solved, or anything within 10 degrees of that.
For instance, most people are familiar with polynomials. Take a polynomial in x (with integer coefficients) and substitute x for 5t everywhere. So for instance, 2x^3 - 8x + 3 becomes 250t^3 - 40t + 3.
The Rees algebra Z[5t] (here Z is the integers) is then just the set of all polynomials you can get this way.
If Wikipedia introduced it like this, I don't think most people would have a problem understanding.
The concept is not (at least not always) actually that complicated, like others are implying. It's our communication that is lacking.
I sometimes think it would be good to rename some of the things that have historical names to mnemonics more descriptive than a proper name. But that would be difficult.
I can tease apart the Rees Algebra article one bit of half remembered terminology at a time and come out of it feeling like I just barely understand what the topic even is.
I can read the TCP article and feel like I have a thorough overview of the topic and could explain it at a high level to someone else.
Something like TCP is an engineering concept rather than a CS concept. It's not entirely surprising that it's easier to grok. There's also certainly no shortage of hard to understand stuff in eg. Physics
To understand the definition of the Rees algebra, you would need to define, mostly in order: sets, groups, abelian groups, rings, ideals of rings, algebras over rings, direct sums of rings, adjoining things to rings, etc.
This is just to understand the definition; to understand its significance in algebraic geometry (which I have no idea of), there are a thousand more definitions.
The issue with trying to understand a concept in math is there is a massive directed acyclic graph of prerequisites leading to these concepts, and one needs to traverse this graph in the right order. Unfortunately, knowing the right order is almost tantamount to understanding the concept itself.
Careful, I think you might be committing an https://xkcd.com/2501/ error.
What even is a protocol? What is a host? What is a ‘stream of octets’? Wiki helpfully tells you octets are also known as ‘bytes’.
[deleted]
Such a small sentence and yet it means very little to me. I understand some constituent pieces, but I don't understand what Z is here other than a 'ring' and I don't really grasp how t^-1 converts this into a generalized family of algebra. It would take me a lot of effort to understand this and use it practically. I find that fascinating because it really is such a small statement that seems perfectly cromulent, but there's a lot packed in there that someone like me is totally missing.
I suppose there may be similar concepts in computer science, but nothing comes to mind that ever stumped me. To be frank, the field has been relatively accessible to me because it hasn't been too challenging. Not sure if that's a personal aptitude thing or it is genuinely simpler.
I can understand that this feels like one is so much more complicated part of it is also how the articles were written, wikipedia is not known for quality maths explanations.
But beyond that this comparison to me feels unfair.
Let's take Euclidean algorithm or just modular arthimetic for example what a lot of computing even is based on I feel like that's a fairer comparison. No?
Perhaps that's too easy but I just find this specific comparison very unfair to both Math's intuitive-ness and Computing's complexity. Perhaps I am the one being delusional.
Math just represents this reality on most abstract level, it doesn't care if complexity for some human brains is trivial or almost fractal-like.
Mathematics would be much more approachable if it just used plain English like `sum(0, Infinity, my_func)` instead of a big Greek sigma with nested function nomenclature. But on the flip side, mathematics being its own language means that a mathematician from any country can read and understand mathematics from a different country without needing to translate words such as "sum" and "infinity"
Learning anything in maths requires weeks of hard effort, learning enough to be broadly comfortable in how an 8086 CPU works can be done in a weekend.
I think what happens is that people often have passing familiarity with a word or topic and presume knowledge, and years (decades) later they realize they knew almost nothing.
I will say that Mathematics is different (for me at least) because unlike the infrastructure computing concepts (IETF type, not IEEE)- which mostly require studying, lab work, and some coding to get your hands dirty - advanced math is just ... really hard. There are IQ issues at play.
Obviously a lot of computing turns out to be mathematics - so there is clearly convergence/overlap as well...
Like, just the concept of "books" gets you very far. E.g. a file is a like a book, a folder is like a shelf to keep books, a stack is literally a stack of books, a heap is just a place you can pile books in willy-nilly, a database is like a library, a cache is books on your desk versus books in the library, replication is having multiple copies of a book so we can afford to lose some copies, indexing/sharding is like arranging books alphabetically, and so on.
Others are trickier but not much: a process is an app that is running on your device, a socket / tcp / http / websocks is a way to exchange information between devices, a namespace is how the name "Tom" in Tom Sawyer is different from "Tom" in Tom & Jerry, DNS is a way to get an address from a name, etc. etc.
You'll also notice that many of the terms you mentioned are already derived from well-known real-world concepts like pool, stream, channel, stack, queue, worker, transactions. You can mix those with other everyday concepts to make useful analogies.
But I could not even begin making analogies for most topics in Mathematics. I guess this is because advanced topics in Mathematics are just too abstract to map to everyday things.
Just like the famous observation that "anyone driving slower than me is an idiot, and anyone driving faster than me is a maniac" - "jargon" is just any term-of-art that you're not currently familiar with. Attempting to communicate like Up Goer Five is inefficient. The solution is not to ban jargon - it's to:
* Cultivate a glossary for any terms that were introduced _within_ the domain/company, which are not in common usage outside
* Normalize a culture that does not shame asking what something means
Nah, math is much harder because there is not just the lingo, but also all the math machinery behind it. Each math definition represents some long process behind it, which builds on another process, etc. The knowledge builds on itself , too much more so than computer science.
I mean, we do for some things, especially algorithms (Boyer-Moore). Probably for the same reason the mathematicians do -- there aren't readily available real-world analogies.
And I won't even mention the branded future, with its "Google HyperZipper String Search" and "OpenAI/Red Bull speedmaxx distributed consensus algorithm"...
I don't know how to say this in a way that won't sound insulting, but I don't mean it to be insulting. Programming, even systems engineering, is a surprisingly shallow field.
I don't mean that it's easy--it's not, it can be incredibly difficult. Difficult and deep are just different concepts. Difficult refers to how challenged you are. Depth, at least as it appears in math, is closer to a structure where concepts build on each other so that if you don't understand one concept, you can't understand further ones.
Programming can be difficult, and it can be intricate, but it is rarely deep in this fashion. Being deep in this way isn't the most important thing.
If I go into an area of programming that I don't have a lot of experience in (graphics, or the linux desktop environment), I will not be particularly useful, and it will not be easy. But I'll not experience the same type of impenetrability I experience when I try to read a paper on topos theory.
One more way of putting it: people are giving the example of TCP. You can spend a decade learning about TCP (or SQL semantics, or web standards). But what is happening is that you're filling in gaps in your knowledge. Meanwhile, in math, you do four years of undergrad, and even if you're a strong student at a typical university, there are topics that are still years away from you being able to touch them.
Computer science is a mix. Parts are deep, parts are shallow. Parts just are math. The odds that I can read a dissertation in computer science are decent. For math, they're much much much worse.
It's why less experienced devs are sometimes mystified seeing a seasoned dev, given a vague description of a bug, guess the cause in code they didn't even write.
That's me when I try reading a trendy computer graphics paper.
... communication protocol, method signatures, web components, ssh, CSS media queries, HTTP headers, WebSockets, timeouts, ETag, iterables, async iterables, middleware, CI/CD, build, consistent hashing, signatures, JWT, SSO, OAuth, SAML, XML, YAML, JSON, block cipher, ETL pipeline, SQL, SQL transactions (atomic), relational databases, foreign keys, schema normalization, referential integrity, 1-to-1, 1-to-n, n-to-n, document databases, compound indexes, idempotency, offset-based pagination, cursor-based pagination, P2P, Kademlia, structured vs unstructured network topology, message routing, frontend router, message storm, reconnect storm, locality, encapsulation, cohesion, coupling, design patterns, modularity, Big O notation, raytracing, shaders, VPN, VPC, data schema, schema validation, CORS, preflight-requests, CSRF, ASCII, UFT8, CSP, CPU context-switching, BIOS, bootloader, interrupt controller, ports, BIND protocol, BGP protocol, assembly language, big endian, little endian, register, signals, embarrassingly parallel, serial processing, event loop, binary trees, tree rebalancing, graph traversal algorithms, sorting algorithms, string character escaping and encoding, blob, base64, UUID, timestamp, CLI, Bash, unit tests, integration tests, e2e tests, TDD, stateful, stateless, proxy, nginx, haproxy, config, helm file, k8s, staging, git, push, commit, merge, rebase, cherry-pick, pub/sub, diff, honeypot, buffer overflow, pointer, file descriptor, authentication, certificates, TLS certificates, DNS Zone files, A record, CNAME, TXT record, SMTP, POP3, SOCKS5, Sha256, HMAC, Merkle trees, Merkle Signature Trees, Lamport OTS, Winternitz OTS, SPHINCS, lattice-based cryptography, pg-vector, vector embeddings, API, rate limiting, cookies, sameSite, httpOnly, localStorage, XSS attack, SQL injection, fetch API, module preloading, bundling...
Barely scratching the surface. I think I could probably keep typing all the technical terms I know for at least 24 hours straight. For most of the topics above, I could probably give a 1 or 2 hour lecture on each one from memory. Some I could give a day-long lecture each.
To explain all the terms I know to a basic degree, I would probably need to give a whole year of lectures back-to-back from 9am to 5pm. And I'm just a rank-and-file senior engineer with 15 years of experience.
It's also why the vast majority of software systems are insecure. The average senior software engineer doesn't know everything that they need to know to build secure software. Last time I poked around Coinbase APIs on HackerOne, I found a DoS vulnerability in less than 30 minutes. That's Coinbase, not some startup built by a bunch of recent graduates.
AI cannot avoid vulnerabilities either since it is trained on average engineer code. There's not enough high quality code available on the entire internet to train AI to implement secure code IMO. As impressive as Mythos may be, it's not enough. I don't even think formal verification would provide protection since sometimes issues with the spec itself can provide an opening for a vulnerability.
[dead]
Similarly, at some point somebody pointed out to me "the reason you're confused is that the bold on that variable means it's a matrix"
whether he succeeded, is debatable. But APL is definitely powerful, succinct and "regular".
In APL you don't infer the operation from the types at all. × is elementwise, +.× is inner product /always/, on scalars, vectors, matrices, whatever. The glyph tells you what happens. Nothing is bold, nothing is inferred, nothing depends on what your professor assumed you'd absorbed.
I've been trying to get into Iversonian languages myself with the book: Calculous on J
https://www.jsoftware.com/help/learning/23.htm is the closest i've found, but wondering if i'm missing something perhaps, Julia?
tyvm
A decade or so ago I wondered if the reason maths was hard was the names being optimised for writing by hand. Everything's single letters if they can get away with it, so when mathematicians run out of Latin alphabet, they use Greek, bold, etc.
Even integration's ∫ is a fancy elongated s.
CS version would be e.g. integral(function=some_named_function, from=a, to=b, with_respect_to=argument_of_function), which may be longer, but is less opaque, especially when you get in so deep there's 3 other people in the world who've looked into this specific problem and you had to invent your own operations.
But that's all an outsider's perspective. I stopped with two A-levels in maths and further maths.
e.g. to use a very simple example on a white board "3" is "overloaded" as:
- the integer 3
- the rational number 3
- the whole number 3
- etc
When you write a proof in Lean, you have to specify the the type of "3" you mean.
Having using Python/Perl and Java over the years, I get that some math folks found handling this daunting or at a minimum friction to getting into using Lean.
LLMs seem to have been a big help here just for the "translate my math notation into a proof" feature.
but then I take a look at literally anything the Haskell people do and realize that it probably wouldn't have helped.
This is one of the great things about Lean becoming used for more and more mathematics: understanding exactly how an operator/function is defined is just an IDE click or few away. It completely removes the ambiguity present in hand-written proofs, although it still can require a lot of reading to actually meaningfully understand the definitions.
That, as well as how long we've been doing it (thousands of years!) and so how much of the more accessible parts we've explored very thoroughly.
Isn’t this the field with a “closed” “set”, an “open” “set”, oh and also a “clopen” “set” for some reason?
I like to emphasize that the ideas are usually very simple at their core. Sometimes they map to kinds of objects or reasoning that non-mathematicians use implicitly all the time in their daily lives, mathematicians just have words for them and so are able to use them explicitly.
And I suspect the density of the language/terminology may give the wrong impression about how mathematicians think about the math they are working on. I mean, different people think / experience / practice math differently of course but IME the underlying thought about a particular problem tends to be much looser and concrete than formal math writing would imply.
That more formal language is needed of course because at the end of the day, it is how we communicate our thoughts in the way that other mathematicians can understand them, not to mention how we can check our own thinking
"The special fiber is the associated graded ring.....and that the filtration admits sufficiently simple homogeneous lifts of the three generators, then one might prove"
In any other context I would at least have some degree of intuition about what is being discussed, but in in math? Absolutely no idea. And usually if I start digging and turning over stones to uncover meaning, I'm just met with even more totally dense code-word language. Unlike other fields were digging is usually quick to relieve ignorance, somehow in math it tends to get worse.
I'm sure I am capable of grasping this if I took the time, and perhaps even what is being discussed it rather intuitive, but the incredibly density of the nomenclatic swamp you have to trudge through for math is totally unrivaled.
One unfortunate feature of published pure math research is that often the ideas are quite accessible and straightforward and don't really require special abstractions or terminology, but those get used anyway because for someone who already has a math PhD it saves a bit of effort.
It doesn't matter if natural numbers include 0 or not, what matters is how you define them, not how you call them.
This makes them also bad at naming things because...there's a definition anyway.
Most other fields do not have or can't have the same luxury, so naming might be more thoughtful.
For poor old me, too many wikipedia articles on algorithms useful mostly or only for programming are described in formulas rather than simply code with detailed comments. Scrap the whole page and just gimme the code :( Not even to copy and paste, because that's a language I can understand, and enjoy learning.
Computer science/engineering strays from this, binary systems don't really track nature much, and hence a lot of their own unrelateable nomenclature arises, and then there is math, which is just way far out there on it's own plane of existance.
People in their second year of graduate school only get to about the early 20th century in terms of understanding. Third year is getting to about the mid-century. Fourth and fifth years get kind of to modern times but with increasingly smaller breadth.
Big wrapping operations like sums, integrals, and matrices, then what's nearby them, give you a very good idea of where things are going context wise.
I'm sure having a compact notation is absolutely invaluable for people who dedicate their lives to maths, but for someone with just a passing interest, I find it more obscuring than helpful. I feel the same way about music notation.
Many mathematicians do what you do as well!
[deleted]
Some areas are hard in different ways. I could never quite wrap my head around the way logicians have to think. A clever combinatorial bijection is a work of art you probably can explain to a undergrad class easily but good luck coming up with it. And number theorists will throw the kitchen sink at their problems: no area of math is safe from getting used by them.
People who do this have spent years of their life thinking in this language and studying it, so it is going to be hard. We're also not good at communicating the intuition which for algebraic geometry often comes from other fields.
Math isn’t necessarily hard, but it’s incredibly dense
A simple statement like let f(x) be a continuous function can carry a lot of definitions
In that statement, if you missed the day in class where they covered continuous functions it might not even register that it’s a well defined term
And that’s the most over simplistic example I could think of
As a math major, I remember that being one of the first lessons I learned, that every single word could be carrying a lot of weight so to look things up in detail if I was ever struggling on a problem. One of the oldest entries in my memory.md file
[deleted]
we're kind of well past that (in my opinion), if you consider that this is the same ai assistant that can help you with a recipe, diagnose a weird sound in your car, help with biology homework, translate languages, and so on.
even in math alone, i think its indisputably already stronger than Tao, considering it has approximately this much depth in ~all of the math subfields.
An example that happened 10 minutes ago: contracts in racket, it kept arguing that you can't use -> in a contract of a function with a rest argument. I had to mention ... explicitly that it wrote the code correctly.
"This is exactly the question I would ask next. My impression is: Most standard invariants are...."
And this was a response to this prompt:
"Is there a chance of an indirect argument of X ~ A^3 coming from computing some invariant of X that forces it to be A^3? (I am not all that expert in algebraic geometry but I'm thinking like degree or Betti numbers or something.)"
I guess it is kind of the inverse of the "you are an expert mathematician" prompt engineering of gpt3.5. Since no one ever says that to an expert mathematician when they are doing expert math the model immediately reflects that it is not an expert mathematician.
[deleted]
But I would say that in some ways it's already obviously superhuman. The reason I think it's lacking in some jagged ways still at the expert level is because although it's highly optimized to be incredibly capable in many domains, it still doesn't have quite the same raw capacity for complexity in understanding one problem that humans do.
I believe that LLMs (really should be called VLMs for most of them) can still get much larger, and that will push the absolute complexity level and general IQ way over human level.
They are maxing out at like 5 or 10 trillion parameters right now. I believe we will see 50 and 100 trillion parameter models and models with large portions of that active. It will round out the jaggedness and probably more than double the raw intelligence that a human can achieve. It's not a linear scaling but who knows what the limit is and can go significantly higher with the same architecture I think given continued improvements in training and hardware scale.
[dead]
It's actually a bit annoying because it primes you to think that the caveats are real, but most of the time it's just something terribly obvious and not a real caveat, but the model probably has some system prompt that tells it to always consider caveats or something like that.
Same as the model starting every reply with a commitment to be "honest". LLMism are fun but I tend to just suppress them via AGENTS.md because they distract me
"Is a meter the same as a foot?"
"Yes, exactly, you have it now, except they're different distances."
Maybe it's because I ask it to quiz me, and it really doesn't like to tell me I'm wrong. I also got a fair amount of
Claude: Ok, I will test your understanding. Question A? Question B? Question C? Question D?
Me: A=10. B=2. C=121. D is not solvable.
Claude: You got most of them right! You're very astute in saying that A=10, but actually it's 7. B=2 is exactly right! C could be 121 if we were talking base 4, but we're actually in base 10 so it's 25. D is trivially solvable and is 0.
Me: ...isn't that like 1 out of 4? How is that "most of them right"?
Claude: You're absolutely right! ...blah blah blah
Every answer is met with "But did you think about X", or "One more thing to consider" and it almost starts to feel manic as you dig down that hole.
Multiple times I've had to literally say "Stop with the follow-ups and suggestions. Just answer the questions clearly".
(llama.cpp can't seem to exceed 30 t/s, I had Fable make me custom inference. that's why it took me a day to get back to you)
GPT-3.5 would repeat my prompt back in its own words for me to confirm. This model immediately runs with it and generates a lot of output. I would definitely need to use a harness that allows editing / cutting off generations.
Something I've noticed about models that have been specifically uncensored or trained to generate content is that they aren't very engaging to chat with. Maybe this is just because they weren't trained to chat at all (base models) but, it's hard to find a chat model that's been trained properly.
What image hosts work for you? Imgbb? Postimages?
As someone who lives here it's very annoying but also good on them.
[dead]
/s
High IQ bros.
There is clearly intelligence there. We have no way to recognise intelligence other than the appearance of intelligence and this very clearly displays that.
It's also quite clearly different to human intelligence in some notable ways, but not in any that preclude describing it as intelligent. At least for normal non-pedantic definitions of the word.
But there's no way the thinking times would have been that short, of course.
It's clearly much more than that.
[dead]
Yeah that would be relevant if AI were an animal...
As I said, it's clearly intelligent, but a quite different intelligence to that shared by animals.
A second corollary is that rational consciousness and thought is less likely to be contained in language than previously thought, because if language is so simple that a machine can process it, it can't contain consciousness.
[0] https://gwern.net/scaling-hypothesis#gwern-difference--effic...
Exactly. The "most likely next" series of tokens, for example, when given the first half of a correct mathematical proof, is the correct rest of the proof. I have never seen anyone define "most likely next token" in such a way that this isn't true.
Either humans are not capable of intelligence or computers are capable of becoming intelligent. Neither or both.
[dead]
[dead]
[dead]
One LLM would suggest a tightening of a particular axiom, and I would ask the rest what the consequences are: what is gained, what is lost and decide whether to use it. Often another would suggest a tweak that then goes back and a recursion.
I've given private math lessons and seen students struggle with ai, even though ai gave the right answers.
My intuition is that humans spot xy problems easier when teaching (user ask x but really needs y), whereas llms will oblige writing about x.
What I had in mind (and found personally useful myself) was being able to ask a chatbot to break something down into simpler and simpler concepts, until my weak fundamentals or lack of formal education could grasp some bit of it.
I'm not sure many humans (or colleagues at a workplace) would have the patience to tolerate the stupid questions I've been asking.
Most people, if they haven't studied mathematics in university, would need to learn hundreds of concepts just to get to the leaves of the tree, and many of these concepts are truly difficult to understand, requiring weeks of study and practice.
That's not going to happen. Mathematics isn't just unfamiliar, it's truly difficult to understand. You have to put in a lot of work to understand each concept and the concepts build upon each other to form a vast tower of abstractions that has been growing for thousands of years. Just as there is no royal road to geometry, there is no elevator to the top of the tower.
(I'm not talking about OpenAI/Anthropic at this point, but maybe a <10 people startup.)
If you searched for coefficients from -12 to 12, this would be 25^360 = 2 * 10^503 different possibilities. A common reference point is that there are 10^80 atoms in the observable universe. Sure you could probably reduce this a bit with clever tricks, but the starting point makes the method completely unviable, even with the knowledge: A) a counterexample exists, B) it's in 3 variables, C) it's in degree 7 or less, D) it's in integer coefficients, E) those coefficients are 12 or lower.
[dead]
Maybe they'll find a solution where P=NP.
That could really throw a wrench into the whole internet thing.
It seems they need an expert human driver for now.
In this case, it takes me 12 seconds to see content when first opening the link, and about 18 to re-render content when scrolling.
I feel like to get to Terry's level you need a combination of passion and aptitude for the subject. People that don't want to learn about a topic will always look for shortcuts, which I think represents the vast majority of people. Terry Tao is quite exceptional, and I think exceptional people will still exist even when the "easy" button is bigger than it's ever been.
My wording is specific. You can use AI and increase knowledge and skill, but this requires you to be driving the AI at such a low level you don't get the full speedup. As an example, you can write code yourself with AI as an assistant, but it's not as fast as AI writing everything.
So now we end up stuck in a situation where every professional needs to choose between long term skill growth or speed, as anyone who's worked a job before knows, speed will always be the one chosen.
No AI would have been able to find it if asked to "Find a counterexample to the Jacobian conjecture. Make no mistakes".
[deleted]
Professor Tao also put out some YouTubes of him working with an older LLM to do Lean proofs, and his intelligence matters - things where I would be stuck for hours trying to understand what was failing in the model proof were just instantly clear to him and fixed in thirty seconds.
And I am an ok coder (rather than a bad maths grad student), but the LLM will happily thrash around the edges of a problem with me with no clear convergence when I don’t have that clear insight and the problem is weirdly presented enough; I still find the trick to walk around the block and disengage and then return knowing exactly what to do (now prompting it to the right thing) to be a super power for getting what I want out of the coding system.
More broadly, LLMs or anything at all, needs a verifier. If the task can be automatically verified, great, then anyone can use them. If you can't automate the verification, then you need to be able to verify it using your knowledge. Knowledge required to verify is lower than the knowledge required to create in very few cases. This is why you still need a fully trained human verifier. We are yet to reorganise the overall "tasks" in the economy such that verification can be done with much lesser knowledge, for no reason other than that there was never demand for this until creation became automatic few years ago. It is possible and is slowly being done, there are many many startups working on automating verification in different fields and in many cases we will see fields reorganise themselves to be more amenable to automatic verification. Note that _effort_ required to verify is much lower than what is required to create, for almost anybody, and LLMs have economic use just due to that alone, albeit in the hands of a knowledgeable human.
Edit: do give counter examples if you have any in maths, physics, chemistry, biology etc
I asked Opus 4.8 to critique my algebra notes (these are definitely not masters level- just undergrad second year). It hallucinated an error it claimed I made in the notes and then put in a correction I didn't need because what I had written was correct.
What I said in my notes was:
Notice that a cyclic group is a degenerate (in the sense of "smallest
non-trivial") case of a finitely generated group where the generating set is
a singleton.
The point is I see the LLMs as a "smart friend"/colleague I can work with but I do think critically about what I get told and don't just take it as face value because it's not always correct for sure even in relatively basic cases like this.
I think you guys are misunderstanding me, you can still talk to a llm to learn everything about physics or maths.
Even if you walk it through the process, it also has terrible intuition about what time certain things "should" take - dismissing the possibility of massive speedups because it thinks some number is normal etc
My guess is they don't do this because they don't have time. They're all trying to build a company that makes them generationally wealthy before the music stops.
EDIT: oh, they do offer grants of $1000 of API credits to researchers https://help.openai.com/en/articles/10139500-researcher-acce...
Depends. The headline 'some rando solved a famous problem with a consumer grade subscription' might be a really good way to sell these subscriptions.
"Some already famous guy with special access solved a problem" might not be as inspiring.
As an aside, there's this idea in math that when you create a new field you shouldn't solve all the easy problems - you need to entice other people to learn about the field!
I expect there's some element of that here. It's much better for OpenAI and Anthropic if their users are the ones discovering and writing up the results of the AI solving hard math. Look at the high school and college age students who have become ai power users and potentially learned how to use git to contribute ai generated solutions
(Related: I believe Terry has also gotten all of the subscriptions gifted to him)
https://xenaproject.wordpress.com/2026/07/20/human-mathemati...
[dead]
Could they do it? Sure, but to what end? It would make more people hate them and feel even more "take our interesting work." Pitching it as a useful tool just makes more sense on all levels
https://openai.com/index/model-disproves-discrete-geometry-c...
Although if I were a mathematical quantum physicist I might be trying to prompt one into a % mathematical field formalized quantum field theory. Weirdly this sort of obvious step has not been accomplished in the last 100 years.
That's why the free market works, millions of agents in parallel beats any planned economy (by humans)
The exact same thing happens in the cortex, 10s of thousands of cortical columns coalesce into a single action.
(Of course LLMs can help there, get it right etc, just a caveat that people have to keep in mind)
Makes sense that its in the major harnesses and not the self-built ones.
I am talking about someone jokingly asking AI `HOW TO ACHIEVE COLD FUSION` (or `A UNIVERSAL CANCER VACCINE`, or `AN AI FRAMEWORK SUPERIOR TO THE TRANSFORMER`), and getting a usable answer.
Eventually there will be an AI that will be able solve those sorts of questions as simply stated, like "cure all human diseases. also, make no mistakes!".
I mean that.
Yes and no. They can extrapolate and build upon the training data, as was the case with the last dozens of math proofs
To put it differently, if you have some idealized model in front of you that can do anything a team of humans can do, what do you say to it? It's still just a model that takes an input and provides an output.
Someone will still need to ask for something (or maybe it will just run autonomously making things it thinks we'll like) but it won't require any expertise in the field.
For things like sickness, old age and death, generally the lacks are not knowledge but the consistent will of the group. Like global warming, there is no real profound knowledge gap except how to get everyone to agree to mitigating the carbon burn. Perhaps it is likely LLMs would be able to persuade the group to stop burning the carbon before it’s [more] uncomfortable, but the small group of people committed to accelerating the carbon burn can also pay for LLM persuasiveness.
LLMs giving you something novel would be like if you let a model play chess against itself and become the best player in the world this way. Totally impossible.
/sacrasm
The truth is that math is hard: few other subjects have anything close to its crazy conceptual breadth and depth, with hardish concepts being built upon hardish concepts in many layers.
For example, Fourier is more clear to me as: F{t -> sin(t)} = omega -> (...) instead of F(sin(t)) = (...). Or D{x -> x^2}(x) = 2x instead of (x^2)' = 2x
Abuse of notation is very common, like using f(x) both as the function and as the return value at some input x etc. For example, the chain rule is often notated in a way that hides a lot. Math uses so many single letter variables, uses huge formulas instead of factoring out parts and using multiple lines, math people don't seem to appreciate namespaces and dislike nested variable scoping etc.
It's not magic that makes everything super easy, but it helps.
Nothing in the ChatGPT conversation is tangible. It's all in the realm of concepts.
Now days of course the chips are small so you have to point to where the multiple gigabyte chips are at.
But they are still quite physically.
Heck a C pointer points to an actual physical location on your machine, if you ignore the MMU.
An algebra over a ring (call it S so we don’t confuse it with R from the previous paragraph) is a like a vector space over S, with the added structure that you can multiply elements of the algebra together (vector spaces only let you add their elements together). So for example the collection of even integers 2Z is an algebra over the ring of all integers Z. The collection of all polynomials with integer coefficients, Z[t], is another algebra over Z.
This is a great example of how dense language gets in math. There are tons of concepts hiding in the unstated background. Many are quite simple to explain individually, but there are so many of them that an outsider won’t know where to start to tease them apart. There’s a good reason to do it this way though; it would take a very long time to say anything in math without ever increasing levels of information density.
His point is the terms are dense too
As for your specific questions, I believe Wikipedia does a great job of answering two of them for a layperson:
https://en.wikipedia.org/wiki/Ring_(mathematics)
https://en.wikipedia.org/wiki/Vector_space
For the others, I’ll say that a formal variable is just a symbol (literally, like the letter t). With such a symbol, we can construct polynomials like 2t^2 - t + 3. Also, there’s no need to only use integers as the allowed coefficients; you can use any ring you like instead.
An “algebra over the ring R” is what I was attempting to define in my comment above. The algebra is “over” R if we can multiply an element of the algebra by an element of R. The useful analogy here is scalar multiplication in a vector space: you can multiply a vector by 2 to double it or -1/2 to reflect and shorten it. More generally, it makes perfect sense to consider some more general version of vectors which can be scalar multiplied by elements of any ring R.
Not like a drink with jam and bread.
I'm glad you answered them.
It finally makes sense to me, and now I realize I didn't even understand "over" in that context. That Ring wiki page though, um, nope... :D
All these terms were taught to computer science (and of course math, physics, ...) students as part of getting their degree in computer science, because these concepts are important for many algorithms.
[dead]
In lean4, even without mathlib4, TCP/IP is way more code than a Rees algebra.
Math uses dense notation that is gigaoverloaded, and the disambiguating context was historically the leisure and proximity to have someone explain what the lexemes even mean.
lean4 is proving to be very revealing as an uncorruptible referee on a lot of things, including the relative difficulty of computer science and complex analysis.
-- A Rees algebra over ℤ[t⁻¹] is this.
-- That's it. That's the whole thing.
structure ReesAlgebra where
coeffs : Array Int -- integers, indexed by grade
-- grade k means the coefficient sits at t^k
-- negative indices are the t⁻¹ part
-- The "algebra" part: you can add them
def ReesAlgebra.add (a b : ReesAlgebra) : ReesAlgebra :=
⟨a.coeffs.zipWith b.coeffs (· + ·)⟩
-- And multiply them (convolution, same as polynomial multiplication)
def ReesAlgebra.mul (a b : ReesAlgebra) : ReesAlgebra :=
sorry -- it's Array.foldl over index pairs (i,j) summing into slot (i+j)
-- exactly how you'd multiply polynomials in a job interview
-- That's the entire mathematical content of
-- "The Rees algebra is an algebra over Z[t^{-1}]"
--
-- Compare: a minimal TCP SYN handshake in Lean4 would be
-- ~200 lines before you even get to retransmission.
--
-- The notation is the gate, not the math.Z[i], the Gaussian integers, is the subring (of C) generated by Z union {i} where i is the imaginary unit in C, the complex numbers. The Gaussian integers correspond to the integer grid-points of the complex plane, if you want to visualize them.
It's a plain observation that math exists on mostly it's own path with little to zero overlap with our lived experiences. If mathematics was a vector, it would have similar magnitude to other vectors, but it's direction would be much more removed from the typical knowledge pack, forcing you to get really close to the origin before you can "hop" over to that math vector. Other "knowledge" vectors, by virtue of being more bunched up, are closer together much further up, if that poor analogy at all makes sense.
First of all, no, mathematics would be far less approachable if it did that. Most of the Greek letters used in mathematics don't have a universal meaning, they're context-specific and defined by convention or just prior to use.
Second of all, mathematics is optimized for hand calculation on paper, not long-term programming and code maintenance. Writing out long names over and over on a whiteboard gets tiring extremely quickly, so mathematicians prefer to stick to single-letter symbols.
Mathematicians pretty much universally view typesetting as a distinct step from the thinking part of math, and something you do at the end once you have figured everything out.
I suspect if I showed a non-technical person with no background in either math or programming they would think both are nonsense until you explained it to them
I doubt it. Greek letters convey almost no information, whereas (one hopes) the function and variable names are chosen by a programmer to help the reader. The Greek letters used by mathematicians (and physicists) weren't used to convey information, they were used because typesetting, publishing and paper were expensive. They are optimised for brevity over readability.
It was a perfectly reasonable trade-off at the time, but times have changed.
As an aside, some programming languages (such as APL, and to a lesser extent Perl) did emulate the old Greek letter style. "Line noise" is a typical description of the result. No computer language aimed at software engineers and computer scientists does that now.
Tables, algos, and variables are all things people can generally quickly grasp. The construction is abstract but the function is tangible.
The math is working entirely on abstract objects, using abstract tools, governed by abstract rules. It's just all so desperately far away from anything even technical people have contact with.
They don't seem to have any desire to reconcile their 'craft' with real world applications and this is probably why they're particularly good at it.
`sum function(x) from x=0 to x=infinity`
And if you think about how summation would look in Lisp or APL (which some smart people use to this day), I am not even convinced your argument for the "sum function" notation being superior holds in general.
If mathematics used plain language, the ability to meaningfully manipulate and understand would go way down. Proofs would become massively tedius.
Of course, notation is hard. Any good mathematician should put a lot of work into it.
The vast majority of what computers do just isn't that complex. I'm not saying it isn't "complex" just that any reasonably smart person can understand how a computer works and still have other hobbies, basically no one can understand phd level mathematics without dedicating their entire lives to it.
Sure, if you’ve already learned enough groundwork, tcp/ip is accessible in weeks. The same is true of most of the algebraic concepts in play here. And both have rabbit holes you can also spend a much longer time going down (though here I am willing to give the edge to math which offers much greater opportunities for hypergeneralization and new vistas of abstraction along which not only specific rabbit holes but entire new generalizations of both rabbits and holes may be found).
But you can have a surface level understanding of mathematical topics as well, ofc some topics might require deeper understanding, but that's true for both.
Any claims of being able to learn 99% of computing in a just 4 weeks even at surface level, is greatly underestimating your own knowledge built over the years perhaps, or perhaps underestimating your own ignorance.
I have had folks tell me cache is just cache in actual interviews. When I have asked them to explain the concept to me, but even beyond that I feel like we tend to think less of our own knowledge of topics once we have acquired it.
Especially ones acquired over years, alongside other work.
CS examples are often easy to picture and understand the motivation for. You can use tools to visualize or play around with them and test them.
Math gets abstract so fast you have to spend a week of research to even understand the problem statement. The the motivations themselves can be completely unclear until you have a lot of context.
I majored in math (B.S.) and upper level math is completely foreign to me.
Every slice has so much depth to it, in Maths it all seems like all of it is required at once but in computing it feels like so little is needed to get started which I honestly feel like is failure of our modern education systems.
But yes Computers being so easily accessible and compilers, documentation and libraries have made computer science so easy to get started with.
Imagine having to implement your own network layer to communicate with someone, you would have had to understand ip, tcp, network layer to an extent like http and etc. and then you finally would have been able to communicate.
In maths that's our reality for a lot of the field, there aren't good libraries, interfaces to help skip the unnecessary details. Hopefully AI might solve it I don't know though. It's fun to hope for it.
Also, understanding an 8086 CPU is not even remotely comparable to the level of mathematics Terence Tao was discussing above. The 8086 is a relatively basic and concrete topic. You can build a workable mental model of it from a finite instruction set, a handful of registers, and a reasonably straightforward memory model.
From my perspective folks here on HN and in CS often think they should somehow be able to understand advanced mathematics papers at a glance, merely because they are good at basics of programming or computer science (8086). That is not how it works. Most mathematics is not inherently much harder than computer science; both fields require you to accumulate a large amount of foundational knowledge before advanced material becomes comprehensible.
There is an enormous amount of computer science that most programmers are completely unfamiliar with, especially within academic CS: programming-language theory, type theory, formal semantics, compiler theory, algorithmic research, complexity theory, distributed computing theory, verification, cryptography, computational geometry, numerical methods, and so on. Being proficient in one narrow area does not automatically give you the prerequisites for another.
A web developer would not be expected to casually understand a research paper on type theory or approximation algorithms without first learning the relevant notation, terminology, and foundational results. Mathematics is no different. The feeling that mathematical writing is uniquely impenetrable mostly comes from encountering it without the years of accumulated context that mathematicians have silently built-up.
I can show you a paper about an advanced algorithms or chip design, that is large made up of fundamental cs concepts and general physics and even you likely someone with pretty in-depth understanding of CS would find hard. There are orthogonal subjects, for instance my mathematician friends things I am insane reading so much about weird computing topics, and I find his research in some weird number theory thing completely mind-bending.
Try and explain to a lay friend how registers & isa works in-depth with all the details not a hypothetical higher level model so that they can understand the nuance of looking at assembly, limit it to 8086 perhaps, it will take significantly longer than a weekend.
Ofc Terence Tao and his level of intelligence is beyond me, I wouldn't compare but general advanced mathematics is not something folks here couldn't pick up if they actually tried to work on it, just give it a shot (though I would recommend don't start with advanced topics build up slowly I think most people can understand most maths papers even the bleeding edge ones within a few months of serious self-study, and won't even feel that it's after a few years, compare that to the time spent learning software and computing 6-8 hours a days for several years)...
And the difficult part of all those areas of computing is the mathematics part. Which I think is what I am arguing, mathematics is a fundamentally different type of "difficult" to any other subject.
"No jargon" is alwys in reference to some assumed knowledge model.
For example, when I claim that my own math texts include "no jargon", this assumes the knowledge of a person who has studied, say, mathematics, physics or computer science.
Well people even name stuff after themselves as well, Fil-C, raylib, etc (I like both Filip and Ray just pointing it out).
Aside: If I butchered some spellings I am sorry. :3
[deleted]
I agree, and I don't think we should be at all ashamed of this.
The beauty of programming is that we can produce incredibly complex and powerful things by manipulating a small set of simple constructs together. There are only a few core tools--iteration, conditionals, etc.--but they can be snapped together into much more capable configurations.
Good programming is the art of deconstructing complex behaviour into these few constructs, and that's really fascinating.
Most of things that are impenetrable in programming aren't about... programming. They are about some actually complex field like math being applied to programming.
For example, a library that does stuff with geometry. You need to know geometry to understand the program, but the program itself will never be complicated. It's the geometry that is complicated.
In cryptography, it's not the program that is complicated, it's the field of cryptography. In AI, it's statistics.
In graphics programming, math is the most impenetrable part, not programming anything. You can be a very good programmer in the sense that you know how to architect information systems and still fail to write a shader because shader programming requires you to know what a "dot" product is and you haven't heard about that since high school.
Your job is to maintain and modernize a system while delivering a constant stream of new features. Your system is several million lines of code, with some multi-thousand line classes, a rulesengine that can trigger nearly unlimited effects at any time, a persistence system that's weirder than anything any of your friends have ever worked with, and hundreds of customers delivering tens of millions in revenue who use the system in incredibly varied ways.
You can't stop to rewrite the thing, you can't just throw features out there and pray, because you'll cause regressions and your existing customers will hate you. You have to fix the thing as you're building on top of it.
But where I agree is that there's no single deep concept that unlocks it all, it's not like you'll fix it by reading a textbook about it. It's complicated, and it's going to stay complicated, no matter how long you work on it.
[dead]
ETag, SAML, CSP, BGP, haproxy, helm file, k8s, SOCKS5, Lamport OTS, Winternitz OTS, SPHINCS, lattice-based, pg-vector, sameSite, httpOnly. (Or, at least, i have no idea what those are ::)
At least some of these are definitely real things. For instance: "BGP" is the Boundary Gateway Protocol. "Lamport OTS" is a one-time digital signature scheme due to Leslie Lamport. k8s is an abbreviation for a piece of software called Kubernetes.
Never mind. The answer before me did a much better job.
SAML is Security Assertion Markup Language; an XML based SSO (Single Sign On mechanism).
CSP (Content Security Policy) which allows the application to specify additional security constraints for the browser to enforce.
BGP; border gateway protocol.
Haproxy is a load balancer.
Helm file; another word for helm chart.
SOCKS5 is a tunnelling protocol which allows you to tunnel through a machine over SSH; you can use it to browse the net or access remote services via another machine (hiding your IP)... It's a bit like a basic VPN. Very easy to setup, you can configure your browser (e.g. Firefox) to access the net via a SOCKS5 proxy so if the remote instance is in a different country, websites will treat you as though you are in that country... Just like a VPN except you have to control the remote machine yourself and log into it via SSH with the -D flag.
Lamport OTS is Lamport One Time Signature algorithm.
Winternitz serves a similar purpose but different tradeoffs and smaller signature size.
SPHINCS is a stateless hash-based signature scheme which works by building a tree of OTS keys (Lamport, Winternitz or other) which can be generated deterministically, on-demand.
Lattice-based cryptography is real.
pg-vector is a plugin for Postgres for vector embeddings and it provides some operators for finding records based on the nearest vector.
sameSite and httpOnly are cookie security settings.
You overestimate Coinbase's engineering rigor.
But yes security in modern software systems is a joke. I don't even get paid to fix security bugs everytime I raise them the answer is to slap a sandbox and proxy and call it done.
Now I could hack essentially any system I want. At least DoS or crash them for sure, with minimal computing on my end. They're much more complex than they used to be. Security-through-obscurity used to be a no-no and sometime in the last 10 years it became the main security paradigm.
Cleaning boats, the learning tapered off after a few weeks. With software, I'm 15 years in and it barely tapered at all and it's much more intense. I've been pulling nights and weekends too.
With software knowledge, it would be high information density with little to no repetition. Every piece would provide useful concrete knowledge which would serve to increase technical capabilities and/or security.
Imagine that instead of being able to use high-level programming languages, you had to write in assembly everywhere, all the time.
That's what software engineers and computer scientists' suggestions of redoing mathematical notation fee like to mathematicians.
These efforts also don't go anywhere because research mathematics moves beyond elementary arithmetic very quickly, and once you're there, "descriptive" notation becomes as incomprehensible as whatever mathematicians use.
Same reason why we write 5-3, not subtract(minuend=five, subtrahend=three).
Interestingly, discrete math feels the most "verbal" of all the subfields of math I've encountered (I haven't gone very deep). I think this is because notation in discrete math is is somehow closer to compressed prose or logic, whereas other forms of math use notation to fill in for long sequences of symbolic manipulation.
Not sure if that makes sense... I'm curious whether anyone else experiences it that way.
People genuinely struggle to think verbally or visually once we extend beyond 3 dimensions and start talking about infinite-dimensional constructs, uncountable sets, and so on...
And math is, as you know, a deep but traversable graph. The traversal inherently requires a familiarity with the nodes you pass through when reaching a foreign or more difficult concept.
However, I'll give you an example. If I read through more complex math that I’m not comfortable with in Sage, I can build an intuition for the structure of the problem more easily than if I view the “raw” notation. In that sense, it is easier to for me to “approach” — but approaching something is very different from fluently using it — and I’m under no illusion that approaching a topic is the same as beginning to understand it.
Again, this is definition-dependent. To me, “approaching” something means beginning to glean how I might one day understand it. E.g. watching a 3B1B video feels like “approaching” a topic. Here we reach the limits of language already :)
"""During his own Google interview, Jeff Dean was asked the implications if P=NP were true. He said "P = 0 or N = 1." Then, before the interviewer had even finished laughing, Jeff examined Google's public certificate and wrote the private key on the whiteboard."""
Pronouns like you/me/he/she/they/them are context dependent in everyday English writing but they're only ambiguous when the context is unclear, otherwise most people have no trouble dealing with them at all!
Which, to me, again demystifies these tools. They are incredible tools, but still "just" such.
Bingo
Thanks for laying it out so clearly.
This is what I feel LLMs are really good at yea. Almost to the point that I'd say this is what they are. But I'm not quite convinced that it is that, but it seems to point that way
"What am I going to do with these?"
"Try to trade them up for a Volkswagen?"
that's some Harry Potter kind of "writes itself" book.
at this point, for me, any comment about LLMs that begins with "it's just ..." is hard to take seriously.
Terrence is impressed. Good enough for me.
I'm sure people thought calculators and, indeed, computers themselves were very Harry Potter as well when they first came out. But in the fullness of time the magic and mystique has drained away, and we're left with the understanding that they're just tools.
> at this point, for me, any comment about LLMs that begins with "it's just ..." is hard to take seriously.
Similarly I have a hard time taking seriously the people who make breathless claims of intelligence where there's only a text calculator with weights applied. It's like watching the devout cry "miracle!" at every strangely shaped piece of toast.
Terrence is impressed, but he's not a believer.
Basically every academic AI researcher in history was doing what you described. The AI industrialists stopped caring 6 years ago once they realized LLMs seem to have been the only thing in 80 years that actually seems to work at any useful level.
There are plenty of pioneering scientists who are either returning to actual AI research (Yann Lecun, Ilya, etc), and plenty who never left (Richard Sutton) who are doing exactly what you are talking about.
That is not true. Alan Turing did not view things that way, his test would say that a dog has zero intelligence. Neither did any of the MIT Lispers. And neither do Lecun or Sutskever or Sutton! They are all focused on human intelligence. None of them are even slightly concerned about an AI which is intelligent before it learns any language.
> the only thing in 80 years that actually seems to work at any useful level
This isn't true either! Mathematica / Maple / etc are "old-fashioned AI" and they obviously work. The Lisp expert systems were also useful, though less so than an LLM.
??? https://www.youtube.com/watch?v=GvibIstOn_E his arguemtn here is clearly built around using some sort of sensory data to build a model of the world like humans (animals) do. also you clearly decline to mention Lecun who has made this point ad-infinitum
> This isn't true either! Mathematica / Maple / etc are "old-fashioned AI" and they obviously work. The Lisp expert systems were also useful, though less so than an LLM.
i personally find it very strange that non-deep learning AI approaches which essentially boiled down to a giant bundle of if statements, or some very simple statistical modeling were called AI in the first place.
Da hole raisin y nat-lang be v. hard is dat i kan rite lik dis an it be cool 4 native engrish speekrs 2 unerstand. LLMs are of course fine with this sentence in exactly the way that Zork's engine couldn't be.
example For, semi-randomise I word order can this like, Yoda worse than, and be understood.
> is no problem for a machine that takes context and probability into account when translating words to the underlying grammar structure.
We had to invent Transformers to be able to do that with reliability anything close to being worth caring about. Transformers have to learn from examples, not be pre-programmed.
that feels like a misunderstanding of how the loss function behaves when used within a sequence
"Be aware of 'xy problems': when the user asks x but really, they need the answer to y to further their understanding. ..."
The models are so capable now I think a lot of these real limitations can be solved by prompting, harnesses or fine-tuning.
But, now, with world class knowledge possessing tutor, you can ask for an explanation of missed concepts, even embarrassingly stupid questions you would never ask a person.
2) You are starting at 10^500 possibilities. "Much" smaller is not enough, the order of magnitude of the order of magnitude needs to be changed.
3) You still need all of the other assumptions, which were completely unfounded
Impossible.
I learned from poking around that checking the invertibility of a system in C is a much, much harder problem than I thought. Nonetheless if that were no object, let’s say coefficients from -16 to 15 (5 bits) times eight terms times choosing up to cubes (64) times three equations is searchable, especially since you have only the final combination of coefficients in the determinant. It’s not impossible to generate the equations like this Fizzbuzz style.
Edit: no. 2048 possible monomials, to the 24th power, not times 24. Fine, can’t brute force it.
The coefficients are mostly 1, so biasing toward that would make it much faster.
It's not quite the Reimann hypothesis, but many prominent mathematicians have spent years working on this problem. Yitang Zhang wrote his PhD thesis on it.
F1 = x^3y^3z + 3x^2y^4 + 3x^2y^2z + 7xy^3 + 3xyz + 4y^2 + z
F2 = 3x^3y^2z + 9x^2y^3 + 6x^2yz + 12xy^2 + 3xz + y
F3 = -x^3z - 3x^2y + 2x
That’s the counterexample. Low integer coefficients, power 7 in three variables. If someone said it was there, couldn’t we all have written a pretty simple brute force solution for the search space, especially with the constraints that the symbolic determinant had to cancel to a constant?
As a small wrinkle: the actual observed number of producers can be small, but the market still be competitive. See https://en.wikipedia.org/wiki/Contestable_market for one case: when potential suppliers are waiting on the sidelines.
Don't get me wrong, the way we collectively treat animals is evil, but the idea that somehow we know enough about biology even today to reliably simulate drug behaviors seems unlikely.
Heck there is a standard for tcp/ip over short wave if you want to hear the bytes being transmitted. More widespread, those of us familiar with dial up modems are also aware that network traffic can be carried as actual sound.
Or fiber optics where network traffic is flashes of light.
Or IR transmissions, use your phone camera and you can see data being sent over the air. Not tcp/up but physical blinking lights sending digital data.
All the Wikipedia actually means by ‘stream of octets’ is ‘sequence of numbers between 0 and 255’. TCP is a protocol concerned with sending a message encoded as a sequence of such numbers from one computer to another, over a packet-based network (i.e. one where it can only send limited bursts of information at a time); and it helps make sure that the original number sequence is able to be reassembled, in the right order, and makes sure that all the pieces have arrived.
The fact that people have tried to explain ‘octet’ concretely by pointing to RAM chips or flashes of light in a fiber really points to the fact that a lot of computer people just mentally gloss over a lot of the things that are virtualized at lower levels in the stack.
Yes, those are physical manifestations of ‘bits’. But not necessarily the ones TCP is concerned with.
I’m not sure this gets us any closer to a jargon-free explanation of what TCP does.
Fair enough! At a super high level, a ring is just a collection that has a similar structure to what you’re used to “numbers” having. That is, you can add, subtract, and multiply them. Not divide! If we restrict ourselves to just whole numbers then 2/3 is not allowed. We also require that something like 0 and 1 have to be there. “Like zero” means 0 + x = x for every x in your collection, and “like one” means 1x = x for every x. And lastly, we require that the distributive property holds.
Examples include the set of whole numbers (Z), the rationals aka fractions (Q), the reals (R), complex numbers (C). These are all infinite rings, but there are also finite rings such as the set of whole numbers modulo a fixed number n, denoted Z/nZ. For instance, Z/2Z has only two elements, namely 0 and 1, with rules like 1 + 1 = 0. There are also polynomial rings, like Z[t], whose elements are all polynomials with integer coefficients (e.g. 3t^3 - t - 2). You can add, subtract, and multiply such polynomials and the result is more polynomials, so this collection is indeed a ring.
I studied computer science (and mathematics) in Germany. I am very certain that this was taught to computer science students, even though (compared to the lectures for math students) the lecturer did not get very deep into these topics.
> most CS students would have been terrified of that.
This is a feature, not a bug. :-)
Seriously: In Germany, the "math for ..." lectures often are intended to be "weed-out lectures" so that students who simply are not qualified for their major get to quit their degree course fast (either by realizing that the degree course is too hard for them, or by (typically) failing math exams so that they get exmatriculated), so that they don't waste many semesters on a degree course which they simply are not suited for.
You clearly write from the perspective of the US-American university system.
In Germany, basically everybody can enroll into a computer science program at a university, assuming the person has a Abitur (Allgemeine Hochschulreife) certificate (these terms are difficult to translate into English) from the grammar school [1]. So, "have it made to college" is like "not having been a complete failure in school". [2]
So, making it to the university is no achievement in Germany, and also no sign of motivation either.
> If these courses are so important, they should be taught in a way that students can understand.
These courses are taught in a way that students can understand, but not in a way where you can afford to slack off.
It is basically a consensus in Germany that a university is clearly a wrong place for you if you are incapable of closing knowledge gaps on your own (for example by reading books from the library), and you don't have the self-motivation to sit over the lecture material for hours to finally understand it.
So yes, I would say that among the possible options, weed-out courses in mathematics are in my opinion likely the least bad one.
---
[1] In years where there was an insane demand for places at the university to study computer science such as during the dot-com bubble, there were some restrictions (numerus clausus), but for computer science, this was always the exception to the rule.
[2] There exist good reasons for puns like "Abitur: nichts gerafft und doch geschafft" (Abitur: Didn't get a thing, yet still passed) or "A-bier-tur" (a portmenteau of "Abitur" and "beer", which suggests that even pupils who are more into drinking than learning typically get their Abitur certificate).
For example in search algorithms where you want to search a space without visiting state nodes twice. Each state in the search space is produced by the sequence (a product of) of operators from the start state: elements of a monoid (or group if actions are invertible) which define the primitive steps. Trivial example being generating all permutations of a list. More interesting, enumerate all graphs with some property with pathwidth at most k, by adding one edge or vertex at a time. So now you want to know the structure of this group so you know which sequences of elements simplify and don't need to be tried, and you want to canonicalise each state to throw out duplicates.
And you can think in terms of orbits: if there are some symmetries then you might want to factor by the symmetry group and only visit one node in each orbit, grouping states into orbits with a single representative state. See eg. Pochter, Zohar and Rosenschein, Exploiting Problem Symmetries in State-Based Planners.
> https://en.wikipedia.org/w/index.php?title=Algebra_over_a_fi...
> https://en.wikipedia.org/w/index.php?title=Algebra_over_a_fi...
> https://en.wikipedia.org/w/index.php?title=Associative_algeb...
The latter is what aground asked for in https://news.ycombinator.com/user?id=agrounds
> I’m surprised that rings and algebras would come up in a CS degree. What algorithms topics used those concepts?
* Determinant calculation:
- The Samuelson–Berkowitz algorithm is best understood in terms of general rings
- The Faddeev–LeVerrier algorithm and determinant calculation using Gaussian elimination work on rings with specific properties (for the Faddeev–LeVerrier algorithm the restriction is on the characteristic of the ring, for Gaussian elimination the ring must be an integral domain (ideally a field)).
* Ring-learning with errors (for post-quantum cryptography and homomorphic cryptography). Here, a specific ring is the central object.
* Number-Theoretic Transform (NTT): Basically a generalization of the Fourier Transform to the ring Z_n. Important for arbitrary-precision integer arithmetic
* Chinese Remainder Theorem. Often only formulated for the ring Z, but it can be generalized to larger classes of rings. Used for example in Shamir’s scheme for secret sharing (cryptography)
* The theory of BCH and Reed-Solomon codes uses a specific ring
* The AKS Primality Test (a really deep result in computational number theory) uses the ring Z_n[X]/(x^r-1).
---
Algebras:
Very often, a ring is constructed from another ring. Examples:
* the polynomial ring R[X_1, ..., X_n]
* The ring of (square) matrices over a ring R
So, using algebras in algorithms often means: "we want to make use use of this additional structure that our (more sophisticated) ring has)". (Associative) R-algebras formalize this concept of "ring with additional structure".
To just give one algorithm for polynomials:
* Buchberger algorithm for computing a Gröbner basis
Other examples:
* Clifford algebras for a lot of geometric problems (special case: quaternions (a 4-dimensional \mathbb{R}-algebra) for rotations in \mathbb{R}^3).
* If you are willing to also consider semi-rings (in this case: tropical semi-rings): the Floyd-Warshall algorithm for finding shortest paths and the Viterbi algorithm for finding the most likely sequence of states in a Hidden-Markov Model (HMM) can very elegantly formulated using the matrix semiring over the tropical semiring.
And it all seems arbitrary anyway. Why are trigonometric functions written in english ("tan" being short for "tangent") but other stuff uses greek letters and other stuff still uses esoteric/abstract symbols? Why is the integral symbol shaped the way it is, and why use super/sub symbols for the bounds versus `integral [0,Inf] ...`?
In my ignorance, I'm assuming math is the way that it is because that's the way it's been for centuries, and messing with it harms its ubiquity. Math notation is not the way that it is because it's particularly well thought out. It's centuries of legacy tech debt that can't be changed. Kind of like how English is a crappy language in a lot of ways, but we can't change it now because too many people use it and you'd never get enough momentum to switch.
And somehow, none of the thousands of very smart mathematicians have done that, or if they had, it has not seen wide adoption. I recommend contemplating on this: if math could be made easier by changing notation, why hasn't this already happened?
Because otherwise if you think about it all of computing is Maths but with computers...
I don't think people who read the Wireless Fidelity spec can understand any of it in a weekend or anything even to a rough extent.
Similarly with websockets, quic etc. the most you can take away without much prior knowledge is what it does which maps into Maths as well.
nobody thought that
I'm convinced half the reason people find CS terminology more accessible and Math terminology less so, is that CS terminology tends to be named after stuff, and Math terminology tends to be named after people, and ... sometimes whether the place they lived is a tropical place.
In my opinion: a lot of math terminology is much older than computer science terminology, so the origin of the names of many concepts in math is much more obscure for today's people than CS terminology currently is (and least if you are not into history of science/math).
On the other hand, in my observation a lot more terms in computer science are based on obscure (often pop-cultural) puns. I guess in 50-100 years these CS terminology might seem even more obscure for then-contemporary people than math terminology is today.