Comment by WarmWash

I agree with you here, but what's special about tech is that many of us learned all these terms fully casually while using computers as children and teenagers, which would be much less common for a chemist. That makes programmers see a lot of things as computer literacy that most people have rather than specialized knowledge.

My argument is that all the vocabulary for computer science are things. Even if they are virtual, they are tangible. You can draw a picture and label a box "bytes".

Nothing in the ChatGPT conversation is tangible. It's all in the realm of concepts.

Z is the ring of integers, t is a formal variable allowing us to discuss polynomials whose coefficients are in some ring. That’s what R[t] means: the ring of polynomials of the formal variable t with coefficients in R. Adding in t^-1 lets us include inverted terms like 2t^-3.

An algebra over a ring (call it S so we don’t confuse it with R from the previous paragraph) is a like a vector space over S, with the added structure that you can multiply elements of the algebra together (vector spaces only let you add their elements together). So for example the collection of even integers 2Z is an algebra over the ring of all integers Z. The collection of all polynomials with integer coefficients, Z[t], is another algebra over Z.

This is a great example of how dense language gets in math. There are tons of concepts hiding in the unstated background. Many are quite simple to explain individually, but there are so many of them that an outsider won’t know where to start to tease them apart. There’s a good reason to do it this way though; it would take a very long time to say anything in math without ever increasing levels of information density.

It's a class with an array of integers in it with .length() == t - 1 and the same methods as Matrix.

In lean4, even without mathlib4, TCP/IP is way more code than a Rees algebra.

Math uses dense notation that is gigaoverloaded, and the disambiguating context was historically the leisure and proximity to have someone explain what the lexemes even mean.

lean4 is proving to be very revealing as an uncorruptible referee on a lot of things, including the relative difficulty of computer science and complex analysis.

  -- A Rees algebra over ℤ[t⁻¹] is this.
  -- That's it. That's the whole thing.
  structure ReesAlgebra where
    coeffs : Array Int   -- integers, indexed by grade
    -- grade k means the coefficient sits at t^k
    -- negative indices are the t⁻¹ part

  -- The "algebra" part: you can add them
  def ReesAlgebra.add (a b : ReesAlgebra) : ReesAlgebra :=
    ⟨a.coeffs.zipWith b.coeffs (· + ·)⟩

  -- And multiply them (convolution, same as polynomial multiplication)
  def ReesAlgebra.mul (a b : ReesAlgebra) : ReesAlgebra :=
    sorry -- it's Array.foldl over index pairs (i,j) summing into slot (i+j)
    -- exactly how you'd multiply polynomials in a job interview

  -- That's the entire mathematical content of
  -- "The Rees algebra is an algebra over Z[t^{-1}]"
  --
  -- Compare: a minimal TCP SYN handshake in Lean4 would be
  -- ~200 lines before you even get to retransmission.
  --
  -- The notation is the gate, not the math.

I think you are snagging on thinking this is an observation about difficulty, time-to-mastery, or mental firepower requirements. It's not.

It's a plain observation that math exists on mostly it's own path with little to zero overlap with our lived experiences. If mathematics was a vector, it would have similar magnitude to other vectors, but it's direction would be much more removed from the typical knowledge pack, forcing you to get really close to the origin before you can "hop" over to that math vector. Other "knowledge" vectors, by virtue of being more bunched up, are closer together much further up, if that poor analogy at all makes sense.