Hacker News Reader

krackerson Qwenputer: A functioning, deterministic RISC-V CPU inside Qwen3.5

Are you thinking of this one?

https://www.anthropic.com/research/introspection

About halfway down they inject bread into its head.

krackerson Qwenputer: A functioning, deterministic RISC-V CPU inside Qwen3.5

You don't even need SAE for residual stream based steering, you can do so much more naively by just taking the average difference in activations of prompted vs. unprompted versions, then PCA to get a "control vector" that you can use to elicit the prompted behavior

https://vgel.me/posts/representation-engineering/

krackerson Qwenputer: A functioning, deterministic RISC-V CPU inside Qwen3.5

The single-neuron steering stuff has been going around twitter lately, do you happen to know who was the first one to do it?

I wonder how this squares with the recent "NNs are already clean" interpretability finding, which may have also been the impetus for this kind of research. Similar to their work on CNNs, maybe residual-steering is overkill, there might be just a single neuron that "cleanly" corresponds to "evilness" that you can turn up/down?

krackerson Get Ready for Touch on Mac

Is this why UI elements have gotten bigger and rounder?

krackerson About the compromised eMudhra intermediate CAs

>used to use the same certificate store as the rest of the OS

It was technically curl that dropped SecureTransport but I guess because no one at Apple was willing to maintain it and it apparently is a frozen API that doesn't support newer than TLS 1.2 (!). For a while their inbuilt curl could use both but preferred LibreSSL anyway.

https://daniel.haxx.se/blog/2025/01/14/secure-transport-supp...

krackerson Start Doing Graph Theory

You can do that too with spectral graph theory!

krackerson Apple's git still trusts the compromised eMudhra certificates

The thing is Apple used to do this correctly. Back when they still shipped OpenSSL (albeit some ancient version), they had actually patched OpenSSL to do cert validation against the native keychain and only ever had Keychain as the source of truth. You can see this in https://github.com/apple-oss-distributions/OpenSSL098/blob/O...

And curl was patched to use the native TLS implementation (SecureTransport) which obviously used Keychain as well.

For some reason when they switched to LibreSSL everywhere they decided to ship their own copy? I don't know what they were thinking.

krackerson A Mathematical Theory of the Jacobian Lens

Link to authors' summary: https://x.com/neurostrow/status/2114778125896933442#m

It answers one of the conceptual questions that came to mind as to why it's even a well-defined concept:

> When the Jacobian is studied in an LLM, it provides directions in the residual stream that are “verbalizable” (Gurnee et al., 2026), which is to say that it identifies how perturbations change the linguistic output of the model. However, this property holds only in the local neighborhood of the point on which the Jacobian is defined, and the J-lens is defined by averaging over prompts, tokens, and future positions in the output layer. An average Jacobian has no reason to behave like any of its elements.

krackerson The Exponential Time Hypothesis Is False [pdf]

[deleted, originally wrote the hypothesis being true would imply NP=EXPTIME which is wrong, since there can be problems in EXPTIME which aren't in NP.

And the result that it's now false apparently doesn't imply NP!=EXPTIME either since it seems not strongly subexponential enough to offset the expansion in variables from reductions. See the other comments for a much better explanation.]

krackerson Three new discoveries in mathematics, computer science, and physics

Yes. Up until now, it was unknown whether containment of NP in EXPTIME was strict or not. (Obviously you can brute-force all possible witnesses, so any problem in NP can be solved in EXPTIME, it was open whether you could do better than that.)

Showing 3SAT (technically #3SAT) can be solved in less than EXPTIME resolves this. It's only slightly subexponential, not even quasipolynomial, but it is a very surprising result. And that too a constructive algorithm.

Edit: Apparently not true, the constructive algorithm given may not survive under reductions. See discussion in https://news.ycombinator.com/item?id=50252769

krackerson Three new discoveries in mathematics, computer science, and physics

https://github.com/openai/math/tree/main/preprints/The-Expon...

>We give a deterministic algorithm for exactly counting the satisfying assignments of an arbitrary k-CNF formula [in superpolynomial but subexponential time]

krackerson Challenge Is Gone

> Wouldn't the bar for software quality go up

No LLM can help companies that didn't care about software quality in the first place. If they did, they wouldn't have fired QA testers. And now that they've been gone for a decade while revenues have soared, why would they bother using LLMs for QA testing when they could execute on the stakeholder's vision instead!

You'd expect to see the majority of benefit to independent devs who previously _couldn't afford_ QA or a full team, and now can. But since the target audience for this stuff is niche, you're less likely to hear about it unless you're plugged into the subcommunities (see e.g. how LLMs have helped with game preservation, retrogaming).

krackerson LLMs are making formal software verification feasible at a much larger scale

That's a good point, although couldn't you usually black-box those and assume the invariants we expect of those primitives are in fact true? E.g. you don't need to bother trying to prove properties about your prng itself, you can just prove how your program behaves under a random oracle model.

krackerson LLMs are making formal software verification feasible at a much larger scale

I think incompleteness theorem means that you can't guarantee the agents will always be able to converge on a proof, since you can't have both completeness and soundness (and we obviously need soundness since that's the whole point of a theorem prover).

But most real-world programs are maybe not that "expressive" since we don't even want them to be capable of infinite loops (since those would often be denial of service vectors). So you should usually be able to prove that they halt (and presumably other properties as well), especially when you allow agents to rewrite things to pull out invariants that make proofs easier (as they did).

And for cases where getting clean invariants are difficult, I imagine you can just hack it by having some cutoff which trivially ensures things always halt. (Not sure what the equivalent would be for "no bug" proofs, probably rejecting things that are technically valid input per spec but seem unusual?)

krackerson Eight Bits of Trust: eMudhra's CA keys cracked in milliseconds

Oh interesting thank you. I had misunderstood how CT works.

krackerson The recently proposed o(n log n) integer multiplication algorithm [pdf]

Based on skimming the paper (finally a proper explanation that gives some hint at intuition), the path to openai's formulation if you're familiar with undergrad CS is (apparently):

* Start with the usual FFT convolution for polynomials, viewing integers as a polynomial in a given base evaluated at a certain point

* In undergrad you (hopefully) saw polynomial multiplication can be done in nlogn via convolution using FFT, but that assumes complex integer addition/multiplication is O(1). Here we need O(log x) bits to simply represent a number x on a real machine.

* If you use naive (n^2) multiplication for those butterfies, then you end up with O(n[(log n)^2]).

* If you recursively use FFT for the digit multiplication at those butterflies, then you get something like O(n[(log n)^(log log n)]).

* Schonhage-Strassen realized that instead of doing FFT in C where the butterfly involves multiplying by \omega (\omega being roots of unity), you can work in a different ring where 2 is a root of unity and so it's a cheap bitshift, but were constrained in how finely they could break subproblems (could only break an n-bit integer into sqrt-n subpproblems each of sqrt-n bits), resulting in an overall O(nlogn * loglogn).

* The 2019 O(nlogn) version (supposedly, this is out of my depth) found a way to use some technique of "Gaussian Resampling" to do the matrix convolution via _multidimensional FFT_ in a ring where multiplying by root of unity became cheap _and_ subproblems could be finer. The bottleneck was thus only the addition/subtraction in the O(log n) butterfly layers, each of which does O(n) work for total of O(n logn)

* OpenAI's paper uses a fact that it's apparently easier to compute multiple butterfly layers "simultaneously" than doing them one at a time independently (page 10). There is some sort of implicit reuse because the later layers mix the outputs of earlier layers, and they take advantage of this to avoid having to write out layer 1 outputs separately from layer 2 outputs, and instead work in some coordinate system where they can intermingle them. This apparently amortizes to some tiny fractional epsilon shaved off of a layer, and since the whole FFT is recursive they can apparently save a factor of (1 - epislon)^(log log n) overall across "log log n" recursion depth, which is apparently where that ridiculously small overall exponent comes from.

krackerson The recently proposed o(n log n) integer multiplication algorithm [pdf]

Fable was able to help a human understand the paper though, so the situation is quite a bit better than if we just had a lean proof that was apparently correct but for which all attempts at explanation were "hallucinations". There doesn't seem to be an apparently obstacle to a human fully understanding the proof in several months of focused study.

krackerson Eight Bits of Trust: eMudhra's CA keys cracked in milliseconds

How would certificate transparency logs have helped here though? If the private key leaks and anyone can mint a valid certificate that gets accepted, those logs aren't going to reveal it.

krackerson Neural networks are clean

The way he describes the model of neural nets almost reminds me of a decision tree, with the positive/negative poles and stuff. There's another quote from the article about the "textbook" intuition of convnets

>neurons generalize, work together, and build abstractions over layers. Somewhere along the way we overcomplicated that picture, but looking harder brought it back.

and it does seem that if what the article claims is true, then it really is that simple. To clssify e.g. fruit they first detect curves/shape, then the neurons downstream of say the "circle" detector may distinguish based on color, then the ones downstream of a specific color distinguish by texture, and so on. By the end, what you have are neurons that activate only on very specific combination of features, which map to each fruit.

krackerson Types of types: Haskell's Kind system

It's about as difficult as describing vectors in math. Vectors aren't really "little arrows" or "things with magnitude and direction" (because then functions wouldn't count), I think there's a similarly cryptic saying that "a vector is just an element of a vector space" or "a tensor is anything that transforms like a tensor".

In both cases what they really are is an abstract concept defined by things that satisfy some definitions, but in practice it's easier to just look at a few concrete examples like Maybe.

krackerson Furifont, a Japanese font that shows furigana

That's surprising. I'd have thought that a multimodal LLM like openai's would "just work", at the very least enough to generate enough data to distill down to a simpler model.

krackerson An ESPN producer who quit because of sports gambling

> I was going to try the martingale strategy in roulette

This only works of course if the game is actually fair, and you have infinite money reserves.

krackerson Furifont, a Japanese font that shows furigana

You can run LLMs inside the shaping engine, so maybe you can use more advanced segmenting and transliteration algorithms? https://fuglede.github.io/llama.ttf/

krackerson Two-Stack Sliding-Window Aggregation

Hm that's clever. You're basically taking the classic "queue using two stacks" algorithm but then replacing each stack with a min-stack (like in that leetcode problem where each element also tracks the aggregate of all elements below it) to get a "min queue".

And then unlike the usual monotone queue for sliding max/min, this works for any monoid since you're never comparing two elements.

krackerson Do dentists know what they're doing?

SDF is good, but P11-4 Peptide is even better if cavities haven't reached the dentin yet. No idea why you can't buy products with it OTC, it's not like it's hard to apply.

krackerson Do dentists know what they're doing?

> It alternates which nostril feels blocked, sometimes both feel blocked.

To some minor extent this is normal, https://en.wikipedia.org/wiki/Nasal_cycle . Or at least the alternation itself is probably not the issue.

krackerson Is 'Attention' the Essence of Intelligence?

Aren't all of these (including convolution) specific instances of Graph Neural Networks?

I don't have any specific experience in ML but I always liked the formalism presented in https://www.youtube.com/watch?v=J1YCdVogd14 as a way to unify everything

krackerson Is 'Attention' the Essence of Intelligence?

>drops the positional encodings after pretraining,

I thought with NoPE schemes you don't even need it during pretraining

https://arxiv.org/abs/2305.19466

https://sebastianraschka.com/llm-architecture-gallery/nope/

Given the causal mask and the way attention works LLMs can implicitly propagate a signal for ordering

krackerson The Dock on Mac, from OS 10 to macOS 27

Isn't dock also responsible for mission control? There was a trick to set an extremely long show-timeout to effectively permanently hide the dock, if that works it's probably better.

krackerson Auto Research: Integer multiplication below n log n

>instead of costs scaling with the size/precision of the number

But isn't the assumption that arithmetic is "atomic" standard in TCS? Costs do scale with the bit length, presumably they aren't assuming that addition is "constant time" with respect to # of bits (which would defeat the whole point of the exercise).

Maybe I'm missing something, but none of the things mentioned in that blogpost seem particularly "surprising" to me, most of it focuses on the fact that computational models used in TCS don't align with the real-world model of computers, but that seems like something you learn in day 1 of algorithm analysis? If you want something closer to real-world you'd use word ram model.