arnioxux

Pretty sure the answer is no as a math problem where f is pure. If f returns the same answer each time, the square ending at N,N contains [1, N * N]. Then the rectangle ending at N,N+1 must contain (N * N, N * (N+1)] in the nonoverlapping strip. Ditto for N+1,N. But then for N+1,N+1 all other locations must contain low numbers and there's only a single corner cell left which can contain the rest of the missing numbers between (N(N+1), (N+1)(N+1)]. Unless I made a mistake I don't think any function would work here for N > 1. What were the examples you found?

OTOH as a programming problem you can just cheat and store state somewhere to count the row width. This satisfies your interface requirements (python):

    lastJ = None
    def f(i, j):
        global lastJ
        if i != 0:
            return i * (lastJ + 1) + j
        else:
            lastJ = j
            return j


    N = 3
    M = 5
    seen = set()
    for i in range(N):
        for j in range(M):
            q = f(i, j)
            seen.add(q)
    assert sorted(seen) == list(range(N * M))

Is your "winning" strategy so different from other social data / sentiment analysis approaches? There is some novelty with how you weigh the sentiments (based on how much of an insider or expert they are) but I am sure existing trading strategies weren't just taking a dumb average of a twitter firehose either. Shouldn't it be easy for some large firm to replicate your approach and make the alpha disappear?

The most damaging advice I ever got in my life was to talk to myself.

I have always thought in mostly visual/symbolic terms. This made me really good with math early in my life, but it started failing when I began proof writing. Then I got the advice to "explain the problem to yourself and the solution will come naturally" from a friend who is really gifted at mathematical proofs. (And also later received similar advice in programming in the form of "rubber duck debugging").

Surprisingly, it works remarkably well and probably increased my problem solving skills tenfolds, or at least my ability to communicate the answer. I started using it for everything.

But it comes with the side effect of gaining a voice in your head. And that voice is a fucking vicious asshole to me. In the recent years the thoughts even started subvocalizing and I have to forcefully remember to make it stop. It's super embarrassing when there are other people around you.

I am sure this problem is unique to me because I have never heard someone describe it (other than partially matching symptoms of schizophrenia or tourette). But I am certain in my case when the voices started and I am not sure the superpower problem solving skills are worth the trade.

I watched these lectures a few years ago and they were really good.

Since this is meant to be a graduate level research course, I wonder if any cutting edge topics have been added since? Were there any major advances or new ideas in fundamental data structures in the past few years?

I wonder how they are going to handle security/abuse? Once the training is on end user devices, can't the user give fake results?

For example back when recaptcha was introduced, trolls tried to transcribe everything as the n-word (since you only had to get one of the two words correct).

These cases can obviously be noticed and fixed but it's harder now that the training data is opaque right?

I write a lot of scientific code with python and in those cases you really want your equations and matrix columns aligned for readability. These matrices appear so often adding fmt:off destroys the readability/elegance gain from the clever formatting.

Here's an example snippet by Peter Norvig that is beautifully formatted:

  def neighbors4(point): 
    "The four neighboring squares."
    x, y = point
    return (          (x, y-1),
            (x-1, y),           (x+1, y), 
                      (x, y+1))

  def neighbors8(point): 
    "The eight neighboring squares."
    x, y = point 
    return ((x-1, y-1), (x, y-1), (x+1, y-1),
            (x-1, y),             (x+1, y),
            (x-1, y+1), (x, y+1), (x+1, y+1))

Using ln as our utility, at time N we get:

  E[ln(X_1*...*X_N)] = sum E[ln(X)]

So kelly happens to maximize this expected utility by construction since it was derived by maximizing expected log of one round of betting (E[ln(X)]).

But if we use square root as our utility instead:

  E[sqrt(X_1*...*X_N)] = prod E[sqrt(X)]

We would maximize this expected utility by maximizing E[sqrt(X)]. Going through the same calculus we can see that we don't arrive at kelly.

Where did I go wrong?

I think the log is just the utility function. You could substitute it with any non-linear utility function and it would've gave you another answer that makes sense for that utility.

The main takeaway is that a linear expected utility doesn't make sense.

It would've told you to bet all your wealth every game, which does result in a higher linear expected value, where you win (1+1.1)^N with probability 1/2^N at time N, but 0 otherwise. But no real human would take the bet of extreme high payoff at extremely rare chances with ruin otherwise.

Also see St. Petersburg paradox for a similar "paradox" resolved with expected utility theory.