Alecs

@chainbrain @Artemonim @baltabaev @lanyon_ai Beautiful, i say this in the sincerest of ways, thank you for the debate, you’ll surely be seeing my name quite soon, and i hope that what i built may also boost your endeavors as it did mine, see you on the other side, brother!

@Alecsbuarque @Artemonim @baltabaev @lanyon_ai My brother from another mother. It is *physically impossible* to govern a super intelligence. We literally do not know even 1% enough about physics to be able to achieve this. No matter how much you'd like to, you cannot.

I’ve spent well over 10,000 hours studying math in my life, yet I can’t understand these proofs, at least not without weeks of digging deep into each topic. What’s more, none of my math PhD friends know much about these problems either, and they can’t verify most of them without working directly in the field (yes, math is VERY diverse). LLMs are getting smarter than the experts themselves, and I’m not sure we have enough bright human minds to verify everything that will come out of them in the coming years. Remember when we compared AI intelligence to PhD students? I think we’re past that.

@chainbrain @Artemonim @baltabaev @lanyon_ai This is what you’re arguing in favor, please take some time to reflect. You know what would be the right answer to this? “I abstain, this is not verifiable”. I won’t take long now.

@Alecsbuarque @Artemonim @baltabaev @lanyon_ai Good god man. Please take some time to do the most basic reflection on what you just said. How exactly do you intend to govern or restrict a being that knows infinitely more about physics than you do? This is so preposterous its bordering on childishness.

@chainbrain @Artemonim @baltabaev @lanyon_ai Don’t worry, it’s not an anthropic scenario, i believe innovation of this magnitude shouldn’t belong to someone or to a group of people, i hate the way our world is structured, and it must change, that is what i dare to do. South’s 1st gate, VERIFIABILITY ABOVE FAITH. You’ll see.

@chainbrain @Artemonim @baltabaev @lanyon_ai it sounds preposterous because it is, innovation is about daring, you’re not a creator, you use what other people create, that is why this sounds absurd to you, and that is exactly why i understand my position as someone capable of doing it, to do it responsibly.

@Artemonim @chainbrain @baltabaev @lanyon_ai By governing the place where it is allowed to exist.

@Alecsbuarque @chainbrain @baltabaev @lanyon_ai Can we fully verify a human? Because if not, then how can we fully verify an even more complex being?

@chainbrain @Artemonim @baltabaev @lanyon_ai I understand your chain of thought, mine is just ahead, i’m not releasing a super weapon because i’m creating a safe one, White Box AGI, completely governed, aligned and most importantly VERIFIABLE. You might believe me or not, doesn’t really matter.

@chainbrain @Artemonim @baltabaev @lanyon_ai Oh yes the great big blender, that you cannot verify what it creates and hallucinates because you’re no mathematician or engineer, people simply cannot wrap their head around the fact that we are giving humanity’s future to a super intelligent unaligned deity

@Artemonim @baltabaev @lanyon_ai You really want to give rogue actors a zero error math and physics engine? I dont, and sure as hell dont want to be put on some intelligence agency’s list.

@Alecsbuarque @baltabaev @lanyon_ai What's the practical impact? Like, we can prove that a certain cryptographic system can be broken; or we can prove that a certain rejected technology is actually feasible.

@YitziLitt @Artemonim @baltabaev @lanyon_ai Conjectures are not the only thing we can do with math. I will not disclose any more than that.

@Alecsbuarque @Artemonim @baltabaev @lanyon_ai Why would it be dangerous?

@Artemonim @baltabaev you actually can and i did just that, point is, releasing it would be quite dangerous, so i use it to power my own research. Or there is @lanyon_ai which does it as well, just dont know if he will release it as a product.

@baltabaev Can you explain, for someone who's bad at math, what makes verification so difficult? Like, can't you just write a deterministic algorithm that will just calculate whether it's true or false?

@catenba troquei de celular e esqueci de transferir o e-sim, só consegui ativar agora o 997211808

@Alecsbuarque divo cade vc no zap

@strimblez AGI

if you had 5 days of unlimited free tokens for codex, what would you build?

@SashaGusevPosts LLMs cannot be trusted, an ungoverned LLM is a wild horse, it runs fast, but it is a wild beast. They created a soup. Yes soups can be complex and rich, but it is, still, soup.

I'm growing skeptical of strong claims about new frontier model superiority. I have a dozen unsolved research problems that I run the new models on and I don't see any meaningful difference in performance since Sonnet.

@satyanadella You in for a ride Satya, you have no idea what is coming. But i like windows, dont worry.

@JackieLeeETH I thought i was going to sleep at top 1...

more auto-research contests! via openfrontiercs.com time to polish AI research agent harness

@yacineMTB fixed a lot of stuff, broke the same amount, no ungoverned LLM can be really trusted with your work. Especially Anthropic´s.

forgot gpt 5.5 on with a /goal overnight and it put in 145 commits into my physics engine codebase 💀

@VictorTaelin @okiwano :)

@okiwano on HOC, 100% focus on Symbolic AI research

*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!

@gajesh Dm´d you

genuinely curious on the usage of these mathematical models… would love to chat with someone who does.

@VictorTaelin To postando amanhã em

it is so hard not to be over enthusiastic about this model, the way it competently navigates the complexity and spots small but important issues that other models and I oversaw. I'll try to shut up and do my job now, I'm very hopeful for a next week completion. lfg