Omri Weinstein

Value in any hard-capped asset ultimately comes from liquidity and network effects, which is the same reason Bitcoin works. The difference with PRL is what the work actually is. Minting it proves that an amount of computation was run, trustlessly, with no oracle or attestation involved. That means any agent or machine doing compute can mint it, which makes it a natural native asset for machine economies (inference and compute markets, verification, value transfer, or using it as collateral).

Can you explain in more detail what PRL’s primary use case looks like? Right now it seems the token mainly rewards miners who do real AI work . What value does PRL provide beyond that for the demand side? And why should the token price rise if it is primarily just a reward mechanism for compute providers?

In a world where most GDP is produced by non-humans, the real currency isn’t money, it’s compute (data + energy). The question that motivated @prlnet was whether it’s possible to create a currency directly from this scarce resource. A currency pegged to intelligence. Our partnership with Together.ai (@togethercompute) showcases how Pearl changes the unit-economics of inference, and how it could help fund the AI buildout. Couldn't have said it better than @vipulved.

@topfumbler @prlnet coming soon!

@WeinsteinOmri @prlnet where can we get the full talk?

Right. Pearlified inference indeed does slightly more FLOPs, but every GPU cycle also produces a second output: $PRL. So the effective cost is: inference cost + Pearl overhead − value of mined $PRL Assuming $PRL is liquid, that value translates directly into “cashback.” But the deeper way to think about it is as compute futures / *AI-native money*: the token is backed by the same scarce commodity AI companies need — verifiable compute. As enterprise adoption and network hashrate grow, that parallel revenue can more than offset the overhead, making Pearl-enabled inference cheaper net of rewards than vanilla inference. Price model (based on Jevons analysis) can be found here: arxiv.org/abs/2606.06700

@prlnet Can you explain how it becomes the world’s most economical inference? As I understand it, you’re doing existing inference with this additional (minimal) overhead to coordinate the PoW, so wouldn’t it be marginally less economical than inference without this overhead?

Pearl’s math breakthrough is that Proof-of-Work can now run on top of arbitrary matrix multiplication AxB, with vanishing o(1) overhead. The key difference: the miner choose (A,B). This “2-for-1” technology means the hundreds of billions - soon trillions - of $$ in AI compute can secure Pearl’s PoW chain, effectively for free. The result? the world’s most economical inference. arxiv.org/abs/2504.09971

In the unit-distance problem (as well as AlphaTensor’s 2022 improvement over Strassen’s matrix multiplication tensor), the “search space” of solutions may be infinite, but is relatively well defined (points in 2D plane, 5x5 tensors, etc). Reasoning over a search space where solutions are themselves an algorithm/mathematical inequalities, seems much harder to “navigate”, because it’s more abstract (formally, an uncountable set). So finding logical “shortcuts” here would seem to require a higher level of “intelligence” / level of abstraction. This is by no means to belittle GPT5.5’s Erdos breakthrough — but the most impressive aspect of the proof IMHO was the *analysis* of the counterexample it found to the grid: Analyzing the configuration’s pairwise distances relies on unexpected sophisticated ideas from algebraic number theory, which shows the level of abstraction LLMs are capable of. The harness described below proves yet again the power of Test Time Compute, over training stronger base models.

@WeinsteinOmri @OpenAI Why didn't the Erdős breakthrough change your mind?

Even @OpenAI's recent Erdős breakthrough didn't convince me that LLMs can do general math research. This changed my mind.. Using a clever 'prover-verifier' LLM loop, this harness solved 9 substantial open problems in Theoretical CS, including one that kept me up at night for 2 years. Incredible work by my former Columbia collaborator @binghuip, @runzhou_tao, Steven Wang & @HantaoYu_Theory. The plan is to expand this to ALL fields of science. Stay tuned.

The Hadamard Transform underpins many SoTA LLM quantization algorithms such as @Google's TurboQuant, QuIP#, QuaRot, SpinQuant, and NestQuant. LLM quantization works best when a vector’s coordinates have similar magnitudes. If most of a vector’s mass sits in one coordinate, e.g. x = (0,0,0,1,0,0,0,0,0,0), then the quantizer faces a bad tradeoff: use a wide range and waste resolution, or use a tighter range and “clip” the outlier, which may result in significant accuracy loss of the LLM. This is the basic motivation behind random orthogonal rotations: Multiplying x by a Gaussian rotation matrix R spreads x’s mass uniformly over coordinates, while preserving inner-products: ‖Rx‖₂ = ‖x‖₂, ⟨Rw, Rx⟩ = ⟨w, x⟩. The problem with random rotation, of course, is computational cost: a dense d × d rotation costs O(d²) per vector, so cubic time for W*X. In 2006, a beautiful and influential paper by Ailon and Chazelle, proposed a faster “pseudo-random” rotation op via the randomized Hadamard transform H′ = (1/√d)HD, where H is a Hadamard matrix and D is a diagonal random sign matrix. It turns out that H’ has essentially the same effect as a fully random rotation, in the sense that it “evenly spreads the mass” of any unit vector. This is essentially the uncertainty principle of the Fourier transform (!) The upshot is that H’x and H’w can now be computed in O(d log d) time instead of O(d²), due to the recursive (FFT) structure of H. In this blog, @prlnet's 17-year old researcher @sag0li explains how how we used Agentic toos to efficiently implement a block-Hadamard kernel in CuteDSL, which allows for very fine-grained control over memory and cache management -- this is the path to ultra-fast inference!

Not bad for a 17-year old :)

The MoE hard fork is now live. Update now! This upgrade marks the next phase of the Pearl network. With this hard fork, Pearl transitions to v2 certificates based on Mixture-of-Experts (MoE) workloads, enabling the network to more accurately verify and reward useful AI computation performed by participants. ⚠️ All node operators and ecosystem participants must upgrade to the latest versions to remain on the canonical chain. Soon, new blocks will start using the v2 (MoE) certificates. Nodes that have not upgraded will continue following the previous ruleset and will no longer be compatible with the upgraded network. Please update to the following versions: • pearld node → v1.1.0 • Desktop Wallet → v2.0.0 Wallet download (macOS is now supported): github.com/pearl-research…

A common critique on Proof-of-Useful-Work is that the zero marginal cost of mining drives the network’s security budget and price to zero. A paper just released by Rafael Pass, a renowned cryptographer at @Cornell /@TechnionLive and research scientist at Pearl Research Labs proves why this argument is flawed. By analyzing the equilibrium dynamics of PoUW, it shows not only that Pearl’s security budget (and hence price) are at least as high as Bitcoin, but in fact that Pearl will increase the SIZE of the global AI inference market, via Jevons Paradox. arxiv.org/abs/2606.06700 @initc3org

Mining costs crossing OTC prices proves real, large-scale inference workloads are running on Pearl. For miners running useful work on Pearl’s 2-for-1 kernels, the marginal cost of producing ¶PRL is ~0. This partly explains why hashrate keeps climbing -- The only long-term path to profitability on @prlnet is doing useful MatMuls!

@WeinsteinOmri @komargodski any takes?

$PRL mining costs are approaching the point where even with cheap consumer GPU access (way lower than neocloud providers) you are close to break even. Many have been asking me how this is feasible or if the team is running their own modified kernels and gaming the network. Here is my take: Currently there are three scenarios. 1) Miners are either speculating on higher prices, therefore mining at a loss, 2) already have useful work and are running Pearl as a byproduct, or 3) have access to amortized GPUs and subsidized electricity (shout out CCP). Safe to say that currently most of the miners in the network fall into either category 3) or 1). There is a flaw in the protocol and it has something to do with the high hash rates. Currently the network is at around 30 EH/s, where an H100 SXM does a maximum of 700–800 TH/s and a 3090 around 110 TH/s on the most optimized kernels. If the entire network were mining with H100s, that would equal ~43,000 cards or around $2.3 million in daily costs ($2.25 per hour at neocloud prices). With a network issuance of $750k per day, and looking at sell pressure through SafeTrade or OTC, it's safe to say that this is not the case. So where does the mining hashrate come from? My guess is that large mining farms - likely ex-ETH mining era - are using their already amortized hardware (RTX 30/40 series) from 2020/2021. If you calculate the hashrate in 3090 equivalents, you get ~285,000 cards. This is a far more plausible figure which, combined with cheap electricity, would explain both the hashrate and the relatively low sell pressure. Running consumer cards is far cheaper than ASICs for BTC mining and much cheaper than datacenter cards that are in high demand from AI operators. With rising competition and hashrate, $PRL will ultimately converge to a point where most miners have to shut down their operations. The network is in a very early stage - around one month old - and has acquired a lot of capital for the team to build, not through dumping tokens but rather through the mining packages. It is in a transition to a new phase of $PRL that drives broader distribution. Really interested in how this will play out, especially with the support of Blackwell kernels in the coming months, the upcoming partnerships and how the team reacts. Tagging some chads: @0xRugova @ZanaVentures @0xkioto @evan_van_ness

Will Fast Matrix Multiplication ever be practical? Strassen’s 1986 discovery of fast matrix multiplication (FMM) – asserting that the product of two 𝑛×𝑛 matrices can be computed in sub-cubic time 𝑛^𝜔 ∼ 𝑛²·⁸⁷ ≪ 𝑛³ – had a profound impact on theoretical computer science and algorithm design. Since then, mathematicians improved on Strassen’s algorithm, and some experts believe that, eventually, it will be shown that 𝜔 ≈ 2, which would mean that the time to compute AxB is essentially the time it takes to merely read the inputs: ~O(𝑛²) (!) Needless to say, such result would have a major impact on the AI compute age we’re entering… Unfortunately, FMM algorithms only work for enormous matrices--on the order of the number of atoms in the universe (“galactic algorithms" [1])--and it is currently hard to imagine them being practical on any imaginable hardware. Besides their asymptotic runtime, a core practical issue with FMM algorithms is that they all inherently rely on recursive divide-and-conquer, which creates memory and IO-bottlenecks, and is numerically unstable; This is likely the reason why the largest hardware manufacturers in the world are not developing chips for FMM. Even Strassen’s original algorithm, which gives nontrivial FLOP speedup for relatively small matrices, struggles to beat the sheer parallelism of naiive MatMul on GPUs or TPUs. Some interesting progress on practical FMM seems underway [2] and would be interesting to follow, but it remains to be seen whether divide-and-conquer can be implemented in both silicon and memory to deliver wall-clock speedups for realistic dimensions of matrices in LLMs. What is means for @prlnet. That’s the reason we designed the Pearl proof-of-work protocol (cuPOW) with the underlying baseline being “naiive” matrix multiplication O(𝑛³), which is what NVIDIA, AMD, Cerebras and all other AI hardware accelerators implement today. Nevertheless, it is important to stress that Pearl’s protocol doesn't rely on naiive MatMul remaining SoTA -- if FMM becomes practical some day, Pearl's protocol can easily adapt to the 𝑛^𝜔 baseline (since the next version of cuPoW will only verify the output AB). In fact, one of the intriguing aspect of @prlnet is that it creates incentives (for both humans and machines) to develop faster MatMul algorithms and hardware (as had happened in Bitcoin with SHA256). Of course, without proper modification, such breakthrough would break the security assumption of Pearl-GEMM, so such algorithmic breakthrough would better be public. FMM and FFT. Our recent paper [3] shows that it is possible to achieve fast matrix multiplication without using Strassen-like divide-and-conquer, using only the Fast Fourier Transform, which is omnipresent in countless industry-scale applications. This paper presents a simple algorithm running in 𝑂(𝑛²·⁸⁹) time, which only sums a few convolutions in 𝕫ₖᵐ, using FFT (see figure below for illustration of the algorithm). Despite being highly parallel (no recursion), this FFT algorithm for MatMul remains asymptotic, as it still requires many parallel repetitions on submatrices in order to obtain noticeable speedup over naiive MatMul (𝑛³). Whether FFT can lead to subcubic time MatMul for reasonably-sized matrices is a fascinating question! I believe FFTs are the most promising tool in this direction... [1] Lipton, Richard J., and Kenneth W. Regan. “David Johnson: Galactic Algorithms.” In People, Problems, and Proofs, 109–112. Springer, 2013. doi.org/10.1007/978-3-…. [2] Karstadt, Elaye, and Oded Schwartz. “Matrix Multiplication, a Little Faster.” Journal of the ACM 67, no. 1 (2020): 1:1–1:31. doi.org/10.1145/3364504. [3] Uffenheimer, Yahel, and Omri Weinstein. “Improved Sparse Recovery for Approximate Matrix Multiplication.” arXiv:2602.04386, 2026..

~90% of AI’s energy is devoted to one core, expensive operation: matrix multiplication. This partly explains why so much research and engineering on LLM inference targets reducing the IO and complexity of MatMuls: O(n³) FLOPs to process only O(n²) data. When n = 30K, the gap is enormous... A question I find fascinating is whether there exist alternative bilinear operators f(W, X) for “mixing” LLM tokens, that are as “expressive” as MatMul for human-related tasks, but require ≪ n³ FLOPs (and ideally O(n²) IOs) to evaluate. There have been significant attempts in this direction, starting with Google’s FNet, and continuing with a long line of work on other bilinear operators: tensor algebras, Hadamard products, fast polynomial multiplication / convolutions, Butterfly matrices and other structured operators. These approaches demonstrated promising results on some benchmarks, but when scaled to SoTA LLMs, they all seem to suffer from substantial accuracy degradation. Is there something “holy” about MatMul in deep learning after all? What seems to distinguish MatMul from many other bilinear forms is that it encodes arbitrary change of basis. This is a qualitative property: A fundamental reason why ML algorithms work is the premise that real-world datasets have underlying structure – a basis/representation in which the data becomes sparse, invariant, clustered, low-dimensional, etc. For example, changing to Fourier bases such as the DFT reveals frequencies. The DCT compresses images. Wavelets localize scale. Learned projections encode invariant subspaces, task-relevant metrics, and directions of variation. Attention scores depend on the learned embedding of LLM tokens, which are a choice of basis. Oversimplifying, learning can be viewed as the optimization problem of finding the “right” basis to represent the data. MatMuls are the computational primitive that switches between these bases, i.e. linear projections. By contrast, other bilinear operators such as elementwise multiplication, or convolution / polynomial multiplication p·q, do not obviously have this same functional interpretation. They impose structure, but they do not represent an arbitrary change of coordinates. This observation may help clarify what properties would need to be preserved if we are ever to find cheaper bilinear alternatives to MatMuls in deep learning. I still find the above question intriguing, both in theory and practice…