firechickenbird

The proof of non-regularity is a bit convoluted. You can easily apply the pumping lemma there

If we save billions there will be no space for other people

At first glance I thought SHALL standed for SHA-language model :|

With the upcoming recession and market crash it’s the perfect timing

Ima short this bubble to zero

Backprop doesn’t give a shit

Quality of these LCM is not the best though

Please don’t call this mess “type-safe”

I think your last chart is slightly incorrect: the game server is sending a message directly to the user, whereas it should theoretically only talk to the intermediate message queue (or frontend server)

Cool idea, but why such an overkill website? You could've just created a youtube playlist

Broken

> The government hopes that the move will spur competition and lead to app price drops

Most apps are free. The paid one are also already very cheap

My graph is a partial representation of the supermarket and does not contain all the goods. It has just the stuff that I've bought at least once and manually positioned into the nodes. Sometimes the supermarket decides to relocate groups of goods and I have to update my graph again, but it does not happen too often (they do it probably once or twice a year)

An app that helps me with shopping at my main supermarket.

I usually go always to the same supermarket twice a week. I was frustrated that every time I changed something in my shopping list I had to mentally recompute the optimal path to pick up everything.

Now with my app I am able to build the graph of the entire supermarket (each node represents a rack with shopping items) and then given my shopping list it computes the optimal path from the entrance to the exit. It's a version of the classical travelling salesman problem

At this point I'm wondering if the TypeScript type system can be used for dependant types that would allow formal verification of the programs

No? In fact, if you understand what what I wrote, by generalizing this small piece of code it would mean that most of the codebase must be also partially rewritten to rust to be able to interoperate with the new data structures moved in rust. Thus these “less than 100 lines of code” refer to just this simple example program, which was fully rewritten in rust, hence, by generalizing, the premise was pointless

OP fully rewrote the example program in rust, by also moving the entire data structures there. This would mean that any interaction with these ndarrays could be possible only on the rust side, hence any other code that uses them must be rewritten, unless there’s some porting of rust ndarrays to python numpy ndarrays

The premise was to not rewrite everything in rust, but you basically ended up rewriting 90% of it in rust

Why should I trust these random charts? Where do you get the data from? Feels like sponsored fake news by bing

Disable JS for full article

Very interesting, although I was expecting the Stable Diffusion paper[1] to be one of the most cited in 2022

[1]: High-Resolution Image Synthesis With Latent Diffusion Models, https://arxiv.org/abs/2112.10752

Let me first try to briefly summarize NP-completeness:

A problem A is NP-complete if:

- you can verify it's solution in polynomial time

- you can reduce it to any other NP-complete problem in polynomial time

Since polynomial reduction is transitive, the second point is equivalent to saying that "you can reduce it to SAT in polynomial time".

The reduction is simply a function that compiles the starting problem to SAT and preserves it's solvability (in a bijective way). In other words, to prove that a problem is NP-compelte, you must write a compilation function to SAT and also prove that every solution to the starting problem is also a solution to the destination problem in SAT. Furthermore you must also prove that any solution in the SAT version can be "decompiled" to a proper solution in the starting problem, so this is where the equivalence comes from and it's the reason that SAT is not really anyhow harder than other NP-complete problems.

The thing is, SAT has been heavily researched, so that's why you have extremely efficient SAT-solvers. So if you want to solve an NP-complete problem, you can simply compile it to SAT, solve it with well-known SAT-solvers and "decompile" the solution to your starting problem

> That is not entirely true

what are you referring to?

Obviously x^4 != x^10, but noone has ever proven that "if SAT is P, then it would have the lowest (or highest) polynomial complexity among the other problems", or anything similar

Interesting informal summarization of SAT. However, there is no such thing as "the hardest" NP-complete problem. By definition of NP-completeness, if you solve ANY NP-complete problem in polynomial time, you can solve every other NP-complete problem in polynomial time, thus they have equivalent difficulty (although, some problems may seem intuitively easier than others).

> severely underhyped: voice AI

These two words made it all sound like they are just trying to ride the AI wave instead of actually solving a real world problem

IMO CTOs must have a broad knowledge of how things are done in all the fields, eg. web, mobile, backend, devops, nowadays ML etc. That way they can take more sane high-level and long term technological decisions. Otherwise you end up with a cto asking you to move everything on microservices for your 1k users app because he/she heard of a friend's company using them (based on a true story)