Background

At a basic level, Guesswork is pretty simple. Each logical statement produces a stream of possible answers (which may be lazy and could be infinite), and statements that take other statements as inputs (such as And, Or, and Not) don’t know anything about their inputs, aside from the fact that they are Enumerable. Furthermore, the calculations behind that Enumerable can be pretty expensive. For Or and Not, this isn’t much of an issue. Not is very simple, it uses Stream.map/2 to turn each answer into it’s logical negation, and Or uses Stream.concat/1¹.

And, however, is more complicated. For And to produce a single answer it takes a single answer from each of its inputs, and uses Guesswork.Answer.union/2 to combine them. But to build the next answer, only a single answer is pulled from a single input, and then combined with the already pulled answers from the other streams. So not only must And hold all the previously pulled answers in some form of state, but it must then produce the new answers in a lazy fashion.

An Eager Attempt

Before doing the hard work of building a lazy version, we’ll build a simpler, eager version². The answer sets are just maps of terms³, and two answer sets can be combined with union/2, provided that they have the same terms for all values.

defmodule LazyCombinations.Answer do
  @type t() :: %{atom() => term()}

  @spec new() :: t()
  def new() do
    %{}
  end

  @spec union(t(), t()) :: t() | nil
  def union(a1, a2) do
    new =
      Map.merge(a1, a2, fn
        _, t, t -> t
        _, _, _ -> nil
      end)

    if Enum.any?(new, fn {_, t} -> t == nil end) do
      nil
    else
      new
    end
  end
end

Building on the answer set, anding sets together is surprisingly⁴ straightforward. Enum.reduce/2 allows us to walk through the args, unioning all possible pairs together, and removing all invalid combinations.

defmodule LazyCombinations.EagerAnd do
  defstruct [:args]

  alias LazyCombinations.Answer

  @type t() :: %__MODULE__{args: Enumerable.t(Answer.t())}

  @spec new([Enumerable.t(Answer.t())]) :: t()
  def new(args) do
    %__MODULE__{args: args}
  end

  @spec resolve(t()) :: [Answer.t()]
  def resolve(%__MODULE__{args: args}) do
    Enum.reduce(args, fn val, acc ->
      Enum.flat_map(val, fn val_item ->
        acc
        |> Enum.map(&Answer.union(&1, val_item))
        |> Enum.filter(&Kernel.!=(&1, nil))
      end)
    end)
  end
end

Finally, we can confirm that everything works.

arg1 = [%{a: 1}, %{a: 2}]
arg2 = [%{b: 1}, %{b: 2}]
arg3 = [%{c: 1}, %{c: 2}]

LazyCombinations.EagerAnd.new([arg1, arg2, arg3])
|> LazyCombinations.EagerAnd.resolve()

[
  %{c: 1, a: 1, b: 1},
  %{c: 1, a: 2, b: 1},
  %{c: 1, a: 1, b: 2},
  %{c: 1, a: 2, b: 2},
  %{c: 2, a: 1, b: 1},
  %{c: 2, a: 2, b: 1},
  %{c: 2, a: 1, b: 2},
  %{c: 2, a: 2, b: 2}
]

Laziness

The above example is a good starting point, but it is obviously not exactly what we want, because if we tried to represent ‘Let A be some positive number’⁵ and passed that stream of answer sets to the above And, the resolve/1 function would never return.

Iterating over Streams

Before getting into the meat of this problem, we have to resolve the issue of pulling items from our Enumerable inputs one at a time⁶. As there is no way to do this directly in the standard library, we’ll have to use Enumerable.reduce/3. This is actually how many of the functions in the standard library are implemented, and it provides very fine-grained control over how we iterate over the data.

The stream here is another infinite list of numbers, built with Stream.iterate/2. To pull items one at a time we need to use a reducer/0 function that always returns :suspend, which in turn instructs reduce/3 to pause the stream and return the next value and a continuation.

stream = Stream.iterate(1, &Kernel.+(&1, 1))
reduce_fun = fn item, _acc -> {:suspend, item} end
{:suspended, nil, continuation} = Enumerable.reduce(stream, {:suspend, nil}, reduce_fun)
{:suspended, val, continuation} = continuation.({:cont, nil})
val

1

Once we have the continuation we can just keep calling it with {:cont, nil}, which instructs the closure to move the stream forward once, before the reducer/0 function suspends it again.

{:suspended, val, continuation} = continuation.({:cont, nil})
val

2

Lazy And

To actually build a stream of values we are going to use Stream.unfold/2. This function works for our purposes because it allows us to store state in an accumulator. We can then generate our sequence from that state, updating it as we go. The exact details of that ‘state’ are abstracted away here using a behavior⁷ where the important callback is next_unions/1. next_unions/1 just takes a list of converted streams and either indicates that there is nothing left to calculate (:empty or :done) or returns a list of ‘unioned’ answer sets and the next version of the streams to keep in the accumulator.

defmodule LazyCombinations.LazyAnd do
  defstruct [:partial_module, :args]

  alias LazyCombinations.Answer

  @callback new(Enumerable.t(Answer.t())) :: term()
  @doc """
  Takes a list of partial evaluations and attempts to calculate the next set of
  unioned answer sets, based on the next evaluated answer set unioned with the
  previously evaluated answer sets.
  """
  @callback next_unions([term()]) :: :empty | :done | {:ok, [term()], [Answer.t()]}

  @type t() :: %__MODULE__{args: Enumerable.t(Answer.t())}

  @spec new(module(), [Enumerable.t(Answer.t())]) :: t()
  def new(partial_module, args) do
    %__MODULE__{partial_module: partial_module, args: args}
  end

  @spec resolve(t()) :: Enumerable.t(Answer.t())
  def resolve(%__MODULE__{args: args, partial_module: partial_module}) do
    streams = Enum.map(args, &partial_module.new/1)
    Stream.unfold({streams, []}, &unfold_streams(&1, partial_module))
  end

  def unfold_streams({streams, []}, partial_module) do
    case partial_module.next_unions(streams) do
      :empty -> nil
      :done -> nil
      {:ok, new_streams, unions} -> unfold_streams({new_streams, unions}, partial_module)
    end
  end

  def unfold_streams({streams, [head | rest]}, _), do: {head, {streams, rest}}
end

There is a lot of code in the state below, but that is mostly handling all the edge cases. The first bit, new/1 and head/1 are just modified versions of the iterated stream we saw above. The only noticeable difference is that a defstruct is used to hold the continuation (stream) and the previously evaluated answer sets.

The rest of the module is spent implementing next_unions/1, which simply works through the streams, pulling an answer set if nothing has been evaluated, and ‘unioning’ everything together as it works.

defmodule LazyCombinations.LazyAnd.SimplePartiallyEvaluated do
  @behaviour LazyCombinations.LazyAnd

  defstruct [:continuation, evaluated: []]

  alias LazyCombinations.Answer

  @type t() :: %__MODULE__{
    continuation: Enumerable.continuation() | nil,
    evaluated: [Answer.t()]
  }

  @impl true
  @spec new(Enumerable.t(Answer.t())) :: t()
  def new(stream) do
    reduce_fun = fn item, _acc -> {:suspend, item} end
    {:suspended, nil, continuation} = Enumerable.reduce(stream, {:suspend, nil}, reduce_fun)
    %__MODULE__{continuation: continuation}
  end

  @spec head(t()) :: t()
  def head(%__MODULE__{continuation: nil} = stream), do: stream

  def head(%__MODULE__{continuation: continuation, evaluated: evaluated}) do
    case continuation.({:cont, nil}) do
      {:suspended, item, continuation} ->
        %__MODULE__{continuation: continuation, evaluated: [item | evaluated]}

      {:halted, item} ->
        %__MODULE__{continuation: nil, evaluated: [item | evaluated]}

      {:done, nil} ->
        %__MODULE__{continuation: nil, evaluated: evaluated}
    end
  end

  @spec done?(t()) :: boolean()
  def done?(%__MODULE__{continuation: continuation}) do
    continuation == nil
  end

  @impl true
  @spec next_unions([t()]) :: :empty | :done | {:ok, [t()], [Answer.t()]}
  def next_unions(streams) do
    case Enum.reduce_while(streams, {false, [], [Answer.new()]}, &collect_next_head/2) do
      :empty -> :empty
      {false, _, _} -> :done
      {true, new_streams, unions} -> {:ok, new_streams, unions}
    end
  end

  defp collect_next_head(%__MODULE__{continuation: nil, evaluated: []}, _), do: {:halt, :empty}

  defp collect_next_head(%__MODULE__{evaluated: []} = stream, {_, streams, acc}) do
    next = head(stream)

    if done?(next) do
      {:halt, :empty}
    else
      {:cont, {true, [next | streams], union_pulled_value(next, acc)}}
    end
  end

  defp collect_next_head(
         %__MODULE__{continuation: continuation} = stream,
         {false, streams, acc}
       )
       when not is_nil(continuation) do
    next = head(stream)

    if done?(next) do
      {:cont, {false, [next | streams], union_unpulled_value(next, acc)}}
    else
      {:cont, {true, [next | streams], union_pulled_value(next, acc)}}
    end
  end

  defp collect_next_head(%__MODULE__{} = stream, {pulled, streams, acc}),
    do: {:cont, {pulled, [stream | streams], union_unpulled_value(stream, acc)}}

  defp union_pulled_value(%__MODULE__{evaluated: [head | _]}, acc) do
    acc
    |> Enum.map(&Answer.union(&1, head))
    |> Enum.filter(&Kernel.!=(&1, nil))
  end

  defp union_unpulled_value(%__MODULE__{evaluated: evaluated}, acc) do
    Enum.flat_map(evaluated, fn eval_item ->
      acc
      |> Enum.map(&Answer.union(&1, eval_item))
      |> Enum.filter(&Kernel.!=(&1, nil))
    end)
  end
end

Now we can confirm that everything works! The only difference is that, because our new and is lazy, we need to use Enum.to_list/0 to force evaluation.

arg1 = [%{a: 1}, %{a: 2}]
arg2 = [%{b: 1}, %{b: 2}]
arg3 = [%{c: 1}, %{c: 2}]

LazyCombinations.LazyAnd.new(LazyCombinations.LazyAnd.SimplePartiallyEvaluated,
  [arg1, arg2, arg3])
|> LazyCombinations.LazyAnd.resolve()
|> Enum.to_list()

[
  %{c: 1, a: 1, b: 1},
  %{c: 2, a: 1, b: 1},
  %{c: 2, a: 2, b: 1},
  %{c: 1, a: 2, b: 1},
  %{c: 2, a: 2, b: 2},
  %{c: 1, a: 2, b: 2},
  %{c: 2, a: 1, b: 2},
  %{c: 1, a: 1, b: 2}
]

Ensuring Equal Evaluation

Now we’ll test some infinite streams with a helper function that, again, builds a stream of positive numbers.

defmodule Test do
  def build_answer_stream(var) do
    Stream.iterate(1, &Kernel.+(&1, 1))
    |> Stream.map(&%{var => &1})
  end
end

But, sadly, there is a subtle issue with this implementation. If you take a look at the result below, you’ll see that our :b stream never gets past 1. This can be a bigger problem than it might first appear. Consider the Pythagorean triples example and imagine our current setup. If you request at least one answer, the function will never return because there is no valid answer where B is 1.

arg1 = Test.build_answer_stream(:a)
arg2 = [%{b: 1}, %{b: 2}]
arg3 = Test.build_answer_stream(:c)

LazyCombinations.LazyAnd.new(LazyCombinations.LazyAnd.SimplePartiallyEvaluated,
  [arg1, arg2, arg3])
|> LazyCombinations.LazyAnd.resolve()
|> Enum.take(10)

[
  %{c: 1, a: 1, b: 1},
  %{c: 2, a: 1, b: 1},
  %{c: 2, a: 2, b: 1},
  %{c: 1, a: 2, b: 1},
  %{c: 3, a: 2, b: 1},
  %{c: 3, a: 1, b: 1},
  %{c: 3, a: 3, b: 1},
  %{c: 2, a: 3, b: 1},
  %{c: 1, a: 3, b: 1},
  %{c: 4, a: 3, b: 1}
]

The above bug is a result of the order in which the streams are evaluated. The first incomplete stream seen in the list will have a new value calculated. In the above example, that first stream is always one of the infinite streams. An answer is to ensure that the smaller streams are always seen first.

The module below achieves this by tracking the count (so we do not have to count through every item of the evaluated list each time we order the streams) and then sorting the streams on each call of next_unions/1⁸ in lines 51-53.

defmodule LazyCombinations.LazyAnd.OrderedPartiallyEvaluated do
  @behaviour LazyCombinations.LazyAnd

  defstruct [:continuation, evaluated: [], count: 0]

  alias LazyCombinations.Answer

  @type t() :: %__MODULE__{
          continuation: Enumerable.continuation() | nil,
          evaluated: [Answer.t()],
          count: integer()
        }

  @impl true
  @spec new(Enumerable.t(Answer.t())) :: t()
  def new(stream) do
    reduce_fun = fn item, _acc -> {:suspend, item} end
    {:suspended, nil, continuation} = Enumerable.reduce(stream, {:suspend, nil}, reduce_fun)
    %__MODULE__{continuation: continuation}
  end

  @spec head(t()) :: t()
  def head(%__MODULE__{continuation: nil} = stream), do: stream

  def head(%__MODULE__{continuation: continuation, evaluated: evaluated, count: count} = partial) do
    case continuation.({:cont, nil}) do
      {:suspended, item, continuation} ->
        %__MODULE__{continuation: continuation, evaluated: [item | evaluated], count: count + 1}

      {:halted, item} ->
        %__MODULE__{partial | continuation: nil, evaluated: [item | evaluated]}

      {:done, nil} ->
        %__MODULE__{partial | continuation: nil, evaluated: evaluated}
    end
  end

  @spec done?(t()) :: boolean()
  def done?(%__MODULE__{continuation: continuation}) do
    continuation == nil
  end

  @spec count(t()) :: integer()
  def count(%__MODULE__{count: count}) do
    count
  end

  @impl true
  @spec next_unions([t()]) :: :empty | :done | {:ok, [t()], [Answer.t()]}
  def next_unions(streams) do
    case streams
         |> Enum.sort_by(&count/1)
         |> Enum.reduce_while({false, [], [Answer.new()]}, &collect_next_head/2) do
      :empty -> :empty
      {false, _, _} -> :done
      {true, new_streams, unions} -> {:ok, new_streams, unions}
    end
  end

  defp collect_next_head(%__MODULE__{continuation: nil, evaluated: []}, _), do: {:halt, :empty}

  defp collect_next_head(%__MODULE__{evaluated: []} = stream, {_, streams, acc}) do
    next = head(stream)

    if done?(next) do
      {:halt, :empty}
    else
      {:cont, {true, [next | streams], union_pulled_value(next, acc)}}
    end
  end

  defp collect_next_head(%__MODULE__{continuation: continuation} = stream, {false, streams, acc})
       when not is_nil(continuation) do
    next = head(stream)

    if done?(next) do
      {:cont, {false, [next | streams], union_unpulled_value(next, acc)}}
    else
      {:cont, {true, [next | streams], union_pulled_value(next, acc)}}
    end
  end

  defp collect_next_head(%__MODULE__{} = stream, {pulled, streams, acc}),
    do: {:cont, {pulled, [stream | streams], union_unpulled_value(stream, acc)}}

  defp union_pulled_value(%__MODULE__{evaluated: [head | _]}, acc) do
    acc
    |> Enum.map(&Answer.union(&1, head))
    |> Enum.filter(&Kernel.!=(&1, nil))
  end

  defp union_unpulled_value(%__MODULE__{evaluated: evaluated}, acc) do
    Enum.flat_map(evaluated, fn eval_item ->
      acc
      |> Enum.map(&Answer.union(&1, eval_item))
      |> Enum.filter(&Kernel.!=(&1, nil))
    end)
  end
end

Finally, we’ll check that this change works. And, low and behold, :b makes it to 2! Everything is being evaluated, and while we might have to check a lot of possibilities, we won’t ever get stuck because an answer set is never created.

arg1 = Test.build_answer_stream(:a)
arg2 = [%{b: 1}, %{b: 2}]
arg3 = Test.build_answer_stream(:c)

LazyCombinations.LazyAnd.new(LazyCombinations.LazyAnd.OrderedPartiallyEvaluated,
  [arg1, arg2, arg3])
|> LazyCombinations.LazyAnd.resolve()
|> Enum.take(10)

[
  %{c: 1, a: 1, b: 1},
  %{c: 2, a: 1, b: 1},
  %{c: 2, a: 2, b: 1},
  %{c: 1, a: 2, b: 1},
  %{c: 2, a: 2, b: 2},
  %{c: 1, a: 2, b: 2},
  %{c: 2, a: 1, b: 2},
  %{c: 1, a: 1, b: 2},
  %{c: 2, a: 3, b: 2},
  %{c: 1, a: 3, b: 2}
]

Conclusion

Elixir’s standard library is very comprehensive (especially the Enum and Stream modules), but not every use case is, or should be, implemented in it. However, the abstractions that those modules are built on, like the Enumerable protocol, provide a lot of leverage and let one build pretty complex behavior with surprisingly little work.

Edits

2025-07-03

• Fix pythagorean triples link

It is a perfect style because this is how people not only watch but play baseball. It is, at the core, a very conversational game. The most important conversation is between the pitcher and batter. It is often not especially loud and highly intimate. First the pitcher hides everything but his eyes, and looks at the batter. He sees how tall the batter stands, the way he holds the bat, and then he says something.

All pitchers talk differently. Some only talk in short, sharp, cutting statements. Some are less direct. They take their time getting to the point and their path there is less than direct. After all, what is a curve-ball but proof that the longest way round is the shortest way home.

It is then up to the batter to respond. Batters have a rather obvious time limit and so are forced to speak without fully thinking through their response. As a result, they speak when they should be silent or talk loudly when silence was called for. They frequently miss the mark and find themselves talking past the pitcher. But in this conversation the batter has to only say one thing to put the pitcher on their heels and while they all want to say it loud, a well placed point said just at the right volume will also work.

They are not the only ones talking. They are the ones everyone at the table is listening too, but infielders are all whispering about possible responses to the batter. At the ends of the tables, the managers discus who might be most eloquent.

And in the stands the fans talk too. The fans are not at the table, and so not required to follow every word. Sometimes they cannot help themselves, they follow every utterance either speechless or so full of things to say it comes out only as wordless sound. But baseball is a full, nine course meal at a very long table.

So the fans talk to each other. They get a beer. They discus the season. They talk about last night’s game. They take cheap shots at someone who stayed home. Which means that the broadcasters are doing the same thing as the fans, and they are both emulating the players. It’s baseball— lean back, think, lean in, then say something. And don’t worry too much about what you say. It’s a pastime and the wordsmiths are on the field.

I am not yet very good at this, but luckily pork chops are easier. The first time I remember making pork chops was with my mother. We used the bacon fat my father kept in the freezer and cooked them in a cast iron frying pan. For a long time, this is how I made pork chops. I didn’t always have bacon fat, but other things worked: olive oil especially, sometimes butter. But it wasn’t quite right; the olive oil was too greasy and the butter too rich.

More than anything pork’s flavor is straightforward. Chicken actually has a great deal of flavor, but it is easily swayed, easily convinced to pick up others. Steak is loud. That is why you can marinate it so many ways and it still screams above the crowd. But pork, pork is at its best when smoked and with maybe two other flavors. It is just too honest for the richness of butter and not light enough for olive oil.

The next recipe I learned was from my grandfather. He liked the chops thinner. He would score the sides with a pairing knife, and then season them with salt and pepper. He used one of his mother’s cast iron pans, but instead of any fat or grease he would use coarse salt, and at a much higher heat.

I really liked that recipe, but it was hard to get the chops I needed. The little grocery stores in Waltham and Sewanee just never had them in stock, and the apartments I lived in were so small they would fill up with smoke and set off the alarm. Often I could either let the alarm scream or let the chops burn. So I went back to the first recipe. I cooked them a little hotter so they weren’t as greasy and still scored the sides, but largely the process was the same.

Then my mother got my father a cast iron ridge grill for his birthday. If there is any evidence against progress it is this: despite all our metallurgy, our chemical non-sticks, our pressure cookers, and our ovens of various heat sources, the best way to cook a slab of meat since the invention of a hot slab of iron, is a hot slab of iron with raised ridges. The iron just captures more heat, and the ridges function a lot like my grandfather’s coarse salt; lifting the meat just enough that the flesh does not burn and does not adhere, but is still as close to the heat as possible.

And so it goes, bacon grease to oil, oil to salt, salt to iron ridges. The underlying recipe never really changed: pork, salt, pepper, heat, and it was always cast iron above the flame. After all, I am in many ways a traditionalist. I cook like my mother and like my grandfather and I trust that slab of iron to do for me what it did for my great grandmother. And yet, my traditions demand a better pork chop and so I cycle: grease to oil, oil to salt, salt to iron.

The work of freaking out the listener, or at least putting them off balance, starts in the proceeding song. ‘Share a Little Joke’ starts slow and for most of the song stays slow, but right at the end, after lyrics the are done, it speeds up. When music speeds up, your body can’t help it, your heart rate speeds up. When your heart rate speeds up, you can’t help it, you feel just a little rush of that flight or fight response— your lizard brain reaches up into that mammal gray matter and demands to be heard. And this is the state of mind Jefferson Airplane seems to want you in when ‘Chusingura’ begins—just a little bit primal.

The song itself starts with a high pitch. Not a whine or a bell or anything describable, just a tone. An echo rises out of the tone followed by the almost anxious tapping of drum-sticks. The tapping isn’t fast so much as hurried, like the clacking of of a woman’s heels when she thinks she is being followed late at night. Then the tone is joined by more, but they are irregular. They come and go with no rhyme and no rhythm and the echo is back, it is back and it is louder. The tapping now occasionally speeds up and you can hear the woman grabbing her skirt and running, turning, slowing down, doing it again, and again. The tapping gets louder. A few out-of-tune guitar strings are plucked one at a time and then, after a pause, a few of them all at once. The tapping gets louder. The tones all go away. And then the tapping fades.

And this is the end of the LP’s A side so now, all you should hear is first silence, and then the sound of the headshell hitting the spindle clack… clack… clack… before you get out of the chair, raise the arm, and flip the record.

Jefferson Airplane does make up for it. The next song, ‘If You Feel’, is calming and downright jovial. It has all the rhythm and all the order ‘Chushingura’ does not. Break china laughing, laughing, laughing, they sing. It’s a relief.

But is that why they did it? Did Jefferson Airplane just raise your heart rate and instill anxiety in you just so that the next feel-good tune could really land? I doubt that. For one, Crown of Creation is always circling and always anxious. The center of the album may be the height of this anxiety, but worry, concern, and fear are always around the corner. It is, after all, an album that finds peace only after nuclear oblivion.

And Jefferson Airplane is not the only psychedelic rock band to play this game. The first song on the first album by King Crimson, 21st Century Schizoid Man on In the Court of the Crimson King tells you right in the title what effect it is going for. It succeeds through lyrics shouted through static and the overwhelming, constant, but unreliable instruments. King Crimson does it again fifteen years later in a later incarnation on a pair of songs on Three of a Perfect Pair, ‘Industry’ and ‘Dig Me’. ‘Industry’ is even somewhat reminiscent of ‘Chushingura’. It also uses higher-pitched tones and an off-putting beat to place the listener in an anxious state. The next song goes even farther with the singer talking from the perspective of a car in a junkyard.

His voice is just slightly distorted so that you know he is the car and he is rotting and is decaying. There can be no doubting it.

You do not need these songs to make your skin crawl. Spin around in your room and pick something, a newspaper headline, a letter from the city, an app on your phone, the neighbors fighting through the wall; where can you turn that is not a source of fear? Even the cures are tinged by their enemy exactly because they are offered in opposition. We are told to exercise because it will calm us, to drink less because it cannot fix us, meditate because it will center us.

But psychedelic rock does not meditate. Instead it indulges: sound, emotions, genres, and stories. True rockstars can be gluttons for anything and everything. These albums are as much orgies as anything else; twisting vats of sensation and sound that explode out from the speakers. That anxiety, then, is just another aspect of the world to be indulged in—just another sensation in which to exult. “So drink deep,” says psychedelic rock. “What is there to fear in a little indulgence?”

I know this because for a very long time I did not appreciate it. I have always been fond of gin. At first it tasted like summer to me, because growing up, my parents had gin and tonics when it was warm and they could sit out on the porch. But this is not the true essence of gin and instead I have learned to recognize in it the smell of pine trees. This is why the liquor taste should be so strong—like fresh air, that first sip of strong alcohol pulls us into the present and reminds us that we are in the here and now.

And at first I thought of martinis as only a large glass of booze. I would wave the vermouth over the glass as if the essence of it could somehow travel through the air in to the liquid. A few drops would fall, the texture of the drink would change, I would add bitters, and then would call it a martini. I am afraid to say that there were some negative results from this behavior; the average person is not well prepared to drink a actual glass of largely uncut gin, much less a parade of them.

Since then I have learned that mysticism does not create a good cocktail. I bought a jigger and accepted the fact that a bottle of vermouth does not last six months. Then learned about ratios. There isn’t just a big difference between a martini that is seven or eight parts gin with one part vermouth compared to a martini that is three or four parts gin with one part vermouth; there is a big difference between a martini that is six parts gin and a martini that is four parts gin.

In retrospect, this is not surprising. When I made pizza dough with too much yeast, it rose too fast. I once added too much oregano to my eggs and found them inedible. So why shouldn’t any change in the amount of vermouth have an effect on the resulting martini? There is, after all, a reason why a martini with more gin is dry. Like cold air and dust, gin makes you reach for water and leaves the skin feeling dry.

Vermouth is more moderating. It smells like wine and even dry vermouth has a sweetness to it. Combine the dryness of the gin and the sweetness of the vermouth and you create these undercurrents, like the air at the edge of a storm. They mix and tumble, falling in and out of each other as the bitters tumble between the fronts. Dry martinis, then, are like a high pressure system, lots of cool, dry air that bring good weather and light winds. In comparison a martini with lots of vermouth is a low pressure system. That circling warm, sweet air brings storms and strong winds. All of which speaks to the versatility of the drink. You want rain, you add vermouth. And if you want a cool fall day, I would use a ratio of eight to one.

Not all of these agreements are the same; especially not for novelists. Amor Towles (the author of A Gentleman in Moscow) does not give the reader much by way of latitude. He writes with a prose that could only be produced by someone who had spent decades within east coast upper society. The former investment banker notes the display of every fork, just how close each couple is, how many times someone looks away from the movie. The world he creates is the result of painstaking detail and he traps both you and his main character in it. It is not that there is not a cast, but in both of his books there is only one character Towles really, truly loves. He dotes on his main characters; indulges them and then exposes them to the reader. But he is a very jealous writer, that character is his and no one else’s. In legal language the reader only really has visitation rights.

But Yuri Herrera gives the reader nothing but latitude. In his book Kingdom Cons the characters do not even have names. Instead they have roles: King, Artist, Commoner. His prose is fluid and filled with rough images. It reads like the first version of a fairy tale or a ballet with his King and his Artist dancing through set pieces. This is not to say that the work is not deathly serious; the king is a drug lord and if nothing else is, the blood on the floor is very real. But the Herrera requires the reader to work through the haze he creates. As a result he and the reader work alongside to tell his story. This a far more equitable relationship where the writer and the reader gain joint custody and joint responsibility in the raising of their love child. This can be exhausting (a few pages of Herrera’s novels have made me want to just lie down and close my eyes while I devoured Towles’ much longer books in days) but can also be very rewarding. Who doesn’t want to watch their love child grow up?

But the dynamics between the reader and the writers of superheroes are far more complex. For one, there are writers, plural. While in novels different writers can re-imagine previously existing characters, this is less transformation than it is a newly conceived character. There are countless Odysseuses experiencing very similar plots in different ways.

The rules for superheroes are in many ways the reverse. There is only one hero and many plots. When I pick up a Spider-Man comic I expect certain things: I want the web shooters he uses to go thwip-thwip, I would be taken aback if there wasn’t enough guilt to fuel a thousand confessionals, and I hope for at least one doomed romantic interest (I want Peter to be happy, even if it is only fleeting). There is a commercial aspect to this. Readers probably would not respond well to a calm, confident, guilt-free Peter Parker because they come for the chaos, but there is more going on than economics.

The custody agreement is not just flipped here. When it comes to superheroes the readers, the mass, have full ownership of the character. The writers can shift things, make the story darker or refocus on aspects of the character previously ignored, but they can never subvert the readers’ demands because the connection is so much stronger.

The character in a novel, however real, is the creation of a single person. They are a piece in a larger story, birthed to play their role alongside others. But in a comic the superhero is the only thing that matters; the plots, the villains, the love stories only exist to further strengthen the hero. This is because we don’t believe in those things, but we believe in the hero. I believe in Captain America. And I believe in him because I believe in the virtues of dignity and basic decency. And I believe that these are not just ends but means. And when he says to a little girl, “I know you’re scared. I don’t blame you. But if you really feel like you can’t face him alone let me help you,” I feel relief.

But maybe the problem is the superheroes are not characters at all. They’re thin wrappings of origin stories and spandex around something that was already present and already compelling. In this version superheroes are not born and they cannot be owned. Instead they must be collected— found on street corners and in alleyways before they are pieced together. In a novel characters are still real people, or at least as close to real people as the skill of the author will allow. They have hopes and dreams and feel a little shame when they have a dirty thought about the girl behind the counter.

Superheroes may have flaws, but they are not real people. We do not believe in real people, we believe in ideals. And sometimes we dress those ideals up in a suit and have them fly over Manhattan and save us.

I noticed when they were gone though. Not at first, since my dorm rooms were small, cluttered, and I covered the walls with posters in a way that I had never done at home. The transience of dorm rooms means that they resist becoming yours; you do not so much reside in them as stay, like an extended visit at a half star hotel. The rules remind you of this, they say what tape you can use, what kind of hooks can be attached to what walls. The allowed supplies are never good enough. Posters peel and hooks holding up picture frames fail in the middle of the night. I still owe Sewanee fees for damage some tape did to the walls of my senior year dorm.

But at least you are allowed, briefly, to try to own the space. This is not always true. I spent a summer working in Lincoln, Nebraska, a place I have little fondness for. The worst part was not the sweltering heat, the dull work, or even the endless, rolling boredom, it was the walls of the apartment building I lived in. They were gray, and we were not allowed to cover them.

This gray was a very special gray. It was completely non-committal, not especially dark, not light. In fact, it seemed to suck in the light and it was everywhere. Every hallway, every room, it would seep into my dreams fading the other colors like paint remover. And I could not cover it.

It has been a while since I lived in Lincoln. I haven’t stepped in a dorm room since I left my senior year. In grad school I lived with roommates, and could only cover the walls of own room, but I did that much. The posters went away, and I put up prints. Gifts mostly, but I found money to fill any holes so everything could have a proper place.

Prints are the most democratic form of visual art. A single plate or set of wood blocks can become numerous works, each numbered and marked. In some cases after the original run new reprintings can be run so that the next generation can partake. Art for everyone.

There has always been something attractively democratic about printing in general; in many ways it is the mirror image of the democratic process. In an election many voters come together to create a single government. In printing a single design, plate, or screen is used create many copies. And while museums house incredible exhibits of breathtaking work, they stop at their own doors and cannot and should not fill my apartment with beauty. You will probably never have a Van Gogh hanging in your bedroom, but you can have a Toulouse Lautrec reprint. Trust me, I do.

It is one of my favorites, La Vache Enragee, it was a gift from my father. It is genuinely funny. Every time I look at it I always see the same thing first; a balding man with skin the color of the street fleeing down the avenue, checkered pants clashing with the cobblestones, long green coat billowing behind him, and his hands, raised up in surrender, holding a distinctly feminine umbrella. Behind him is a bull. He is red, his head is down, and his horns are up. Around them there are others, a policeman, a baker, a dog, a clown and a monkey riding the bike, but they are probably bystanders.

Not that they have to be. A challenge of visual art is that nothing says you can’t tell a story, only that you have a single frame. But if you only have a single frame you can provide infinite possibilities. Sometimes I look at that print and see the obvious, the angry bull and the fleeing, rich fool. But sometimes I am more interested in the baker. Is he really just a bystander? Does he know more than his happy smile would suggest? Sometimes I see the dog, maybe about to pounce on the fool. Or maybe just running along side because what fun this is.

I love that print. And I love that it hangs from a nail that no one could tell me not put there. And I love that every time I look at it and tell a new story that story sinks down that nail into the wall. And then that story, my story, seeps into the wood, the bones of the apartment, and this place becomes a little more mine.

I found this interesting because (though she claims to hate it) in another life she could have been a mathematician. There are more similarities between mathematics and theology than mathematics and science; we have all learned that nothing is ever true in science. Today a virus is airborne, tomorrow passed only by touch. Yesterday immunity lasted three months, tomorrow it might last six. In a world of p-values there cannot be truth, only things that are acceptably possible, and one day the apple that has fallen from its tree, time and time again, will float up into the sky, or explode into a thousand cherry blossoms. The fact that these things almost certainly will not happen means that there is the smallest of possibilities that they could.

But math— math will offer a level of certainty (provided various assumed things actually are true). If \(x = 4 - 1\), then in that situation \(x\) always was three. It was three the moment the equation was written. It will be three when you die. It will be three when the sun falls into itself. Sadly this is not usually as satisfying as theology. Socrates may have considered death the next intellectual horizon, but I am afraid the rest of us might gain some comfort from knowing, if not what the destination is, at least that there is one.

But this is why mathematics and science are in bed together (despite their differences), not mathematics and theology. Imagine, for only a moment, that there was an ultimate formula for everything: want to know the position and velocity of a particle (use the formula), want to know if the patient has cancer (use the formula), want to know if your mother-in-law would prefer that your wife had married the boy down the street (use the formula).

What a dull world. Certainty would become an everyday phenomenon. We would all know the ideal path to work, the exact number of minutes to cook a steak, how many drinks you should have to be charming. No one would ever fall off a bar stool, tell their crush the truth, or play a video game. Not unless the formula told them to.

But you go to a bar because it is funny when your friends fall off bar stools and you blurt out the truth because it is worth saying. Just like mathematicians thrive on the undiscovered portions of their fields and scientists live on a need to understand a fundamentally unknowable universe, it is not worth getting out of bed for a preordained day. Somewhere, there is a woman staring at a chalkboard filled with symbols trying to build some new form of topology. She does not know if it is even possible, just like the man in an observatory trying, once again, to see something that cannot be seen. They have failed a thousand times, but still look.

Which is to say, it is not that the coin can not work that way, it has too. It must be heads, and tails, and every one of an uncountable supply of supposedly impossible options, because otherwise there would be no reason to flip it.

Part of what is odd about this is that, in many cases, that electric stove is itself powered by natural gas. Electricity is not magic. It is not conjured out of the air but comes from movement. A magnet must move, turning electrons in the surrounding wires, creating a flow of energy, which is itself expressed as heat.

But to move a magnet, we often turn to the oldest of discoveries, fire. In the country I live in we largely burn coal and natural gas, the heat boils water, the water creates steam, the steam turns a turbine, and so a magnet turns and, after a great many steps, my stove heats. And so heat becomes movement, movement becomes electricity, electricity moves and then becomes movement, which finally becomes heat.

I thought about all of this as my chicken burned. To be fair, it was probably not the stove’s fault that my chicken turned out charred; electric stoves require far more patience than gas stoves that are, on the whole, quite eager to please. But it still seemed to me that this was a lot of intermediary steps to further remove me from a gas fire.

But then, even the gas stove has more steps than are immediately visible. I have cooked on an open flame. It is far more work than turning a knob: wood must be gathered, a fire started and then stoked to the point where it is hot enough to do its job, the coals then moved to get a desired heat. But to turn that knob the natural gas must be extracted from the earth: first the bedrock fractured, then those fractures held open as the gas is collected. The collected gas then transported to the gas company who then pipes it into our homes via gas lines. But even this can be further examined, given that burning gas is really burning ancient sunlight, which is itself a product of a massive fusion reactor that was, itself, born of gas.

None of this, of course, much mattered. The chicken was still charred. The knob was still too high and the stove top too hot. I had still been too impatient.