eutectic

You don't have to use sorting networks; to differentiate (or get a subgradient, anyway) a sorted list you just pass the derivative back to the original index, so you can use any sorting algorithm as long as you keep track of the permutation. You could even use radix sort.

Also, I would say that random number generation is a well-solved problem.

I really love the auction algorithm for maximum-weight matching, especially the variant where bidders bid the price that makes them indifferent with their second-best option.

It's so simple and elegant.

Bias is underfitting.

Urea doesn't smell like anything much. Leave it long enough and it breaks down to make ammonia, which does.

Isn't the log factor only in the alphabet size?

The poisson distribution is quite-light tailed. With a poisson distribution, the probability of completing the task per unit time is constant.

Real world tasks are likely to take longer if they have already gone on for longer; maybe a Pareto distribution would be more appropriate.

Isn't diluted high-concentration electrolytes an oxymoron?

I'm English and I've always seen it as 'bat(ting) an eye'. I don't think I've often heard it said though.

We live in a world in which it is easier to collect 'sin taxes' than to tax the rich.

The wealthy have resources to fight any attempt to collect a fair, let alone progressive, share of their earnings.

And yet, it might be rational in terms of social utility to increase the cost of acquiring alcohol. We face a challenge if we want to balance fairness and utility.

The optimal policy surely includes measures which go beyond making psychotropic substances harder to aquire, but I don't know what the answer is. We could spend money on therapy, but would it really pay for itself?

I already appreciate bats for how awesome they are! They're the fastest (and only flying) mammals. Surely that should be enough. If I were a bat, would it be rational to harbour animosity about any of the myriad diseases spread by humans?

How do you model the crop response to environmental factors? Did you have to run experiments?

I though Haar wavelets were good for text and other hard-edged images?

A nuclear power station is not exactly a university or an art gallery.

Water can dissolve KNO3, and ethanol can dissolve sulfir (slightly) and tar from the charcoal, so maybe it helped create a more intimate mix? It would also have kept down sparks and reduced the chance of ignition while mixing and grinding.

I had good success using a DAWG for pruning, and letter-wise (rather than word-wise) branching, picking the letter with fewest options. If you want to get fancy, you can use back-jumping instead of backtracking.

I wonder how well gpt-3 + search would perform as a crossword-solving agent. I guess the tokenization might be tricky to deal with.

Hydrogen peroxide is a very aggressive oxidizer compared to molecular oxygen and will break down molecules instead of just adding to them.

I'm also a Dvorak user with a randomly generated password, but I memorized it by coming up with an approximate pronunciation so it's still firmly lodged in my brain.

I meant how effectively can your body use it as a source of energy. I think the conversion efficiency is much lower than e.g. sugar or fat.

But how efficiently are alcohol calories metabolizied? (I think not very)

I got nerd-sniped and wrote a simple Python solver for this problem. You can find the ngram files at Norvig's site (https://norvig.com/ngrams/).

    import collections
    import math
    import heapq

    with open('count_1w.txt', 'r') as f:
        unigrams = [l.split() for l in f]
    unigram_map = collections.defaultdict(lambda: 0)
    for word, count in unigrams:
        unigram_map[word] = int(count)
    with open('count_2w.txt', 'r') as f:
        bigrams = [l.split() for l in f]
    bigram_map = collections.defaultdict(lambda: collections.defaultdict(lambda: {}))
    for word0, word1, count in bigrams:
        bigram_map[word0][word1] = int(count)
    log_p_unseen = collections.defaultdict(lambda: 0.)
    for word0, counts in bigram_map.items():
        for word1, count in counts.items():
            unigram_map[word1] += count
        total = sum(counts.values())
        #smoothing for unseen words
        mn, mx = min(counts.values()), max(counts.values())
        if mn == mx:
            p_unseen = 0.5
        else:
            #geometric series approximation
            r = (mn / mx) ** (1. / (len(counts) - 1))
            n = mn * r / (1. - r)
            p_unseen = n / (n + total)
        log_p_unseen[word0] = math.log(p_unseen)
        c = (1. - p_unseen) / total
        bigram_map[word0] = {word1: math.log(c * count) for word1, count in counts.items()}
    c = 1. / sum(unigram_map.values())
    unigram_map = {word: math.log(c * count) for word, count in unigram_map.items()}
    max_len = max(map(len, unigram_map))

    def optimal_parse(text):
        word_spans = {j: [] for j in range(len(text) + 1)}
        for i in range(len(text)):
            for j in range(i + 1, min(i + max_len, len(text)) + 1):
                if text[i:j] in unigram_map:
                    word_spans[i].append(j)
        min_cost = collections.defaultdict(lambda: float('inf'))
        parent = {}
        queue = [(0., 0, 0)]
        while queue:
            cost, i, j = heapq.heappop(queue)
            if cost > min_cost[(i, j)]:
                continue
            if j == len(text):
                break
            if j == 0:
                word0 = '<s>'
            else:
                word0 = text[i:j]
            for k in word_spans[j]:
                word1 = text[j:k]
                if word1 in bigram_map[word0]:
                    word1_cost = -bigram_map[word0][word1]
                else:
                    #It would technically be more correct to normalize the unigram probability only over unseen words.
                    word1_cost = -(log_p_unseen[word0] + unigram_map[word1])
                cost1 = cost + word1_cost
                if cost1 < min_cost[(j, k)]:
                    min_cost[(j, k)] = cost1
                    parent[(j, k)] = i
                    heapq.heappush(queue, (cost1, j, k))
        words = []
        while j != 0:
            words.append(text[i:j])
            i, j = parent.get((i, j)), i
        return words[::-1]

    print(optimal_parse('ivehadathoughtandamcurioushowpeoplewouldsolveit'))

I would try an n-gram model with dynamic programming.

e.g.

logp(_, "") = 0

logp(word0, text) = max(logp_bigram(word0, word1) + logp(word1, rest) for word1, rest in prefix_words(text))

Organic compounds burn up, lead just accumulates.

What about suspended water droplets?

Presumably you mean to rather than by?

Surely copper at least is worth recycling?

4096, here we come!

The work that most (even highly skilled) people do is more like playing chess or writing a novel than proving theorems.

Not pushing the boundaires of human knowledge, but requiring skills which are not easily learned without experience and within which there is a huge variation in human ability.

Can you really say that the existence of an agent (or a million) matching or exceeding the 100th percentile in many different skills would not be a massive change?

Humanity is an existence proof for human level AI, and it seems arrogant to assume that our brains are at the limit of what is possible.

Reproductive fitness requires many attributes which obviously compete with intelligence, and evolution is a blind hill-climbing search which cannot easily escape deep local minima.

To me it's obvious that the development of superhuman AI is inevitable assuming we don't wipe ourselves out before we have time to develop it.

This shows that masks aren't perfect, not that they don't help.