Hacker Newsnew | past | comments | ask | show | jobs | submit | well_ackshually's commentslogin

Mathematicians, famously known for being extremely precise in their specification of problems and absolute lack of errors writing down proofs.

It's always, always, always stating problem wrong.


No. A lean codebase that certifies that whatever definition of the Riemann hypothesis their LLM wrote is correct.

I can write Lean that certifies that 2 + 2 = 5 is correct, by redefining every axiom about natural numbers on the way. Or abusing bugs in Lean. Stop believing Lean is the response to everything.


Just like Navier stokes etc they use independently written Lean statements written by humans; formal conjectures [1]. Indeed, they have one for the Generalized Riemann Hypothesis too [2].

> I can write Lean that certifies that 2 + 2 = 5 is correct, by redefining every axiom about natural numbers on the way.

Which you would catch using comparator?

> Or abusing bugs in Lean.

And just like all the other ones, people check with multiple independent kernels, so you need to abuse bug(s) in all of them.

> Stop believing Lean is the response to everything.

Stop believing Lean is so flawed.

[1]: https://google-deepmind.github.io/formal-conjectures/

[2]: https://google-deepmind.github.io/formal-conjectures/theorem...


The statement of the Riemann hypothesis is included in the Mathlib library which is a human written and highly regarded foundation for formalization. See https://github.com/leanprover-community/mathlib4/blob/master... for the two-line statement.

For a discussion of how to check that the untrusted proof isn't playing fast-and-loose with the axioms of mathematics or exploiting kernel bugs, see Kevin Buzzard's recent post "...and the proof is checked in Lean" at https://xenaproject.wordpress.com/2026/11/12/and-the-proof-i....


It imports a standard definition of RiemannHypothesis. It could be wrong in other ways, but not that one.

The axioms would be a given to the theorem prover of course, as is the norm for theorem proving. This then reduces a complex proof to checking whether the theorem is stated correctly and the proof kernel is correct. This may not be (provably) easier, but it is so far removed from yet equivalent to the original problem that you get a machine-verifiable independent audit as a result.

And don't reduce "is not the answer to everything" to "is the answer to nothig", there is tremendous value in automated verification, especially in the AI age where the moat to it going mainstream is shrinking by the day.


> whatever definition of the Riemann hypothesis

Do you... think that there might be existing definitions for one of the most famous math problems of all time and that maybe they used that?

Or do you think that they just vibe coded up a different definition, for kicks?

This kinda feels.... easily provable either way.


>whatever definition of the Riemann hypothesis their LLM wrote

Given that the proof is provided by Levent Alpöge, who is known to be more than familiar with Lean, is it not unlikely he made up his own definition of the problem?

https://leanprover-community.github.io/mathlib4_docs/Mathlib...


"support foldables" doesn't mean "have custom layouts for them", merely "don't attempt to prevent foldable users to use the app".

Every single Android app will, by default, support foldables. You have to ACTIVELY take steps to not support them. Sure, it might not look great, but you're not forced to make it look great.

You're also conflating two things: Android starting to ignore the screen orientation declaration in the manifest on some devices (which is the right thing to do), and play store (optional, although the main way people get apps) requiring you to not attempt to block foldables

And of course emulator screenshots are allowed lmao. There's so many more egregious things that Google is attempting with Android than "boohoo they're deprecating a terrible thing that allowed developers to be incompetent"


If all apps support foldables by default why should I have to submit screenshots of my app running on a foldable? This is clearly authoritarian behavior: we make you do it because we can!

I support the notion that Android developers should put in some periodic effort to keep their apps in the Play Store, but the hoops they're now forcing you to jump through are getting downright ridiculous.


Yes, it's annoying, but opening the emulator and taking a few screenshots (or telling your agent to do so) isn't that hard. Google also isn't de-listing apps that don't provide screenshots, they're just not promoting them and you'll have to add screenshots with your next update.

Like GP said the basic requirement that applies to all apps is more or less just "the app fills the screen without black bars". For normal apps using Compose or Views that'll be the case unless you've done something very odd. This requirement is mainly about games and such that render directly with OpenGL/Vulkan and might assume a fixed aspect ratio.


First they came for the screenshots.

> Because they rule on the sprit of the law, not as it was written.

Extremely funny to say that about US law when it is entirely based on precedent, and a single judge having vibes on a particular day changes how your entire country works for the next 50 years.

US law is explicitly made to be skirted, as is every common law system in the world and they are all irrevocably flawed.


> and they are all irrevocably flawed

All human systems are flawed because humans are flawed.


>MegaSpeed was illegally diverting chips to China.

Last time I looked, the US's laws weren't applied by default to the whole world, and states remain sovereign. Is there a piece of international law that you know of and the rest of the world does not ?


Ok, more accurately, Huang was attempting to prevent the U.S. government from blocking sales to MegaSpeed (and probably violating laws by ignoring the red flags).

Last time you looked the US didn't have export controls that require Nvidia to KYC and not sell its most advanced processors to China? Well, look harder I guess? Checkout the ECRA and the associated executive orders.

Good news MegaSpeed is a Malaysian company then. Unless you're claiming that Malaysia is chinese territory, in which case that's a nice can of geopolitical worms you're opening.

I’m saying that there is widespread reporting that megaspeed is diverting chips to China, and if that is the case it’s illegal for Nvidia to sell to them. Nvidia is required by US law to impose restrictions on its customers and to make an effort to ensure their customers are complying with those restrictions.

You seem to think I’m making a novel or wild claim, but this is pretty bog-standard export controls. Just like advanced weapons. You can’t sell missiles to a company in Malaysia if that company is going to resell them North Korea.

Go read about alan hao hsu. Literally smuggled Nvidia chips to china through a Malaysian company and is now heading to prison.


>holding both volume keys turns talkback on and off, and android plays a sound when you do it. a very loud sound. WHY IS IT SO LOUD

The fun part about it is that even if you lower TalkBack's sound, enable the debug tool that just writes the text in a toast because listening to accessibility announcements all day long is a recipe to go mad, turning it on/off always give you the horribly loud TALKBACK ENABLED, all my colleagues know when one of us is doing accessibility work.


>A DSL needs it clear the minimum bar of “why is this not just using a real programming language?”.

No, a DSL only needs to be better than the language itself to write a layout in. UI is a whole different beast than anything else, where deep nesting is common, layouts flow in many ways, and more. Rust is simply not appropriate to make that pleasant.

Take a simple layout like you'd declare it in Kotlin using Compose:

    @Composable
    fun GreetingScreen(title: String, onBack: () -> Unit) {
        var count by remember { mutableStateOf(0) }
        val scope = rememberCoroutineScope()

        Column(Modifier.fillMaxSize()) {
            Surface(Modifier.weight(1f)) {
                 Text("Count: $count", style = TextStyles.h1)
            }

            Button(onClick = onBack) {
                 Button(onClick = { count++ }) { Text("+1") }
                 Button(onClick = {
                    scope.launch {
                        delay(1000)
                        count++
                    }
                 }) { Text("+1 later") }
            }
        }
    }

Kotlin naturally has trailing lambdas, method references, has the advantage of being a GC'd language so memory management is out the window.

In pure rust ?

    pub fn counter_screen(ui: &mut Composer, on_back: Rc<dyn Fn()>) {
        let count = remember(ui, || 0_i32);

        column(ui, Modifier::new().fill_max_size(), {
            let count = count.clone();
            let on_back = Rc::clone(&on_back);
            move |ui, col| {
                surface(ui, Modifier::new().weight(col, 1.0), {
                    let count = count.clone();
                    move |ui| {
                        let label = format!("Count: {}", *count.lock().unwrap());
                        text(ui, TextProps {
                            value: &label,
                            style: Some(&TextStyles::H1),
                            ..Default::default()
                        });
                    }
                });

                row(ui, Modifier::new(), {
                    let count = count.clone();
                    move |ui, _row| {
                        button(ui, ButtonProps {
                            on_click: {
                                let count = count.clone();
                                move || count.update(|n| *n += 1)
                            },
                            enabled: true,
                            modifier: Modifier::new(),
                        }, |ui| text(ui, TextProps { value: "+1", ..Default::default() }));

                        button(ui, ButtonProps {
                            on_click: {
                                let count = count.clone();
                                move || {
                                    let count = count.clone();
                                    spawn(async move {
                                        sleep(Duration::from_secs(1)).await;
                                        count.update(|n| *n += 1);
                                    });
                                }
                            },
                            enabled: true,
                            modifier: Modifier::new(),
                        }, |ui| text(ui, TextProps { value: "+1 later", ..Default::default() }));
                }
            });

            button(ui, ButtonProps {
                on_click: { let on_back = Rc::clone(&on_back); move || on_back() },
                enabled: true,
                modifier: Modifier::new(),
            }, |ui| text(ui, TextProps { value: "Go back", ..Default::default() }));
        }
    });
}

What a delicious piece of trash. Since you've said no macros, you're carrying an additional variable everywhere (Composer is a Compose system, but you have the same thing in every UI library that does the same. Call it Context, whatever you want). You have shitty lambdas that need to pass the scope too (because Modifier.weight() only works on a ColumnScope). You have no named parameters, and the only way you would would be crap like having a ButtonProps struct. You have impl Fn() + 'static written in your code. And then if you start to want to do some actual work like "clicking on the button increases a counter", you're suddenly spamming Arc::clone, |move| Rc's everywhere in your code because Rust is simply not a good language for UIs.

(And if you want to go the old school way of simply managing yourself a widget tree, good luck, not only is it always full of bugs, it's also an unmaintainable garbage fire.)

Clojure is not a good language for DSLs either, and the post you've linked is just jerking itself off saying "look i can convert some clojure into the exact bash equivalent by only changing one thing" when it's the exact reason why every single clojure project ends up reimplementing the wheel twelves times and is a piece of shit unmaintainable kludge of whatever code the local genius wanted to commit in this morning. Good languages have constraints.

So yes: DSLs _always_ offer a better alternative. QML is a good DSL, and using Javascript is not the reason why.


> So yes: DSLs _always_ offer a better alternative.

As with all absolutes (DSLs are always better), you are simply wrong. Objectively. :)

A good DSL can go a long way.

…but, mostly, they suck and don't need to exist.

We fortunately now live in an AI era where the non-standard nature of DSL is actively discouraged by LLMs that will (rightly) reject them for what they are.

Anyway, whatever. Slint isn’t bad. It just isn't a rust UI library; because you don’t write the code in rust. QED my friend.


Tough fucking luck ?


We produce more than anyone could want. We don't have a debt problem, we have a capital and resource allocations problem. Capitalists jerk themselves off with "capitalism dragged billions out of poverty", but when suddenly the idea of using that capital to provide everyone with basic necessities, you shit yourselves.


But think about the poor people with only ten million dollars, how will they face inflation when in ten years their $5 carton of eggs that they don't purchase is $8? :(


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: