Nathan McRae

Order-of-Magnitude Ternary Graphs

2025-10-09T00:00:00-07:00

Ternary graphs are a type of two-dimensional graphs with three axes. The axes are not perpendicular, but at 60° from each-other, like an equilateral triangle. Because of this, the variables the three axes represent necessarily cannot be independent. Instead of representing arbitrary relationships between two variables like a typical graph ternary graphs represent three variables which always sum to a constant.

For some visual intuition of how this works, see below where we move a point along axis C two units. Since axes A and B aren't perpendicular to C, this means that the point moves some along them as well.

In axes A and B the point moves one unit each, countering the amount added by axis C[ref]Depending which direction the axes are oriented[/ref]. Whatever value the three variables added up to at the first point, they will add up to at the second point. And this is true no matter what direction you move in.

Ternary graphs are usually used to see how three components of a mixture add up to 100% like in this soil type chart:

[ref] https://creativecommons.org/licenses/by-sa/4.0/deed.en Author: cmglee, Mikenorton, United States Department of Agriculture[/ref]

One thing to note is that in these graphs, the three axes are oriented at 60° from the graph edges. You can see this by how they orient the percentage labels. This is done because when one component is 0%, you still need to represent the entire range of mixtures of the other two. To fit this in a graph where the axes are perpendicular with the graph edges (like we're used to with two axis graphs) you end up with a lot of wasted space:

So to avoid this, these graphs are presented with the unusable space chopped off and the whole thing rotated to a more natural orientation. This is worth doing if you're making these composition graphs, but otherwise I believe it is more readable to keep the graph axes parallel to the edges of the graph like normal graphs.

So ternary graphs are neat as a concept, but I'm specifically interested in using them to illustrate order-of-magnitude relationships. They are particularly suited to this because they can represent linear relationships of three variables (i.e. $a = b \times c$). This works because when you take the logarithm of the equation, it becomes additive: $log(a) = log(b) + log(c)$. This means we can take any linear relationship and plot it out on an order-of-magnitude ternary graph which is whats going on in the first graph of the post where we see the listed 'energy events' plotted out.

Plotting these relationships out can help illuminate the patterns that emerge when considering things from an order-of-magnitude perspective. For example, if we graph out the relationship between mass, volume, and density for major solar system objects, we get this:

Here we see that even though the volume and mass varies greatly, there are just two rough categories of density. But even if there is no visual pattern that needs deciphering, having the data layed out is a good way to quickly reference order-of-magnitude values.

The relationships don't even strictly need to be linear. For example, as an experiment I graphed out the stellar intensity vs. temperature and radius for a number of stars which is $L = 4 \pi R^2 \sigma T^4$[ref]Where $\sigma$ is the Stefan-Boltzmann constant[/ref].

Notice how for example if we increase radius by a factor of ten while keeping temperature constant, then Luminosity increases by a factor of 100 (i.e. we move one full tick on the radius axis without moving on the temperature axis, then we move two ticks on the luminosity axis).

This does introduce some issues which I have not found a satisfactory solution for yet. For example, look at Pollux on the graph. Notice how it sits on the tick marks for E28 W Luminosity and E10 m Radius, but in between E3 and E4 K Temperature whereas its actual temperature is best represented by E4 K. If we were to move it to any other position it would not be clear what its luminosity and radius are since it's already at the intersection of those two ticks. To indicate that it's actually E4 K, I added a little arrow to it pointing in that direction along the temperature axis. This is serviceable, but not particularly clear. As of yet I have not been able to come up with anything I feel is better suited.

Honestly I think that, as a visualization tool, ternary graphs of order-of-magnitude relationships are more of a curiosity and experiment for me right now. It's fascinating that these relationships can be represented this way, and the visual stimulation of the graphs is valuable to draw someone in and make them think about the relationship being represented. However, as far as whether the technique is generally effective or efficient I think is still an open question.

Addendum: Representing Mismatched Estimations

Every order-of-magnitude value is an approximation, for example E3 is an approximation of 450. However, when you have approximations of three different numbers in a relationship like one of the above, the sum of the approximations might not match the approximation of the sum. Suppose we have an energy event we want to plot on the graph above where the event's time is 390 s, it's power is 501 W and so the total energy of the event is 195,390 J. However, taking the order-of-magnitude of these values we get E3 s, E3 W, but E5 J. Of course $3 + 3 \ne 6$ which is a natural hazard of these kinds of approximations, but that leaves us with a dilema of how to represent this on the graph. There is no intersection of these three values at a single point.

To deal with this, ideally we'd be able to represent 1. the exact values of the data point 2. the fact that those values don't match up. I have not found a single satisfactory solution, but here are some possibilities:

1: Use a triangle. By placing a triangle between tick marks, the edges can line up with the data point's tick marks and the different shape indicates that this data point is unusual.

This is clever, but is just not visually intuitive. If you included this in a graph, you would probably need something to explain it (although ternary graphs are unusual enough you would probably need that anyway).

2: Use a (slightly different) triangle. By using a triangle with rounded corners with the same radius as the other data points, this should hopefully indicate that the value could be any one of the values covered by it.

While this (hopefully) deals with the visual ambiguity, it introduces some data ambiguity. First, it's not clear which of the values is indicated by it. Second, it's not clear that this data point is mismatched. For example you could use the same technique to indicate a case where the value may vary which is what I did in the graph at the top. This is used to represent the range of values I found while getting data on punch energy genuinely do range over the values that the spread data point covers[ref]Not that the values range over an order-of-magnitude, but that they span the break-point between two orders-of-magnitude[/ref]. In this case I did not use this technique to indicate that there was a mismatch but if I did make a habit of that it might be less clear what I was trying to convey here.

3: Punt. This is the technique I have used so far. If you have a choice of what data points to include in the graph, and you don't need to include a mismatch point, then you can just not include it.

Brutalist Product Design: Mattress Cooler V2 as a Case Study

2024-08-04T00:00:00-07:00

Brutalist architecture has often been more about the aesthetics of simplicity and functionality rather than simplicity and functionality themselves. Still, it has always held the promise of designs which are the result of dedicated focus on that functionality, and I've spent much time speculating about how many things—cars, computers, appliances—would look if they had been designed like that. Examples of these are rare, but the redesign of the Mattress Cooler is one of them.

Background

The Mattress Cooler is a product that does exactly what it says and is made by a company of the same name. Briefly, it has a reservior of water and a pump which circulates water through a mat on top of your mattress to keep you cool. After the water comes back from the mat it is dripped over an evaporation pad which is in front of a fan to increase evaporation and keep the water cool.

The outside of the cooler looks fairly conventional for a household appliance. It has two ports on the side to connect the tubes which lead to the mat. On top there are some buttons and a display for control, and a panel which you can remove to add water to the cooler.

Inside, there's the reservior, the fan, the evaporative pad, and a miscellanea of wiring and plumbing.

The pad is not shown because it was gross

This original version is about par for the course as far as a household appliances. The case, reservior, and brackets are all injection-molded plastic with screws to hold them together. It could have easily come out of any of the dozens of corporations that make this class of product. However, the successor to this version is far less conventional.

Version 2

The original version of the mattress cooler was discontinued and a significantly different one was released as a replacement. Here you can see it on the right. We'll look the differences between them broken down into the body/construction, plumbing, and electrical systems.

The opening on the top of the new one is for filling it up. It comes with a funnel that fits the opening.

Body

The most obvious difference in the new design (when you see it up close) is the fact that it is almost entirely 3D printed (the whole gray case on top). Taking off the lid we see that it has an integrated drip trough where the water can drip down on to the filter after being pumped through the mat.

One of the neatest bits of the new design is that the evaporative 'pad' is 3D printed as well. It uses what looks like a gyroid infill pattern that allows the air from the fan to flow over the water as it's dripping down.

The main part that's not 3D printed is the reservior which is simply a rectangular injection-molded box which the body of the cooler sits nested just inside the lip of.

Plumbing

In the original version, there were several separate pieces of the rubber tubing to route the water between the ports, the drip trough, and the reservior. In the new version, the tubes from the mat are routed through the body directly to the pump and the drip trough. This means no additional tubing is needed. The new version also has a black, 3D printed downspout that guides water down into the reservior to avoid splashing noises.

So far the new version has managed to significantly reduce part count and complexity, but it does so even more aggresively for the electrical system.

Electrical

In the original, there was the fan and pump, but also: buttons, a 7-segment display, an ion generator, a float sensor, even an IR sensor (maybe some versions came with a remote control?), and of course the microcontroller to integrate them all together.

The new version only has the fan and the pump, both of which are commercial off-the-shelf parts. The fan fits in the slot in the 3D printed body, and the pump sits on suction cups on the bottom of the reservior. Both have stock cables which are simply routed outside the body. This means that virtually no extra components are need for integration.

Now the only control for the cooler is the power supply, which has a knob that alters the voltage going to both the fan and the pump and therefore adjusts the speed of both.

Advantages

From the user's perspective this stripped-down design is a huge advantage since everything is simple enough that 3D printing replacements should be pretty straightforward (though the evporative 'pad' might take some tinkering with). You could even make some modifications or improvements easier than for something designed more conventionally.

Even if you don't want to print anything yourself, the fact that the manufacturer is not relying on whichever supplier has the molds for their parts means that you're much more likely to be able to get spare parts. This is particularly true for the evaporative pads since it's clear this was a problem with the previous generation of pads (which are no longer available for purchase).

The redesign also made some incremental improvements not related to the total design overhaul:

The analog voltage control makes finding the sweet spot for temperature easier since in the original version there were only discrete steps to control fan speed and duty cycle.
The reservior is larger in this version which makes it much less likely that water from the mat will overflow the cooler.

Disadvantages

Stripping down the design and functionality does have some trade-offs:

The new version doesn't auto-shutoff if the water level gets too low, it just sits there making weird noises until you turn it off.
No timer. The original had a shutoff timer which was convenient. Of course the design of the new one allows you to just plug it into an outlet timer if you want.

You could even plug the cooler into one of the outlet timers that runs on a daily schedule, that way it could turn itself on automatically at bedtime. This wouldn't have been possible with the original since it does not run automatically when given power.
You can't see the level of the water in the reservior. It seems like the most direct way to deal with this would've been to have a transparent or translucent reservior. That might've had the side-benefit of encouraging you to clean it more since you could see the gunk build up.
Since the tubes from the mat are routed through the cooler body, it looks like replacing the mat (which is a consumable and needs to be replaced every ~6 months) will be more of a pain than the original version where the tubes just plugged into the side of the body.
Since the body is 3D printed, which tends to produce porous parts that will always have higher surface area than the equivalent injection-molded part, I'm concerned this will lead to more bacterial growth. This might require more regular cleaning than the original.
The aesthetics of the new one are a significant downgrade from the original when seen up close. The 3D printing lines are very apparent, and the edges around the top are actually a little sharp where they were attached to the print bed. Personally I'm not concerned about this, but I could see someone wondering why they paid $100+ for this kind of (superficial) quality.

For me, the lack of auto-shutoff and having to deal with the tube routing when replacing the mats are the only two serious downsides.

Conclusion

This design radically simplifies, strips out non-essential functionality, and drops part count to the bare minimum. Time will tell whether the redesign will be worthwhile, but for myself I'm much happier having a version that is simpler and more repairable.

Subcommit Git

2024-07-20T00:00:00-07:00

Git is my go-to version control system, but I first learned source control on SourceGear Vault. While I've appreciated getting comfortable with git and would not go back, there are some features of Vault that I miss. In particular, Vault is a mono-repo, and so each project is simply a subfolder in that repo. This way, each folder has its own version at any given time. While you can have a mono-repo in git and there are various ways of mixing and matching repos, it's still not very natural to treat each directory as having its own history and version information.

So I wanted to see how git could be modified to include this and it turns out to be pretty easy to adjust the core data structure to accomodate this. This shouldn't be considered as a serious proposal, but just an exploration of an alternate universe of git.

To make this concrete I implemented it on top Write Yourself A Git, which would make a for a simple starting point. My code is here.

Background

To see how we're modifying git, you'll need to know about how git structures its data. If you don't know anything about this at all, I suggest the Pro Git book's Git Internals chapter, particularly the Git Objects section.

In a regular git repository, we have a branch which points to a particular commit. That commit will point to a parent commit, and also to a tree object, corresponding to the top-level directory of the repository. That tree objects then points to the blobs (files in the repository), and other tree objects (subdirectories in the repository). In this way the commit represents the state of the repository at the time the commit was made.

What we're changing

In order to give each tree its own history, we will need commit objects pointing to each tree. This means that instead of pointing to other tree objects, trees will point to subcommits. These subcommits then point to the parent subcommit for that tree (i.e. last time the tree changed).

Note that subtrees are only updated with new subcommits when the contents of the tree changes, so the chain of subcommits 'skips' changes in the main commit chain that don't modify the subcommit's corresponding subdirectory.

Use-Case: Extracting history for a subdirectory

It is possible in vanilla git to extract the history of a directory (using git subtree) and use that to share the history of a subdirectory with another repository. However, the problem with this is that 1. the commits for the subtree have to be generated at the time of the split 2. after integrating the subtree into another repository there will be no clear indication of where the commits came from. By using subcommits, the history of the directory is already available to split out. And when the subcommits are brought to another repository, they will have the exact same hashes as the subcommits from the original repository.

Demo Repository

There is a demo subcommit-git repository in the project repository.

Is this a Good Idea?

No, probably not as such. Setting aside the fact that this is incompatible with vanilla git, this is more an exploration of an idea rather than a serious proposal.

Order-of-Magnitude Local Knowledge

2023-11-04T00:00:00-07:00

How well do you know the place you live? Try to find the answers to these questions for yourself and learn them to the nearest order-of-magnitude.

For your town / city:
- How many people live there?
- What is its area?
- How much electricity does it use?
- What is the area's GDP?
What is the nearest significant body of water and what is it's area?
- What is its volume?
What is the nearest significant river and what is its flow rate?
What is the area and yearly flow of your watershed?
For your province / state:
- How many people live there?
- What is its area?
- How much electricity does it use?
- Check how much of a major product is exported.
What is the nearest power station and how much does it produce?
If there is a nearby port, airport, or train terminal, how much cargo goes through it daily or yearly?
What is your annual precipitation?

A lot of these are subjective. What counts as a 'significant' body of water? If you can think of one near you that's probably it, though you may check a map and be surprised.

My Answers

Seattle metropolitan area
- E7 (4,102,400) persons
- E10 (1.52E10) m²
- E9 (1.05E9) W
- E12 (4.8E11) USD / yr.
Lake Washington: E8 (88E6) m²
- E9 (2.9E9) m³
Cedar river: E1 (18.7) m³/s (average)
Cedar river watershed: E9 (3.668E8) m²
Washington state
- E7 (7,785,786) persons
- E11 (1.8E11) m²
- E10 (1.028E10) W
- Civilian aircraft: E10 (16.7E9) USD / yr.
Jackson Hydrolectric Project: E8 (112E6) W
Northwest Seaport Alliance: E10 (28E9) kg / yr.
E0 (0.998) m

Nibble-Precision Floating Point

2023-11-02T00:00:00-07:00

Why would you need values larger than 3? Just use ∞.

Datatype-Generic Programming in Lean4

2023-09-09T00:00:00-07:00

A while back I ran across the paper Datatype-Generic Programming by Jeremy Gibbons and wanted to implement it. Lean4 is a language meant primarily for formalizing mathematics, but also is geared towards more conventional functional programming and so would be a good fit for this.

The goal here is just to go through implementing the idea both to help understand it as well as get some experience with Lean. Whether or not the implementation is good, or whether implementing it at all is a good idea are out-of-scope.

Background - Generic Programming

Typical generic programming (the paper discusses many other kinds) abstracts data structures and functions on them where they only differ by an underlying type.

For example, if we have the type of lists of integers and the type of lists of strings, we might end up with two different append functions that look nearly identical.

inductive ListI where
| Nil : ListI
| Cons : Int → ListI → ListI

def AppendI (a b : ListI) : ListI :=
match a with
| ListI.Nil => b
| ListI.Cons head rest => AppendI rest (ListI.Cons head b)

inductive ListS where
| Nil : ListS
| Cons : String → ListS → ListS

def AppendS (a b : ListS) : ListS :=
match a with
| ListS.Nil => b
| ListS.Cons head rest => AppendS rest (ListS.Cons head b)

By using generic programming we can write a single List type and a single Append function that are both parametized by the underlying type.

inductive List (a : Type) where
| Nil : List a
| Cons : a → List a → List a

def Append {a : Type} (a b : List a) : List a :=
match a with
| List.Nil => b
| List.Cons head rest => Append rest (List.Cons head b)

Background - Datatype-Generic Programming

Similarly, when you have an inductive datatype like a list or a tree we have some common functions we can define on them like map or fold:

inductive List (α : Type) where
| Nil : List α
| Cons : α → List α → List α

def mapL {α β : Type} (f : α → β) : (List α → List β) := fun l1 =>
  match l1 with
  | List.Nil => List.Nil
  | List.Cons head rest => List.Cons (f head) (mapL f rest)

def foldL {α β : Type} (seed : β) (f : β → α → β)  (list : List α) : β :=
  match list with
  | List.Nil => seed
  | List.Cons head rest => f (foldL seed f rest) head

inductive BTree (α : Type) where
| Tip : α → BTree α
| Bin : BTree α → BTree α → BTree α

def mapB {α β : Type} (f : α → β) (t : BTree α) :=
  match t with
  | BTree.Tip a => BTree.Tip (f a)
  | BTree.Bin left right => BTree.Bin (mapB f left) (mapB f right)

def foldB {α β : Type} (g : α → β) (f: β → β → β) (tree : BTree α) : β :=
  match tree with
  | BTree.Tip val => g val
  | BTree.Bin left right => f (foldB g f left) (foldB g f right)

Here you have to squint a little bit, but the two maps and folds are doing very analogous things. The paper emphasizes that the differences between the functions are solely due to the 'shape' of the data structures they are operating on. If we can abstract away that 'shape', then we'd be able to only have one of each function that works on List, Map, and most any other inductive data type we'd need to use.

Implementation

The way to abstract the shape is using the somewhat mysterious Fix datastructure:

unsafe inductive Fix (s : Type → Type → Type) (a : Type) : Type
| In : s a (Fix s a) → Fix s a

-- This is the reverse of the In constructor
unsafe def out (s : Type → Type → Type) (a : Type) (t : Fix s a) : s a (Fix s a) :=
  match t with 
  | Fix.In x => x

We need to define Fix with 'unsafe' because Lean requires all code to terminate and so doesn't allow inductive datatypes with the type of recursion the Fix requires. I'm not sure whether there's a way around this, but for this implementation it doesn't matter much.

Here, the s parameter is the 'shape' that we're trying to abstract and a is the underlying type parameterizing that shape (e.g. Int or String in the above examples).

So what do these 'shapes' look like? Essentially they are identical to the inductive datatype definitions but with an extra parameter passed to recursive cases. We then define the actual datatypes using Fix and these 'shape' types:

inductive ListF (α : Type) (β : Type) : Type where
| Nil : ListF α β
| Cons : α → β → ListF α β

unsafe def List (α : Type) := Fix ListF α

inductive BTreeF (α : Type) (β : Type) : Type where
| Tip : α → BTreeF α β
| Bin : β → β → BTreeF α β

unsafe def BTree (α : Type) := Fix BTreeF α

To make things more concrete let's look at how to create the elements of the actual data types. To do this, we just pass the constructors for the shape type to the Fix.In constructor:

unsafe def List.Nil {a : Type} : List a := Fix.In ListF.Nil
unsafe def List.Cons {a : Type} (head : a) (rest : List a) : List a := Fix.In (ListF.Cons head rest)

unsafe def BTree.Tip {a : Type} (tip : a) := Fix.In (BTreeF.Tip tip)
unsafe def BTree.Bin {a : Type} (l r : BTree a) := Fix.In (BTreeF.Bin l r)

The last thing we need to do before implementing the datatype-generic functions is to implement a 'bimap' for the shape types. This allows us to take a function and apply it to the underlying type of shape types. The behavior is captured by the Bifunctor type class:

class Bifunctor (F : Type → Type → Type) where
(bimap : ∀ {α α' β β'}, (α → α') → (β → β') → F α β → F α' β')
export Bifunctor ( bimap )

Types that are meant to be bifunctors must in theory satisfy a few properties which we will bypass here for brevity. So all we need to do is implement bimap:

instance : Bifunctor ListF where
  bimap := fun {γ : Type} {γ' : Type} {β : Type} {β' : Type} (f : γ → γ') (g : β → β') (t: ListF γ β) => match t with
    | ListF.Nil => ListF.Nil
    | ListF.Cons head rest => ListF.Cons (f head) (g rest)

instance : Bifunctor BTreeF where
  bimap := fun {γ : Type} {γ' : Type} {β : Type} {β' : Type} (f : γ → γ') (g : β → β') (t: BTreeF γ β) => match t with
    | BTreeF.Tip tip => BTreeF.Tip (f tip)
    | BTreeF.Bin l r => BTreeF.Bin (g l) (g r)

Now we'll just implement the datatype-generic functions by copying from the paper without comment:

unsafe def map (α β : Type) [Bifunctor s] (f: α → β) : (Fix s α → Fix s β) :=
  Fix.In ∘ bimap f (map α β f) ∘ (out s α)

unsafe def fold (α β : Type) [Bifunctor s] (f: s α β → β) : (Fix s α → β) :=
  f ∘ bimap id (fold α β f) ∘ (out s α)

And there we have it. As an example usage, let's make our data structures instances of ToString using fold:

unsafe instance [ToString α] : ToString (Fix ListF α) where
  toString (list : List α) : String :=
    fold α String (fun foo : ListF α String => match foo with
    | ListF.Nil => ""
    | ListF.Cons head rest => s!"{head}, {rest}") list

unsafe instance [ToString α] : ToString (Fix BTreeF α) where
  toString (tree: BTree α) : String :=
    fold α String (fun foo : BTreeF α String => match foo with
    | BTreeF.Tip tip => toString tip
    | BTreeF.Bin l r => s!"({l} {r})") tree

Conclusion

Aside from just being practice translating the concept from the paper to code this leaves something to be desired. Aside from the ergonomic issue of having everything downstream of Fix needing to be defined as 'unsafe' there's the core issue for the fold function that requires you break down the 'shape' type into cases.

Still an interesting exercise though.

Appendix: Full Code

class Bifunctor (F : Type → Type → Type) where
(bimap : ∀ {α α' β β'}, (α → α') → (β → β') → F α β → F α' β')
export Bifunctor ( bimap )

unsafe inductive Fix (s : Type → Type → Type) (a : Type) : Type
| In : s a (Fix s a) → Fix s a

unsafe def out (s : Type → Type → Type) (a : Type) (t : Fix s a) : s a (Fix s a) :=
  match t with 
  | Fix.In x => x

unsafe def map (α β : Type) [Bifunctor s] (f: α → β) : (Fix s α → Fix s β) :=
  Fix.In ∘ bimap f (map α β f) ∘ (out s α)

unsafe def fold (α β : Type) [Bifunctor s] (f: s α β → β) : (Fix s α → β) :=
  f ∘ bimap id (fold α β f) ∘ (out s α)

inductive ListF (α : Type) (β : Type) : Type where
| Nil : ListF α β
| Cons : α → β → ListF α β
deriving Repr

instance : Bifunctor ListF where
  bimap := fun {γ : Type} {γ' : Type} {β : Type} {β' : Type} (f : γ → γ') (g : β → β') (t: ListF γ β) => match t with
    | ListF.Nil => ListF.Nil
    | ListF.Cons head rest => ListF.Cons (f head) (g rest)

unsafe def List (α : Type) := Fix ListF α
unsafe def List.Nil {α : Type} : List α := Fix.In ListF.Nil
unsafe def List.Cons {α : Type} (head : α) (rest : List α) : List α := Fix.In (ListF.Cons head rest)

unsafe instance [ToString α] : ToString (Fix ListF α) where
  toString (list : List α) : String :=
    fold α String (fun foo : ListF α String => match foo with
    | ListF.Nil => ""
    | ListF.Cons head rest => s!"{head}, {rest}") list

unsafe def testList : List Int :=
  (List.Cons 5 (List.Cons 4 (List.Cons 87 (List.Nil))))

#eval testList

#eval (map Int Int (fun x => x + 1) testList)

#eval fold Int Int (fun foo : ListF Int Int => match foo with
  | ListF.Nil => 0
  | ListF.Cons head rest => head + rest) testList

inductive BTreeF (α : Type) (β : Type) : Type where
| Tip : α → BTreeF α β
| Bin : β → β → BTreeF α β

instance : Bifunctor BTreeF where
  bimap := fun {γ : Type} {γ' : Type} {β : Type} {β' : Type} (f : γ → γ') (g : β → β') (t: BTreeF γ β) => match t with
    | BTreeF.Tip tip => BTreeF.Tip (f tip)
    | BTreeF.Bin l r => BTreeF.Bin (g l) (g r)

unsafe def BTree (α : Type) := Fix BTreeF α
unsafe def BTree.Tip {α : Type} (tip : α) := Fix.In (BTreeF.Tip tip)
unsafe def BTree.Bin {α : Type} (l r : BTree α) := Fix.In (BTreeF.Bin l r)

unsafe instance [ToString α] : ToString (Fix BTreeF α) where
  toString (tree: BTree α) : String :=
    fold α String (fun foo : BTreeF α String => match foo with
    | BTreeF.Tip tip => toString tip
    | BTreeF.Bin l r => s!"({l} {r})") tree

unsafe def testTree : BTree Int :=
  BTree.Bin (BTree.Bin (BTree.Tip 5) (BTree.Tip 4)) (BTree.Tip 87)

#eval testTree

#eval (map Int Int (fun x => x + 1) testTree)

#eval fold Int Int (fun foo : BTreeF Int Int => match foo with
  | BTreeF.Tip tip => tip
  | BTreeF.Bin l r => l + r) testTree

The Space of Triangles

2023-05-23T00:00:00-07:00

Plus: How do you generate a random sample of triangles? and: How can you measure the distance between two triangles

Whenever you want to model something, say a physical system like the tumbler and pins in a door lock or a robotic arm, it's helpful to think of each possible state of the system as a point in a space. This can help if you want to find a way to get from one state to another (e.g. planning a path for the robotic arm), or if you want to know how likely a state is if you randomly sample a space (e.g. vibrating a lock to try to pick it). Usually it's best to try to find a good representation and build up from there. To illustrate the process, we'll take an extremely simple example—triangles—and work through each step.

Representing Triangles

The naive way to do this is just to represent the triangle as three points in a plane. The problem with this is that many triangles which we should consider the same have different representations:

So we can have triangles of the same shape be different sizes or in different positions and so have a different set of representative points. Ideally our representation would be unique for a particular shape of triangle regardless of the size or position we see the triangle in.

If you remember from trig class, the internal angles of every triangle add up to exactly 180°. That means we could represent a triangle by its angles to avoid the issues of varying size and position. So we can use a list of three angles and all we have to do is to make sure they add up exactly to 180°.

The Space of Triangles

Now that we have a representation for all triangles we can think about what the space they form looks like. Since we have three numbers for a representation, we can associate any possible value of our representation with a point in 3D space. And since the numbers must add up to 180°, we don't use the entirety of our space (because not all points have coordinates that add up to 180). Also, angles are always positive, so we'll only be using the octant of space where all coordinates are positive.

It may take a little legwork, but it should be possible to work out that the shape this makes is a triangle with one vertex on each axis where that axis equals $\pi$ (also known as a simplex):

So here we see a space where each point represents a triangle. However, there's one snag. If we look at what triangles are represented where, we see that any triangle can be represented by three different points:

To deal with this situation, we only need to restrict our space to one third of the original space such that we treat the corresponding points in the other thirds as equivalent:

In terms of our coordinates this simply means that we make sure the first coordinate is the smallest of the three.

Measuring the Space

Now that we know what the space of triangles looks like, we can go ahead and calculate what its size is. First we can see that the long edge of the space forms a triangle with the two axes it is closest to, which means it must be $\pi \sqrt{2}$ long.

And since the formula for the area of an equilateral triangle is given by $\frac{\sqrt{3} l^2}{4}$ where $l$ is the length of one of the sides, we have the area for our space (remembering it is one-third of the equilateral triangle):

$$\frac{\pi^2 \sqrt{3}}{6}$$

It's weird seeing a $\pi^2$, but since we're calculating area in a space whose dimensions are angles that's somewhat bound to happen.

So what does this value mean? Not much by itself, but now that we've gone this far there are a couple of other questions that come to mind:

How Can You Randomly Choose a Triangle?

Often it's useful to be able to randomly sample a space. This can be for generating test cases or examples, for optimization (used in some metaheuristic methods), or even for statistical mechanics. So if for nothing else than practice, let's see how to generate random samples in our space of triangles.

The idea of the sampling is to generate samples in a space we know how to (such as a square) and then transform that into the space we want. Our approach will be to start by sampling a square (just by sampling two random variables $[0,1)$), which we'll call $u$ and $v$. Then we'll reflect the samples about the diagonal (just by making $u$ always be the smaller sample) so that the sampling space is a triangle. Then we need to transform that triangle so that it coincides with the space we've described. After banging your head against some linear algebra for a while, you should arrive at these equations:

$$a = \frac{-u + v + 1}{3} \pi$$

$$b = \frac{2 u - v + 1}{3} \pi$$

$$c = \frac{u - v}{3} \pi$$

Where $a$, $b$, and $c$ are the angles of the triangle. Here's an implementation of sampling:

import random

def sample_triangles():
    u = random.random()
    v = random.random()

    # We want to sample a triangle, not a rectangle
    if (v > u):
        u,v = v,u

    a = np.pi * (-u + 3 * v + 1) / 3
    b = np.pi * (2 * u - 3 * v + 1) / 3
    c = np.pi * (1 - u) / 3
    return a,b,c

Note that this code might not deal properly with edge-cases. It's merely for illustration

Now with code to generate samples we can display some examples of what it generates:

import numpy as np
import matplotlib.pyplot as plt

# Generate a consistent sample set
random.seed(1)

triangles = []

for i in range(5):
    a_ang,b_ang,c_ang = sample_triangles()

    triangles.append([a_ang, b_ang, c_ang])

    # c must be largest angle so longest edge is down

    if (a_ang == np.max([a_ang, b_ang, c_ang])):
        a_ang,b_ang,c_ang = b_ang,c_ang,a_ang

    if (b_ang == np.max([a_ang, b_ang, c_ang])):
        a_ang,b_ang,c_ang = c_ang,a_ang,b_ang

    print(f"a: {a_ang:0.2f}, b: {b_ang:0.2f}, c: {c_ang:0.2f}")

    b_len = np.sin(b_ang) / np.sin(c_ang)

    x = b_len * np.cos(a_ang)
    y = b_len * np.sin(a_ang)

    triangle_vertices = np.array([[0, 0], [1, 0], [x, y]])

    triangle = plt.Polygon(triangle_vertices, edgecolor='#333333', facecolor='#00000020', linewidth=5, joinstyle='round')

    plt.figure()
    plt.gca().add_patch(triangle)
    plt.axis('scaled')
    plt.gca().set_axis_off()
    plt.show()

Now that we have some examples, there's one more question we might like to answer:

How Can You Measure the Distance Between Two Triangles?

Since we have a representation of triangles in a euclidean space, measuring the distance between them should be trivial, we just have to take the euclidean distance between their points:

$$distance = \sqrt{(a_1 - a_2)^2 + (c_1 - c_2)^2 + (c_1 - c_2)^2}$$

However, there's one more wrinkle. Here we have some points in triangle space, and if you look at the points on opposite ends, you see that they are actually very similar despite being far apart.

This makes sense because the other two parts of the original representation space directly abut these edges so we should expect a continuous transition across those edges. And the reason we only kept one third of the original space was because all three were identical, so the triangles across that edge are in fact the same ones as those on the opposite end of our space.

This means we can move across that edge and wrap over to the other side. It might be better to visualize by rolling up the space into a cone:

So, given this, how would we calculate the distance taking into account that points may be closer to each other across the joining edge? A straightforward approach is to take the points we're comparing and rotate them $2 \pi / 3$ to one of the other thirds of the simplex. Then we find the shortest distance of the distances between each pair.

Because the simplex is symmetric with respect to all three axes, rotation is just as simple as rotating the coordinates.

$a' = b$

$b' = c$

$c' = a$

def triangle_dist(T1, T2):
    T1_rotated = np.array([T1[2], T1[0], T1[1]])
    T2_rotated = np.array([T2[2], T2[0], T2[1]])

    return min(np.linalg.norm(T1 - T2), np.linalg.norm(T1 - T2_rotated), np.linalg.norm(T1_rotated - T2))

So now we can get the exact distances between the triangles we sampled before. First we just plot them in the space:

And then we rotate all the points to another section to see what the actual distances are (remembering that the length of the long edge of the space is $\approx 1.41\pi$):

Conclusion

If you're wondering what the point of all this is, then, realistically, it was mostly just for fun. But each of these questions are ones that we might want to ask about other concepts and spaces, so it might be useful to have a simple but non-trivial example which answers those questions.

A Map for the Space of Triangles

Update 2023-09-23

Some other treatments of the idea:

J. Gaspar and O. Neto, All triangles at once, Amer. Math. Monthly 122 (2015), 982-982.
I. Stewart, Why do all triangles form a triangle?, Amer. Math. Monthly 124 (2017), 70-73.

Practical One-Time Pad

2023-04-02T00:00:00-07:00

One-time pads are well known for their ability to provide unbreakable encryption, but they do not see very widespread use. This is understandable: they are limited in the amount of information they can practically convey, and generating them properly is tedius and slow[ref]There are some computer-based one-time pads, but pencil-and-paper pads offer significant security benefits by side-stepping the issue of spyware completely. Digital pads do however offer the possibility of offline encryption.[/ref]. And while there are some guides for using them (see Resources), these are mostly discussions of historical uses or require a lot of leg-work to follow.

However, pen-and-paper one-time pads offer a level of simplicity and observability that is unmatched by any (electronic) digital encryption. This also means that they are far more accessible than most conventional encyprtion methods for those who are not very proficient in computers and computer security. This, along with the promise of perfect secrecy if handled properly, is reason enough to make sure an implementation of the idea is usable and readily available.

So I set out to make a simple, straightforward process for creating and using one-time pads. The result is provided below as a pair of templates for sending and receiving pads. Each document is two pages and meant to be printed two-sided so that the front provides a brief explanation, warnings, and instructions for use. The back side then has the pad itself in the form of a worksheet that can be filled out cell-by-cell following the instructions on the front and using the character translation table that is provided.

The idea is that the template must be filled-out with the one-time pad values by someone who has an understanding of the requirements for secure one-time pad use (such as the need for the numbers to be generated by a True Random Number Generator), but can then be packaged and given to someone who only needs to follow the instructions on the sheet (e.g. a less technically-inclined parent).

Note that although the instructions are meant to be easy-to-follow, they are not foolproof. There are many ways to fail to encrypt the messsage and accidentally leak the secret. It would probably be best to work through a couple examples with whoever you want to share the pads with.

Template Downloads

Note: Each one-time pad template is meant to be printed out on a single sheet with the instruction page on one side and the pad itself on the other. That way the instructions will always remain with the pad.

Source Files:

How to Fill out the Template

Note: When writing down the values, keep the pad on a hard surface, especially not on top of another sheet of paper. The sheet below the pad can keep the impressions of the writing which leaks the secret pad values.

The one-time pad values on the sheet must be generated by a True Random Number Generator and the values must be from 0 to 9 inclusive. Anything pseudo-random or generated deterministically in any way (e.g. keystretching) will violate the requirements for the perfect secrecy of the one-time pad and will reduce the security of the system.

The best way to generate values for the one-time pad is to use 10-sided dice. Get as many 10-sided dice as you can and roll them in a box, then tilt the box so the dice form a line on the edge and the results can be copied off on to the one-time pad. Using this method with four dice takes about 30 minutes to make a one-time pad pair (i.e. rolling, filling out the values on one sheet, then copying the values to the other sheet).

6-sided dice can also be used following the chart below where one die is marked as black and the other as white.

Black,White	B,W	B,W	B,W	B,W	B,W
1,1: 0	2,1: 6	3,1: 2	4,1: 8	5,1: 4	6,1: reroll
1,2: 1	2,2: 7	3,2: 3	4,2: 9	5,2: 5	6,2: reroll
1,3: 2	2,3: 8	3,3: 4	4,3: 0	5,3: 6	6,3: reroll
1,4: 3	2,4: 9	3,4: 5	4,4: 1	5,4: 7	6,4: reroll
1,5: 4	2,5: 0	3,5: 6	4,5: 2	5,5: 8	6,5: reroll
1,6: 5	2,6: 1	3,6: 7	4,6: 3	5,6: 8	6,6: reroll

Note that the first eight digits that are generated should go in the 'Encrypted Message' line in both sheets since they are simply used to identify which pad the message is for. The rest of the generated digits will go in the 'One-Time Pad Value' line.

It is possible to use other sources of random values, but not recommended. Dice are common, simple, and, with rare exceptions, known to be good sources of randomness. The same cannot be said for most other, especially computer-based, methods. If you are worried about the dice you have, try using several from different sets or purchasing casino-grade dice[ref]At the very least, it seems to be the case that dice with sharp edges may be more random than those with rounded edges. See A Scientific Analysis of Dice[/ref].

Once the pad values are generated and written on one sending/receiving pad, copy them over to a receiving/sending pad.

Caution: Handwriting is prone to errors. Try to write distinctly and avoid glyph variations that can be confused with each other (like a one with only a serif and a seven without a stroke).

Handling the Filled-out Pads

After filling out both pads in a pair, you should ensure they can't be surreptitiously read. A couple simple steps will raise the required sophistication for this from casual snooper to dedicated adversary. First, note the shared identification digits for the pads so that you can put them on the packaged receiving pad. It will be used to find which pad should be used to decrypt a message that has been received. Then place each pad in an envelope, first wrapping them in aluminum foil. That should prevent someone from just shining a light through to see the pad's numbers[ref]Note that even so-called 'security' envelopes don't prevent this[/ref]. Seal the envelope as usual, then apply a tamper-evident, serialized seal across the normal seal. These seals won't stop snooping, but will indicate if they've been removed or replaced. They are also cheap and widely available.

Labelling packaged pads with the name of the other party does potentially leak some information, but for most cases (e.g. for pads shared with family members), it is probably worth the convenience. Remember that losing or mixing up pads is a real risk too.

Lastly, a pad from each pair must be delivered to the other party. While it's easy to go down the rabbit-hole of paranoia, It's best to keep to the simple rule that you should deliver the sealed pad in-person. Other than that, don't worry too much about extra precautions.

Custom Codebook

Because the character conversion table is only (0,0) to (4,9), the rest of the codes can be used for other purposes. Custom codebooks can be created using the template to assign complete words to those codes. This can significantly shorten messages if the codebook contains frequently used words. They are usually best if tailored to whatever specific use they will be put to, but a good general example with 50 very common words is given here:

word	code	word	code	word	code	word	code	word	code
about	5 0	from	6 0	like	7 0	receive	8 0	way	9 0
all	5 1	get	6 1	make	7 1	repeat	8 1	we	9 1
as	5 2	have	6 2	not	7 2	take	8 2	what	9 2
be	5 3	he	6 3	of	7 3	that	8 3	when	9 3
because	5 4	his	6 4	on	7 4	the	8 4	which	9 4
but	5 5	in	6 5	or	7 5	there	8 5	who	9 5
by	5 6	into	6 6	other	7 6	they	8 6	will	9 6
could	5 7	it	6 7	out	7 7	this	8 7	with	9 7
do	5 8	just	6 8	say	7 8	time	8 8	would	9 8
for	5 9	know	6 9	send	7 9	to	8 9	you	9 9

Once you choose the words you want to use, it's best to put them in alphabetical order so they are easier to look up.

Make sure to keep a copy of the codebook with each pad in the pairs that will use it.

Disadvantages

While this method has much to offer, it's important to understand all its disadvantages when using it.

Short message length: Only 172 characters for each pad pair
Labor-intensive to create: Roughly 30 minutes for each pad pair
No error-detection or error-correction, and the values involved in the message must be copied / calculated about 8 times
1. Maker of pad: Copy values from dice to one-time pad template
2. Maker of pad: Copy values from template to its paired pad
3. Sender: Encode message on sending pad
4. Sender: Encrypt message on sending pad
5. Sender: Copy encrypted message to separate sheet
6. Receiver: Copy encrypted message to pad
7. Receiver: Decrypt message
8. Receiver: Decode character values
You must keep pads for each person you want to communicate with.
You must be able to distribute pads securely.

Use-Cases

Despite these disadvantages, one-time pads are genuinely useful for a few common uses (in addition to many uncommon ones):

Sending passwords
Providing some authentication (e.g. to instruct someone to transfer money, especially if one party is travelling internationally). Especially now that AI techniques allow for difficult-to-identify voice and video impersonations.
Bootstrapping another, more convenient encryption scheme by exchanging keys using OTP.

Resources

Getting a Broad View of History

2023-01-01T00:00:00-08:00

For a long time I've felt that my grasp of history was very weak. My understanding of when significant chunks of history (even as big as the Roman empire) occurred relative to others has been murky at best. I think this has really stunted parts of my education because I haven't been as willing to engage with ideas and facts which are embedded in a historical context.

I realized that to overcome this, I needed to internalize a broad view of history within which I could situate those facts and ideas I had glossed over before. The past few years I have been gradually developing my spaced-repetition flashcard practice and this seems like the perfect candidate for it. It is much easier to be willing to dive into a chunk of history and memorize the dates for it if I can be confident that I will retain that information for that long term, and spaced-repetition gives me that confidence. However, the hard parts of making flash cards are in deciding what to memorize in the first place and then in digesting that down into pieces that will stick while retaining the cohesion of the whole.

This is a real obstacle since the time it would take to find sources that are at the appropriate level of depth for my purposes while also gathering enough of them to cover the entire sweep of human history could easily take more time than I'd be willing to devote to the project. And so the idea languished, until I came across the Core Knowledge curriculum, which is a creative commons licensed curriculum for elementary schools. This actually makes it perfect for my purposes: elementary school will typically cover the breadth of recorded history at a depth that makes it easy to get through without being bogged down. Each course is short enough that I can cover it with the free time I have (I can do an entire course in a day if needed), but has enough content that the cards I make from it can support each other instead of being separate, unconnected facts.

So I selected a few dozen of the history courses and threw in some geography for good measure. I figured I'd start with the high-priority ones and add in others as I felt like it. So far I've done only three courses over about a year since I'm only doing this as a side-side-project. However, at this point, I feel like I have a good rhythm and have some confidence that I will actually retain the courses I've covered while still having the time to continue making progress.

Only the long-term will tell whether this approach is worthwhile, but I'm confident enough to keep at it.

Order-of-Magnitude Probabilities

2021-04-17T00:00:00-07:00

Representing Probabilities

Order-of-Magnitude values are excellent for representing both low probabilities and high probabilities, and make several common types of calculations easily workable in the head alone.

For representing low probabilities, we can just directly use the value. For a one-in-a-million chance, that probability is just $E^-6$. Using this scheme, we can easily represent very-rare probabilities (see Wikipedia - Orders of magnitude (probability) for more examples):

Event	Probability
Winning the lottery with one ticket (UK national lottery, 2009)	$E^-7$
Yellowstone erupting in any given year	$E^-6$
Being dealt a straight flush in poker	$E^-5$
Being dealt four of a kind in poker	$E^-4$
Sharing a birthday with any one random person	$E^-3$
Giving birth to twins	$E^-2$
Rolling a natural 20 on a D20.	$E^-1$
Getting heads on a fair coin toss	$E0$

How do we represent high probabilities though? At first glance they'd all be $E0$ ($99\% \sim E0$, $99.9\% \sim E0$, etc.), which wouldn't be very helpful. We can deal with this by remembering that very-likely events have a very small chances of not happening. So we represent high probabilities as the complements of low probabilities. If my server has 99.999% reliability, then we can say that probability of it being up at any time is $\overline{E{}^-5}$ (i.e. the complement of $E^-5$ or $1 - E^-5$ to abuse notation a little). Using this syntax, we don't have to worry about always reversing the event we're talking about e.g. we don't have to talk about the probability of the server failing when we actually want to talk about the probability of it being available.

Iterating Probabilities

When given probabilities, commonly we will want to find out what happens when we iterate them. If I know going skydiving has an $E^-5$ risk of death, how about going every week for a year? Or if there's an $\overline{E^-3}$ chance of rain each day in Seattle, what is the probability I'm going to go without sun for the next month?

Notice these are two different types of questions. The first asks what the probability is of dying at any point during the year--even though we could calculate it, the probability of dying every week is not a particularly useful value. The second asks what the probability of it raining every day is. So we actually have two types of iteration we might want to calculate for. And naturally these types of iteration will lead to different answers: if I ask how likely something is to happen at every iteration, I expect that to be less than the given probability. If I ask how likely something is to happen at any iteration, I expect that probability to be more.

Since we're representing low probabilities and high probabilities in two separate ways, and because we have two different types of iteration we want to calculate, we have four cases to consider. Thankfully though, due to some symmetry we'll see, we only end up with two simple types of calculations.

Skip to Methods Summary to just see the rules.

To start, let's take the case of a 'low' probability event and finding out how likely it is to occur on every iteration. Let's say we're playing the lottery (with an $E^-7$ chance of winning), but we're really greedy so we want to win every time we play.

We know from general probability that for two independent events the probability of both happening is the two probabilities multiplied together. So for two iterations, we have $E^-7 \times E^-7 \sim E(^-7-7) \sim E^-14$ to win twice in a row. In general, with $N$ iterations, we have $(E^-7)^N \sim E(^-7 \times N)$, which is just due to the laws of exponentiation since $(10^{^-7})^N = 10^{^-7\times N}$. So we probably shouldn't get our hopes up.

Now what about if we reverse both parts of the question, and we want to know what the probability of a 'high' probability event happening at any point in an iteration? What if we can make a server $\overline{E^-2}$ (i.e. it is up 99% of the time), but we want at least an $\overline{E^-5}$ one like mentioned before? One way to do this is to set up multiple servers and make it so that if one fails, then the next one takes its place. That way, at some random time, the service I'm running on them will be available if any of the servers are up. So how many servers do we need running concurrently in order to get $\overline{E^-5}$ or better?

Well we can just think about what the odds of failure would be. The odds of any individual failure are $E^-2$, and the odds of all of them failing simultaneously are $E(^-2 \times N)$ for $N$ servers, just like we saw above. So for three servers we get a total failure probability of $E^-6$, which means our uptime probability is $\overline{E^-6}$.

So we see that this question (high-probability, any iteration) is just a mirror image of the first case (low-probability, every iteration), and we end up doing the exact same calculation.

We have two cases left to figure out how to calculate, so we'll start with calculating a low probability event occurring any iteration:

Let's go back to lottery case, but with the more reasonable stipulation that we want to win on any iteration of playing the game. There isn't a rule to immediately solve this, so to help, let's visualize the probability space, starting with one iteration:

Where $x$ is our probability of winning the lottery (greatly exaggerated for visual clarity). And now again with two iterations:

The orange square is the probability of winning both times, and the green square is our probability of losing both times. So the value we're interested in is the total area outside of that green square. Since the area of the entire square is $1\times 1 = 1$, the probability of winning either time is $1-(1-x)^2$.

The pattern is the same for more iterations: We calculate the probability of losing every time and take the complement of that. So if we play the lottery $N$ times, the probability of winning any of those times is $1-(1-x)^N$.

But it's not immediately clear how you would calculate this when using order-of-magnitude values. The trick is that when $x$ is small (i.e. we're representing it as a 'low' probability with order-of-magnitude values) then $1-(1-x)^N$ can be approximated by $x \times N$. At the end of the post I'll try to justify this approximation, but for now it makes our job very easy:

If we play on the order of 10 times ($E1$), then our probability of winning any of those times is $E^-7 \times E1 \sim E^-6$. If I play on the order of $E3$ times, then it would be $E^-4$.

The only thing to keep in mind is that this breaks down when the number of iterations greatly exceeds the unlikelihood of the event i.e. if I go crazy and somehow play the lottery $E8$ times, I can't exceed a probability of 1, so the order-of-magnitude maxes out at $E0$.

Our last case is that of a high-probability event occurring every iteration.

Let's say I'm a long-haul trucker and I want to know the odds that I'll make it to the end of my career. The odds of surviving on any given day as a truck driver are $\overline{E^-7}$¹, so how would we calculate the odds of surviving through my career? Let's look at our probability space again, but this time our event is the larger portion of the space $1 - x$.

And so with two iterations, we're interested in the large square, i.e. $(1 - x)^2$:

But, again, the way we're representing high probabilities is by their small complements, so our $E^-7$ is actually $x$ in the diagram. So how do we get $(1-x)^2$ from $x$? Well if we know the area outside the big square, then we can $(1-x)^2$ by taking the complement. Recognizing that by representing a probablity via $E^C$ we exactly are taking the complement, then the actual value we use is the area outside the square, i.e. $1 - (1 - x)^2$ as we did above.

So again we get to use the approximation $1 - (1 - x)^N \approx x \times N$. Back to our example, if I work for 30 years $\sim E4$ days, then my probability of living through my career is $\overline{E \left( {}^-7 + 4 \right)} \sim \overline{E^-3}$, which is not terrible odds.

As before, if we take this to an extreme, our probability maxes out at $E0$. Suppose I got life extension and really wanted to commit to the truck-driving career, then around $E4$ years I'd reach an $E^C0$ chance of surviving. It's possible to come up with rules for calculating the actual probability beyond that point, but the numbers quickly become absurd and useless for mental arithmetic so we'll leave that alone.

Methods Summary

That all is a lot of description which can be summed up in its tersest form as:

where

So $P(\forall i \in [1..N]: e_i)$ is the probability of the event occurring every time, while $P(\exists i \in [1..N]: e_i)$ is the probability of the event occurring any time.

Addendum: Geometric Argument

I claimed that $1-(1-x)^N$ can be approximated by $x \times N$, but I don't have a real proof of that; so right now I'll just sketch an argument to get some intuition.

The key is again to use a geometric approach i.e. we recognize that the value we want is the area of a region of probability space and then examine how that region changes as we increase iterations N in order to determine how the probability relates to N

Suppose we're approximating $1 - (1 - x)^N$, where x is 'small'. It will still be useful to think of these regions as probabilities where the overall area is 1 and each iteration adds a dimension.

The idea is to get an intuition for how much of the space (which always has a total 'volume' of 1 no matter how many dimensions) the green region takes up as a function of the number of iterations (dimensions, geometrically).

Here we see the green portion is $(1 - x)^2$, but before we start drawing conclusions, let's look at 3 iterations:

Here we can see that the volume outside the green is mostly taken up by the slabs at the side and top. There's a more concrete way to say that: when numbers are small, we can ignore their higher powers in approximation. The corner box's volume is $x^3$, and the edge boxes are $x^2 \times (1-x)$, so we can safely ignore those. The side slabs have volume $(1-x)^2 \times x = (1 - 2x + x^2) \times x \approx x$, so we can see more directly that they are the dominant contributors to volume outside our green region.

So what about more than three iterations? The situation is more difficult to represent visually, but behaves similarly. For N iterations, we will have N high dimension slabs on the sides of our hypercube that each have an approximate volume of x and the other components will be negligible, so the total volume outside our survival case is $\approx N \times x$. Of course this breaks down when $N \gg 1/x$ and is just $\approx 1$.

6371 truck driver deaths in 2019: injuryfacts

3,592,000 truck drivers employed in 2017: census

$371 / (3592000 \times 365) = 2.83E^-7 \sim E^-7$ ↩

Order-Of-Magnitude Mental Arithmetic: Basics

2021-03-08T00:00:00-08:00

In "Order-of-Magnitude Mental Arithmetic: Motivation", I talked about how working with order-of-magnitude values might help with internalizing a rough sort of the numerical mental models that experts develop over the course of extensive experience. The mechanics of this are simple, but are worth going over deliberately.

The first thing we need to be able to do is to identify the order-of-magnitude of a given number. For some numbers, this is trivial: the order-of-magnitude of 1,000,000 is $10^6$. We're actually going to write that as $E6$, both to distinguish it from the actual number $10^6$ and to get our brain to treat it as an atomic value instead of an operation on the numbers 10 and 6. This notation comes from how we sometimes write scientific notation as $1.0E6$.

So we can do this for powers of 10 easily enough, but what about any other random number? Say, what is the order-of-magnitude of 42? Well, it's probably either 10 or 100, i.e. $E1$ or $E2$. But this is the first example of a shift in thinking when using order-of-magnitude values. Normally we think in terms of distance, so for example if I'm on the stretch of road between Lakeview, Oregon, and Winnemucca, Nevada that has no gas stations and I want to know which direction to go, then I naturally head towards the closest one.

In fact, usually what you do in your head is not calculate the distance to both and compare them, but calculate (or estimate) the midpoint between them and go towards the one that's on the same side of it as you are. So in the case of 42 where we're trying to figure out which order-of-magnitude value is a better representative, we would take the midpoint of 10 and 100: 55 and see that we're on the same side of 55 as 10 is.

But let's propose a different analogy: let's say you want to understand whether a salary of $42,000 is more like a salary of $1,000 or a salary of $100,000. This is clearly a different type of question, that is, it's a question of scale, not of distance.

So how do we find the midpoint in terms of scale? In terms of distance, we know there is a number we can add to the starting point that gets us to the midpoint, then if we add it again we get to the end. If we're thinking in terms of scale rather than distance, we do the same thing, but we multiply instead of add.

Since $1,000 * 10 * 10 = 100,000$, our midpoint is 10,000 and so we see that $42,000 is closer to $100,000 in scale even though it is closer to $1,000 in terms of distance.

This case is a little easier to see since 1k and 100k ($E3$ and $E5$) are two orders-of-magnitude apart, and so it seems natural that the midpoint of scale between them would be 10k $(E4)$. But if we want to choose the most representative order-of-magnitude for any arbitrary value, we need to know the midpoint between any two adjacent orders-of-magnitude. This way we can quickly choose the best of the two for any given value between them.

Let's take the example of 1 $(E0)$ and 10 $(E1)$ and use our method to get the midpoint in scale between them. Since $1*10 = 10$, the two halves of our journey are $1*\sqrt{10} * \sqrt{10} = 10$, and so our midpoint is $1 * \sqrt{10} = \sqrt{10} \approx 3.16$. The neat thing is that all other adjacent orders-of-magnitude look pretty much the same, so $10 * \sqrt{10} * \sqrt{10} = 100$ and the midpoint is $\approx 31.6$.

This is why, in terms of scale, 4 is closer to 10 than it is to 1. So when we're deciding which order-of-magnitude best represents a value we need to take that into account.

Then the process of determining a value's order-of-magnitude is easy enough you can quickly get comfortable enough with it to do it without really thinking:

Look at the leading significant digit and see what order-of-magnitude it would be if it was 1 and all other digits zero
If the most significant digit was in the ones' place, would the value be greater than $\sqrt{10} \approx 3.16$? If so, add one to the order-of-magnitude since we want to round up rather than down in that case.

Value	Leading digit = 1	Rounding	Order-of-Magnitude
4,000,000	$1,000,000 \sim E6$	$4 \ge 3.16$	$E7$
2	$1\sim E0$	$2 \ngeq 3.16$	$E0$
78	$10 \sim E1$	$7.8 \ge 3.16$	$E2$
0.5	$0.1 \sim E^-1$	$5 \ge 3.16$	$E0$
$7.5E19$	$1.0E19 \sim E19$	$7.5 \ge 3.16$	$E20$
$4.8 \times 10^{-7}$	$1.0 \times 10^{-7} \sim E^-7$	$4.8 \ge 3.1$	$E^-6$
$\pi \approx 3.14$	$1.00 \sim E0$	$3.14 \ngeq 3.16$	$E0$

That's it, but if you want an explicit formula, it's just this: $v \sim E \left[ round(log_{10}(v)) \right]$

Calculations

This is the 'Mental Arithmetic' part, and it's incredibly easy thanks to the magic of logarithms: When you multiply two values, say 100 $(E2)$ and 100 million $(E8)$, the resulting order-of-magnitude is the sum of the two: 10 billion $(E10)$. And division is just as easy since dividing by a number is just subtracting its order-of-magnitude, so $100 \ million / 100 \sim E \left[ 8 - 2 \right] \sim E6$.

Let's look at an example: How long does it take for light to get from the sun to Earth? Well Earth's orbit is about $1.496 \times 10^8 km \sim E11 \ m$. And the speed of light is $2.99 \times 10^8 m/s \sim E8 \ m/s$. Since we want the time it takes, we want a value with units of seconds which would be given by $\frac{E11 \ m}{E8 \ m/s} \sim E \left[ 11 - 8 \right] \ s \sim E3 \ s$. If we check the actual time it's $499 \ s \sim E3 \ s$, so we're right where we want to be.

Units

Pretty much any useful calculation is going to have some physical units attached to it. In fact, because the calculations themselves are typically so easy, most of the heavy lifting is done in Dimensional Analysis. This means we need to pick units. The units themselves don't matter so much because nearly any value we could come across in any given unit will still be a manageable number (the mass of the Milky Way is $E46 \ carats$ by the way). But having consistency can make it a lot easier to adapt values across contexts. Because of this, I suggest sticking with the SI base units and derived units whenever practical. But of course, there are likely situations where that would be cumbersome or confusing so use your judgement.

One cool thing is that to do unit conversions you just end up adding a constant. Say you keep on running into values given in light years but you want to keep track of it on your already-familiar order-of-magnitude scale. Since a light year is $9.46 \times 10^{12} \ km \sim E16 \ m$, any time we see light year, we can take the order-of-magnitude of the value and add 16 to get it in metres. So now if you see that the Milky Way disk is 185 kly in diameter, you can mentally note it as $E21 \ m$. And it is indeed, at $1.75 \times 10^{21} \ m$. Now if you want to remember that value for more than just a passing note, it's best to do the conversion and take the order-of-magnitude after that or you risk losing accuracy.

Conclusion

Once you get the basic concept the mechanics of doing this are incredibly easy, so I'd like to explore all the interesting applications of this I can.

Sredni Vashtar

2021-01-01T00:00:00-08:00

Sredni Vashtar (1981)

OOM Summation

2020-11-28T00:00:00-08:00

How do you sum a set of order-of-magnitude values? For example, if my personal library contains E0 dieting books, E0 classical literature volumes, E1 textbooks, and E2 fantasy books, then how many books do I have total? Clearly the fantasy books dominate and I have E2 total books. So to get the sum total, I take the maximum E-value of the set?

Sometimes, but this is not true when there are many of the lower terms. For example let's look at the world population by country. To get a picture of it, we take the values from wikipedia and group them by their order-of-magnitude:

OOM	Count
E1	0
E2	1
E3	6
E4	13
E5	41
E6	44
E7	92
E8	41
E9	3

To get the contribution of each order-of-magnitude, we multiply with their count (i.e. add with their count's E-value):

OOM	Count	Contribution
E1	0	0
E2	1	E2
E3	6	E4
E4	13	E5
E5	41	E7
E6	44	E8
E7	92	E9
E8	41	E10
E9	3	E9

So now we take the maximum of the contributions and we get E10 from the E8 countries (take that, China, India, and U.S.A!), which is in fact ~ the world population at 7.8E9.

I wouldn't expect to use this technique all that much since it's a bit laborious for what I want, but it's nice to keep in mind and serves as a conceptual sanity check.

Follow-up: What are some pernicious examples? What is the process of binning by E-value? This probably has a common name.

NOTE: v ~ $E(round(log_{10}(v)))$

Conceptual Maps For Clearer Writing

2020-07-24T00:00:00-07:00

Steven Pinker gave an interesting talk on effective writing which focused on the 'classical' style. The talk is worth watching, but there is one particular component of it I would like to look at.

In one section of the talk, he describes writing as essentially taking a non-linear mental map of the concepts we are writing about and putting them down linearly as prose. As a concrete model, he uses a graph of nodes with arrows between them.

This means that there are many possible choices for writing down this map, some better than others.

The simplest case of this process is a single arrow going between two nodes. We can think of any single arrow as a simple sentence in Subject-Verb-Object form.

So this graph:

could be written as "Jim threw the ball."

But any sentence like this can also be reversed while keeping the same meaning by using the passive voice: "The ball was thrown by Jim."

So the passive voice can be seen as a reversal of the arrows in our map.

Dr. Pinker argues that while the common advice to avoid the passive voice is often right, it is usually because in those cases passive voice is a symptom of badly-thought-out orderings of concepts.

And therefore we can avoid the underlying problems by considering the natural order of ideas inherent in our conceptual graph.

Instead of primarily wondering "am I using the passive voice too much?", we can ask "does the order I am going through my concepts in make sense?".

Why PowerShell? Responses

2019-07-08T00:00:00-07:00

Scoop is a package manager for windows that is written in PowerShell. In their documentation they list some well-thought-through reservations for using PowerShell and their reasons for using it anyway. These are my responses to their reservations.

The Verb-Noun verbosity, commands that were seemingly not designed to be typed
- I disagree. Having default-verbose commands helps clarity and discoverability. Most commands used interactively have aliases already defined. If you find yourself regularly typing one that doesn't, make your own. If it makes sense, share it. In addition, the auto-complete works well
- The ISE—a GUI for a command line interface. I know the commands are hard to type—but is point-and-clicking a solution?
- It's true that PowerShell doesn't have a high-quality integrated development environment. ISE is a start and really shines in its intellisense (which doesn't require mouse interaction), but just doesn't cut it and it looks like it isn't being developed any more. Effective development environments can still be set up, but they won't be integrated. Sadly though, no other scripting host I've seen has as slick intellisense as ISE.
- Caveat: I haven't tried any of the paid development environments, those may be effective.
- The name PowerShell, and the unofficial abbreviation PoSH. Cringe.
- meh. I usually write 'PowerShell' for consistency's sake, use 'PS' to abbreviate and it hasn't caused me any aneurysms lately.
- Everything's an object! ends up feeling clumsy. Sometimes text is just easier to work with. Support for primitives, arrays and hashes would have been enough.
- This is only partly true. If you're primarily working with text or trying to emulate the unix scripting philosophy it will definitely feel clumsy. If you're working within .NET/PowerShell idioms then everything will feel effortless. Most of the time it will be somewhere in between. This is also true of any scripting language.
- Modules. Who knows how they work?
- I won't claim that they're perfect or to know all their secrets, but I'll say they're one of the nicer features of PowerShell. Creating and using modules has been pretty painless for me.
- Doesn't seem like a first class shell within Windows
- Yes. Hopefully this is changing. It seems like windows 10 is a major step forward for this.
- The built-in parameter parsing isn't good
- I disagree. Parameters are easy to set up, and because most commands use the built-in parsing you can have reliable expectation about how any given command will parse. The built-in parsing is a huge win for discoverability since parameters are automatically shown when you Get-Help <command>. If you don't like PowerShell's parameter parsing you can ignore it and roll your own, but overall I think this is one of the best features of PowerShell.
- A heavy 'sysadmin' feel that makes developers/devops sad
- Could be, but not really sure what this means.

I also have my own reservations for PowerShell

Tentatively, I'm not sure how the Verb-Noun philosophy will play out long term. Honestly, it has worked really well for me so far. I've been able to find conformant command names without too much trouble and it has helped me structure modules in a fairly consistent way. I guess I just find myself skeptical about this kind of crystallization. We'll see.
The language syntax. Once you get used to it, it is actually very reasonable but there's no denying that is seriously steepens the learning curve early on until you get that it's a combination of several different syntax styles.
- Despite this, I don't think the syntax is a valid reason for broadly avoiding the language because: 1. The syntax is actually consistent and well-thought-out, even if it doesn't initially appear so, and 2. it is well documented.
I kind of worry about the language being too 'heavy'. In that I'm not sure that if Microsoft became a bad actor that the independent developer community would be able to successfully fork it and continue on. There's some hope in the Mono development community, but Microsoft's move to cross-platform support may end up neutering them. We'll see. (Caveat: I have no idea what I'm talking about)
PowerShell seems to have a pretty big, healthy community, but in my current workplace basically no one uses it so I can't really expect anyone to invest time into it. Don't know how widely-applicable this is.

Notes on High-Altitude EMP Impact Report

2019-06-22T00:00:00-07:00

It is also not known how American society in general would react if massive infrastructure failures occur over a large region and for a long time.

"The Early-Time (E1) High-Altitude Electromagnetic Pulse (HEMP) and Its Impact on the U.S. Power Grid"

Sections of interest:

7.2 Susceptibility of Power System Equipment

Table 7-2. Some previous studies of the response of the power grid to E1 HEMP

One of the referenced studies: [ORNL HEMP Assessment Program ](http://www.ed-thelen.org/pics/EPRI-HEMP-2017.pdf)

Seems like most of the power grid vulnerability comes not from the power systems themselves (transformers etc.), but from the associated control systems.

it can be seen that the “brains” and communication systems of any modern power facility could be vulnerable to E1 HEMP

Fun:

In this case we heard a “bang” associated with the damage, and further testing showed that a resistor on the circuit board was blown up

Table 7-8. Fast pulse results for a typical PC and network switch
Section 8: Impacts on Society of E1 HEMP Power System Failures
Appendix: E1 HEMP Myths
- Important note: it doesn't seem like personal electronics will likely be affected (though, as the authors qualify, it's always possible).

Value	Leading digit = 1	Rounding	Order-of-Magnitude
4,000,000	\(1,000,000 \sim E6\)	\(4 \ge 3.16\)	\(E7\)
2	\(1\sim E0\)	\(2 \ngeq 3.16\)	\(E0\)
78	\(10 \sim E1\)	\(7.8 \ge 3.16\)	\(E2\)
0.5	\(0.1 \sim E^-1\)	\(5 \ge 3.16\)	\(E0\)
\(7.5E19\)	\(1.0E19 \sim E19\)	\(7.5 \ge 3.16\)	\(E20\)
\(4.8 \times 10^{-7}\)	\(1.0 \times 10^{-7} \sim E^-7\)	\(4.8 \ge 3.1\)	\(E^-6\)
\(\pi \approx 3.14\)	\(1.00 \sim E0\)	\(3.14 \ngeq 3.16\)	\(E0\)

Event	Probability
Winning the lottery with one ticket (UK national lottery, 2009)	\(E^-7\)
Yellowstone erupting in any given year	\(E^-6\)
Being dealt a straight flush in poker	\(E^-5\)
Being dealt four of a kind in poker	\(E^-4\)
Sharing a birthday with any one random person	\(E^-3\)
Giving birth to twins	\(E^-2\)
Rolling a natural 20 on a D20.	\(E^-1\)
Getting heads on a fair coin toss	\(E0\)