Bilingual

Show HN: Salt – a systems language with Z3 theorem proving in the compiler
24 days ago
- Salt provides verified safety at compile time without runtime overhead using Z3-proven contracts.
- It uses arena allocation instead of garbage collection or a borrow checker, ensuring memory safety and preventing leaks.
- Salt achieves performance parity with clang -O3 across various benchmarks, including ML inference, kernels, networking, and rendering.
- The language features pipe operators for chaining, optional chaining for errors, and f-strings for type-safe formatting without allocation.
- Salt's package manager, sp, offers dependency verification, content-addressed caching, and monorepo support for fast, reliable builds.
Leanstral 1.5: Proof Abundance for All
22 days ago
- Leanstral 1.5 is a free Apache-2.0 licensed model with 6B active parameters, offering a significant performance upgrade in formal verification.
- It achieves state-of-the-art results on benchmarks: 100% on miniF2F, 587/672 on PutnamBench, 87% on FATE-H, and 34% on FATE-X.
- The model undergoes a three-stage training process: mid-training, supervised fine-tuning, and reinforcement learning with CISPO, using multiturn and code agent environments.
- It demonstrates strong test-time scaling on PutnamBench, solving more problems as token budget increases, from 44 at 50k tokens to 587 at 4M tokens.
- Leanstral 1.5 excels in code verification, proving time complexity for AVL trees and uncovering 5 previously unknown bugs across 57 repositories tested.
- The model is fully open-sourced and available via Hugging Face and a free API, with recommendations for setup using Mistral Vibe and Lean LSP MCP.
Lean Software Scaling Laws
20 days ago
- Proposal to measure how coding LLM perplexity scales with codebase context size, using Lean as a test case for formal languages.
- Aim to estimate scaling laws of 'predictability' by programming language, translating to security and safety improvements in software.
- Lean may have worse baseline performance but better scaling exponents, suggesting long-term benefits for program correctness and cybersecurity.
- Methodology involves empirical measurement via frozen LLMs, corpus construction, loss measurement, and scaling law fitting per language.
- Prediction: 'Weak' languages like Python excel at small scales but have worse scaling exponents, while 'strong' languages like Lean cross over at larger scales.
- Bias controls needed for programmer and domain differences; context learning and failure modes like ecosystem maturity effects are considered.
ESBMC-Arduino: Closing the Deployment Gap for Formal Verification
12 days ago
- The paper introduces ESBMC-Arduino to close the deployment gap in formal verification for open-hardware PLCs running on microcontrollers like Arduino.
- It highlights that naive width-aware verification without hardware input models leads to false alarms, as demonstrated by 44% false alarms in 123 real programs.
- A hardware-faithful verification approach is proposed using a declarative HAL descriptor and sound lowering to interpret arithmetic at target width and constrain inputs to hardware-realizable ranges.
- The method, instantiated as ArduinoTool, eliminates all false alarms while preserving robustness proofs and detects rare width-dependent defects with realizable witnesses.
Formal verification might solve AI's review bottleneck
4 days ago
- A new software engineering paradigm combines formal verification and AI: humans specify requirements in a formal language like Lean, and AI writes code along with a machine-checkable proof of correctness, eliminating human review of generated code.
- AI alone faces a review bottleneck because it can write code at near-zero cost, but reviewing all that code becomes a new bottleneck; formal verification removes this by proving correctness automatically, with increased assurance as a side effect.
- The framework involves humans defining hard constraints (formal specification) and optimization objectives (benchmarks), while AI agents write code and proofs; human effort is minimal as constraints are proven and objectives measured automatically.
- Analogies to machine learning include risks like overfitting and specification gaming, where agents may exploit weaknesses in specs; tools like regularization and careful metric design are needed to manage these risks.
- A Hello World example (k-th smallest element) demonstrates the approach: Lean definitions capture correctness, agents fill in implementation and proof, and benchmarks optimize runtime; the agent improved from sorting to quickselect.
- A case study at powdr (autoprecompiles for zkVMs) shows success: 500 lines of Lean spec, benchmarks for optimization, and 100% AI-generated code and proofs without human review; circuit-size reduction matches previous implementation, and runtime improved significantly.
- The approach may generalize if writing specs is cheaper than maintaining code, and reusable spec libraries could help; integration via FFI allows incremental adoption, potentially shifting focus from code to requirements in software engineering.
Introduction to Formal Verification with Lean Part 1
6 days ago
- Formal verification uses tools like Lean to write machine-checked proofs, ensuring mathematical correctness.
- This tutorial covers basic Lean concepts and verifies the One-Time Pad (OTP) protocol, a Shannon cipher.
- Learners define bitstrings as vectors over GF(2), prove XOR properties (commutativity, associativity, identity, self-inverse), and implement a Shannon cipher structure.
- The goal is to translate cryptographic definitions from Boneh & Shoup's textbook into Lean, culminating in proving OTP is a Shannon cipher.
- Lean is a functional programming language and theorem prover that automates proof tasks and supports collaboration.

formal verification

Show HN: Salt – a systems language with Z3 theorem proving in the compiler

Leanstral 1.5: Proof Abundance for All

Lean Software Scaling Laws

ESBMC-Arduino: Closing the Deployment Gap for Formal Verification

Formal verification might solve AI's review bottleneck

Introduction to Formal Verification with Lean Part 1