It’s not a GUI library, but Jupyter was pretty much made for the kind of mathematical/scientific exploratory programming you’re interested in doing. It’s not the right tool for making finished products, but is intended for creating lab notebooks that contain executable code snippets, formatted text, and visual output together. Given your background experience and the libraries you like, it seems like it’d be right up your alley.

Can Z3 account for lost bits? Did it come up with just one solution?

It gave me just one solution the way I asked for it. With additional constraints added to exclude the original solution, it also gives me a second solution – but the solution it produces is peculiar to my implementation and does not match your implementation. If you implemented exactly how the bits are supposed to end up in the result, you could probably find any other solutions that exist correctly, but I just did it in a quick and dirty way.

This is (with a little clean up) what my code looked like:

#!/usr/bin/env python3

import z3

rand1 = 0.38203435111790895
rand2 = 0.5012949781958014
rand3 = 0.5278898433316499
rand4 = 0.5114834443666041

def xoshiro128ss(a,b,c,d):
    t = 0xFFFFFFFF & (b << 9)
    r = 0xFFFFFFFF & (b * 5)
    r = 0xFFFFFFFF & ((r << 7 | r >> 25) * 9)
    c = 0xFFFFFFFF & (c ^ a)
    d = 0xFFFFFFFF & (d ^ b)
    b = 0xFFFFFFFF & (b ^ c)
    a = 0xFFFFFFFF & (a ^ d)
    c = 0xFFFFFFFF & (c ^ t)
    d = 0xFFFFFFFF & (d << 11 | d >> 21)
    return r, (a, b, c, d)

a,b,c,d = z3.BitVecs("a b c d", 64)
nodiv_rand1, state = xoshiro128ss(a,b,c,d)
nodiv_rand2, state = xoshiro128ss(*state)
nodiv_rand3, state = xoshiro128ss(*state)
nodiv_rand4, state = xoshiro128ss(*state)

z3.solve(a >= 0, b >= 0, c >= 0, d >= 0,
  nodiv_rand1 == int(rand1*4294967296),
  nodiv_rand2 == int(rand2*4294967296),
  nodiv_rand3 == int(rand3*4294967296),
  nodiv_rand4 == int(rand4*4294967296)
  )

I never heard about Z3

If you’re not familiar with SMT solvers, they are a useful tool to have in your toolbox. Here are some links that may be of interest:

• https://en.wikipedia.org/wiki/Satisfiability_modulo_theories
• https://en.wikipedia.org/wiki/Z3_Theorem_Prover

Edit: Trying to fix formatting differences between kbin and lemmy
Edit 2: Spoiler tags and code blocks don’t seem to play well together. I’ve got it mostly working on Lemmy (where I’m guessing most people will see the comment), but I don’t think I can fix it on kbin.

If I understand the problem correctly, this is the solution:

I solved it with Z3. Took less than a second of computer time, and about an hour of my time – mostly spent trying to remember how the heck to use Z3 and then a little time debugging my initial program.

I think they’re specifically wondering if using @@ mention syntax will result in a notification popping up for the user on Lemmy.

I’ve been wondering that too (in the context of threads though) – and if it does work, are there limitations regarding visibility between instances that people should be aware of. e.g. what happens if I @ someone in a post to a community on a lemmy server that is defederated from their home instance? Or, in a community that no one on their home server has subscribed to? Will they still get a notice?

I guess I don’t really have a good mental model for how @ works on the Fediverse.

I’ve seen those posts too, but can’t speak German. What does “ich_iel” actually mean?

deleted by creator

Rule 9 from Agans’s Debugging: If you didn’t fix it, it ain’t fixed

Intermittent problems are the worst…

I think it’s probably an Indian English-ism. It’s understandable but sounds weird to speakers of American English (and maybe other English dialects).

A more natural sounding title (to an American English speaker) would use “Microsoft is making” or “Microsoft is planning to make” rather than “Microsoft might want to be making”.

They are! There are US antitrust cases going on right now against Google (x2), Amazon, and Meta/Facebook. Some links that may be of interest:

• FTC Sues Amazon for Illegally Maintaining Monopoly Power
• U.S. and Plaintiff States v. Google LLC (2020) – trial began on September 12, 2023 (this case regards search, I think)
• U.S. and Plaintiff States v. Google LLC (2023) – complaint PDF (this is a second case against Google)
• FTC v. Facebook

It’s not clear to me either on exactly what hardware is required for the reference implementation, but there’s a bunch of discussion about getting it to work with llama.cpp in the HN thread, so it might be possible soon (or maybe already is?) to run it on the CPU if you’re willing to wait longer for it to process.

Let us know how it goes!

Lots of discussion on HN: https://news.ycombinator.com/item?id=37675496

This is totally going to turn into another JBIG2 lossy compression clusterfuck isn’t it…

For those who are unfamiliar, JBIG2 is a compression standard that has a dubious reputation for replacing characters incorrectly in scanned documents (so 6 could become an 8, for example) leading to potentially serious issues when scanning things like medical and legal documents, construction blueprints, etc.

Adding a summary to this: the article has some history about OpenOffice (which is a zombie project that was essentially replaced by LibreOffice after Oracle bought Sun) followed by a description of patterns of weird commit history recently (e.g. regular changes that are entirely or almost entirely just fiddling with whitespace), and a request to email the Apache foundation to ask them to make it clear that the project is dead.