yellowflash

But the training data is "predominantly" human written sentences or even interaction. It's like asking you to use non dominant hand to do something. Won't they do better with human sounding english, rather than a made up format text? Are there any literature around this? I was also skeptical of this caveman extension etc.. Won't they work better in their actual language space it's trained on rather than made up language?

Kernel is a bad analogy, if you understand how it behaves you can understand how its built. LLMs don't have that, their behaviour is not completely defined by how they are built.

Every abstraction is leaky, its not like I have 1 in every 100 tickets I work on needs understanding of the existence of filesystem buffers, it's in the back of my mind, it's always there. I didn't read linux kernel source, but I know it's existence. LLM output doesn't have that.

Today I learned, Stockfish moved to neural network on 2023. I knew that it was just a minmax with alpha beta pruning and a really good eval function. Now its not.

Very good question. This is totally dependent on the starting point of the search. The entire domain is not a contraction in such cases, there are sub sets of domains where it is a contraction and as whole it's not. Like multiple pieces where we can apply Banach theorem.

Sorry, can you check now?

I was wondering if I could get a different way of thinking about reasoning machines as such. Reasoning models are trying to just externalize the reasoning through chain of thought or fine-tuning on reasoning focused dataset.

They all seem very hacky and not really reasoning. I wanted to see if there are alternative fundamental ways to think about reasoning as end by itself.

I am trying to get a better understanding of what reasoning could possibly mean. So far, I am thinking that more we are able to compress knowledge more it's an indicator for reasoning. I would like to understand more about these, please tell me where my understanding is lacking or point me what I should learn more regarding this.

I think observable notebooks like Pluto.jl is something like his vision though not exactly. It's just more general and useful ?

"Once, Zhuang Zhou dreamed he was a butterfly, a butterfly flitting and fluttering about, happy with himself and doing as he pleased. He didn't know that he was Zhuang Zhou. Suddenly he woke up and there he was, solid and unmistakable Zhuang Zhou. But he didn't know if he was Zhuang Zhou who had dreamt he was a butterfly, or a butterfly dreaming that he was Zhuang Zhou. Between Zhuang Zhou and the butterfly there must be some distinction! This is called the Transformation of Things"

My understanding is rudimentary, but it doesn't alter the system. But it fixes what state the system should have to produce the given observation, retroactively. Which is counterintuitive in lot of ways. It can be thought as if the observation caused the determination of past state. Do I make sense or I am just talking absolute non-sense.

One of them is per family and other per person (family of size 1). Is it even comparable? I am not saying it is lesser, it's pretty high, probably 200% not 560% if I am right.

That's how mongodb geospatial indexes work IIRC

Very interested in your idea. How does concurrent updates work with the augumented trees? I have been thinking about the same for a while something like CouchDB but segment aggregations (monoid) augumented so we can do interval queries over time too. But the only thing bothering is augumented trees are notorious of contention on concurrent updates. Do you have any ideas on merging back if we have multiple versions of augumented trees.

The probability of the `b` being chosen for A is 1 (No other choice) and for B it is 1/2. The probability of `b` being chosen for both (The only common token), is |{(b,b)}| / |{(a, a), {(a, b)}| = 1/2 which is jaccard's similarity |{b}|/|{a, b}|

I could have explained that a bit better I suppose.

It would be Graham Hutton's Programming in Haskell. That one little chapter on parser combinators was totally worth it.

If I can include this functional pearl "A play on regular expression", Not a book though.

These two showed how composition and simple abstraction could make the solution super beautiful.

True, it's just he loosened the notion of real and virtual to an extent that's unfamiliar to people.

Anyway nice profile name. :D

Divert to Ganges and make it a sewage too?

This idea is bad in so many ways. It's gross hatred due to mass propaganda. First rule for sustainable water management is having local water supply used locally. We need better water management at individual city/village level like reviving lakes have a good ground water recharge etc.. Diverting rivers and desalination ideas are going to have huge ecological cost even if we forget about the economical possibility of them.

I always visualized that the tidal locking to be sort of like meshed gears, such that the one revolution around itself is same as a rotation around the star/planet if its a satellite.

But that shouldn't affect the day/night in this case right? Since we are talking about planets not satellites of planets and they are light sources not just reflecting light from the star. Can you please correct where I am wrong?

* per day

It never says, its all of them (Sort of LEM is working in all of them). It just says, thats all you can work with.

Can't we just produce a function from Nat -> 0|1|2|3..9? Which in effect can represent reals?

Though addition might not be defined on some of the reals, if represent it like that.

But Proof checkers like lean/coq all use Cauchy sequences to represent reals. So they are in effect constructible.

Actually it's pretty elegant by itself, Consider this all traversals are same,

val someDS;

while(!someDS.isEmpty()){

  addChildren(someDS.pop()) 

}

Now replace, someDs with

Queue -> BFS

Stack -> DFS

Priority Queue, with priority of distance so far -> Dijkstra.

Priority Queue, with distance + heuristic -> A*

Its beautiful.

I would say it was yesterday. Though I worked may be 2 hours yesterday, I felt like the result was good. I think its mostly the clarity of what I need to do that helped, (I had the idea the previous night and couldn't really sleep at all the for the entire night). https://github.com/yellowflash/godel . That's what I have been working on.

Regular expressions are truly elegant. If the regex engine is built in a functional (compositional style), it is even more elegant. This particular Functional pearl is my favorite, http://sebfisch.github.io/haskell-regexp/regexp-play.pdf

And my implementation of the same in scala (40 lines if you ignore some niceties, and its terribly fast asymptotically) https://gist.github.com/yellowflash/826004277874cadabbc502e6...

For TLDR on the paper, It slowly builds an abstraction and implementation on regex engine which runs on O(mn) where m is length of the regex and n - length of the text. Then they generalize it to do grouping and even extend it to match context free grammar (using lazy evaluation mostly).

First order logic can express precisely what relational algebra can express. And what Datalog represents is First order logic with least fixed point, in case if there is linear order on the data (cells), it could represent P-solvable problems.

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