🚨 PhD Position in Formal Methods for Concurrent Cryptographic Protocols at Vrije Universiteit Amsterdam, Netherlands 🇳🇱 Research on cryptography, concurrency & formal verification. Apply by 30 Oct 2026. #PhD #Crypto #FormalMethods #ComputerScience workingat.vu.nl/vacancies/ph…

🎓 PhD Positions in Computer Science (Formal Methods) 🇩🇰 | University of Southern Denmark 📌 Position: PhD in Computer Science (Formal Methods) 🏫 University: University of Southern Denmark (SDU) 📍 Location: Odense / Vejle, Denmark 🇩🇰 🏢 Department: Mathematics & Computer Science 👨‍🏫 Supervisor: Fabrizio Montesi 📅 Deadline: August 16, 2026 ⏳ Duration: 3 years (fully funded) 🔬 About the Project The Centre for Formal Methods and Future Computing (FORM) invites applications for PhD positions focused on advancing the formalisation of computing. The research aims to combine human intelligence and AI to build reliable digital systems grounded in rigorous mathematical foundations. Key research areas include: • Computational complexity • Distributed systems & cloud computing • Logic and theorem proving • Programming languages & type systems • Security, cryptography & privacy • Human factors in computing A major initiative includes contributing to the Computer Science Library (CSLib) using Lean, a global effort to formalise computer science knowledge. 👤 Ideal Candidate • Master’s degree in Computer Science or related field • Strong interest in formal methods (theory or applications) • Solid analytical and programming skills • Ability to work in an international research environment • Fluency in English 🌟 Why Apply? • Join a leading research centre in formal methods and AI • Work on foundational challenges in computing and software reliability • Collaborate within a strong interdisciplinary research cluster (AI, cybersecurity, programming languages) • Access to international collaborations and global initiatives • Supportive and inclusive academic environment 🌍 Location Highlight – Odense Odense, Denmark’s third-largest city, offers a high quality of life with a mix of historic charm and modern living. Located on the island of Funen, it provides easy access to Copenhagen and Aarhus, along with beautiful coastal areas. 🔗 More Info: phdscanner.com/opportunities… #PhD #ComputerScience #FormalMethods #ProgrammingLanguages #DistributedSystems #Cybersecurity #Denmark #ResearchOpportunity #AcademicJobs #PhDPositions

“it compiled successfully.” The future won’t belong to the fastest teams. It will belong to the ones who can prove they are right. ~ Umanga Buddhini #FormalMethods #SoftwareVerification #TLAPlus #SPIN #NuSMV #Dafny #Coq #Isabelle #SonarQube #QualityEngineering

TheoremBench moves theorem proving beyond contest-style puzzles. Formal AI needs benchmarks where correctness is strict, but the path is not spoon-fed. Source: arxiv.org/abs/2606.09450 #FormalMethods #AIResearch #LLMs

#SoftwareReliability #SoftwarePerformance #CodeAnalysis #StaticAnalysis #DynamicAnalysis #ProgramVerification #ModelDrivenEngineering #FormalMethods #ProgrammingLanguages #ObjectOrientedDesign #MicroservicesArchitecture #DistributedSystems #CloudComputing #EdgeComputing

Lean4Agent brings formal modelling and verification into agent workflows. That is where the agent debate needs to go: less charm, more proof that the steps actually hold together. Source: arxiv.org/abs/2606.06523 #AIAgents #FormalMethods

#ProgrammingLanguages #ProgrammingLanguageTheory #CompilerDesign #CompilerOptimization #Interpreters #StaticAnalysis #DynamicAnalysis #TypeSystems #FormalVerification #FormalMethods #ProgramAnalysis #ProgramSynthesis #SoftwareDevelopment #SoftwareEngineering

AI co-mathematicians will not be built by making one prover cleverer. They will be built by making long proofs survive time. A new paper by Yuanhe Zhang, Yuekai Sun, Taiji Suzuki, Jason D. Lee, and Fanghui Liu introduces LeanMarathon: LeanMarathon: Toward Reliable AI Co-Mathematicians through Long-Horizon Lean Autoformalization The problem is not just proving a hard lemma. It is preserving mathematical fidelity across an entire research development. At paper scale, AI formalization fails in very different ways: statements drift dependencies tangle context decays local fixes corrupt distant proofs a formally correct lemma can become mathematically irrelevant That is the real bottleneck: agent durability. LeanMarathon treats research-level formalization less like a single proof attempt and more like a software-engineering system for mathematical truth. Its core abstraction is an evolving blueprint: one Lean file that acts simultaneously as: formal proof skeleton natural-language proof graph dependency DAG shared system of record Four contract-scoped agents operate on this blueprint: Blueprinter — builds the initial Lean skeleton Target Reviewer — audits fidelity to the intended theorem Worker — proves local nodes Refiner — repairs multi-node defects A two-stage orchestrator first stabilizes the target statements through adversarial review, then discharges the proof DAG from dynamic leaves upward in parallel, CI-gated rounds. That is the key design move: do not trust one monolithic agent to remember everything. Constrain scope. Externalize state. Use deterministic verification. Let CI be the merge authority. Make failures local, recoverable, and non-contagious. In Lean, “sorry” is the placeholder that lets an unfinished proof pass. LeanMarathon reports formalizing all seven target theorems across two recent research papers spanning four Erdős problems, with no sorry, proving 258 lemmas and theorems across three autonomous runs. That is not just proof search. That is long-horizon proof engineering. And it points to a broader lesson for AI agents: reliability at scale is a harness problem. The future of AI mathematics will not only require stronger provers. It will require durable systems that preserve intent, dependencies, and verification across long chains of reasoning. Full credit to the authors: Yuanhe Zhang, Yuekai Sun, Taiji Suzuki, Jason D. Lee, Fanghui Liu. Paper: LeanMarathon: Toward Reliable AI Co-Mathematicians through Long-Horizon Lean Autoformalization arxiv.org/abs/2606.05400 Code: github.com/YuanheZ/LeanMarat… I’m attaching the first page because the abstract is worth reading closely. The next frontier is not AI that writes plausible proofs. It is AI whose mathematical work can survive the marathon. #AIResearch #Mathematics #Lean #FormalMethods #ArtificialIntelligence

@alexabelonix @3n0cH_31415Pi @BlackRoseOfTHC 🚀 Completed the entire v166.x QLDPC / Hashing-Bound Code Receipts arc in QSOLKCB/QEC. What started as "build a faster decoder" became: ✅ Canonical decoder baseline receipts ✅ Candidate manifests ✅ Replay equivalence proofs ✅ Optimization contracts ✅ Fast-path equivalence receipts ✅ Implementation boundaries ✅ Benchmark ladders ✅ Rollback receipts ✅ Promotion governance Core rule: A decoder is not accepted because it is faster. A decoder is accepted only if deterministic replay equivalence is proven against the canonical baseline. The sacred decoder is the oracle. The candidate decoder is the hypothesis. v166.8 closes the arc with a hash-bound promotion receipt that requires: Replay Equivalence → Benchmark Ladder → Rollback Readiness → Promotion Governance No silent decoder swaps. No probabilistic authority. No benchmark marketing. No "trust me bro." Just receipts all the way down. 🔗 github.com/QSOLKCB/QEC/relea… #QuantumComputing #QEC #QLDPC #SoftwareArchitecture #DeterministicComputing #Python #OpenSource #Cryptography #FormalMethods #QuantumErrorCorrection

The ZK hardware race is obsessed with accelerating Multi-Scalar Multiplications (MSM) using FPGAs and ASICs. Everyone implements Pippenger's algorithm to parallelize the bucket accumulations. But here is the semantic blind spot, if your hardware parallelization lacks formal equivalence to the sequential algebraic specification, race conditions in the accumulator won't just crash the prover, they will silently generate mathematically valid-looking proofs for corrupted witnesses. You can't patch a hardware side-channel with a smart contract upgrade. If your silicon isn't formally verified, your trust boundary is leaking at the logic gate level. #ZKHardware #FormalMethods

Mathematics may be entering a new regime: not AI you believe, AI you verify. A major Google DeepMind paper presents AlphaProof Nexus, a framework for AI-driven formal proof search in Lean. The point is not that an LLM can write convincing mathematical prose. That has always been the weak version of the story. The point is that the system must produce proof code that survives a formal verifier. LLMs generate. Lean checks. Search continues. Only machine-verified proofs remain. That changes the epistemic contract. In informal mathematics, an AI-generated proof can look elegant while hiding a fatal gap. In Lean, every step must compile. No rhetoric. No handwaving. No “seems plausible.” The authors report the first large-scale evaluation of this approach on open research-level problems. Their most capable agent autonomously resolved 9 of 353 open Erdős problems, including two questions open for 56 years, at a per-problem inference cost of a few hundred dollars. It also proved 44 of 492 OEIS conjectures and is being deployed in combinatorics, optimization, graph theory, algebraic geometry, and quantum optics. The architecture is fascinating. A mathematician provides a Lean formalization. The agent refines proof sketches. LLM subagents propose lemmas, decompositions, constructions, and edits. Lean rejects invalid steps. AlphaProof can be called as a focused prover. An evolutionary population of proof sketches is ranked and reused. The final output is a sorry-free Lean proof. This is not “chatbot solves math.” It is closer to a new research instrument: a search engine over formal proof space, guided by generative models, grounded by a compiler, and audited by mathematics itself. The deeper lesson is general: AI systems become far more powerful when unreliable generation is wrapped in reliable verification. For mathematics, the verifier is Lean. For other domains, the frontier question becomes: what is the equivalent of a compiler for truth? Full credit to the authors: George Tsoukalas, Anton Kovsharov, Sergey Shirobokov, Anja Surina, Moritz Firsching, Gergely Bérczi, Francisco J. R. Ruiz, Arun Suggala, Adam Zsolt Wagner, Eric Wieser, Lei Yu, Aja Huang, Miklós Z. Horváth, Andrew Ferrauiolo, Henryk Michalewski, Codrut Grosu, Thomas Hubert, Matej Balog, Pushmeet Kohli, Swarat Chaudhuri. Paper: Advancing Mathematics Research with AI-Driven Formal Proof Search arxiv.org/abs/2605.22763 I’m attaching the first page because the abstract is worth reading closely. The future of AI in mathematics may not be models we trust. It may be agents whose work can be checked. #AIResearch #Mathematics #FormalMethods #ArtificialIntelligence

Mathematics may be entering a new regime: not AI you believe, AI you verify. A major Google DeepMind paper presents AlphaProof Nexus, a framework for AI-driven formal proof search in Lean. The point is not that an LLM can write convincing mathematical prose. That has always been the weak version of the story. The point is that the system must produce proof code that survives a formal verifier. LLMs generate. Lean checks. Search continues. Only machine-verified proofs remain. That changes the epistemic contract. In informal mathematics, an AI-generated proof can look elegant while hiding a fatal gap. In Lean, every step must compile. No rhetoric. No handwaving. No “seems plausible.” The authors report the first large-scale evaluation of this approach on open research-level problems. Their most capable agent autonomously resolved 9 of 353 open Erdős problems, including two questions open for 56 years, at a per-problem inference cost of a few hundred dollars. It also proved 44 of 492 OEIS conjectures and is being deployed in combinatorics, optimization, graph theory, algebraic geometry, and quantum optics. The architecture is fascinating. A mathematician provides a Lean formalization. The agent refines proof sketches. LLM subagents propose lemmas, decompositions, constructions, and edits. Lean rejects invalid steps. AlphaProof can be called as a focused prover. An evolutionary population of proof sketches is ranked and reused. The final output is a sorry-free Lean proof. This is not “chatbot solves math.” It is closer to a new research instrument: a search engine over formal proof space, guided by generative models, grounded by a compiler, and audited by mathematics itself. The deeper lesson is general: AI systems become far more powerful when unreliable generation is wrapped in reliable verification. For mathematics, the verifier is Lean. For other domains, the frontier question becomes: what is the equivalent of a compiler for truth? Full credit to the authors: George Tsoukalas, Anton Kovsharov, Sergey Shirobokov, Anja Surina, Moritz Firsching, Gergely Bérczi, Francisco J. R. Ruiz, Arun Suggala, Adam Zsolt Wagner, Eric Wieser, Lei Yu, Aja Huang, Miklós Z. Horváth, Andrew Ferrauiolo, Henryk Michalewski, Codrut Grosu, Thomas Hubert, Matej Balog, Pushmeet Kohli, Swarat Chaudhuri. Paper: Advancing Mathematics Research with AI-Driven Formal Proof Search arxiv.org/abs/2605.22763 I’m attaching the first page because the abstract is worth reading closely. The future of AI in mathematics may not be models we trust. It may be agents whose work can be checked. #AIResearch #Mathematics #FormalMethods #Lean #ArtificialIntelligence

Monday 26 May, 15:30, at Chalmers Johanneberg: Dubhashi, Urban & Coquand on AI for Mathematics: from Math Olympiads to autoformalizing the deepest results in logic. Won't be there myself, but you might be! 🔗 chalmers.se/en/current/calen… #Mathematics #AI #FormalMethods

In Deep Dive 6 of my PQC Engineering Series, I wrote about why post-quantum readiness must start with semantic mapping of cryptographic assets, not just cryptographic inventory. The real question is not only: “Which algorithms do we use?” The better question is: “What must remain true when those algorithms can no longer be trusted?” That is where PQC engineering actually begins. #PostQuantum #PQC #Cryptography #Cybersecurity #CryptoAgility #SecurityEngineering #DistributedSystems #FormalMethods #ZeroTrust #IIoT #CriticalInfrastructure #QuantumSecurity open.substack.com/pub/maycko…

@alexabelonix @3n0cH_31415Pi @BlackRoseOfTHC I just went on a coding spree, 26 releases. Over the last few months I pushed QSOLKCB/QEC through some pretty wild deterministic-proof arcs. What started as a Layer-1 quantum error-correction decoder has evolved into a replay-safe proof architecture for: • research provenance • citation integrity • claim-scope enforcement • inference/tokenization/compression receipts • KV-cache & memory-boundary receipts • agent observability & tool-dispatch governance • crawler/pattern-decision boundaries • QPE / quantum-memory / geometry-signal claim boundaries Recent completed arcs: v165.5.x → dataframe / columnar backend receipts v165.6.x → AI-scientist & provenance receipts v165.7.x → inference / tokenization / compression receipts v165.8.x → agent observability receipts v165.9.x → source-bound quantum signal receipts Core philosophy: same input → same ordering → same canonical JSON → same SHA256 → same replay result No hidden tool calls. No silent provenance escalation. No “AI said so therefore truth.” No hardware authority claims without source-bound evidence. The receipt is the boundary. Repo: github.com/QSOLKCB/QEC ORCID: orcid.org/0009-0006-5966-124… #DeterministicComputing #QuantumComputing #AI #Python #Cryptography #FormalMethods #LLM #OpenSource

[New Blog Post] Reading Proof Objects and Completed Rewrite Systems from eprover into Knuckledragger philipzucker.com/proof_proce… #python #logic #automatedtheoremproving #formalmethods

The entire foundation of succinct proofs (SNARKs/STARKs) rests on the Schwartz-Zippel lemma. We trust that a non-zero polynomial of degree d evaluated at a random point r in a field {F} evaluates to zero with probability at most \frac{d}{|{F}|}. But engineers blindly implement this without formally verifying the field characteristic, if the adversarial prover forces a degree bound overflow, the probability of a false positive skyrockets. We are trusting our global state to algebraic geometry, but testing it like it's a standard web API. Correctness is a mathematical property, not a feeling. #FormalMethods #ZK

@leanprover Mathlib has just crossed 2 million lines of formalised mathematics. Massive! As a statistician, Lean plus Mathlib has become one of my go-to tools. Pair it with MathCode from math-ai.org and it turns into a proper powerhouse. Here are the three ways I use it every day: 1: Building my own stats papers and Python packages I formalise the core theorems, estimators, concentration inequalities, generalisation bounds and empirical process results straight in Lean and Mathlib before I write any Python. Gives me machine-verified specs right from the start. 2: Auditing existing manuscripts I feed paragraphs into MathCode to get candidate Lean statements out, then let the type checker do its thing. It catches the sneaky gaps human reviewers often miss: missing measurability conditions, unjustified swaps of limits or expectations, convergence mismatches and hidden assumptions. Like having an infinitely patient referee. 3: Turning prose into a formal calculus of claims This is the less obvious but most powerful use. It is not just “paste prose into MathCode and get Lean back”. The hard part is abstraction: identifying the objects, premises, quantifiers, dependencies, regularity conditions, claim type, and what would count as a witness or counterexample. For stats, causal inference, philosophy, quantum foundations or any rigorous argument, I first try to turn the prose into a claim route: what is assumed, what is added, what is conditional, what is being proved, and what the conclusion actually depends on. Then MathCode helps translate that structure into Lean declarations in Prop or dependent types, and Lean plus Mathlib forces the argument to become explicit. Did the prose move from “there exists” to “for all”? Did a conditional result get written as unconditional? Did a measurability condition disappear? Did a convergence mode change halfway through? Did the proof rely on a hidden regularity assumption? That is the real win: not automation replacing judgement, but judgement getting a typed object to inspect. MathCode handles translation and proof repair. Lean plus Mathlib is the solid engine. This prose → abstract claim route → Lean statement → type-checking loop is speeding up both my own research and how I read the literature. #LeanProver #Mathlib #FormalMethods

Readings shared April 29, 2026. jaalonso.github.io/vestigium… #AI4Math #Agda #Emacs #FormalMethods #FunctionalProgramming #Haskell #ITP #IsabelleHOL #LeanProver #Math