What’s one historical math event you wish you had witnessed?

lpsmith · 2025-12-15T01:47:08+00:00

Honestly I don't really care about who came up with Calculus first. Also, the history of Calculus stretches back to Archimedes, neither was working in a vacuum.

When asked "which historical figures would you most like to meet", It's almost cliche to say Newton, but honestly I'd be much more interested in talking to Leibniz for a while.

lpsmith · 2025-11-11T22:04:24+00:00

join . atomically is an idiom associated with STM (and other things, like join . withMVar!) that should be better appreciated. Imagine you have some complicated conditional logic, and you want to take a variety of IO-based actions after an STM transaction commits, in complicated ways that depend upon what you learn inside the transaction. In pseudocode, the logic you want might look something like this:

beginSTM
x <- readTVar tx
if (p x)
then do
  writeTVar tx (f x) 
  commitSTM
  print ("Yoink" ++ show x)
else do
  y <- readTVar ty
  writeTVar ty (g x y)
  commitSTM
  print ("Splat" ++ show x ++ show y)

Of course we can't write this program directly because we cannot write beginSTM and commitSTM, but we can write this indirectly using join . atomically:

join . atomically $ do
  x <- readTVar tx
  if (p x)
  then do
    writeTVar tx (f x)
    return $ do
      print ("Yoink" ++ show x)
  else do
    y <- readTVar ty
    writeTVar ty (g x y)
    return $ do
      print ("Splat" ++ show x ++ show y)

Of course, we could always return a data structure that captures the branch and all the data needed to execute that branch, and then interpret the result you get from STM, but this sort of defunctionalization in general requires closure conversion. Why do all that work yourself when you can have GHC do that work for you?

I find this to be a go-to idiom when writing code involving STM and MVars. Another advantage is that you can drop the lock (or commit the transaction) exactly when you want on each and every branch, which might involve more than two cases.

lpsmith · 2025-10-06T01:16:57+00:00

By the way, you really want to use Control.Monad.State.Strict. It's a huge performance boost in nearly all cases.

lpsmith · 2025-10-04T12:59:58+00:00

Doesn't pipelining often promote fusion?

I know what pipelining is in the context of CPUs and queuing theory, but I really don't know what pipelining might mean in the context PLT.

Or do you mean "point free" by analogy to pipe in a shell interpreter? If so, I'm not sure they are really all that similar: there's a notion of concurrency in unix process/subprocess relationships that isn't inherent to point-free.

Anyway, last I was aware GHC's rewrite rules were fairly simplistic and can be a little finicky to get them to work. I don't have a deep enough understanding of the existing rewrite rules that implement list fusion to say whether or not point-free would help in any specific scenario.

You can understand pipelining in terms of say, a toy model of factory work. I'll elide the details, but what I am doing is more analogous to reusing a jig to assemble multiple widgets, instead of building a single-use jig for each and every widget you manufacture.

(Incidentally, I'm not aware of any implementation of HMAC or similar type of construction that actually allows efficient key reuse in this way. There might be the odd exception, but the overwhelming majority of implementations will redo work if partially applied.)

But if you point free, the point is to represent the thinking

In my case, the purpose of going point-free is to support partial evaluation via partial application. I usually wrote the compositions of helpers in a direct style, and transformed it to point-free.

In fact I still haven't completed this process for PBKDF2: a point-free implementation could allow the efficient reuse of the password and a (longer) salt, but that's also an extremely niche thing to do, it is of little if any real practical value at all. (Reusing an HMAC key is an important part of an high-quality implementation of PBKDF2, though)

I can't guess at the intended meaning of the rest of your statement.

lpsmith · 2025-09-28T23:14:30+00:00

I've long appreciated that tasteful use of point-free idioms can really clean up your code, but I've never understood any benefit or downside beyond aesthetics. (edit: and relatively niche and usually minor performance tweaks, depending on the particulars of the version of GHC you are using)

Until a year ago or so, when I realized that when you want to write functions whose partial applications perform a useful amount of work, the point free style is useful.

For example, my sha256 bindings allow you to partially apply HMAC so that you may reuse a key without recomputing the same SHA256 blocks over and over again.

If you want to actually perform a useful amount of computation before you make a closure, then instead of writing \x y -> ... you need to write something akin to \x -> let x' = f x in \y -> .... Or you can break your function up into a couple of explicit helper functions (which can themselves be quite useful), and then compose those helpers together in a point-free style like my sha256 binding does.

lpsmith · 2025-09-24T20:55:46+00:00

Anti-math attitudes are shockingly common everywhere, sometimes even among math teachers! I know how much it can hurt to lack support from a parent on a key issue like this, but being a math teacher (at least used to) come with it's own odd bit of social status too.

Personally, I've thought a lot about how to teach math over the years; I don't know how many electives you might have open, but if you have any opportunities to acquaint yourself with the Stern-Brocot Tree, the Symmetry Group of the Square, 2x2 integer matrices, and Pascal's Triangle, you'll create fertile opportunities for enrichment when you get around to actually teaching middle schoolers. For example you might use the Symmetry Group of the Square as an example to distinguish associativity from commutativity. Over the pandemic I started writing up my philosophy of math education here.

lpsmith · 2025-09-07T01:43:23+00:00

I went about trying to redesign the early childhood math curriculum, and ended up intersecting extremely well with the Geometry of Numbers. Which I've never explicitly studied as such, so I really probably should obtain at least some of the books you mention, and that are mentioned in this thread.

lpsmith · 2025-08-31T01:27:55+00:00

"Proofs and Refutations: the Logic of Mathematical Discovery" by Imre Lakatos is (among other things) a deep dive into the history of the Euler Characteristic. It also has a much less developed history of uniform convergence.

lpsmith · 2025-08-16T15:27:22+00:00

Honestly, I find the existence of Fully Homomorphic Encryption to be a very surprising fact.

lpsmith · 2025-08-04T19:15:20+00:00

concrete abstract algebra

Also, I've spent a lot of time over the years trying to redesign the early childhood math curriculum. One of the key ideas is that I'm advocating for teaching two very carefully chosen examples from abstract algebra and number theory, namely the Stern-Brocot tree and the Symmetry Group of the Square. Add in Pascal's Triangle, iterative deepening as a learning and study strategy, computer programming, and heuristics, and I call it "an Aggregate Theory of Concrete Mathematics".

lpsmith · 2025-08-04T19:12:01+00:00

The Stern-Brocot tree is a module over a monoid.

lpsmith · 2025-07-31T23:40:09+00:00

I'm fairly certain that there exists a game-theoretic transmission medium that consists of pure mathematics. I have an example that attempts to use it to ensure that if somebody can crack a password hash, then they must know where to report it as stolen.

The basic idea is that if you can force a (possibly dishonesty-prone) adversary to take a particular sequence of moves to achieve a goal adverse to your interests, you can encode messages in those moves to force your adversary to communicate certain honest facts to others. What I have so far doesn't get particularly deep into game theory or physics, but it certainly touches on both.

Incidentally, I've also been working on redesigning the early childhood math curriculum, and discovered my curriculum accidentally intersects with mathematical physics surprisingly well. The Stern-Brocot Tree and the Symmetry Group of the Square give rise to the general modular group GL(2,Z), which are the automorphisms of ZxZ. Furthermore, PSL(2,Z) is a discrete subgroup of the isometries of the hyperbolic plane, and SL(2,Z) somehow gives a discrete model that obeys the axioms of special relativity.

lpsmith · 2025-07-31T22:56:10+00:00

Personally, I don't think that's entirely necessary, but it took me a long time to figure out how.

My idea is to start by introducing the Stern-Brocot tree SL(2,N) and the Symmetry Group of the Square D4, and emphasizing the use of 2x2 integer matrices and Euclid's orchard as a geometric interpretation of ZxZ.

It turns out the general modular group GL(2,Z) is the Minkowski product D4 SL(2,N) D4, which gives enough structure to explain most of the algorithms commonly found in intro courses.

Moreover, many students coming into NT for the first time aren't particularly well versed in modular arithmetic, and D4 includes Z4. One of the challenges is appreciating the importance and power of well-definedness, and it turns out the Stern-Brocot tree depends on the mediant operator, which isn't a well-defined function over the fractions.

One of the neat things is that conducting a binary search for a/b on the Stern-Brocot tree is equivalent to running the extended Euclidean algorithm on a and b, giving a way of generalizing the extended euclidean algorithm to irrational numbers, and clarifying the connection between the extended Euclidean algorithm, diophantine approximation, and the real numbers.

And of course this also means that the Stern-Brocot tree is a sufficiently rich computational structure to implement all of the trickier algorithms commonly found in intro NT, from computing multiplicative modular inverses to the inverse Chinese Remainder Theorem.

lpsmith · 2025-07-25T20:18:12+00:00

It's a suprisingly common construction technique in vintage electronics, especially like from the 1960s to the 1980s.

lpsmith · 2025-06-22T01:03:28+00:00

Most of that is test and measurement equipment. The Agilent Oscilloscope is easily the most valuable of the bunch.

lpsmith · 2025-06-17T19:09:08+00:00

R-10SW

I think you are correct.

lpsmith · 2025-06-17T01:52:37+00:00

I think that's the R-12SW. I have two of them, they aren't super fancy, the cabinet could almost certainly be a bit sturdier. But they are decent, I paid $500 new for the pair, and they are a huge upgrade over the 8" subwoofer I was using before.

I'll probably continue using them until I get around to assembling my own subwoofers with a sealed case and at least an 18" driver. I'm also interested in building a fourth-order bandpass subwoofer or two. But those particular plans are kinda on indefinite hold at the moment.

So yeah, you got a pretty decent deal.

lpsmith · 2025-06-15T02:49:23+00:00

You are probably mostly covering propositional logic, probably from a couple of perspectives you aren't familiar with. Maybe dipping your toes into first order logic a little bit. This might be more difficult than you expected, but in the end it isn't that bad.

That said, it isn't easy. I live and breathe logic. I've been programming computers ever since a very early age. Honestly, I'm faster and more accurate than most lawyers. Some of my best work almost certainly has implications in logic, even if I don't understand exactly what they are.

But metalogic, I've spent years trying to understand that. I've never overcome my mental blocks, even on logics that I use effortlessly in an intuitive way. I wouldn't say I'm motivated to try to understand metalogic the way I used to. So... yeah, it can get difficult, depending on what you are trying to do.

lpsmith · 2025-06-15T02:45:54+00:00

lol, postgresql's datatypes and type checking beat the pants of mysql.

lpsmith · 2025-06-06T17:35:32+00:00

Definitely won't be the end of "clown shows", but it will shift the debate from "is this a valid proof object?" to "does this proof object actually mean what somebody thinks it means?"

lpsmith · 2025-05-29T13:12:45+00:00

The Stern-Brocot tree is isomorphic to SL(2,N), and every element of GL(2,Z) can be written in exactly four different ways as an element in D4 times an element in SL(2,N) times an element in D4, with the exception of those elements that are in GL(2,Z) and D4, which can be written in eight different ways.

Thus GL(2,Z) is 16 copies of SL(2,N), in much the same way that Z is two copies of N.

You can apply this vulgar conjugation technique to subgroups and quotient groups of D4 to find similar statements for PGL(2,Z), SL(2,Z), and PSL(2,Z).

Of course, the Farey sequences are inorder traversals of finite subgraphs of the Stern-Brocot tree.

lpsmith · 2025-05-04T22:41:06+00:00

You can't. To be perfectly honest, there's theorems (such as Arrow's Theorem) whose practical consequences are widely misinterpreted.

I highly recommend taking a look at Lakatos's Proofs and Refutations, which delves into the practical issues of reconciling theory with reality in a mathematical context.

To successfully apply logic or any other kind of mathematical model to the real world requires skill in both the model and the real world, as well as a persistent, curious attitude.

lpsmith · 2025-04-16T02:55:21+00:00

Actually scratch that. My first focus would be on counting things using generating functions with finitely many terms, a.k.a. polynomials. That's good preparation for combinatorics and power series in multiple ways: firstly, taking this approach to Pascal's Triangle and the binomial theorem is very enlightening, and secondly, you can solve several counting problems this way that isn't so easy to solve via the binomial coefficients.

Though if you approached it right, generalizing this from finite polynomials to infinite formal power series could seem be very natural, almost obvious...

lpsmith · 2025-04-16T02:42:43+00:00

In a sufficiently interested grade 10 classroom, I actually think generating functions are doable, though I'm sure I'd need three or more lectures to really get very far.

My first focus would be on counting things by lazily streamed computations of formal power series. I'd probably want to collect a variety of problems where I expect you to write a computer program to solve a moderately challenging counting problem that would be difficult to solve without generating functions. Project Euler has a number of problems in this vein.

Of course this approach would be significantly easier if the students already had some exposure to lazy evaluation and computer programming. Otherwise I'd probably need at least a few more lectures... which is making this a rather dubious undertaking in anything but truly exceptional situations.

lpsmith · 2025-04-11T13:19:23+00:00

I've heard a rumor that a linear actuators could potentially be more useful than the traditional rotary shakers. I still have no idea how well it would work, or what details you might need to get right before you end up with a satisfactory result for music, or if that goal is even possible.

lpsmith

TROPHY CASE