@Cotabe_M@Giveth@thedaofund I can't thank the team @ETHCincoDeMayo enough for their hospitality at such a high quality event. 🙏🙏🙏 It was a true pleasure to share our work on PQ Transactions inside Ethereum!
My slides are available here:
We’re in the final stretch to mainnet 🦋
Accounts, swaps, points, compute subnets, and QVM are live on testnet, and coming together in one app.
One step left: an external chain audit.
Thanks to everyone who’s been a part of this.
Full update ↓
https://t.co/rpwOItM0ws
@quipnetwork@cadillion@rcarback@cyphertalkmedia if those coins move nobody can tell which one it is...
satoshi's coins sit in P2PK outputs...i called this a second mining gold rush back in 2024, I think Satoshi did this on purpose.
https://t.co/YQfg8sIO9h
Big news! Today we are launching Mixie!
Send private invoices, auto convert, streamline
Offramp to Revolut, Wise, Venmo etc without KYC or login.
60+ tokens
9 fiat pairs available
14 languages supported
Available as a telegram and Signal bot!
Use Today!👇👇👇
It is a weird weird year to be a formal methods expert.
Some unorganized thoughts on the new @AnthropicAI and @theoremlabs post on formal verification (https://t.co/YoymKXYFJa):
- This is very cool.
- The main innovation is verifying a later stage of the program. Normally provers take the source code, LLM it into a theorem language, and then prove that, which means you have to make assumptions about source semantics and compilation properties. It's very easy to make a mistake in translating and prove the wrong thing!
What they instead do is compile the code into assembly, and then (if I understand this correctly), compile that assembly into a theorem language (which they call LPS). So as long as the compiler is faithful you can skip the whole divergence problem.
- I'm glad they clarify that you still have to trust the translation process, the "hardware, OS, OCaml" compiler, the LPS model, and also assume that the program is single threaded with fixed memory. The single biggest source of errors in formally verified code is when the proof assumes something that isn't true in practice. It's really, really important to state your assumptions!
- I'm not clear why they need to compile the fuzzer into the theorem. Is it to act as a description of valid inputs and workload? Maybe to embed assertions in as theorems?
- Holy crap, 180 million lines of Rocq. Is that more Rocq than exists in the world already? I notice they say a 600,000 line proof corresponds to roughly 20k CPU instructions. That would be like, 1-2k lines of source code at most? Really goes to show how inefficient this approach is and how it only works because you can throw LLMs at the problem.
- This, probably deliberately, doesn't address the single biggest gap in AI-based verification: AIs cannot come up with good properties. Doesn't matter if you're doing unit testing, property testing, formal verification. I always assumed this was a "frontier labs haven't trained for it yet" thing, but if Anthropic hasn't talked about that here, maybe they've tried and haven't been successful yet. That's interesting to me.
Instead, they take a known universal property (this code doesn't crash or get flagged by UBsan) and prove that instead. Still very useful, but makes it harder to generalize to proving arbitrary things about arbitrary programs.
- Anybody reading the official post should also read their expert review appendix (https://t.co/qQU0E0nJwW). It points out some interesting things, like the fact that most of the code the LLM wrote wasn't used in the proof (over one billion lines of Rocq), that they had to prove the equivalence between fuzzed and unfuzzed programs, and (this is most interesting), some experiments find that the LLM-method of proofwriting may not scale to more complex things.
- Also read the description of LPS (https://t.co/hRTCL05X0H) to understand the limitations of the assembly -> Rocq compilation. In particular, it does not handle concurrency at all (which is one of the main use cases for formal methods!) or OS signals. Also it can't prove things about program arguments with slash characters, meaning they can prove stuff about `rm foo` but not `rm foo/bar`.
- The official skill (https://t.co/weDOdmJUfO) doesn't tell us much about the nature of FM and AI. Probably too much for me to hope of any skill.
- Some of the article's specific caveats and throat clearings make me think someone at Anthropic reads my stuff ( ͡° ͜ʖ ͡°)
She did it! In 2min @rheastatic came by the https://t.co/aTH8vSIQeN booth, downloaded the @zodl_app@Zcash wallet, and got herself set up to receive $ZEC. 💪🏻
That's the first step towards becoming immune from debanking, an issue affecting 63% of her colleagues! 😬
#ExxxoticaNJ
What a horrible take… the local government is telling them to block orgs globally they have no association with and you think they are the problem?
Complying affects all users and orders like this break dns and core pillars of internet infrastructure🤦
Go after the source or cut it at the isp layer, not the worlds phone books.
i’m sorry that your warrantless surveillance regime was built on the assumption that people would never discover every single backdoor you put into their applications
What is infuriating is that this is not the first time they have dealt with such issues, and it is such a loss to the people affected.
The government here is deciding that a road needs to be closed because they don't like one of the shops on the street. Madness!
@TechloreInc@Quad9DNS What is infuriating is that this is not the first time they have dealt with such issues, and it is such a loss to the people affected.
The government here is deciding that a road needs to be closed because they don't like one of the shops on the street. Madness!
🎙️ New CypherTalk: @cadillion and @ourcarback of @quipnetwork join us to talk quantum.
How much of the quantum threat is hype, and how much is real? Find out in this episode as we discuss the reality, threats, and opportunities.
🎧 https://t.co/PD10rpulAt
SHA-256 is not broken, but its security margin lost 1 more round this year:
Last week I found a collision attack on reduced 39-round that improves prior art by over 30 bits and the first differential attack on that round better than generic search on @yukonresearch Hashsmash board.
The attack rests on the same method as prior art ePrint 2026/1120 with new insights that first 2 state words could remain free, allowing a critical condition at step 16 rebuilt as a claw-search problem rather than a probabilistic filter. Took days of watching SAT logs, burning cores and arguing with Claude on what's possible to get a result close to generic search.
Since my initial submission, other hashsmash participants sraiw, @cyberaxe, @privacymage, @lamb356_ and @geeknik pushed it down by over 6.5 bits, currently estimated at 118.15 bits. The tree of submissions is hard to follow, so I put the construction, insights and numbers into a blog and am working on detailed technical report.
It's fascinating to see an initial structural observation develop into an improvement in the reduced-round collision frontier within days. AI is now a real aid in cryptanalysis and open collaboration speeds it up.
The private key is crypto's original sin.
It's gotten so bad that I default recommend CEXs to people instead of self-custody.
What is the easiest onboarding for new users into a safe non-custodial solution, where if they get phished they don't lose everything?