Maybe it’s just my math background shouting at me about what “model” means, but if object X models object Y, then I’m going to say that X is Y. It doesn’t matter how you write it. You can write it as R^2 if you want, but there’s some additional mathematical structure here and we can recognize it as C.

Mathematicians love to come up with different ways to write the same thing. Objects like R and C are recognized as a single “thing” even though you can come up with all sorts of different ways to conceive of them. The basic approach:

1. You come up with a set of axioms which describe C,

2. You find an example of an object which follows those rules,

3. That object “is” C in almost any sense we care about, and so is any other object following the same rules.

You can pretend that the complex numbers used in quantum mechanics are just R^2 with circular symmetries. That’s fine—but in order to play that game of pretend, you have to forget some of the axioms of complex numbers in order to get there.

Likewise, we can “forget” that vectors exist and write Maxwell’s equations in terms of separate x, y, and z variables. You end up with a lot more equations—20 equations instead of 4. Or you can go in the opposite direction and discover a new formalism, geometric algebra, and rewrite Maxwell’s equation as a single equation over multivectors. (Fewer equations doesn’t mean better, I just want to describe the concept of forgetting structure in mathematics.)

You can play similar games with tensors. Does physics really use tensors, or just things that happen to transform like tensors? Well, it doesn’t matter. Anything that transforms like a tensor is actually a tensor. And anything that has the algebraic properties of C is, itself, C.

If you haven't read to the end of the post, you might be interested in the philosophical discussion it builds to. The idea there, which I ascribe to, is not quite the same as what you are saying, but related in a way, namely, that in the case that X models Y, the mathematician is only concerned with the structure that is isomorphic between them. But on the other hand, I think following "therefore X is Y" to its logical conclusion will lead you to commit to things you don't really believe.

I would love to hear an example… but before you do, I’m going to clarify that my statement was expressing a notion of what “is” sometimes means to a mathematician, and caution that

1. This notion is contextual, that sometimes we use the word “is” differently, and

2. It requires an understanding of “forgetfulness”.

So if I say that “Cauchy sequences in Q is R” and “Dedekind cuts is R”, you have to forget the structure not implied by R. In a set-theoretic sense, the two constructions are unequal, because you use constructed different sets.

I think this weird notion of “is” is the only sane way to talk about math. YMMV.

(Of course using "is" that way in informal discussion among mathematicians is fine -- in that case everyone is on the same page about what you mean by it usually)

It’s reasonable to want to express that difference in specific circumstances, but it would be completely unreasonable to make this the default.

For example, I can say that Z is a subset of Q, and Q is a subset of R. I can do this, but maybe you cannot—you’ve expressed a preference for a more rigid and inflexible terminology, and I don’t think you’re prepared to deal with the consequences.

It's helpful sometimes to think of our collective body of mathematical knowledge as like a "codebase", and our notations and concepts as the "interface" to the abstractions at play within. Any software engineer would immediately acknowledge that some interfaces are FAR better than others.

The complex numbers numbers are one interface to the thing they model, and as you say, in a certain sense, it may be the case that the thing is C. But other interfaces exist: 2x2 antisymmetric traceless matrices, or a certain bivector in the geometric-algebra sense.

Different interfaces: a) suggest different extensions, b) interface with other abstractions more or less naturally, c) lend themselves to different physical interpretations d) compress the "real" information of the abstraction to different degrees.

An example of (a): when we first learn about electric and magnetic fields we treat them both as the "same kind of thing"—vector fields—only to later find they are not (B is better thought of as bivector field, or better still, both are certain components of dA). The first hint is their different properties under reflections and rotations. "E and B are both vector fields" is certainly an abstraction you CAN use, but it is poorly-matched to the underlying abstraction and winds up with a bunch of extra epicycles.

Of (d): you could of course write all of quantum mechanics with `i` replaced by a 2x2 rotation matrix. (This might be "matrix mechanics", I'm not sure?) This gives you many more d.o.f. than you need, and a SWE-minded person would come in and say: ah, see, you should make invalid states unrepresentable. Here, use this: `i = (0 -1; 1 0)`. An improvement!

Of (b): the Pauli matrices, used for spin-1/2 two-state systems, represent the quaternions. Yet here we don't limit ourselves to `{1, i, j, k}`; we prefer a 2-state representation—why? Because (IIRC) the 2 states emerge intuitively from the physical problems which lead to 2-state systems; because the 2 states mix in other reference frames; things like that (I can't really remember). Who's to say something similar doesn't happen with the 2 states of the phase `i`, but that it's obscured by our abstraction? (Probably it isn't, but, prove it!)

I have not given it much more thought than this, but, I find that this line of thinking places the "discontent with the complex numbers in physics" a number of people in this thread attest to in a productive light. That dissatisfaction is with the interface of the abstraction: why? Where was the friction? In what way does it feel unnecessarily mystifying, or unparsimonious?

Of course, the hope is that something physical is obscured by the abstraction: that we learn something new by viewing the problem in another frame, and might realize, say, that the interface we supposed to be universally applicable actually ceases to work in some interesting case, and turns out to explain something new.

Amazon has demonstrated a preference for “unregretted attrition” (URA). URA is the name for what happens when engineers exit the company and Amazon is happy that they do. The exit can either be due to a PIP failure (performance improvement plan) or just unhappiness with the company. If you believe URA works well, then URA is how Amazon gets rid of low-performing employees. If you are like me, then you believe that URA is mostly explained by the following factors:

- Failure of Amazon to successfully develop engineers. A good company will turn engineers into better engineers, and Amazon gets rid of them instead, which is inefficient. The attrition is only unregretted because Amazon was not competent enough to develop these engineers into better engineers.

- Consequences of poor culture, causing good engineers to mentally check out and eventually leave. The attrition is only unregretted because the good engineers will care less and therefore look like bad performers, when they’re good performers in a bad environment.

- A way for Amazon to avoid paying out stock grants at the 2-year mark (which is when you get most of your stock grants at Amazon). The attrition is only unregretted because somebody at Amazon cares more about the short-term bottom line.

- A way for managers to exercise control over employees they don’t like. The attrition is only unregretted because Amazon’s decisions about employee performance are based on bad data provided by managers.

I won’t share stories here but the targets are around 5% per year, maybe a little higher.

I can’t understand how people would run agents 24/7. The agent is producing mediocre code and is bottlenecked on my review & fixes. I think I’m only marginally faster than I was without LLMs.

And specifically: Lots of checks for impossible error conditions - often then supplying an incorrect "default value" in the case of those error conditions which would result in completely wrong behavior that would be really hard to debug if a future change ever makes those branches actually reachable.

I don’t know where the LLMs are picking up this paranoid tendency to handle every single error case. It’s worth knowing about the error cases, but it requires a lot more knowledge and reasoning about the current state of the program to think about how they should be handled. Not something you can figure out just by looking at a snippet.

At the same time, the amount of anti-patterns the LLM generates is higher than I am able to manage. No Claude.md and Skills.md have not fixed the issue.

Building a production grade system using Claude has been a fools errand for me. Whatever time/energy i save by not writing code - I end up paying back when I read code that I did not write and fixing anti-patterns left and right.

I rationalized by a bit - deflecting by saying this is AI's code not mine. But no - this is my code and it's bad.

This is starting to drive me insane. I was working on a Rust cli that depends on docker and Opus decided to just… keep the cli going with a warning “Docker is not installed” before jumping into a pile of garbage code that looks like it was written by a lobotomized kangaroo because it tries to use an Option<Docker> everywhere instead of making sure its installed and quitting with an error if it isn’t.

What do I even write in a CLAUDE.md file? The behavior is so stupid I don’t even know how to prompt against it.

Think about it, they have to work in a very limited context window. Like, just the immediate file where the change is taking place, essentially. Having broader knowledge of how the application deals with particular errors (catch them here and wrap? Let them bubble up? Catch and log but don't bubble up?) is outside its purview.

I can hear it now, "well just codify those rules in CLAUDE.md." Yeah but there's always edge cases to the edge cases and you're using English, with all the drawbacks that entails.

In particular writing tests that do nothing, writing tests and then skipping them to resolve test failures, and everybody's favorite: writing a test that greps the source code for a string (which is just insane, how did it get this idea?)

The assumption is that your test is right. That's TDD. Then you write your code to conform to the tests. Otherwise what's the point of the tests if you're just trying to rewrite them until they pass?

If a historian is going to uncover personal accounts from 2026, then they’ll be full of people who are struggling to make ends meet but are still drowning in a sea of inexpensive consumer electronics.

Of course inflation measurements are also flawed but that once again gets back into the broad point about how the reality of people is so much more relevant than any given number, especially once those numbers become seen as a goal to maximize, at any cost.

  .blog-entry p:first-letter {
    font-size: 1.2em;
  }

https://www.newyorker.com/business/currency/is-passive-inves...

March 9, 2016

> O’Neill fears that the result will be a “bubble machine”—a winner-take-all system that inflates already large companies, blind to whether they’re actually selling more widgets or generating bigger profits.

Part of the problem is that if you look at the stellar long-term performance of indexes, they are largely explained by a small number of stocks in the index that perform extremely well… but you don’t know ahead of time which stocks those are. If you want the performance of the S&P500, you need a similarly diversified portfolio, the theory goes. It is hard to get a portfolio with that kind of diversity unless you buy index funds.

When index funds grow to huge levels of assets under management, their own asset allocations come to make up a significant portion of the market cap of the stocks in the portfolio. Thus the cap-weighted investment strategy becomes a self-fulfilling prophecy.

Either you’re doing the math wrong or you’ve skipped some steps.

Let’s say you have companies X and Y, each with 50% of the market. X is a winner, and the stock price goes from $10 to $45. Y is a loser, and the stock price drops from $10 to $5. The new weight is X=90% and Y=10%.

But this cannot be a self-fulfilling prophecy for index funds, because the index funds do not have to buy or sell any shares of X or Y to keep up (I mean rebalance, specifically). In this scenario, the index funds are just holding. (By “holding” I mean “not rebalancing”.)

This is… an oversimplified scenario. But it illustrates the problem here with the “index funds cause a small number of stocks to be winners” theory. There are alternative theories that make sense, but not this one.

(What makes the scenario more complicated is when you think of buybacks, dividends, delisting, etc.)

When they're more concentrated in specific holdings, and have enough new money, wouldn't that artificially support higher prices for those holdings (above what the market would otherwise bear)?

The sensible and consistent way to this is that... Index funds don't really have any effect on relative stock prices. If stock A is overvalued or undervalued, it's due to active investors being morons.

I do understand how they can stabilize allocations where they are, which I think is the concern. Zombification rather than a positive feedback loop.

Trying to beat the market is playing a zero sum game. Someone has to lose for you to win. I understand savvy winners add information, but most winners are just lucky and it still makes me uneasy to play a zero sum game.

When you simply try to match the market, you float on the tide that mostly raises all boats and sometimes lowers them. That sits much better with me.

In other words, the risk is to miss the winners, not that you will invest in a loser.

The problem is that it is very hard to predict the winners, so it is best to invest in all companies to make sure you have the winners