rjeli

the implementations have a distinctly "I wrote this at a 3 AM hackathon" vibe

The LLM handles the natural language interaction and orchestration, while the computer algebra system does what it does best ... exact symbolic manipulation.

this smells like claude :D

Author’s announcement xeet with some context and highlights: https://x.com/camrobjones/status/1907086860322480233

mirror: https://nitter.net/camrobjones/status/1907086860322480233#m

They link to the webapp which you can play yourself!

https://turingtest.live/

(I have a dozen games played and 100% success rate :3)

they come out thursday nights (in the US) - 9pm EST

Wow, incredible. I told myself I’d stop waffling and just buy the next 800gb/s mini or studio to come out, so I guess I’m getting this.

Not sure how much storage to get. I was floating the idea of getting less storage, and hooking it up to a TB5 NAS array of 2.5” SSDs, 10-20tb for models + datasets + my media library would be nice. Any recommendations for the best enclosure for that?

there are a lot of interesting people on twitter

IIRC when I played KSP it was necessary to point slightly down if you wanted to reach orbit in a continuous burn, rather than waiting to burn more at perigee. Is that true in general?

(was playing with a mod that models ullage, so relighting was quite finicky)

For C++, `bit_cast<uint32_t>(0.f)` should be Well Defined, right? I'm curious, in C, is union-casting float->uint32_t also Perfectly Legal And Well Defined?

(I am not a C or C++ expert.)

Funny that when I reached the "Key Findings" section, my brain immediately parsed it as ChatGPT output. Maybe it's the bullet points, the word choice, or just the font...

Note that the FFT has this property of “convolution is pointwise multiplication” for any cyclic multiplicative group, see https://www.sciencedirect.com/science/article/pii/S002200007... for a more algebraic derivation.

Some call this a “harmonic” fft, and there are also non-harmonic FFTs:

- the “additive NTT” of [LCH14] on GF(2^n)

- the circle fft on the unit circle X^2+Y^2=1 of a finite field [HLP24]

- the ecfft on a sequence of elliptic curve isogenies [BCKL21]

[LCH14]: https://arxiv.org/abs/1404.3458

[HLP24]: https://eprint.iacr.org/2024/278

[BCKL21]: https://arxiv.org/pdf/2107.08473

There’s a nice writeup on group hashes here: https://cronokirby.com/posts/2021/07/on_multi_set_hashing/

In particular, if you choose a group where discrete log is hard (such as prime order elliptic curves), multiset hashing falls out for free

With high enough accelerometer accuracy, you need to start adjusting your subtracted gravity vector with maps, right?

Very cool! I assume it uses WebCodec VideoEncoder to encode in browser, maybe with a wasm ffmpeg fallback? How reliable/easy to use have you found that?

ZKML is actually not horrible, probably only 100-1000x overhead atm. Unfortunately it doesn’t solve the problem, you would need FHE which has much higher overhead

Got in late, seems like I can't rewind on this stream??

See also levomethamphetamine, the mirror image of meth found commonly in drugstores in Vick’s inhalers, acting as a vasoconstrictor

Does anyone have recs for doing really low level performance tuning on Apple Silicon? Xcode Instruments isn’t very easy to use or interpret. Things like what % of time is spent on memory stalls, simd units, etc

I’ve always thought it was strange that btc community encourages only running core, rather than having several implementations to make consensus more robust

hm yeah i wonder if you could use the phase change tanks as an acoustic antenna to communicate with buoys on the surface

You can do it without a TEG: https://sci-hub.se/10.1109/48.972077

Essentially you use a fluid which freezes at the bottom of the ocean and loses volume (some kind of paraffin)

And then you hook it up with some actuated valves and N2 accumulators so the volume change and energy harvesting happens "out of phase" - at the surface, you can deflate an external bladder and sink, and at the bottom, you use some stored energy to reinflate the bladder

With a large enough volume you get near infinite range, only have to pay for payload and any onboard electronics

this report has some more info on the absurd efficiency of thermal gliders: https://escholarship.org/content/qt1c28t6bb/qt1c28t6bb_noSpl...

I'm curious, do you have any intuition for what percent of the time is spent shifting & masking vs. adding & subtracting (int32s I think)? Probably about the same?

I love rhymezone, I use it all the time! Thanks!

Nice! I rewrote it in z3 and was able to avoid the if-elses by tracking the occupancy of each cell as an integer, and constraining it to exactly 1: https://gist.github.com/rjeli/a1612da0e3c8b99ec4514e689ebdfa...

  First, we take some of the safety into our own hands. While this approach won't result in corrupted memory, double frees or accessing freed pointers, it can lead to run-time panics and other problems because we deal in "raw" indices to a vector.

There was a story a few weeks ago about some odd picture taken, and it turned out to be motion blur compensation / HDR / some other computational method creating artifacts. That’s my first instinct looking at this pic, but who knows!

Huh? How do you read from the ram after you write to it?

There is a very simple solution to emacs pinky, although it doesn't work on laptop keyboards: pressing the ctrl key with your palm. Whenever I see someone contort their pinky I am shocked that this convenient (and obvious in retrospect) alternative hasn't caught on.

http://xahlee.info/kbd/how_to_press_control_key.html

For example, to create a JPEG, part of the process is removing the "high frequency" parts of your image, since those take the most information to store. Here, high frequency refers to noise, or any large difference between neighboring pixels, as opposed to low frequency parts, which are averages over larger groups of pixels. So, at the extreme, if you average the whole image, you only have to store one pixel, so it's obviously less data to store, vs storing info about every single pixel. JPEG (and other lossy compression formats) tries to find a good middle ground between storing every pixel perfectly and storing just one pixel.

So, how do you remove the high frequency parts? You apply a Fourier transform to the image (in this case, it's a "Discrete Cosine Transform", which is extremely similar to a DFT and has no differences for the purpose of this explanation) and get a 2d array. This 2d array has the low frequency parts in the upper left corner, and the high frequency parts everywhere else (to the right and down for horizontal and vertical frequencies). So your compression algorithm will simply zero out the high frequency parts so you don't have to store them. In the simplest case, this is equivalent to a simple blur of the image, but there are some heuristics about how much to remove (zero out) to minimize image degradation.

To decode the image, you take the 2d array and apply the inverse FT to get the original image (now slightly blurry because it's been compressed).

More details here: https://en.wikipedia.org/wiki/JPEG#Discrete_cosine_transform

this looks nice, but I feel like mixing the python into the source is actually the reason I like cog so much. It feels weird at first, but having it all inline and checking it in together is simpler to work with IMO

No, the difference is too large for it to be rolling shutter. (not sure if the rolling shutter is even vertical or horizontal). It seems like it takes a short video and stitches together the sections with the least motion blur in each frame.

See also "π plays Pokemon Sapphire", currently at 372 24-hour segments, and still stuck in the starter town (with a level 76 Sceptile):

https://www.youtube.com/watch?v=pegjULYJae4