David A.

@MaadSurgeon

Zurich, Switzerland

Joined June 2010

3.8K Following

383 Followers

386 Posts

MaadSurgeon retweeted

Taelin

@VictorTaelin

about 22 hours ago

*sighs* it is already depressing enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some shit is another level of stupid problem is, when I write too technically, it tends to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts that, I admit, may sound a bit over-excited sometimes. that said, the proof is simple enough to be explainable in a way you all can appreciate, so, I'll give it a shot. with you, in its full glory, how Fable contributed to Bend's consistency proof, why it was incredible and, yes, very valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (like riemann's hypothesis!) trivially, in a few lines of code. that wouldn't net them $1 million, but it would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean and undermining the language's credibility. I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, if the set of all sets contains itself, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language" and then got flattered into thinking I'm a genius. I studied the subject 10 fucking years and used AI to aid me materialize and double check my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if the solutions are mine, how Fable helped here? well, the argument per se is obviously sound, and nobody serious would contest it. the problem is that implementing a proof assistant is hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! full proof below ↓ that was Fable's contribution, and, if you can't see how incredible this is, I don't know what could possibly impress you. as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below!

VictorTaelin's tweet photo. *sighs*

it is already depressing enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some shit is another level of stupid

problem is, when I write too technically, it tends to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts that, I admit, may sound a bit over-excited sometimes. that said, the proof is simple enough to be explainable in a way you all can appreciate, so, I'll give it a shot. with you, in its full glory, how Fable contributed to Bend's consistency proof, why it was incredible and, yes, very valid

first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (like riemann's hypothesis!) trivially, in a few lines of code. that wouldn't net them $1 million, but it would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean and undermining the language's credibility. I obviously don't want that to happen to Bend2

fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part.

the second part is much more difficult:

"prove every well typed program in your language terminates"

this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how?

the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do.

so, is that it?

unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program:

evil = (lambda f: f(f))(lambda f: f(f))
print evil

it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, if the set of all sets contains itself, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox:

data Evil { bad(f : Evil -> Evil) } // this would break Lean!

that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums!

in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it.

this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable

my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system.

this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination:

- infinite loops → there are no loops

- infinite recursion → only allow decreasing recursion

- self-duplicating λ-terms → lambdas can't be cloned

from termination, consistency follows easily.

and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you?

now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language" and then got flattered into thinking I'm a genius. I studied the subject 10 fucking years and used AI to aid me materialize and double check my ideas. this is the antidote I found to AI psychosis. I call it "competency"

that said, if the solutions are mine, how Fable helped here?

well, the argument per se is obviously sound, and nobody serious would contest it. the problem is that implementing a proof assistant is hard, and it is easy to introduce accidental bugs that detour from the intended semantics.

turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less.

QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! full proof below ↓

that was Fable's contribution, and, if you can't see how incredible this is, I don't know what could possibly impress you.

as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below!

613

156K

MaadSurgeon retweeted

Ihtesham Ali

@ihtesham2005

19 days ago

Sergey Brin said compute is dessert. The companies winning the AI race right now are not the ones with the most chips. They are the ones with the best algorithms. Every headline you read about AI is about data centers, Megawatts, and Nvidia orders. Billions in infrastructure and more. The entire investment thesis of the last three years has been built on compute scaling as the primary moat. Sergey thinks that framing is wrong. He pulled out an example from physics. The N-body problem. Scientists have been running those simulations since the fifties. Over the decades, raw compute improved on Moore's law. But the algorithms to solve the problem improved faster. Not slightly faster. Far faster. The algorithmic gains made the compute gains look small. He says the same thing has happened in AI over the last decade. Compute is not the meal. It is the dessert. You still want it. Nobody is turning down frontier compute. But the companies that figured out the algorithms first are the ones actually ahead. The market is pricing AI winners by who has the most chips. Sergey Brin just said that is the wrong scorecard. The ones who win this are not building the biggest data center. They are solving the harder math problem.

499

358

130K

MaadSurgeon retweeted

KuriptoMan 🔮 🦣 @KuriptoMan

12 days ago

@const_reborn The real Q is not only how Bittensor rewards subnets, it is how those reward rules evolve. If validators decide today, what stops them becoming tomorrow’s new center of power? $TAO reaching the problem https://t.co/Cc7Rm0w9tu was built to solve 🟪 A convo is due @const_reborn

145

MaadSurgeon retweeted

Tau Net

@Tau_Net

about 2 months ago

We reached this conclusion and have built the spec language for it. Tau Language is self-referential formal logic: • you specify what software must achieve • the system constructs and proves it correct Tau Net runs on it. The “final form” already has an implementation. :) https://t.co/y30MD43UC3

Who to follow

Bangcoy

@Bangcoy27292248

Oke

MaadSurgeon retweeted

Ohad Asor @ohadasor

about 2 months ago

New paper https://t.co/IhWfjN4vVS

MaadSurgeon retweeted

Tau Net

@Tau_Net

2 months ago

1/3 🛠 April Dev Update – Node Architecture Overhaul & Fork Choice Major month: Docker model replaced with native C++ bindings, fork choice with chain reorg is live, and user-controlled dynamic consensus is in development. Top highlights: • Native C++ Tau API — Docker removed entirely • Fork choice + chain reorganization • BDD library completed, entering normalization • Benchmarking framework operational

MaadSurgeon retweeted

Tau

@TauLogicAI

3 months ago

The Claude leak needed the rule "never send private data over the network." The Mercor breach needed "reject any update that hasn't been formally verified." Obvious rules but no language can enforce them across all future states of a system apart from the Tau Language. Tau Language is "The critical ingredient for Safe AI" - Ohad Asor

MaadSurgeon retweeted

Anthropic

@AnthropicAI

4 months ago

The open source ecosystem underpins nearly every software system in the world. As AI grows more capable, open source security becomes increasingly important. We're donating to the Linux Foundation to continue to help secure the foundations AI runs on.

182

118

115

163K

MaadSurgeon retweeted

Tau Net

@Tau_Net

6 months ago

Yes! And even if token holders could vote on every decision, someone still has to translate votes into code. Which is where additional centralization and botlenecks hide. This is impossible to solve by adding more voting. You need governance decisions that are directly executable specifications. We have MVP in the works, will DM you with an invite.

736

MaadSurgeon retweeted

Tau Net

@Tau_Net

over 1 year ago

https://t.co/Qp9tpevVXE

181

17K

MaadSurgeon retweeted

Tau Net

@Tau_Net

6 months ago

As 2025 winds down for most, the Tau team is still making commits! We've made some incredible progress together and would like to thank you from the bottom of our hearts. Your support means more than you could imagine. Highlights of 2025 include: - Released Tau Testnet repository publicly, marking trackable progress towards the first blockchain with automatic software development and logical consensus detection. - Granted multiple patents, including a USPTO patent for safe AI systems through Boolean algebra theories. - Monadic Second Order Logic extended to work over Atomless Boolean Algebras - "a first in history". - Extended a fragment of first-order logic larger than LTL, making Tau more powerful. - SAT Solver Migratio: Switched from Z3 to CVC5, unlocking better normalization and satisfiability checking - Optimization efforts achieved 60% performance boost in the parser. - Developed Android developer wallet with client-side validation for Tau rules. - Ohad Asor featured on Machine Learning Street Talk podcast (200k+ subscribers), discussing Tau Language's revolutionary approach to software synthesis. - Shifted business strategy to become the premier DAO and Project launch platform, sharing our technology with permissive licensing and incentives to benefit builders, creators, and community members. Looking Ahead to 2026: We plan to advance to Tau Net's Testnet Alpha launch, expand testnet capabilities, add developer tools, and foster a collaborative ecosystem. Our roadmap includes continued enhancements to Tau Language performance, public development showcases, and $AGRS utility-based mechanisms designed to support participation and network engagement. A huge thank you to our amazing community for the support and collaboration. Your enthusiasm drives us forward every day! Happy Holidays from the Tau Team! 🎄

Tau_Net's tweet photo. As 2025 winds down for most, the Tau team is still making commits!

We've made some incredible progress together and would like to thank you from the bottom of our hearts. Your support means more than you could imagine.

Highlights of 2025 include:
- Released Tau Testnet repository publicly, marking trackable progress towards the first blockchain with automatic software development and logical consensus detection.
- Granted multiple patents, including a USPTO patent for safe AI systems through Boolean algebra theories.
- Monadic Second Order Logic extended to work over Atomless Boolean Algebras - "a first in history".
- Extended a fragment of first-order logic larger than LTL, making Tau more powerful.
- SAT Solver Migratio: Switched from Z3 to CVC5, unlocking better normalization and satisfiability checking
- Optimization efforts achieved 60% performance boost in the parser.
- Developed Android developer wallet with client-side validation for Tau rules.
- Ohad Asor featured on Machine Learning Street Talk podcast (200k+ subscribers), discussing Tau Language's revolutionary approach to software synthesis.
- Shifted business strategy to become the premier DAO and Project launch platform, sharing our technology with permissive licensing and incentives to benefit builders, creators, and community members.

Looking Ahead to 2026:
We plan to advance to Tau Net's Testnet Alpha launch, expand testnet capabilities, add developer tools, and foster a collaborative ecosystem.

Our roadmap includes continued enhancements to Tau Language performance, public development showcases, and $AGRS utility-based mechanisms designed to support participation and network engagement.

A huge thank you to our amazing community for the support and collaboration. Your enthusiasm drives us forward every day!

Happy Holidays from the Tau Team! 🎄

MaadSurgeon retweeted

l0g1x @tau_l0g1x

7 months ago

Tau is the Engine, Others are Only Messengers Tau is not a tool - Tau is the FOUNDATION Tau is not a worker - Tau is the MANAGER Tau is not a library - Tau is the SYSTEM Tau is not an executor - Tau is the DECIDER Everything else just translates between Tau and the world.

MaadSurgeon retweeted

l0g1x @tau_l0g1x

7 months ago

📄 New white paper: "Provably Fair Multiplayer Gaming via Formal Verification" Leveraging Tau Language's unique temporal features (NSO/GSSOTC) for: - Decidable real-time game state validation - History-dependent game mechanics with guarantees and more! https://t.co/Ptdfp9u65i

MaadSurgeon retweeted

Anthropic

@AnthropicAI

7 months ago

Anthropic is donating the Model Context Protocol to the Agentic AI Foundation, a directed fund under the Linux Foundation. In one year, MCP has become a foundational protocol for agentic AI. Joining AAIF ensures MCP remains open and community-driven. https://t.co/718OwwyFJL

254

780

906

MaadSurgeon retweeted

Tau Net

@Tau_Net

7 months ago

🧵 Big news: The Tau Testnet repository is now public! After months of development, you can now track our progress toward the first blockchain with automatic software development and logical consensus detection. Here's where we are:

Tau_Net's tweet photo. 🧵 Big news: The Tau Testnet repository is now public!

After months of development, you can now track our progress toward the first blockchain with automatic software development and logical consensus detection. Here's where we are: https://t.co/08O0vPFoYs

MaadSurgeon retweeted

Spencer Baggins

@bigaiguy

8 months ago

🚨 MIT just humiliated every major AI lab and nobody’s talking about it. They built a new benchmark called WorldTest to see if AI actually understands the world… and the results are brutal. Even the biggest models Claude, Gemini 2.5 Pro, OpenAI o3 got crushed by humans. Here’s what makes it different: WorldTest doesn’t check how well an AI predicts the next word or frame. It measures if it can build an internal model of reality and use that to handle new situations. They built AutumnBench 43 interactive worlds, 129 tasks where AIs must: • Predict hidden parts of the world (masked-frame prediction) • Plan multi-step actions to reach goals • Detect when the rules of the environment suddenly change Then they tested 517 humans vs the top models. Humans dominated every category. Even massive compute scaling barely helped. The takeaway is wild: Today’s AIs don’t understand environments they just pattern-match inside them. They don’t explore, revise beliefs, or experiment like humans do. WorldTest might be the first benchmark that actually measures understanding, not memorization. And the gap it reveals isn’t small it’s the next grand challenge in AI cognition. (Comment “Send” and I’ll DM you the paper 👇)

bigaiguy's tweet photo. 🚨 MIT just humiliated every major AI lab and nobody’s talking about it.

They built a new benchmark called WorldTest to see if AI actually understands the world… and the results are brutal.

Even the biggest models Claude, Gemini 2.5 Pro, OpenAI o3 got crushed by humans.

Here’s what makes it different:

WorldTest doesn’t check how well an AI predicts the next word or frame.
It measures if it can build an internal model of reality and use that to handle new situations.

They built AutumnBench 43 interactive worlds, 129 tasks where AIs must:

• Predict hidden parts of the world (masked-frame prediction)
• Plan multi-step actions to reach goals
• Detect when the rules of the environment suddenly change

Then they tested 517 humans vs the top models.
Humans dominated every category.
Even massive compute scaling barely helped.

The takeaway is wild:

Today’s AIs don’t understand environments they just pattern-match inside them. They don’t explore, revise beliefs, or experiment like humans do.

WorldTest might be the first benchmark that actually measures understanding, not memorization. And the gap it reveals isn’t small it’s the next grand challenge in AI cognition.

(Comment “Send” and I’ll DM you the paper 👇)

258

665

191K

MaadSurgeon retweeted

Tau Net

@Tau_Net

8 months ago

https://t.co/rJbfLYDkSk

10K

MaadSurgeon retweeted

Ohad Asor @ohadasor

9 months ago

Really really funny. Not even close. Maybe his analogy holds for extremely simple logical systems, far from enough for software specification. He thinks he's the first to find the connection between Datalog (polynomial time) and matrix multiplication (while seemingly he missed expressing recursion using matrix inverse). Can kill his argument using undergrad complexity theory!

MaadSurgeon retweeted

h1dd3nGEMS @h1dd3nGEMS

9 months ago

1/ Everyone’s scaling AI. Almost no one is asking: Can we verify what it does? $TAO optimizes predictions. $AGRS is designed to make reasoning provable. 🧵Here’s why that distinction matters.⬇️

h1dd3nGEMS's tweet photo. 1/
Everyone’s scaling AI.
Almost no one is asking:
Can we verify what it does?
$TAO optimizes predictions.
$AGRS is designed to make reasoning provable.
🧵Here’s why that distinction matters.⬇️ https://t.co/ouQJLfMAQY

MaadSurgeon retweeted

Rohan Paul

@rohanpaul_ai

10 months ago

Powerful new discoveries in this paper for autonomous software design.🎯 Will completely shift the way Software and AI programming will be written. 1/ Tau is in the process of constructing the next wave of AI. Tau Language lets you write a spec of what a program should and shouldn’t do, and its logical engine automatically constructs a program mathematically guaranteed to meet your spec, removing manual implementation. The most consuming aspect of software dev used to be writing correct code; now, it's about conveying intent accurately in specifications and getting correct-by-construction software. This foundation is also the subject of a U.S. patent that covers using such temporal logics and Boolean‑algebraic theories for safe AI and a software‑spec logic, which matches the design. 2/ How this is different from today With Tau, you directly state properties of the program like a formalization of “never send private data over the network”, and it produces a provably correct implementation that satisfies them. This breaks away from today’s coding in which you write how and what a program should do at each step. And unlike Tau, in code you can’t say what the program should never do, you test and hope you covered edge cases. In the Tau Language, programs, inputs, and outputs can be sentences in the Tau language itself, which is the first logic ever that can consistently refer to its own sentences. Why LLMs Fall Short: People expect deterministic and correct output from probabilistic tools, which can’t be trusted to be reliable. Imagine the disastrous results if an Airplane manufacturer decided to use code generated by LLMs, how many of you would take that flight? Gen AI's probabilistic nature creates entropy precisely where complex systems need precision and reliability. The V-model dev model is the standard for critical products developed for the medical industry. The deeper you are into your V-model product development cycle, the more it costs to fix a defect. 🧩 What makes Tau Language a huge breakthough: Tau’s Founder @ohadasor made several novel inventions, which together work as a masterpiece in theoretical computer science. Tau Language straddles a fine line retaining decidability while being expressive enough to write specs of complex systems in their entirety, where other decidable formal languages simply aren’t strong enough. Let’s dive deeper into Tau Language’s novel research: 🧵 1/n

rohanpaul_ai's tweet photo. Powerful new discoveries in this paper for autonomous software design.🎯

Will completely shift the way Software and AI programming will be written.

1/ Tau is in the process of constructing the next wave of AI.

Tau Language lets you write a spec of what a program should and shouldn’t do, and its logical engine automatically constructs a program mathematically guaranteed to meet your spec, removing manual implementation.

The most consuming aspect of software dev used to be writing correct code; now, it's about conveying intent accurately in specifications and getting correct-by-construction software.

This foundation is also the subject of a U.S. patent that covers using such temporal logics and Boolean‑algebraic theories for safe AI and a software‑spec logic, which matches the design.

2/ How this is different from today

With Tau, you directly state properties of the program like a formalization of “never send private data over the network”, and it produces a provably correct implementation that satisfies them.

This breaks away from today’s coding in which you write how and what a program should do at each step. And unlike Tau, in code you can’t say what the program should never do, you test and hope you covered edge cases.

In the Tau Language, programs, inputs, and outputs can be sentences in the Tau language itself, which is the first logic ever that can consistently refer to its own sentences.

Why LLMs Fall Short:

People expect deterministic and correct output from probabilistic tools, which can’t be trusted to be reliable. Imagine the disastrous results if an Airplane manufacturer decided to use code generated by LLMs, how many of you would take that flight?

Gen AI's probabilistic nature creates entropy precisely where complex systems need precision and reliability.

The V-model dev model is the standard for critical products developed for the medical industry.

The deeper you are into your V-model product development cycle, the more it costs to fix a defect.

🧩 What makes Tau Language a huge breakthough:

Tau’s Founder @ohadasor made several novel inventions, which together work as a masterpiece in theoretical computer science.

Tau Language straddles a fine line retaining decidability while being expressive enough to write specs of complex systems in their entirety, where other decidable formal languages simply aren’t strong enough.

Let’s dive deeper into Tau Language’s novel research:

🧵 1/n

106

183K

David A.

@MaadSurgeon

Who to follow

Last Seen Users on Sotwe

Trends for you

Most Popular Users