sivat.eth

@cronokirby one for zkp😅

At this rate, it’s very likely AI will win the Fields Medal and the Nobel Prize 😅

Jeff Bezos on AI job doomers: "These people ARE WRONG. What's really going to happen [AI] is going to elevate all these [jobs] people" "Someone is about to hand you a bulldozer (versus shovel to dig)" "We're going to have so much productivity in our economy" "I predict we're going to have deflation in certain [things due to producivity gains. food cheaper, housing construcrtion cheaper]"

(5/8) This leaves us with a mix of excitement and humility. 1. AI is especially good at connecting distant fields of research. Here it finds bridge between algebraic number theory and discrete geometry. We hope to see more bridges built by AI connecting different fields.

AI has now solved a major open problem -- one of the best known Erdos problems called the unit distance problem, one of Erdos's favourite questions and one that many mathematicians had tried. openai.com/index/model-di…

Bolt - very fast for realistically large statements, proofs are not too big, a bunch of interesting open problems Tradeoffs which I believe are fitting for an era where proofs become important everywhere With @AndrijaNovakov6 and @ronrothblum 😀

One of our distinguished @CEGguindy ECE department alumni from the 1986 batch. And an inspiration to many!

Like Brakedown’s speed but not the large proofs? Turns out you can get the best of both worlds! New work with the incredible @AndrijaNovakov6 and @kobigurk

Excited to share Bolt, a new multilinear polynomial commitment scheme (MLPCS) with @kobigurk and @ronrothblum ia.cr/2026/310. To appear at Crypto 2026.

I believe that, in the near future, AI will give us safer, more reliable digital systems using formal verification. Today we must ask: What does FV actually give us, in practice? My latest blog post investigates this question using SP1 Hypercube as a case study within the zkVM landscape. zkevm.ethereum.foundation/blog/sp1-fv Here’s the story👇

“Uber thoughts” are those shower thoughts that don’t occur at home! 🚘🤔💭💡

The best languages (from personal experience) for those who aim mastery: - FP (scheme / lisp) - statistics (R)

It’s only a matter of time before compute / GPU-hrs enter the commodity market? 🤔

FAFO is how you make the most out of LLMs. That’s the real meta (or alpha). No one knows what’s happening under the hood (probably, except the interpretability teams). It’s uncharted territory, ensure every experiment focuses on maximum learning and leverage.

Ethereum is about to fundamentally change how blocks are executed. With the upcoming Glamsterdam hardfork, it's shipping EIP-7928: Block-level Access Lists, a proposal that brings parallelization to the EVM. Here's a short explainer of what it is, how it works, and why it's a big deal for scaling. Let's start from the top. Alongside EIP-7732 (ePBS), EIP-7928 is the execution-layer (EL) headliner for Glamsterdam. Like ePBS, the main focus has been scaling Ethereum, though both proposals come with a bunch of other, equally important properties on the side e.g. removing trust requirements from the PBS pipeline or improving sync. EIP-7928 adds a Block Access List (BAL) to every Ethereum block. A BAL is a list of accounts and storage slots that the block touches, but that's not all: it also contains post-transaction state diffs (this part is critical!). Post-transaction state diffs tell you what the state looks like after each transaction. Quick example: user A swaps 1 ETH for DAI on DEX B. The BAL tells you that user A's ETH balance decreased by 1 ETH + tx fees and their nonce went up by 1; that DEX B's ETH balance went up by 1 ETH; and that inside the DAI contract, user A's DAI balance increased while DEX B's decreased. In other words, all of that info becomes statically available, something that previously required tracing the transaction. Client software (Geth, Nethermind, Besu, Erigon, Reth, Ethrex, Nimbus) can use this to do a few very powerful things: 1. Parallelize transaction execution. Knowing the post-state of each tx resolves the dependencies between them. No transaction has to wait on the previous one anymore, so execution can be perfectly parallelized. Instead of large parts of block validation sitting idle waiting on sequential execution, clients can finally make much better use of modern hardware. 2. Batch prefetch. One of the most cumbersome jobs for a node has been fetching the state needed for execution from disk. Because state locations (e.g. the exact storage slot in the DAI contract where user A's balance lives) are only discovered along the way, while executing, state-fetching has been a real drag on scaling: it blocks execution, takes time, and eventually slows everything down. With BALs, everything a node needs for execution is known upfront and can be loaded into cache in one go, in parallel. This speeds things up even further. 3. Parallelize post-state root calculation. Another expensive task is walking the updated state tree to compute the post-state root, which is needed so that everyone agrees on what's on disk after executing the block. With the post-tx state already in the BAL, nodes can do this in parallel while executing. A heavy task that used to wait until all transactions had finished can now run alongside prefetching and execution. 4. Snap sync (v2). An often overlooked, less sexy aspect of blockchains is syncing. Nodes need to catch up with the chain, and they need to catch up faster than the chain progresses. Today, most nodes do snap sync: downloading blocks, headers, and state in parallel while chasing the tip, and then "healing" the database once they're close to the head. Healing means asking peers for trie nodes, receiving them, validating them, and updating the local DB. It's iterative, networking-heavy, can take a while, and especially higher throughput pushes that phase to its limits. BALs help here too: with snap v2, nodes can catch up to the tip and skip the healing phase entirely. Syncing at higher throughput becomes more robust and reliable. So, to summarize, a BAL contains two things: -> The state locations the block accesses -> The state changes after each tx (incl. the new values) We're already seeing big performance gains today: on 6-core machines, EL clients validate blocks up to 5x faster, making block gas limits of 300M a very realistic outcome. ePBS will add to that by decoupling the block from the payload, giving validators 2-4x more time for execution. To not overshoot (security stays priority #1), the fork will likely ship with a 200M gas limit, but we shouldn't be stuck there for long before pushing to 300M and beyond. That's a 10x in scaling since we started taking the topic seriously, without touching hardware requirements. None of this would have happened without people going all-in, heads down, shipping: so many hours spent in calls debating the right design, so many iterations refining the specs, and tons of test cases written (and still being worked on). The road from whiteboard to production-ready code has been a journey, and we're not at the finish line yet, but from what I can tell, things look super bullish for Ethereum. Glamsterdam will be a fork that shows what's possible when a distributed, decentralized community works on a shared goal, laser-focused on providing enough block space to onboard the next wave of users.

VS code/Cursor extensions are a supply chain attack waiting to happen, and have many times... They all contain a crazy amount of node/JS junk, they're often owned by randos, they silently update, nobody looks at them and the security model is shit. Use restricted marketplaces.

Our work “Nebula: Proving machine executions via folding schemes” won the Distinguished Paper Award at @IEEESSP! Key innovations are: (1) devising efficient read-write memory checking in the folding setting, and (2) pay-per-use switchboard circuits. A quick overview of the work

Opsec 101 - avoid third party extensions on vs code, obsidian etc. - avoid third party plugins, skills on your harnesses Any additional layer of complexity increases the attack surface Use open sourced, well-vetted, battle tested tools only.

🤯

It is a shame that the simple act of transferring a large block of data as fast as possible over the internet is not handled effectively by the primitive operating system calls. You either multiplex over parallel persistent TCP connections to combat head-of-line blocking and slow starts, or reinvent reliable delivery and flow control over UDP. QUIC has a lot going for it, but it is a large library (six figure LoC!) and conflates security and performance in a way I don’t love. There is also fundamental information about competition with other processes and link layer congestion that should be useful, but is unavailable to user libraries. You should be able to just write(really_big_buffer) and it is all taken care of for you.

Domain specific harnesses + formal verification layer (built-in) is the way forward! - harnesses are the future of software - FV is the future of harnesses