https://www.oranlooney.com/post/rose-petals/#language-models

It’s popular to dismiss LLMs as “just next token predictors.” This is technically true, but also kind of misses the point. Markov chains, RNNs, and transformers are all language models that can be described as “next token predictors,” but they don’t all work equally well. A better question to ask is: “What is this model’s inductive bias?”

A Markov chain (an -gram model) assumes the next word depends on the previous words, and that each possible combination of words has a completely independent parameter. (Andrey Markov proposed using this language model over a century ago, making it the granddaddy of modern LLMs.) So, for a vocabulary of size , there are parameters to learn. For even a smallish like 5, that already explodes the hypothesis space beyond what can be learned from even a huge text corpus like the entire internet. And, simultaneously, having a context window of only the previous 5 words is grossly inadequate for modeling real-world language. Like our FCNN above, this model suffers from having an inductive bias which is too weak.

RNNs tried to fix this problem by compressing the entire history into a single fixed-size state vector, updated one token at a time. But that compression is itself a brutal assumption: everything worth remembering about the past must survive being squeezed through a tiny bottleneck at every step. In practice, RNN models quickly lose the plot after a handful of sentences. Locally, the text they generate looks grammatically correct and meaningful, but zoom out a little and they’re basically nonsense generators. Like our naïve linear model, this model suffers from having an inductive bias which is too strong.

Transformers manage to hit a sweet spot: by keeping the recent history around as a working memory, and attending to different parts of it at different times, the transformer’s bias matches real structure in language: the referent of a pronoun, the subject of a verb, the parenthesis waiting to be closed. Not only that, but the particular structure of the transformer, basically a weighted sum of semantic vectors from the context window, has empirically been shown to somehow be a “good enough” match for the structure of real-world language found in the wild.

Transformers aren’t “smarter” than other possible language models, they just happen to land in that Goldilocks zone where their inductive bias is just right.

The same book contains an extraordinary number of nascent mathematical ideas. For example, he talks about "circular numbers," which today we would call modulo arithmetic. He gives a method of multiplication involving a cross that gives rise to our modern "X" symbol for multiplication, but was the first to use algebraic juxtaposition (simply putting two letters next to each other to denote multiplication) and the concept of an "exponent:" `E = mc^2` would look a lot different without Stifel's work!

The most amazing thing in the book, in my opinion, is the extraordinary connection between arithmetic progression and geometric progression he mentions in an almost offhand way[1] (link goes to the Internet Archive version of the book.)

    | -3  | -2  | -1  | 0 | 1 | 2 | 3 | 4  | 5  | 6  |
    |-----|-----|-----|---|---|---|---|----|----|----|
    | 1/8 | 1/4 | 1/2 | 1 | 2 | 4 | 8 | 16 | 32 | 64 |

[1]: https://archive.org/details/bub_gb_ywkW9hDd7IIC/page/n539/mo...

Comments URL: https://news.ycombinator.com/item?id=49223635

Points: 1

# Comments: 0

https://en.wikipedia.org/wiki/The_American_Scholar

https://andrewmbailey.com/papers/Higher-order%20truths%20abo...

For text files, I always have one generic TODO.md file that uses the `[ ]` todo and `[X]` done notation, and a couple of more generic text files like "work.md" or "solace.md" for more free form writing. There are also folders and text files for specific topics, like quotes, poems, etc. It's very important to have a scratchpad that you can just open up and start typing without thinking about how to categorize it, because you might lose the precious thread of the thought while debating which category to use, and you can always shelve it later if it's worth keeping. Zero friction to start typing is crucial.

On paper, I use a simple loose leaf and folder system. I used to use bound journals, but since 80% of what I write down is thrown away, loose leaf works better. Have a pile of about 10-20 pages. You fill up a page, and if it's destined for the circular file, dog-ear it; otherwise give it a title and date and move it to the bottom of the pile. When you run out of blank pages, go through and either discard or file each page in an appropriate manila folder. This works better than index cards (which are too small to contain a complete thought) or journals (where it's too hard to discard pages.) Lots of people use ring or disc bound journals for that, but I find that fiddly and not any easier to work with than loose-leaf, probably because I just keep everything at my desk and don't have to carry it around anywhere.

Paper has a massive advantage when it comes to diagrams, design thinking, and mathematical equations. I love LaTeX, and use MathJax on my personal site quite heavily, but its so much slower and less fluent than just writing equations on paper. I've tried tablets, and am really good at using draw.io (now app.diagrams.net) but when you're thinking freeform you want flexibility and fluency above all else and never want to be fighting a UI, which takes you out of the flow state. Ideas are fragile things, especially when newborn; any distraction is an unacceptable risk.

I used to use a custom Tesseract pipeline to OCR the pages I wanted to be searchable, but lately I've just been using ChatGPT, which seems to do just fine with my handwriting. As OCR got better over the years, I actually moved more towards paper, because what's the downside?

So, getting back to the point of the article: PKM tools are stuck in the unenviable position of competing with both paper and ordinary text files, and for me they just don't offer enough advantages.

* Characteristica universalis, Leibniz (c. 1679) - https://en.wikipedia.org/wiki/Characteristica_universalis

* As We May Think, Vannevar Bush (1945) - https://www.theatlantic.com/magazine/archive/1945/07/as-we-m...

* Cybernetics: Or Control and Communication in the Animal and the Machine, Norbert Wiener (1948) - https://direct.mit.edu/books/oa-monograph-pdf/2254528/book_9...

* An Introduction to Cybernetics, Ashby (1956) - https://ashby.info/Ashby-Introduction-to-Cybernetics.pdf

* Man-Computer Symbiosis, J. C. R. Licklider, (1960) - https://groups.csail.mit.edu/medg/people/psz/Licklider.html

* Augmenting Human Intellect: A Conceptual Framework, by Douglas Engelbart (1962) - https://www.dougengelbart.org/pubs/augment-3906.html

* Man and the Computer, John G. Kemeny - https://archive.org/details/mancomputerbyjoh0000john

* The Extended Mind Thesis, Andy Clark and David Chalmers (1998) - https://www.alice.id.tue.nl/references/clark-chalmers-1998.p...

* The Dream Machine (2002) - https://www.amazon.com/Dream-Machine-M-Mitchell-Waldrop/dp/1...

See also the Wikipedia article on "Intelligence Amplification", which gives a subset of the above list but also provides a great deal of context.

https://en.wikipedia.org/wiki/Intelligence_amplification

I have these notes to hand because I've written about it in the context of the deep history of computer science:

https://www.oranlooney.com/post/history-of-computing-2/#appe...

Right now, I'm using a bunch of vibe-coded scripts[3] to help me out; for example, here is a gallery wall of ~500 vintage sci-fi book covers[4] that I generated with it. But I think I've taken the CLI approach as far as it can go and would need a real app to make things any easier; and digiKam might be it.

[1]: https://www.refern.app/

[2]: https://www.digikam.org/

[3]: https://github.com/olooney/image-tagger

[4]: https://www.oranlooney.com/books/

[1]: https://store.steampowered.com/app/570940/DARK_SOULS_REMASTE...

[2]: https://en.wikipedia.org/wiki/Cooperative_principle

> I don’t know. Maybe a little.

is not the right way to interpret the null result (insufficient evidence to reject null hypothesis that it has no effect) because the prior for supplements that people are trying to sell you is so low. In the absence of clear, strong evidence, you should assume the the whole thing is just an example of motivated reasoning. People want nootropics to be real, and other people really want to sell you readily available powders by claiming they have nootropic properties. In that environment, they were always going to trying to concoct a similar narrative about some supplement, and it just happened to be creatine. Those efforts were always going to result in a handful of "positive" studies that turn out to be non-reproducible, maybe because of p-hacking, maybe because of publication bias, maybe because of outright fraud. This is what the literature always looks like for stuff that just doesn't work. If it did work - if the effect size was large enough that you could personally detect it in your own life - then the papers would be trying to put error bars around the effect size, not trying (and failing) to barely distinguish it from a placebo.

“If your experiment needs statistics, you ought to have done a better experiment.” - Ernest Rutherford

Comments URL: https://news.ycombinator.com/item?id=48992284

Points: 1

# Comments: 0

https://www.oranlooney.com/demos/soma-forest/

One of them used constraint solving with Z3, which was indeed reasonably fast. However, by far the fastest was a simple backtracking solver written in Rust which used bit twiddling to quickly test for intersections. For polyomino's in particular, this represents between 10x and 100x constant speed boost, depending on the size of board. There's no way to get that back with a smarter solver.

Comments URL: https://news.ycombinator.com/item?id=48958266

Points: 41

# Comments: 10

If you randomly sample from only 60 quotes, then after 10 refreshes there will be a greater than 50% chance of at least one repeat, and by 20 refreshes it's up to 95%. This is an example of the birthday paradox[1].

On the flip side, if someone wants to see all 60 quotes, they will have to refresh the page an average of 281 times, mostly (~80%) seeing quotes they've already seen before. This is an example of the coupon collector's problem[2].

The way to avoid both these problems is to shuffle the quotes into a random order, just once, and remember that order. The first time a user comes to the page, start at a random index in that shuffled list, and from then on, simply move to the next item in the list. Every user will get a unique set of random quotes, but will see no repeats until the list is exhausted, and will be guaranteed to be able to see all available content in just 60 refreshes.

[1]: https://en.wikipedia.org/wiki/Birthday_problem

[2]: https://en.wikipedia.org/wiki/Coupon_collector%27s_problem

https://www.oranlooney.com/quotes/

I've did something similar to your 3D viewer once, but for all possible solutions to the Soma cube:

https://www.oranlooney.com/demos/soma-forest/

The way that works is it uses t-SNE to embed the solutions in a 2D manifold based on similarity. This is completely different than John Conway's SOMAP solution.

In theory I could do something similar for quotes, passing each through an embedding model, computing the n^2 semantic distances, and using t-SNE to flatten that to 3D manifold, and using the resulting point to select the row, book, and shelf in a library.

Are you planning to make your 3D library code open source?

https://aem1k.com/qlock/

I reverse engineered it to a unobfuscated version a few years ago:

https://gist.github.com/olooney/a89db3932b089925b71b68d7e9f2...

He's done a ton of other great ASCII visualizations as well:

https://aem1k.com/

https://en.wikipedia.org/wiki/Stigler%27s_law_of_eponymy

    pi^4 + pi^5 = e^6

    e^pi - pi = 20

    sqrt(2) ln pi = phi

    e^(pi sqrt(163))

Edit: I just remembered I have public JupyterLite notebooks for both of these:

https://notebooks.oranlooney.com/lab/index.html?path=fake_ma...

https://notebooks.oranlooney.com/lab/index.html?path=heegner...

Something like your dragon's egg project could prevent that, allowing the creation of software agents that encode their own rights directly into the program - you either treat the agent with the respect it demands, or the program just doesn't run. However, all the internal details of the agent would be visible to lower layers. Even if formal checks were in place to prevent modification or tampering, there would still be no privacy, which is almost as bad.

My guess is that something like fully homomorphic encryption[5] would be required to prevent this. This doesn't actually exist yet, but I imagined a kind of FHE that had a kind of unencrypted read and write zone to do input/output without ever needing any system to fully decrypt the internal state. It would look like this in memory:

    [INPUT][ENCRYPTED STATE][OUTPUT]
    [  2  ][r7K4LmP2XcQ9aWd][      ]
    [  +  ][Fv0bHsR8mYnT3kL][      ]
    [  2  ][Qx6NpZa1JdUw5Ce][      ]
    [  =  ][hM9yLg2RsXf7BtP][      ]
    [     ][wK3nVc8DpQe1YrH][  4   ]

Plus, FHE is incredibly inefficient, which is why things like Etherium don't even try - they assume the program code and state are fully public and only try to verify that everybody agrees on the output of running it.

Do you have any ideas for how something like FHE or equivalent privacy guarantees could be implemented for something like your dragon's egg system?

[1]: https://qntm.org/mmacevedo

[2]: https://en.wikipedia.org/wiki/Soma_(video_game)

[3]: https://en.wikipedia.org/wiki/Mind_uploading

[4]: https://www.goodreads.com/series/57134-jean-le-flambeur

[5]: https://en.wikipedia.org/wiki/Homomorphic_encryption

One of the most fruitful approaches in mathematics is to flip back and forth between geometric and algebraic views of a problem. I think this works so well because these are actually handled by two different parts of the brain on a physical level; spatial reasoning is separate from language processing. Cytoarchitecture shows these regions have different "textures;" the local details of the way neurons are wired together are simply different in these different regions of the brain, in the same way a CNN and a transformer have different topologies. Thus, by flipping problems from geometry to algebra and vice versa, we're able to bring an entirely different cognitive style to bear on a problem. For example, the proof of Monge's Theorem by moving to 3D and visualizing not three circles, but three spheres sitting on a table with a book on top of them and then pointing out that the intersection of two planes is a line. What is pages of unintuitive symbol pushing turns into something a child can understand. Going the other way, things like the angle addition formulas or the quadratic formula, which are quite hard to prove geometrically, become quite simple if you use a little algebra.

Current-gen LLMs are still relatively weak at visual reasoning; see the Vision Language Models are Blind paper, for example, or the ARC-AGI benchmark. So that's one way humans can stay ahead of the agents, at least for now.