In with the new: Bevy

Released in 2020, Bevy is a relatively new free and open source game engine in Rust. It is also quite experimental, having breaking changes every few releases. Yet, it has produced fantastic and beautiful games like Tiny Glade, Fields of Aaru, Times of Progress, and many more.

More importantly for me, unlike other game engines, Bevy require no GUI or visual editor³. This means that the workflow is similar to traditional computations that scientists are familiar with, where everything is just code.

In addition to its speed, Rust is also a joy to write in with type and memory safeties, and one can achieve beautiful renders and visualizations thanks to Bevy’s ray-tracer Solari.

The tasks

Their tasks are quite simple really.

After some introduction about the idea of population dynamics and chaos at the start of the class, we got them to derive the logistic map:

where and .

models a proportion of population at year , and is a parameter that might represents some environmental conditions. Depending on the values of , the population can rise and fall, or exhibit complex behaviors.

import numpy as np
import matplotlib.pyplot as plt

x = np.zeros(50)
x[0] = 0.2

A = 0.5
for n in range(49):
    x[n+1] = A * x[n] * (1 - x[n])

plt.plot(x)

for A in np.linspace(3.4, 4, 3000):
    x = np.zeros(600)
    x[0] = 0.2

    for n in range(599):
        x[n+1] = A * x[n] * (1 - x[n])

    plt.plot([A] * 300, x[300:], ',')

plt.xlabel("$A$")
plt.ylabel("$x_n$")

So what should the students actually be learning?

Here’s my thesis:

Students should learn

1. the idea behind programming, not the programming,
2. to compose small behaviors into large solutions.

You might be scratching your head here as this is quite vague, but these two points are really in the spirit of Edsger Dijkstra’s well-known quote of

“Computer science is no more about computers than astronomy is about telescopes.”

logisticMap a xn = a * xn * (1 - xn)

xs = take 50 (iterate (logisticMap 0.5) 0.2)

main = plotList [] xs

x = np.zeros(50)
x[0] = 0.2

A = 0.5
for n in range(49):
    x[n+1] = A * x[n] * (1 - x[n])

plt.plot(x)

task1 a = drop 300 (take 600 (iterate (logisticMap a) 0.2))

aValues = toList (linspace 3000 (3.4, 4.0))

xs = map task1 aValues

task1 a = drop 300 (take 600 (iterate (logisticMap a) 0.2))

aValues = toList (linspace 3000 (3.4, 4.0))

points = [(a, xs) | a <- aValues, xs <- task1 a]

main = plotPath [PlotStyle Points] points

for A in np.linspace(3.4, 4, 3000):
    x = np.zeros(600)
    x[0] = 0.2

    for n in range(599):
        x[n+1] = A * x[n] * (1 - x[n])

    plt.plot([A] * 300, x[300:], ',')

using IterTools

logistic_map(A) = xn -> A * xn * (1 - xn)

task1(A) =
    0.2 |>
    iterated(logistic_map(A)) |>
    (x -> take(x, 600)) |>
    (x -> drop(x, 300)) |>
    collect

xs = map(task1, range(3.4, 4, length=3000))

library(purrr)

logistic_map <- function(A) {
  function(x) A * x * (1 - x)
}

task1 <- function(A) {
  accumulate(
    seq_len(599),
    .init = 0.2,
    .f = function(x, unused) logistic_map(A)(x)
  ) |>
    tail(300)
}

xs <- map(
  seq(3.4, 4.0, length.out = 3000),
  task1
)

fn task1(a: f64) -> Vec<f64> {
    std::iter::successors(Some(0.2), move |&x| {
        Some(a * x * (1.0 - x))
    })
    .skip(300)
    .take(300)
    .collect()
}

fn main() {
    let xs: Vec<Vec<f64>> = linspace(3.4, 4.0, 3000)
        .into_iter()
        .map(task1)
        .collect();
}

def logisticMap(a: Double)(x: Double): Double =
  a * x * (1.0 - x)

def task1(a: Double): Vector[Double] =
  Iterator
    .iterate(0.2)(logisticMap(a))
    .drop(300)
    .take(300)
    .toVector

val xs: Vector[Vector[Double]] =
  linspace(3.4, 4.0, 3000).map(task1)

But what about Einstein’s EPR paper?

Let’s look at the timeline:

• 1927: Einstein first raised his issues with quantum mechanics at the fifth Solvey conference, arguing that it is incomplete. He used the term “peculiar mechanism of action at a distance” (Bacciagaluppi and Valentini 2009, 485–87).

• 1935: Einstein, Podolsky, and Rosen published the famous EPR paper that introduced quantum entanglement. There is no mention of the phrase “action at a distance” in the paper (Einstein, Podolsky, and Rosen 1935).

• 1947: In a letter to Max Born where Einstein maintains his position that quantum mechanics is incomplete, the term “spooky actions at a distance” was used and popularized (Born et al. 1971, 157–58).

It seems to me that the Einstein’s “action at a distance” problem with quantum mechanics predates the concept of quantum entanglement, and that the case of the two entangled particles in the EPR paper that everyone parrots now is simply one example that demonstrates the issue.

Furthermore, in the context of the letters to Max Born in 1947:

“I cannot seriously believe in it because the theory cannot be reconciled with the idea that physics should represent a reality in time and space, free from spooky actions at a distance.”

“But I am quite convinced that someone will eventually come up with a theory whose objects, connected by laws, are not probabilities but considered facts, as used to be taken for granted until quite recently.”

It seems clear to me that Einstein’s problems with “spooky actions at a distance” concerns the nature of “realism” and it’s contradiction with “locality”, rather than entanglement.

This should be clear if we look at his 1927 example at the fifth Solvey conference.

Hardy’s modern example

We have come a long way since then, and there are now many examples that demonstrate this intuitively and formally without the long-winded explanation about entanglement.

Here’s an example provided by Lucien Hardy (Hardy 1995)².

1. Send a single photon to a beam splitter.
2. The beam splitter has a 50% chance of letting the photon pass through, and a 50% chance of deflecting the photon to another path.
3. The single photon is now in a superposition of two paths, and we can let the photon propagate as far as we want down the two paths, so that the two paths are separated by a great distance.
4. Supposed we measure the photon in path 1 using a detector, and found it to be in path 1.
5. Quantum mechanics dictates that instantaneously, the “potential” photon in path 2 must disappears, regardless of the great distance between the two paths, such that a detector at path 2 can now never detect the photon at path 2.

Additionally, if instead we were to remove the detector at the very last minute before the photon would have hit the detector in path 1, then a detector at path 2 can still potentially detect the photon at path 2, as though like our choice of putting the detector in path 1 affects what happens in path 2 a great distance away.

Hardy took Redhead’s definition of locality of (Redhead 1987): “elements of physical reality pertaining to one system cannot be affected by measurements performed ‘at-a-distance’ on another system.”

If we assume that the photon’s paths down either path 1 or path 2 are “ontologically real”, then our action of putting a detector at path 1 somehow affects the “reality” in path 2, regardless of the great distance separating them, i.e., we have to give up on locality.

So where are we at now?

One reason this measurement problem is often ignored is because there is already a mainstream interpretation that physicists learn in textbooks³.

This is the regnant Copenhagen interpretation, where it is accepted that there is indeed no “real” existence of the cat at either houses before measurement, and that we just have to accept the manual updating of the collapse of the wavefunction by hand.

To quote Wikipedia: “no truth can be attributed to an object except according to the results of its measurement”. In other words, it makes little sense to ask why a measurement at your house can affect the “reality” at your neighbor’s house, if we accept that there is no “truth” statement that can be made about a cat at your neighbor’s house before measurement in the first place.

Sometimes, this interpretation manifests as the students learning that the wavefunction is simply a “probability wave” describing the position of the particle, and has no real existence until measurement. This of course runs the risk of conflating with Einstein’s preferred view that it is only a probabilistic description because of our lack of information (of hidden variables)⁴, but I guess students are typically more concerned with being able to solve an exam problem rather than the philosophical aspects anyway.

Appendix

Some examples

I should mention again, just like I did in the post on Haskell, that I am neither a software developer nor am I computer science trained, and so some technical aspects of the language might escape me.

Additionally, I am not really an expert in all of the packages mentioned, and so there might be better solutions that I missed.

Having said that, let’s look at some examples for why I think R is awesome.

library(dplyr)
library(tidyr)
library(purrr)

hugeQuantumSys <- function(x1, x2, x3) {
    ## Some huge calculations
    return(c(y1 = x1 + x2 + x3, y2 = x1 * x2 * x3, y3 = x1 - x2 - x3))
}

df <- expand_grid(
    x1 = seq(-1, 1, length = 100),
    x2 = seq(0, pi / 2, length = 100),
    x3 = seq(0, 1, length = 100)
) |>
    mutate(results = pmap(list(x1, x2, x3), hugeQuantumSys)) |>
    unnest_wider(results)

arrow::write_parquet(df, "file.parquet")

using DataFrames
using Arrow

function hugeQuantumSys(x1, x2, x3)
    # Some huge calculations
    return (y1 = x1 + x2 + x3, y2 = x1 * x2 * x3, y3 = x1 - x2 - x3)
end

df = DataFrame(
    Iterators.product(
        range(-1, 1, length = 100),
        range(0, pi / 2, length = 100),
        range(0, 1, length = 100)
    )
)
rename!(df, [:x1, :x2, :x3])

y_vals = DataFrame(map(hugeQuantumSys, df.x1, df.x2, df.x3))

df = hcat(df, y_vals)

Arrow.write("file.parquet", df)

import numpy as np
import pandas as pd
import itertools

def hugeQuantumSys(x1, x2, x3):
    # Some huge calculations
    return {"y1": x1 + x2 + x3, "y2": x1 * x2 * x3, "y3": x1 - x2 - x3}

df = pd.DataFrame(
    itertools.product(
        np.linspace(-1, 1, 100),
        np.linspace(0, np.pi / 2, 100),
        np.linspace(0, 1, 100)
    ),
    columns=["x1", "x2", "x3"],
)

y_vals = df.apply(
    lambda row: hugeQuantumSys(row["x1"], row["x2"], row["x3"]),
    axis=1,
    result_type="expand",
)

df = pd.concat([df, y_vals], axis=1)

df.to_parquet("file.parquet")

import numpy as np
import polars as pl
import itertools

def hugeQuantumSys(x1, x2, x3):
    # Some huge calculations
    return {"y1": x1 + x2 + x3, "y2": x1 * x2 * x3, "y3": x1 - x2 - x3}

df = pl.DataFrame(
    itertools.product(
        np.linspace(-1, 1, 100),
        np.linspace(0, np.pi / 2, 100),
        np.linspace(0, 1, 100)
    ),
    schema=["x1", "x2", "x3"],
)

y_vals = df.map_rows(lambda row: hugeQuantumSys(row[0], row[1], row[2])).unnest()

df = pl.concat([df, y_vals], how="horizontal")

df.write_parquet("file.parquet")

import numpy as np
import pandas as pd
import itertools

def hugeQuantumSys(x1, x2, x3):
    # Some huge calculations
    return x1 + x2 + x3, x1 * x2 * x3, x1 - x2 - x3

x1 = np.linspace(-1, 1, 100)
x2 = np.linspace(0, np.pi / 2, 100)
x3 = np.linspace(0, 1, 100)

N = len(x1) * len(x2) * len(x3)

x1_vals = np.zeros(N)
x2_vals = np.zeros(N)
x3_vals = np.zeros(N)
y1_vals = np.zeros(N)
y2_vals = np.zeros(N)
y3_vals = np.zeros(N)

for i, (x1_val, x2_val, x3_val) in enumerate(itertools.product(x1, x2, x3)):
    x1_vals[i] = x1_val
    x2_vals[i] = x2_val
    x3_vals[i] = x3_val
    y1_vals[i], y2_vals[i], y3_vals[i] = hugeQuantumSys(x1_val, x2_val, x3_val)

df = pd.DataFrame(
    {
        "x1": x1_vals,
        "x2": x2_vals,
        "x3": x3_vals,
        "y1": y1_vals,
        "y2": y2_vals,
        "y3": y3_vals,
    }
)

df.to_parquet("file.parquet")

df |>
  filter(y3 < 0) |>
  mutate(is_positive = (y1 * y2 >= 0)) |>
  group_by(is_positive) |>
  summarize(y1_mean = mean(y1),
            y2_mean = mean(y2),
            y3_mean = mean(y3))

SELECT
    (y1 * y2) >= 0 AS is_positive,
    AVG(y1) AS y1_mean,
    AVG(y2) AS y2_mean,
    AVG(y3) AS y3_mean
FROM df
WHERE y3 < 0
GROUP BY (y1 * y2) >= 0;

using Statistics

df |>
    x -> filter(row -> row.y3 < 0, x) |>
    x -> transform(x, [:y1, :y2] => ((y1, y2) -> y1 .* y2 .>= 0) => :is_positive) |>
    x -> combine(
    groupby(x, :is_positive),
    :y1 => mean => :y1_mean,
    :y2 => mean => :y2_mean,
    :y3 => mean => :y3_mean
)

# alternatively, without using pipes

df_filtered = filter(row -> row.y3 < 0, df)
df_mutated = transform(df_filtered, [:y1, :y2] => ((y1, y2) -> y1 .* y2 .>= 0) => :is_positive)

combine(
    groupby(df_mutated, :is_positive),
    :y1 => mean => :y1_mean,
    :y2 => mean => :y2_mean,
    :y3 => mean => :y3_mean
)

@chain df begin
    @subset(:y3 .< 0)
    @transform(:is_positive = (:y1 .* :y2 .>= 0))
    @groupby(:is_positive)
    @combine(:y1_mean = mean(:y1),
             :y2_mean = mean(:y2),
             :y3_mean = mean(:y3))
end

(
    df.query("y3 < 0")
    .assign(is_positive=lambda x: (x["y1"] * x["y2"]) >= 0)
    .groupby("is_positive")
    .agg(
        y1_mean=("y1", "mean"),
        y2_mean=("y2", "mean"),
        y3_mean=("y3", "mean")
    )
    .reset_index()
)

(
    df.filter(pl.col("y3") < 0)
    .with_columns(is_positive=(pl.col("y1") * pl.col("y2")) >= 0)
    .group_by("is_positive")
    .agg(
        y1_mean=pl.col("y1").mean(),
        y2_mean=pl.col("y2").mean(),
        y3_mean=pl.col("y3").mean(),
    )
)

# A tibble: 2 × 4
  is_positive y1_mean y2_mean y3_mean
  <lgl>         <dbl>   <dbl>   <dbl>
1 FALSE         0.915  -0.221  -1.87
2 TRUE          1.61    0.187  -0.950

library(ggplot2)
library(ggtypst)

df |>
  filter(x2 == 0 | near(x2, pi / 6) | near(x2, pi / 3) | near(x2, pi / 2)) |>
  mutate(x2 = paste("x_2 =", signif(x2 / pi, 3), "pi")) |>
  ggplot(aes(x1, x3, fill = y1)) +
  geom_raster() +
  scale_fill_steps(n.breaks = 10) +
  facet_wrap(~x2) +
  theme(strip.text = element_math_typst(size = 12, face = "bold"))

import matplotlib.pyplot as plt

filtered_df = df[
    (df["x2"] == 0)
    | (np.isclose(df["x2"], np.pi / 6))
    | (np.isclose(df["x2"], np.pi / 3))
    | (np.isclose(df["x2"], np.pi / 2))
].copy()

filtered_df["x2"] = filtered_df["x2"].apply(lambda x: f"x2 = {x / np.pi:.3f} pi")
x2_groups = filtered_df.groupby("x2", sort=False)

fig, axes = plt.subplots(2, 2)

for ax, (x2_label, group) in zip(axes.flatten(), x2_groups):
    x1_unique = np.sort(group["x1"].unique())
    x3_unique = np.sort(group["x3"].unique())

    X1, X3 = np.meshgrid(x1_unique, x3_unique)

    Z = group.pivot_table(index="x3", columns="x1", values="y1").values

    contourf = ax.contourf(X1, X3, Z)
    plt.colorbar(contourf, ax=ax)

    ax.set_xlabel("x1")
    ax.set_ylabel("x3")
    ax.set_title(x2_label)

plt.tight_layout()
plt.show()

using CairoMakie
using Printf

filtered_df = df[
    (df.x2 .== 0) .|
        (isapprox.(df.x2, π / 6)) .|
        (isapprox.(df.x2, π / 3)) .|
        (isapprox.(df.x2, π / 2)),
    :,
]

filtered_df.x2_label = [@sprintf("x2 = %.3f pi", x / π) for x in filtered_df.x2]
x2_groups = groupby(filtered_df, :x2_label)

fig = Figure()

for (idx, group) in enumerate(x2_groups)
    row = div(idx - 1, 2) + 1
    col = mod(idx - 1, 2) + 1

    ax = Axis(fig[row, col], xlabel = "x1", ylabel = "x3", title = group.x2_label[1])

    x1_unique = sort(unique(group.x1))
    x3_unique = sort(unique(group.x3))

    X1 = repeat(x1_unique', length(x3_unique), 1)
    X3 = repeat(x3_unique, 1, length(x1_unique))

    Z = fill(NaN, length(x3_unique), length(x1_unique))
    for (i, x3_val) in enumerate(x3_unique), (j, x1_val) in enumerate(x1_unique)
        row_match = findfirst((group.x1 .≈ x1_val) .& (group.x3 .≈ x3_val))
        if !isnothing(row_match)
            Z[i, j] = group.y1[row_match]
        end
    end

    contourf!(ax, X1, X3, Z, levels = 15)
end

fig

library(dplyr)
library(tidyr)
library(purrr)

hugeQuantumSys <- function(x1, x2, x3) {
    ## Some huge calculations
    return(c(y1 = x1 + x2 + x3, y2 = x1 * x2 * x3, y3 = x1 - x2 - x3))
}

df <- expand_grid(
    x1 = seq(-1, 1, length = 100),
    x2 = seq(0, pi / 2, length = 100),
    x3 = seq(0, 1, length = 100)
) |>
    mutate(results = pmap(list(x1, x2, x3), hugeQuantumSys)) |>
    unnest_wider(results)

library(tidytable)

hugeQuantumSys <- function(x1, x2, x3) {
    ## Some huge calculations
    return(c(y1 = x1 + x2 + x3, y2 = x1 * x2 * x3, y3 = x1 - x2 - x3))
}

df <- expand_grid(
    x1 = seq(-1, 1, length = 100),
    x2 = seq(0, pi / 2, length = 100),
    x3 = seq(0, 1, length = 100)
) |>
    mutate(results = pmap(list(x1, x2, x3), hugeQuantumSys)) |>
    unnest_wider(results)

reticulate::use_virtualenv("~/.local/venv/")
qt <- reticulate::import("qutip")

J <- 1
t <- 1

Hint <- J *
    qt$tensor(qt$destroy(2L), qt$create(2L)) +
    qt$tensor(qt$create(2L), qt$destroy(2L))

U <- (-1i * Hint * t)$expm()

rhoIn <- qt$rand_dm(c(2L, 2L))
rhoOut <- U * rhoIn * U$dag()

print(rhoOut)

Quantum object: dims=[[2, 2], [2, 2]], shape=(4, 4), type='oper', dtype=Dense, isherm=True
Qobj data =
[[ 0.23766069+0.00000000e+00j -0.12235266-1.04414855e-01j
   0.1342473 -3.25719171e-02j  0.01416946+8.07667926e-02j]
 [-0.12235266+1.04414855e-01j  0.36023742+0.00000000e+00j
  -0.09647204+1.98926694e-01j -0.24404032-3.03698913e-02j]
 [ 0.1342473 +3.25719171e-02j -0.09647204-1.98926694e-01j
   0.15602805-6.93889390e-18j  0.0481154 +1.36967243e-01j]
 [ 0.01416946-8.07667926e-02j -0.24404032+3.03698913e-02j
   0.0481154 -1.36967243e-01j  0.24607384+0.00000000e+00j]]
 signature: (other: 'Qobj') -> 'Qobj'

library(RcppEigen)

reticulate::use_virtualenv("~/.local/venv/")
qt <- reticulate::import("qutip")

Sys.setenv(PKG_CXXFLAGS = "-I/usr/local/include/qpp")
sourceCpp("compression.cpp")

rhoIn <- qt$rand_dm(c(2L, 2L, 2L))$full()

rhoOut <- compressionGate(rhoIn)

#include <RcppEigen.h>

// [[Rcpp::depends(RcppEigen)]]

#include <cmath>
#include <qpp/qpp.hpp>

using namespace qpp;

// [[Rcpp:export]]
cmat compressionGate(cmat rhoIn) {
  cmat compress1 = kron(st.pz0, gt.Id2, gt.Id2) + kron(st.pz1, gt.X, gt.Id2);
  compress1 *= kron(st.pz0, gt.Id2, gt.Id2) + kron(st.pz1, gt.Id2, gt.X);
  cmat compress2 = kron(gt.Id2, st.pz0, st.pz0) + kron(gt.Id2, st.pz0, st.pz1) +
                   kron(gt.Id2, st.pz1, st.pz0) + kron(gt.X, st.pz1, st.pz1);
  cmat compress = compress1 * compress2 * compress1;

  return compress * rhoIn * adjoint(compress);
}

But LLM?

There are some growing sentiments that it no longer matters what language or package one uses, as one can simply ask an LLM to write the code for you.

Here, I’ll make two claims that I believe applies to the current state of LLM at the time of writing (June 2026), that leads to corollaries on why I think the language still matters.

1. Current LLMs are not perfect, and can still generate bug-ridden codes.

2. Different from software development, in scientific computing and data analysis, bugs can be invisible by simply manifesting as plots or values that are incorrect.

The corollary to these is that

3. One has to check and audit the LLM-generated code for any serious work.

I mean, would you submit results generated by LLM-written codes for publication without checking it? Or would you advise your company or clients using the same results without ensuring that the LLM-written codes are correct?

Considering these, my opinion is that

4. The tidyverse syntax and way of doing things is easier and faster to check and audit.

On top of its simplicity, the tidyverse has a somewhat declarative syntax especially when used with higher-order functions (purrr) which makes it even easier to check for correctness¹².

I’ll go even further to say that the declarative approach means that using the tidyverse actually saves you more time than using an LLM, especially considering that LLMs like to generate overly complex codes rather than keeping it simple.

Imagine telling an LLM that¹³:

“write me a pandas code for a dataframe df that keeps only y1 less than 2, create a new column where z is the sum of y1, y2, y3, then plot z against x1 where there is two lines, one for z >= 0 and one for z < 0”

wait for it to generate, copy and paste it, run it and hope that it didn’t hallucinate some functions, and then check that it is actually doing what you want, when you could have type less characters if you do it yourself.

df |>
  filter(y1 < 2) |>
  mutate(z = y1 + y2 + y3) |>
  ggplot(aes(x1, z, color = factor(z >= 0))) +
  geom_line()

import pandas as pd
import matplotlib.pyplot as plt

# example: assume df already exists
# Step 1: keep only rows where y1 < 2
df = df[df['y1'] < 2].copy()

# Step 2: create new column z = y1 + y2 + y3
df['z'] = df['y1'] + df['y2'] + df['y3']

# Step 3: split into two series for plotting
df_pos = df[df['z'] >= 0]
df_neg = df[df['z'] < 0]

# Step 4: plot z vs x1 with two lines
plt.figure(figsize=(8,5))
plt.plot(df_pos['x1'], df_pos['z'], label='z >= 0', color='tab:blue', marker='o', linestyle='-')
plt.plot(df_neg['x1'], df_neg['z'], label='z < 0', color='tab:red', marker='o', linestyle='-')
plt.xlabel('x1')
plt.ylabel('z')
plt.title('z vs x1 (separate lines for z >= 0 and z < 0)')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

library(tidyverse)

# assume df exists with columns x1, y1, y2, y3
df_clean <- df %>%
  filter(y1 < 2) %>%                         # keep only y1 < 2
  mutate(z = y1 + y2 + y3,                   # new z column
         z_sign = if_else(z >= 0, "z >= 0", "z < 0"))  # grouping column for lines

# Plot: two lines (one for z >= 0, one for z < 0)
ggplot(df_clean, aes(x = x1, y = z, color = z_sign)) +
  geom_line() +
  geom_point() +                             # optional: points
  scale_color_manual(values = c("z >= 0" = "steelblue", "z < 0" = "firebrick")) +
  labs(x = "x1", y = "z (y1+y2+y3)", color = "Group") +
  theme_minimal()

import pandas as pd
import matplotlib.pyplot as plt

# Filter dataframe to keep only rows where y1 < 2
df = df[df['y1'] < 2]

# Create new column z as the sum of y1, y2, y3
df['z'] = df['y1'] + df['y2'] + df['y3']

# Create the plot
plt.figure(figsize=(10, 6))

# Plot line for z >= 0
df_positive = df[df['z'] >= 0]
plt.plot(df_positive['x1'], df_positive['z'], label='z >= 0', marker='o')

# Plot line for z < 0
df_negative = df[df['z'] < 0]
plt.plot(df_negative['x1'], df_negative['z'], label='z < 0', marker='o')

plt.xlabel('x1')
plt.ylabel('z')
plt.legend()
plt.grid(True)
plt.show()

library(tidyverse)

df %>%
  filter(y1 < 2) %>%
  mutate(z = y1 + y2 + y3) %>%
  ggplot(aes(x = x1, y = z, color = z >= 0)) +
  geom_line() +
  scale_color_manual(values = c("FALSE" = "red", "TRUE" = "blue"),
                     labels = c("FALSE" = "z < 0", "TRUE" = "z >= 0")) +
  labs(color = "Condition",
       x = "x1",
       y = "z") +
  theme_minimal()

import pandas as pd
import matplotlib.pyplot as plt

# Assuming df is your DataFrame
df = df[df['y1'] < 2]  # Keep only rows where y1 is less than 2

# Create a new column 'z' which is the sum of y1, y2, y3
df['z'] = df['y1'] + df['y2'] + df['y3']

# Plot 'z' against 'x1'
plt.figure(figsize=(10,6))
df_pos = df[df['z'] >= 0]
df_neg = df[df['z'] < 0]

plt.plot(df_pos['x1'], df_pos['z'], label='z >= 0')
plt.plot(df_neg['x1'], df_neg['z'], label='z < 0')

plt.xlabel('x1')
plt.ylabel('z')
plt.title('Plot of z against x1')
plt.legend()
plt.grid(True)
plt.show()

library(tidyverse)

df %>%
  filter(y1 < 2) %>%
  mutate(z = y1 + y2 + y3) %>%
  ggplot(aes(x = x1, y = z, color = factor(z >= 0))) +
  geom_line() +
  labs(color = "z >= 0")

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Sample data creation (replace this with your actual DataFrame)
np.random.seed(42)
df = pd.DataFrame({
    'x1': np.linspace(0, 10, 100),
    'y1': np.random.uniform(0, 3, 100),
    'y2': np.random.uniform(-2, 2, 100),
    'y3': np.random.uniform(-1, 1, 100)
})

# Filter rows where y1 < 2
df_filtered = df[df['y1'] < 2].copy()

# Create new column z as sum of y1, y2, y3
df_filtered['z'] = df_filtered['y1'] + df_filtered['y2'] + df_filtered['y3']

# Create a categorical column for z >= 0 and z < 0
df_filtered['z_category'] = np.where(df_filtered['z'] >= 0, 'z >= 0', 'z < 0')

# Plot z against x1 with two lines
plt.figure(figsize=(10, 6))
for category, group in df_filtered.groupby('z_category'):
    plt.plot(group['x1'], group['z'], label=category)

plt.xlabel('x1')
plt.ylabel('z')
plt.title('z vs x1 by z category')
plt.legend()
plt.grid(True)
plt.show()

library(tidyverse)

# Assuming df is your dataframe
df_filtered <- df %>%
  filter(y1 < 2) %>%
  mutate(z = y1 + y2 + y3) %>%
  mutate(z_group = ifelse(z >= 0, "z >= 0", "z < 0")) %>%
  ggplot(aes(x = x1, y = z, color = z_group)) +
  geom_line() +
  labs(title = "Plot of z against x1",
       x = "x1",
       y = "z",
       color = "z group") +
  theme_minimal()

import pandas as pd
import matplotlib.pyplot as plt

# Assume df already exists with columns: x1, y1, y2, y3
# -------------------------------------------------
# 1. Keep only rows where y1 < 2
df = df[df['y1'] < 2].copy()

# 2. Create a new column z that is the sum of y1, y2, and y3
df['z'] = df[['y1', 'y2', 'y3']].sum(axis=1)

# 3. Plot z vs. x1 with two separate lines:
#    - one line for points where z >= 0
#    - another line for points where z < 0
plt.figure(figsize=(8, 5))

# Positive‑z line
pos = df[df['z'] >= 0]
plt.plot(pos['x1'], pos['z'],
         marker='o', linestyle='-', color='steelblue',
         label='z ≥ 0')

# Negative‑z line
neg = df[df['z'] < 0]
plt.plot(neg['x1'], neg['z'],
         marker='o', linestyle='-', color='tomato',
         label='z < 0')

# Add axis labels, title and legend
plt.xlabel('x1')
plt.ylabel('z (y1 + y2 + y3)')
plt.title('z vs. x1 separated by sign of z')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

library(tidyverse)

df %>%
  # Keep rows where y1 is less than 2
  filter(y1 < 2) %>%
  # Add a new column z = y1 + y2 + y3
  mutate(z = y1 + y2 + y3) %>%
  # Plot z vs x1 with separate lines for z >= 0 and z < 0
  ggplot(aes(x = x1, y = z, colour = z >= 0)) +
  geom_line() +
  scale_colour_manual(name = "z sign",
                      values = c("TRUE"  = "blue",
                                 "FALSE" = "red"),
                      labels = c("z ≥ 0", "z < 0")) +
  labs(x = "x1", y = "z (y1 + y2 + y3)",
       title = "z vs x1 with positive/negative lines") +
  theme_minimal()

import pandas as pd
import matplotlib.pyplot as plt

# Filter the dataframe where y1 < 2
df_filtered = df[df['y1'] < 2].copy()

# Create a new column 'z' as the sum of y1, y2, y3
df_filtered['z'] = df_filtered['y1'] + df_filtered['y2'] + df_filtered['y3']

# Separate data for plotting based on z >= 0 and z < 0
df_positive = df_filtered[df_filtered['z'] >= 0]
df_negative = df_filtered[df_filtered['z'] < 0]

# Plot z against x1 with two lines
plt.figure(figsize=(10, 6))
plt.plot(df_positive['x1'], df_positive['z'], label='z >= 0', marker='o')
plt.plot(df_negative['x1'], df_negative['z'], label='z < 0', marker='x')

plt.xlabel('x1')
plt.ylabel('z')
plt.title('Plot of z vs x1 (filtered by y1 < 2)')
plt.legend()
plt.grid(True)
plt.show()

library(tidyverse)

df_processed <- df %>%
  # Keep only rows where y1 is less than 2
  filter(y1 < 2) %>%
  # Create a new column 'z' as the sum of y1, y2, and y3
  mutate(z = y1 + y2 + y3) %>%
  # Create a categorical column to distinguish lines based on z
  mutate(group = case_when(
    z >= 0 ~ "Positive or Zero",
    z < 0 ~ "Negative"
  )) %>%
  # Plot z against x1, coloring by the group condition
  ggplot(aes(x = x1, y = z, color = group)) +
  geom_line() +
  labs(
    title = "Plot of Z vs X1 (Colored by Sign of Z)",
    x = "x1",
    y = "z",
    color = "Z Group"
  ) +
  theme_minimal()

What you should see is that it is harder to parse the pandas code, and that even LLM-generated tidyverse codes are often overly complicated and with pointless comments¹⁴.

Enters Typst and Lilaq

I have mentioned Typst before, as well as the plotting library Lilaq, lauding the former for its fast live preview due to its incremental compilation. Specifically, the tinymist LSP is able to trigger the preview “on type”, i.e., with every keystroke⁵.

#import "@preview/lilaq:0.5.0" as lq

#set page(margin: 0.5em, height: auto, width: auto)

#let xs = lq.linspace(-10, 10, num: 100)
#let ys = xs.map(x => 2*calc.sin(x) / calc.cos(2*x))

#lq.diagram(
  lq.plot(xs, ys, label: $2sin(x)\/cos(2x)$),
  xlabel: $x$,
  ylabel: $y$,
  title: "This is an example plot"
)

set title "This is an example plot"
set xlabel "x"
set ylabel "y"
set samples 100

plot [-10:10] 2*sin(x)/cos(2*x) title "2sin(x)/cos(2x)"

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-10, 10, 100)
y = 2 * np.sin(x) / np.cos(2 * x)

plt.figure()
plt.plot(x, y, label=r'$2\sin(x)/\cos(2x)$')
plt.title("This is an example plot")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()

using CairoMakie

x = range(-10, 10, 100)
y = @. 2sin(x) / cos(2x)

fig = Figure()
ax = Axis(fig[1, 1],
    title = "This is an example plot",
    xlabel = "x",
    ylabel = "y")
lines!(ax, x, y, label = L"2\sin(x)/\cos(2x)")
axislegend()

library(ggplot2)

x <- seq(-10, 10, length.out = 100)
y <- 2 * sin(x) / cos(2 * x)
df <- data.frame(x = x, y = y)

ggplot(df, aes(x = x, y = y)) +
  geom_line() +
  labs(title = "This is an example plot",
       x = "x",
       y = "y",
       caption = expression(2 * sin(x) / cos(2 * x)))

I would argue that while we sacrificed some conciseness and brevity for responsiveness as compared to gnuplot, this is a little better than Matplotlib and Makie.jl. Not to mention getting access to first-class Math support like LaTeX as we are using Typst.

As for plotting from a CSV file,

#import "@preview/lilaq:0.5.0" as lq

#set page(margin: 0.5em, height: auto, width: auto)

#let data = lq.load-txt(read("data.csv"), header: true)

#let z1 = array.zip(..data.E.chunks(100, exact: true))
#let z2 = array.zip(..data.Em.chunks(100, exact: true))

#let colormesh1 = lq.colormesh(data.xA.dedup(), data.xB.dedup(), z1)
#let colormesh2 = lq.colormesh(data.xA.dedup(), data.xB.dedup(), z2)

#lq.diagram(colormesh1)
#lq.colorbar(colormesh1)
#lq.diagram(colormesh2)
#lq.colorbar(colormesh2)

set nokey
set datafile separator ","

set pm3d at b
set view map
set dgrid3d 100,100

set multiplot layout 1,2
splot "data.csv" using 2:3:5 with pm3d
splot "data.csv" using 2:3:12 with pm3d
unset multiplot

Lilaq is still a little verbose, particularly the reshaping of the data into a 2D array for the plotting of the colormesh in this case, which gnuplot takes care of automatically with set dgrid3d 100,100.

Still, the interactivity and responsiveness is great especially for data exploratory work.

Is it really that important?

To be honest, not really.

In scientific computing, many encounters the “two-language problem”, where the initial prototyping and exploratory research work is performed in a programming language that is highly productive or interactive, such as Python, R, or MATLAB.

However, when the exploratory work is done and when one require fast number crunching (say in a supercomputer), one has to rewrite the program (or at least the computationally expensive parts) in a high-performance language such as C, C++, Fortran, or Rust.

Julia aims to solve this problem with just-in-time (JIT) compilation and LLVM⁶, combining the syntax and interactivity of dynamic languages, with the performance and speed of statically-typed languages.

While the context is obviously not the same, you could say that I’m looking for a “Julia” of plotting. Using plotting libraries such as Matplotlib for complicated plots is like the worst of both worlds: bloated code yet (relatively) slow iteration of plots.

Why can’t we have the best of both worlds instead: plot with stupid simple syntax and see the results instantly as we change the code? I believe gnuplot and Lilaq are the closest we have to this right now, approaching this ideal from the two opposite ends of simple syntax and instant preview, respectively.

So which colormap?

Neither jet nor turbo. Just do not use “rainbow” colormaps (in 99.9% of all cases) regardless of whether you need a sequential or diverging colormap.

But a lot of these programs favors quantity over quality. How do I know if that pretty colormap my favorite plotting library provides is perceptually uniform, linear, and CVD-friendly?

Generally, one just have to know the families of colormaps that were designed with these standards in mind, and plotting libraries with good documentations tend to properly group them into these families, e.g., take a look at Julia’s where anything grouped under “scientific” or “colorcet” is generally fine.

Nevertheless, here are some general recommendations:

Matplotlib’s default, viridis, and a CVD-friendlier version by Nuñez, Anderton, and Renslow (2018), cividis, which I prefer, will suffice for most sequential plots. Though, batlow by Fabio Crameri is another favorite and is scientifically derived (Crameri, Shephard, and Heron 2020). ColorCET by Kovesi (2015) also has the CVD-friendly colormap CET-CBL1. All these are good and are widely available in various programs and plotting libraries.

For diverging colormaps, there’s ColorBrewer’s RdBu, ColorCET’s CET-D07, or the CVD-friendlier CET-CBD1, though you can’t really go wrong with the rest of the colormaps by Fabio Crameri either (Matplotlib provides Crameri’s berlin, managua, and vanimo).

Crameri also has some bi-sequential colormaps that are useful for topographical plots. The only other I know of is cmocean’s topo.

Overall, when in doubt, stick to viridis, cividis, and the colormaps by Crameri.

What about color cycles/sequences?

Color cycles/sequences too are important in scientific visualization given how much more common qualitative/categorical plots are. The only concern is to be perceptually distinguishable, even for people with CVD. However, there are very little consensus on them, and it seems that different programs or libraries often pick their own based on subjective reasoning or aesthetics.

For example, the familiar Matplotlib’s palette (also used by Vega, d3, plotly and various others) often seen in published plots were simply adopted from Tableau⁴, and is not CVD-friendly despite its widespread usage! A number of the colors in the palette are not perceptually distinct to people with CVD (see “Category 10” in the margin figure below).

Still, there have been some attempts to look for CVD-friendly color cycles. For example, the palettes by Paul Tol and the ones by Okabe and Ito are quite well-known, especially after the latter was brought to light again by Wong (2011) (and thus often misattributed to him, e.g., in Julia’s Makie.jl). Crameri too proposed a palette using batlow, though it is only perceptually distinct for roughly the first five colors.

As far as I’m aware, the most thorough study that attempts to balance CVD-friendliness and aesthetics were conducted by Petroff (2024), which features a distance metric to measure perceptual distinguishability (including with CVD), and an online survey with 22000 responses that ranks aesthetical preferences. This resulted in three palettes of six, eight, and ten colors which I am quite fond of. They are also the default used in Typst’s Lilaq plotting library.

Looking at Petroff’s analysis (see figure in the margin), there isn’t a lot of color cycles that are CVD-friendly, so it’s better to stick to Petroff’s color palettes. However, since they are typically not readily available, Okabe’s and Ito’s, and Crameri’s batlowS (up till the first five colors) are good alternatives.

Paul Tol’s “Tol Bright” is also CVD-friendly, but only for people with deuteranopia and protanopia. People with the much less common tritanopia would struggle with it⁵, which is why it has a low score in Petroff’s analysis.

The Barney and Betty Hill Incident (abridged)

On the night of 19 September 1961, American couple Barney and Betty Hill observed a light in the sky while they were driving home from vacation on some stretches of deserted roads. They stopped occasionally to observe the light with their binoculars, and eventually surmise that the light is a UFO after it descended towards their vehicle.

Barney observed the object with the binoculars, spotting some humanoid figures looking out of the craft’s windows. As the craft approached closer, the Hills drove away in fear of being captured. Afterward, they experienced some “missing time” where there are gaps in their memory² before they returned home.

I encourage the interested reader to read the fascinating full story themselves, but our concern here is the star map, which comes 2 years after this incident.

Around 2 years later, under some advice, the Hills underwent hypnosis sessions with Dr. Benjamin Simon to “recover” lost/repressed memories of the incident³. This was when the encounter with the UFO became an abduction story, as Barney and Betty Hill recalled (under hypnosis) that they were abducted onto the UFO, and have their memories repressed by the aliens afterward.

Betty Hill recalled (under hypnosis) that while abducted on the UFO, she asked the “leader” of the Grey-looking aliens where they came from. The leader then took out a 2D sheet depicting a “star map” (that looked 3D from the angle Betty viewed it from). Betty asked where the leader’s “home port” was, and the leader responded by asking Betty where Earth was on the map, before saying that if Betty did not know where she is then there is no point in telling her where he is from⁴.

From this hypnosis session, Betty Hill drew this “star map” that she recalled, which arguably is now the most well-known part of the story, and eventually led to the association of Zeta Reticuli with the Grey aliens.

The Star Map

According to the “leader” alien, the heavy lines are trade routes, the lighter lines are places they occasionally visit, and the broken (dotted) lines are expeditions.

One would think that given the large number of stars in the galaxy (or even in just our local stellar neighborhood), it is impossible to determine anything substantial from some arbitrarily connected dots and circles. Yet, this did not deter people from trying to interpret the star systems shown in the star map.

While many interpretations of the star map exist, e.g., by Charles W. Atterberg, Joachim Koch and Hans-Jürgen Kyborg, or Steve Pearse, the most famous interpretation is by an elementary schoolteacher and amateur astronomer Marjorie Fish in 1969.

We will only examine Fish’s interpretation as it is the most popular, and is the reason for the association between the Grey aliens and the Zeta Reticuli binary star system.

Fish’s interpretation

For the convenience of the reader (click to enlarge).

Admittedly, it looks quite similar to Betty Hill’s star map, and even more impressive is that this interpretation was derived from physical models of nearby stars (assuming our Sun is in the star map) that Fish herself built using data from the Gliese catalog.

Due to the large numbers of stars, Fish filtered out stars based on exobiological considerations. It took years but she succeeded in finding a constellation of stars and vantage point that resembles Betty Hill’s star map using her homemade model.

There are a lot of differences however, e.g., the line to Alpha Mensae is much longer than in Betty Hill’s star map, while the line to Gliese 86 is much shorter. The distance between Tau Ceti and 82 Eridani is also much shorter than expected. All in all, it is not a perfect match.

Despite that, Fish’s interpretation became so popular that it was even discussed by Carl Sagan on Cosmos⁵. Sagan’s argument is that if one can pick and choose from a large number of stars from any vantage point, then one can always find a constellation of stars that resembles Betty Hill’s star map⁶.

⁵ Sagan demonstrated that by removing the lines, there are hardly any resemblance between the two maps at all.

⁶ More on this later as we attempt to try this out for ourselves.

Nevertheless, the most significant result of Fish’s interpretation is that the two big circles (often thought of as the home systems of the aliens) turns out to be the Zeta Reticuli binary star system. This is what sparked the beginning of the association between Grey-type aliens and Zeta Reticuli.

WarningMisleading visuals of Fish’s interpretation

The reader should take note that there are various misleading visualizations of the Fish’s interpretation that are often being shared online. These misleading visuals exaggerate the similarity between Fish’s interpretation and Betty Hill’s star map. Some examples are the one on Wikipedia:

and this one that is often shared on social medias that is just blatantly misleading:

Reproducing Fish’s Interpretation

Let us attempt to reproduce Fish’s results by using the Hipparcos catalog from the 1990s⁷, which contains much more precise data than the Gliese catalog that Fish used in 1969. Specifically, we will create a 3D model of nearby stars within 30 parsecs of our Solar System.

⁷ The Gaia catalog was considered, but it excludes a number of bright stars and the star designations are too long and cumbersome to work with.

The lines of codes are quite short, and I encourage the interested reader who wants their own 3D model to follow along, especially if one has experience in Python.

Getting the positions of nearby stars

We can easily retrieve the catalog as a pandas dataframe in Python with the Skyfield package.

NoteSkip this if you are not interested.

import numpy as np
import pandas as pd
from skyfield.api import Star, load
from skyfield.data import hipparcos

with load.open(hipparcos.URL) as f:
    df = hipparcos.load_dataframe(f)

To get the positions of nearby stars relative to our Sun, we first retrieve the JPL ephemeris DE421, which contains the positions of major bodies in the Solar System from 1900–2050, before finding the Sun’s position relative to the Solar System’s barycenter on 19 September 1961.

These are actually mostly unneeded information, but Skyfield requires a Barycentric object to retrieve the observed position of stars with respect to that object’s position at a certain time, and we will have to make do since we want Skyfield to do the calculations for us.

eph = load("de421.bsp")
sun = eph["sun"]

ts = load.timescale()
t = ts.utc(1961, 9, 20)
sun_barycentric = sun.at(t)

Next, we let Skyfield calculate the observed position (in terms of , , coordinates and distance relative to the Sun) of each star in the dataframe of the catalog, before storing them in their corresponding list. We also convert the units from AU (astronomical unit) to parsec as it’s easier to work with. Note that hips contains each star’s designation in the catalog, e.g., the star Sirius has the designation HIP 32349.

au_1_parsec = 206265

distances_pc = []
coords_pc_x = []
coords_pc_y = []
coords_pc_z = []
hips = []
for i, row in df.iterrows():
    star = Star.from_dataframe(row)
    star_astrometric = sun_barycentric.observe(star)
    _, _, distance_au = star_astrometric.radec()
    coords_au = star_astrometric.xyz

    distances_pc.append(distance_au.au / au_1_parsec)
    coords_pc = coords_au.au / au_1_parsec
    coords_pc_x.append(coords_pc[0])
    coords_pc_y.append(coords_pc[1])
    coords_pc_z.append(coords_pc[2])
    hips.append(i)

Finally, we store these data for each star in a new dataframe, filtered it such that we only keep stars within 30 parsecs (~100 light years), leaving us with just 2350 stars, before saving it to a CSV file.

df_new = pd.DataFrame(
    np.array([hips, coords_pc_x, coords_pc_y, coords_pc_z, distances_pc]).T,
    columns=["hip", "coords_x", "coords_y", "coords_z", "distances"],
)

df_near = df_new[df_new["distances"] < 30]
df_near.to_csv("30pc_stars.csv", index=False)

Note that the obtained positions are the observed positions from our Solar System, that is, the stars actual positions would have changed due to the time it takes for light from these stars to reach us, and an alien star map would probably use the latter instead of the observed positions, let alone our observed positions. However, the difference are negligible and this save us some calculations, so we will stick with this.

Plotting the nearby stars

Next, we will plot these 2350 stars (+ the Sun) in Blender. Blender is chosen because it’s fun, and it’s easy to control and animate the camera when we are looking for different vantage points. The hybrid graphical and Python workflow also greatly makes our lives easier as Python can programmatically handle the placing of the 2350 stars at the right position, while I can easily change the looks of the stars in Blender’s GUI⁸.

⁸ One can also use programs like Gaia Sky or Space Engine to do their own investigation.

NoteSkip this if you are not interested

First, let us load the CSV file that we saved earlier and store them in the list stars.

It’s quite troublesome to install external packages to Blender’s builtin Python, and so we used the builtin csv package instead of pandas dataframe this time.

import bpy
import csv

with open("30pc_stars.csv") as f:
    reader = csv.DictReader(f, delimiter=",")

    stars = []
    for entry in reader:
        stars.append(entry)

In Blender, I have prepared different materials for the Sun (sun), stars in Fish’s interpretations (starmap), and the rest of the stars (starlight). We can refer to these materials in Python as follows.

sun_mat = bpy.data.materials.get("sun")
starmap_mat = bpy.data.materials.get("starmap")
starlight_mat = bpy.data.materials.get("starlight")

I also made a helper function to easily place stars as UV spheres.

def uv_sphere_add(radius=1, name=None, location=(0, 0, 0)):
    bpy.ops.mesh.primitive_uv_sphere_add(radius=radius, location=location)
    obj = bpy.context.object
    if name:
        obj.name = name
    return obj

Creating the Sun and adding the sun material to it is as simple as

sun_obj = uv_sphere_add(0.2, name="sun", location=(0, 0, 0))
sun_obj.data.materials.append(sun_mat)

We can now repeat the process for each star. By checking the HIP designations of the stars in Fish’s interpretation, we can change the materials of these stars to the starmap material, while keeping the starlight material for the rest of the stars. Also note that we scaled the positions up by a factor of 10, i.e., 1 parsec correspond to 10 units of distance in Blender.

fish_starmap = [
    "15330.0", "15371.0", "29271.0", "15510.0", "10138.0", "8102.0", "7981.0", "3093.0", "7918.0", "12843.0", "7235.0", "11072.0", "10798.0", "10164.0",
]
for star in stars:
    star_obj = uv_sphere_add(
        0.2,
        name=star["hip"],
        location=(
            float(star["coords_x"]) * 10,
            float(star["coords_y"]) * 10,
            float(star["coords_z"]) * 10,
        ),
    )
    if star["hip"] in fish_starmap:
        star_obj.data.materials.append(starmap_mat)
    else:
        star_obj.data.materials.append(starlight_mat)

There we have it, we now have a 3D model of 2350 stars within 30 parsecs of our Sun.

After connecting the stars accordingly, we can find a vantage point that roughly matches with Fish’s interpretation.

For the convenience of the reader (click to enlarge).

First of all, note that Kappa Fornacis is way off. This is due to the more precise data provided by the Hipparcos catalog as compared to the Gliese catalog that Marjorie Fish used. Likewise, Gliese 86.1 is actually nowhere close at almost 200 light years away and thus is missing.

These discrepancies were most likely also acknowledged by Marjorie Fish as new data came out⁹, and might be a deal-breaker as according to Fish’s account of her meeting with Betty Hill, Hill claimed to remember the distinctive triangle formation to the left in addition to the ones connected by lines.

⁹ Not that it matters, but according to her niece, Fish did not actually repudiate her star map, and that her obituary saying so was in error.

Nevertheless, huge kudos to Marjorie Fish for producing her version of the star map by hand to such a great accuracy.

Is the Star Map even useful?

As mentioned earlier, Carl Sagan argued that if one can pick and choose from a large number of stars and from any vantage point, one can always find a constellation of stars that resembles Betty Hill’s star map.

I have no doubt that we can indeed find our own star map that resembles Betty Hill’s from our stellar neighborhood (in fact I’ll present one later), but Marjorie Fish achieved this with less than 50 stars.

Is this possible?

A new interpretation of the star map

Finally, let me present an alternate interpretation using just star systems in our local neighborhood of up to 22 light years (~7 parsecs) away from us, much closer than Fish’s and Atterberg’s interpretations.

For the convenience of the reader (click to enlarge).

It’s not a perfect match, but again I emphasize that neither are Fish’s, Atterberg’s, or Koch-Kyborg’s.

It’s not difficult to find this constellation of stars either:

Just by looking at prominent stars in the vicinity of our Solar System, I realized that the Bernard’s star, Proxima/Alpha Centuri, our Solar System, and Sirius, forms the “V” shape formation that appears on Betty Hill’s star map.

I then looked for stars in the “foreground” of this “V” shape formation and found Tau Ceti (and YZ Ceti). Quite coincidentally, slightly in front of Tau Ceti (and YZ Ceti) is GJ 1005, a binary star system, exactly what we need to match with Betty Hill’s star map.

82 G. Eridani seems to be the only possible candidate to the right of GJ 1005, and Van Maanen 2 is right above Tau Ceti (and YZ Ceti). It was then either Tau Ceti or YZ Ceti, Gliese 876 or HIP 114110, HR 7703 or Gliese 784, and Gliese 829 or Altair. I simply chose the ones that best matches with Betty Hill’s star map.

In my opinion, my interpretation matches better with Betty Hill’s star map than Fish’s in certain parts. I even got the triangle formation on the left (by chance really, it was an afterthought)¹¹. Furthermore, the vantage point is facing towards the galactic center, and is slightly above the galactic plane looking downwards, in other words it is not as arbitrary. A number of these star systems also have (or might have) exoplanets.

¹¹ If you are concerned about the lone unconnected star at the middle top part of Betty Hill’s star map, Psi Velorum is the only star that appears around that location if we filter out stars with absolute magnitude .

The distances and lines drawn also make sense. For example, in Fish’s interpretation, one might wonder why the aliens do not connect 82 G. Eridani or Tau Ceti to Sol/our Sun given that they are right beside each other. In my interpretation, Van Maanen 2 is actually in a different direction to Tau Ceti (it is above Tau Ceti and GJ 1005, you can see it in the video above), and so it’s not surprising that the aliens drew the lines to them separately.

This interpretation however, would place the aliens’ origin at GJ 1005 (or Gliese 1005), a binary red dwarf system¹². As far as I am aware, there are no candidate exoplanets on GJ 1005 as of the writing of this post, but it is not uncommon for red dwarfs to have some.

¹² Finally somewhere more mundane. I mean why do all the aliens in Ufology lore always have to coincidentally come from some named star systems?

I also did not account for how likely it is for an alien species to visit these star systems, e.g., I didn’t check if they are variable stars or close binaries or what not which Fish excluded. However, these stars are all quite close to each other, and there aren’t many stars in the vicinity of these routes for the aliens to “skip” or be “uninterested by” like in Fish’s interpretation.

It is important to note that the point here is not to present what I think is the “correct” interpretation of Betty Hill’s star map. Instead, the point is that one can easily find multiple interpretations that resembles it.

In other words, it’s pointless to examine the star map to try to figure out where the aliens come from.

Conclusion

In conclusion, even if we were to be extremely generous and accept that:

1. The UFO that the Hills encountered is an alien craft.
2. The Hills were abducted by the aliens.
3. Hypnotic regression is reliable in recovering these abduction memories that were repressed by the aliens.
4. Betty Hill remembered the star map to a reasonable accuracy while under hypnosis.
5. Betty Hill (who claimed she’s not good with perspective) drew the star map to a reasonable accuracy while under hypnosis.

We still cannot conclude anything from the star map given the large number of possible different interpretations it can lead to.

Carl Sagan was right that if one can pick and choose from a large number of stars from any vantage point, then one can always find a constellation of stars that resembles the star map. We demonstrated this for randomly generated stars, and provided an example using stars in our local stellar neighborhood.

The fact that Fish, Atterberg, Koch and Kyborg¹³, and me, each have our own interpretation of the star map further supports this argument. While Fish only considered a small subset of stars that are Sun-like, we now know that the many red dwarfs in our local stellar neighborhood can host exoplanets, and thus greatly increase the number of possible interpretations.

But what’s with the association between Grey aliens and the Zeta Reticuli star system from the various (supposedly) independent sources then? Especially since the Fish’s interpretation failed to reproduce the triangle formation on the left of Betty Hill’s star map.

I think there are 3 possible explanations:

1. These sources are just parroting each other. A lot of these “independent” sources share the same “lore”, e.g., in addition to Greys from Zeta Reticuli, they also have Reptilians from Alpha Draconis, taller Greys from Orion, and human-looking Nordics or Tall Whites from the Pleiades, Lyra, Arcturus, etc.¹⁴

2. The Grey aliens are really from Zeta Reticuli, and it’s a remarkable coincidence that Fish’s interpretation of the star map shows Zeta Reticuli as the home system of the Hills’ abductors.

3. These aliens are conducting a psyop on us to hide their real origins. Recall that the “leader” alien who abducted the Hills, as well as the “Tall White” alien of the Charles Hall story, seems evasive and dodged the question when asked about their origins (I’m only half joking here).

Anyway, this is just a fun excuse for me to play with Blender, and I am by no means a UFO investigator, nor am I extremely well-read into this story or Ufology “lore”.

Though, considering that there were multiple inconsistencies with the aliens in Betty’s account of the abduction while under hypnosis, e.g., the aliens not knowing what “older”, “age”, and even “yellow” meant despite being able to speak English and communicate telepathically, my opinion is that the recovered memories from hypnotic regression are most likely confabulations or false memories¹⁵. I believe false memories were also what Dr. Simon concluded after the multiple hypnosis sessions he conducted with the Hills.

Pandoc

Pandoc is a universal document converter. It can convert MS Word to and from LaTeX, an HTML page to EPUB, or MS PowerPoint to HTML, and many more! However, the most popular feature of the universal converter is the ability to write in Markdown and convert it to a document or a presentation slide.

Here, we write in simple Markdown and convert to a PDF document via LaTeX².

For a long time I have used Pandoc for all my write-ups, notes, and presentation slides due to the simplicity of writing Markdown over LaTeX, MS Word, and MS PowerPoint³, but I have since moved to better tools below.

Quarto

Coming from the lovely R community and building on top of Pandoc, Quarto is the successor to R Markdown, an attempt at literate programming. R Markdown does the same as Pandoc, allowing one to write in Markdown and outputs to documents and presentations etc., with the additional feature that it also allows one to run and output R codes inside the document. Quarto extends this functionality to include Python, Julia, and Observable in addition to R.

This functionality allows us to mix computation with its documentations, explanations, or mathematics in the same document.

This allows for reproducible research where the codes and outputs are contained in the same research write-up, and is perfect for cases where one wants to share technical reports complete with implementation details to a colleague.

But this is not all! Even without using the ability to run code in your documents, Quarto can still do a lot more, e.g., writing books, creating dashboards for data science, or creating web apps to interact with data⁴. One can also publish to Quarto Pub to share their Quarto documents easily.

Typst

Typst is a modern typesetting system that aims to be an alternative to LaTeX. Fast, easy, sensible, with an actual scripting language, and actively developed, it has completely replaced LaTeX for me except for papers that are submitted for publication⁵. I even made a conference poster recently with Typst⁶.

Not only does Typst has a simple Markdown-like syntax, it is also extremely fast, allowing almost instant live previews while typing.

Typst also has an active package ecosystem, from drawing diagrams with CeTZ, creating presentation slides with Touying, drawing quantum circuits with Quill, to plotting with Lilaq, Typst covers my entire workflow. My research notes that I share with my colleagues are written in Typst, I make diagrams in Typst, and I make worksheets for students in Typst.

Typst has also gained enough popularity that Pandoc and Quarto now support it as a PDF backend in place of LaTeX. It even comes preinstalled in Quarto. Unlike LaTeX, there are almost no wait time in compiling a document and error messages are not cryptic, making Typst a good PDF backend for Quarto⁷.

An RSS feed reader

You most likely have come across this little orange icon in your time on the internet. In fact, there is one at the top right of this very site (though it’s not orange). This is RSS (Really Simple Syndication), a standardized format to aggregate news or contents into a single feed.

Imagine having a single feed where you can read articles from multiple sources such as news websites, right when they are published. This is not an uncommon concept as some smartphones such as the iPhone provides such features with their news app. So how is this useful for academics?

Well, turns out journals typically provide a link to subscribe to their RSS feed too. One can then easily keep up with current research in journals relevant to their fields by aggregating them into a single RSS feed reader.

I check the feed every day, reading through the titles, and then the abstracts for titles that caught my attention. If I find the paper interesting or relevant, I can easily open the paper on a browser with a single hotkey to download or add it to my bibliography manager.

I am subscribed to 11 journals, totaling to around 50 to 100 new papers everyday (arXiv takes up the bulk of this number), a number that is small enough that it’s not a hassle to go through the feed every day⁸.

Given how important keeping up with current developments in the field is for a researcher, an RSS feed reader (and there are many) makes the aggravating task of checking for new papers effortless, and greatly increases one’s exposure to current research.

Shiny

Shiny is an interactive and reactive dashboard/web app package that came out of the R community like Quarto (it is now also available for Python).

For most academics, in addition to exploring, analyzing, and visualizing your data and results by yourself, you will have to present and discuss your results with your colleagues. Most of the time such discussions take place with an opened PDF document or a couple of slides with plots. It is also not uncommon for someone to ask a question where the only answer is:

“I’ll go back and check.”,

even when you already have the data, because opening your favorite programming language and plotting it will take too long, leaving everyone in awkward silence while you embarrass yourself with your programming skills.

Here’s the solution: instead of static plots, use Shiny to present your results⁹!

Shiny is quite powerful. You can even let user upload say a CSV file and let them choose which columns of the uploaded data to plot. If you find the code too boilerplate-ish, you can also write Shiny in Quarto, easily adding Markdown and LaTeX maths into your Shiny app.

As an interactive and reactive app, Shiny requires a server to run, i.e., typically your own laptop while presenting. But it is also possible to publish your Shiny app online at shinyapps.io or Posit’s Connect Cloud¹⁰.

A general purpose editor

Typically, one uses different integrated development environments (IDEs) for different purposes, e.g., TeXstudio or Overleaf for LaTeX, RStudio for R, Spyder or Jupyter for Python, etc.

However, there are general purpose editors that can function as IDEs for almost anything. One popular example is VS Code¹¹, which tops the Stack Overflow survey as the most used editor almost every year.

Other well-known editors that comes up in most online discourse are probably Sublime Text, Vim/Neovim, and Emacs. Personally, I am using Helix¹² and Emacs.

Having a single general purpose editor makes entry to new programming languages or markup languages easy; why learn different tools for different programming languages when they are just plain text at the end of the day? There’s no need to download a new program, just start writing in what you are already comfortable with.

The editor will then be just another general purpose tool on your computer that you are already comfortable with, just like your file explorer, browser, image/video viewer, notepad etc., improving your productivity.

This is even more true for a Linux user, who might write simple shell scripts or edit config files frequently. This is partly why there are very enthusiastic Vim/Neovim and Emacs communities in the Linux space¹³.

Speaking of Linux…

Linux

Free¹⁴ and open source, highly customizable, actually respects you instead of shoving products and ads down your throat, actually own and control your tools instead of the other way round, doesn’t spy on you, no bloatware with random preinstalled programs that you don’t care about.

Honestly, there are so many good reasons to use Linux. But on a more practical level, Linux opens the doors to more efficient and productive workflows.

Perhaps you might find it hard to get started with all the tools that we talked about above. Going to each of their website, look for a download button, running the .exe to install it, figure out where and how you should be writing the Markdown or Typst codes, figure out how to compile it from a command prompt, only to see an error because the command prompt is not at the same directory as your file etc.

All these complications is one of the reason why most people use webapp over local installations, e.g., Overleaf vs. a local installation of LaTeX. More specifically, I believe the main roadblock seems to be the lack of a good general purpose editor and an accessible terminal in the typical workflow of Windows users.

Furthermore, installation of programs is extremely easy in most Linux distros. For example, here’s how I install Firefox, Pandoc, Typst, LaTeX, R, and Julia all in one go in Arch Linux¹⁵:

sudo pacman -S firefox pandoc typst texlive r julia

and to update all programs installed:

sudo pacman -Syu

Ultimately, I find the accessibility and efficiency in installing and working with various programs an important factor in whether academics try, utilize, and tinker with tools that can improve their workflow and productivity, and Linux is the gateway to these¹⁶.

You might not be convinced by this. But imagine having to do your work on a smart phone instead of a PC. The lost accessibility to software and the inefficiency in working with them will greatly affect how you work as compared to on a PC. The transition from Windows to Linux will feel the same for an experienced Linux user.

Marimo over Jupyter

Here’s a bonus one.

I take the somewhat popular yet controversial opinion that Jupyter notebooks are a scourge to scientific research. There are some annoying issues, such as how it’s saved as JSON instead of plain Python files, and how it teaches bad programming practices and habits to scientists. The latter can easily compound with carelessness to lead to invisible bugs and mistakes that produce wrong results, which might even end up in published research¹⁷!

But much more troubling is the fact that Jupyter notebooks increase the chances of making these mistakes due to the creation of hidden states. In fact, a study showed that out of over 800000+ valid notebooks on GitHub, only ~24% are executed without errors, and only ~4% produced the same results (Pimentel et al. 2019).

Perhaps this warrant a separate post¹⁸, but in short, if one wants to present some results with their corresponding codes, use Quarto, and if one really require a notebook environment, use Marimo, an alternative to Jupyter notebooks (only for Python).

The main difference between Marimo notebooks and Jupyter notebooks is the fact that the former is reactive. What this means is that Marimo notebooks always run in the correct order and always rerun the entire notebook on edits, eliminating the hidden states that plagues Jupyter notebooks.

If a code cell defining a variable is deleted, but the variable is used elsewhere, an error will be thrown. On the other hand, Jupyter notebooks continue to sneakily use that variable even when the programmer meant to remove it from the program.

A researcher should be aware of how certain shortcomings of their tools can be detrimental to their work, and should be open to finding alternatives or engage in self-improvement to eliminate them to minimize bad research outputs.

For example, learning to write properly unit tested functions instead of spaghetti codes, or learning to use type hinting in Python (which has been around since version 3.5) to pair with type checkers to minimize invisible bugs caused by carelessness that can lead to wrong published results.

Enters the Bloch sphere

This is called a Bloch sphere, and it captures everything about a qubit (even all the alleged parallel universes).

Anyone can understand and visualize a sphere, so it puzzles me as to why we do not start with this instead of parallel universes or “being 0 and 1 at the same time”. The Bloch sphere is also mathematically accurate. That is, it’s not an analogy, it’s the truth!

In fact, the Bloch sphere also captures classical computing. The familiar logical 0 and 1 bits from classical computing are at the North and the South poles, respectively. In a conventional computer, imagine a bunch of these spheres with an arrow in each pointing only to either the North pole (bit 0) or the South pole (bit 1).

During a classical computation, the arrows simply flip between the North and the South poles, most of the time conditioned on other arrows of other spheres³. The sequence of arrows then represents the results of the computation.

What about a qubit?

Well, we simply free the arrow such that it is able to point to anywhere on the sphere. That’s it. Where the arrow points is the state of the qubit.

So when people say a qubit can be “0 and 1 at the same time”, what they actually mean is that the arrow is pointing somewhere between the North (0) and the South (1) poles. Typically this is at the equator, halfway between the poles.

Of course, there is not just one location on the equator of a sphere. Singapore is at the equator, so is Ecuador, and so are multiple other countries on Earth. This means that two qubits that are “0 and 1 at the same time” can be different. To differentiate them (figure out where their arrows point), or to pinpoint a location on Earth, we require two coordinates, the latitude, and the longitude.

Since the Bloch sphere is also a sphere, the “latitude” and the “longitude” are two variables (or degrees of freedom) that also defines a qubit: the “latitude”, and the “longitude” also known as the relative phase.

So what happens during a quantum computation?

Well, like the classical case, the arrow in each qubit simply jumps (or rotates) around to and from any point on the sphere⁴.

So all these talks of a quantum computer being able to perform computations faster because of “superposition” or because it can performs computation “simultaneously” etc., simply refers to the fact that there is an increase in the degrees of freedom for the computation as compared to classical digital computations.

In other words, this freedom for the arrow (its state) to rotate and point to anywhere on the sphere, allows certain computing tasks to require less operations (flipping or rotating of arrows), than if the arrows are confined to the North and South poles.

But what’s with all the weirdness of quantum physics then?

It’s true that in actual quantum systems that implements a qubit, there are typically two preferred states (the North and South poles of our Bloch sphere). These are sometimes called pointer states. We observes these preferred states in our classical world as they are what remains after the quantum system loses its coherence. But in reality, the quantum system sees no difference between these preferred states and any other states it could take (e.g., at the equator of our Bloch sphere).

Since we only observes these preferred states (and that our macroscopic reality is built out of them), we deemed them as “natural” which led to these apparent weirdness, e.g., how can something that takes the “natural” states of North and South, be placed in the “unintuitive” state of halfway between North and South?

So perhaps there are some credence to the weirdness and hype. However, again, just like how the computer science of classical computation is independent of the physics of electricity and semiconductors (or their interpretations) etc., the computer science of quantum computation should also be seen as separate from the interpretations of what’s happening in the physical systems that implements them.

Entanglement — the actual spice

The Bloch sphere might reminds one of analog computers, where quantities can take a continuum of values instead of the 0s and 1s in digital computers. In fact, if we can build an analog computer with two degrees of freedom like the Bloch sphere, then it can function exactly like a single qubit.

The “quantumness” only comes in if we include the concept of entanglement⁵. Entanglement is the main spice that makes quantum systems special, preventing it from being replicated by classical systems, e.g., the analog computer with two degrees of freedom⁶.

Imagine what would happen if we have two qubits.

One might think that there are now six variables to describe the pair of qubits (where both arrows point) since we now have two Bloch spheres⁷. However, this is only true if there is no correlation between the pair of qubits, that is, the two arrows are independent of each other.

Typically, when the two qubits interact with each other (or undergo quantum computations together), they can become entangled, which means that their two arrows (their states) are now correlated in a way that is impossible to achieve classically.

This is akin to them becoming a single (hyper)sphere with a single arrow pointing at some point that represents their combined state. The dimension of this (hyper)sphere will be the number of variables or degrees of freedom required to describe them.

Quite surprisingly, there can be a total of up to 15 degrees of freedom!

Six variables describe the two qubits independently (three for each), while the remaining nine describes how they are correlated to each other⁸.

It is important to note that this single 15 dimensional Bloch (hyper)sphere describes both qubits together, and it cannot be broken down into separate descriptions for each qubit (without losing information about the entanglement). This means that the two entangled qubits can only be described as single object.

This is the stark feature of quantum systems that sets it apart from classical systems. Supposed that we were to build two analog computers with three degrees of freedom each to simulate the two Bloch spheres, before attempting to correlate their states (perhaps by performing some joint operations on them). We can never correlate them to the extent that entanglement could⁹.

In addition to the increased degrees of freedom, this increased correlation gained by entanglement can also be exploited in various quantum computational tasks.

Is that it?

Yep, that’s it.

Quantum computation is simply the rotations of these arrows on/in Bloch spheres¹⁰. While classical computing is confined to flipping between the North and South poles, quantum computing allows arrows to freely rotate anywhere on the Bloch sphere.

Where the arrows point and how they rotate is how we store and process information, just like how a sequence of North and South poles (0s and 1s) and how they flip, encodes, and processes information in the classical case.

By combining multiple qubits, the allowable space or degrees of freedom for this information processing increases. Combined with entanglement, this information processing can take place in even higher dimensional space, with some algorithms exploiting the increased correlation.

The main “essence” of quantum computing is this change in computing paradigm, regardless of whether quantum systems that implement it do so with the help of parallel universes or not.

Again, I want to emphasize the separation between the implementation’s physics (and its interpretation), and this new computing paradigm that grants these advantages over classical computing.

The difficulty of course, is coming up with algorithms that not only can utilize the increased degrees of freedom, but also can be better or faster than the classical case. It turns out however, that classical computing (being confined to the North and South poles) is good enough in most cases, and quantum algorithms that can be better are rare.

This might be because in classical digital computing, how we encode and process information are quite straightforward, and decades of creating higher abstractions means that no programmers are flipping individual bits. However, in the relatively young field of quantum computation, physicists are still concerned with the individual operations or rotations to perform on individual or groups of qubits.

Perhaps one day quantum computing (or even computing with larger degrees of freedom) will reach the same status as classical computing. But for now, we are stuck with rotating arrows.

A Physicist’s perspective — the conspiracy

The study of life is typically assumed to fall under the domain of Biology. However, physicists have also been attempting to uncover a physical principle that leads to life’s emergence and its behaviors (Prigogine and Nicolis 1971). A hint lies in the stark difference between life and inanimate matter: life’s ability to efficiently absorb or consume useful energy and dissipating it as heat, resulting in increased entropy production.

While this have been pointed out by Erwin Schrödinger in his seminar book What is life? back in the 1940s, it has undergone rigorous thermodynamic treatment in recent years, thanks to advances in the physics of non-equilibrium thermodynamics (Collin et al. 2005; K. Michaelian 2011).

In short, in the presence of an external non-equilibrium energy source (like the Sun), systems adapt and self-organize themselves to better absorb energy and dissipate heat or entropy. This process has come to be known as dissipation-driven adaptation (England 2013; Perunov, Marsland, and England 2016).

Life is hypothesized to be such a dissipative system that serves to increase entropy production.

From the birth of planetoids in the dusts of protoplanetary disks to the formation of vortices we see in chaotic turbulent flows such as hurricanes, stable structures with low internal entropy arise out of such chaotic interactions in order to more efficiently dissipate entropy.

Life might be one of such order out of chaos, a long-running, universe-scale conspiracy to increase the entropy of the cosmos.

Some examples

def sum(xs):
    sum_all = 0
    for x in xs:
        sum_all += x
    return sum_all

sum :: [Float] -> Float
sum [] = 0
sum (x:xs) = x + sum xs

import numpy as np

def tensor_all(Ms):
    tensor_prod = 1
    for M in Ms:
        tensor_prod = np.kron(tensor_prod, M)

    return tensor_prod

import Numeric.LinearAlgebra

tensor_all :: [Matrix C] -> Matrix C
tensor_all = foldl kronecker 1

import numpy as np

def tensor_all(Ms):
    tensor_prod = 1
    tensor_prod_list = []
    for M in Ms:
        tensor_prod = np.kron(tensor_prod, M)
        tensor_prod_list.append(tensor_prod)

    return tensor_prod_list

import Numeric.LinearAlgebra

tensor_all :: [Matrix C] -> [Matrix C]
tensor_all = scanl kronecker 1

Collision model: currying and laziness

Let’s consider a less simple example to reveal more of Haskell’s features:

A superconducting qubit (rho) is sensitive to heat, and is continuously undergoing a thermalization process. We can model this thermalization process with a collision model, where the qubit evolves via repeated “collisions” with different qubits at each discrete time step for (n) number of time steps. The collision is implemented by the function collision. We want to determine how the von Neumann entropy of , , changes in each collision up till time steps. The calculation of the von Neumann entropy is implemented by the function entropy.

For completeness, the function collision performs the operation of where are Kraus operators, and the function entropy computes Therefore, what we want is simply the list of

This might look complicated if one does not know quantum mechanics. However, if we assume that the collision and entropy calculations are done for us in the functions collision and entropy, then we simply want a list of n entropy values, i.e., entropy_list = [entropy(rho), entropy(collision(rho)), entropy(collision(collision(rho))),...].

• Python
• Haskell

import scipy as sp

def collision(ks, rho):
    return sum([k @ rho @ k.conj().T for k in ks])

def entropy(rho):
    return - np.trace(rho @ sp.linalg.logm(rho))

def calc_entropies(ks, rho, n):
    entropy_list = []
    for _ in range(n):
        rho_entropy = entropy(rho)
        entropy_list.append(rho_entropy)
        rho = collision(ks, rho)

    return entropy_list

collision :: [Matrix C] -> Matrix C -> Matrix C
collision ks rho = sum [k <> rho <> tr k | k <- ks]

entropy :: Matrix C -> Float
entropy rho = - trace (rho <> logm rho)
  where
    logm = matFunc log

calc_entropies :: [Matrix C] -> Matrix C -> Int -> [Float]
calc_entropies ks rho n = map entropy rho_list
  where
    rho_list = take n (iterate (collision ks) rho)

NoteExtra things to note for the Haskell example

• Similar to Python, Haskell has list comprehension, which has a mathematical syntax as seen in the function collision, e.g.,

  example = [p * q | p <- ps, q <- qs, p >= 5, q /= 0]

  would give a list of the set

  On the other hand, Python’s list comprehension is less concise:

  example = [p * q for p in ps for q in qs if p >= 5 and q != 0]

• In the entropy and calc_entropies functions, we have used the where keyword, which allows us to break a function into smaller constituents, e.g.,

  exampleFunc a b c = n / d
    where
      n = x + y
      d = x - y
      x = a + b + c
      y = a * b * c

  Alternatively, we can also use the let and in keyword:

  exampleFunc a b c =
    let
      n = x + y
      d = x - y
      x = a + b + c
      y = a * b * c
    in
      n / d

The Python example, being imperative, should be self-explanatory. Instead, we are interested in the Haskell example, specifically the calc_entropies function, which might look arcane if one does not know common functional programming functions such as map, take, and iterate. Let’s look at this line-by-line.

Currying

The very first line of the calc_entropies function is the type signature of:

which states that the function calc_entropies takes in a list of complex matrix, a complex matrix, and an integer, and returns a list of floats. The list of complex matrix refers to the Kraus operators used in the collision function, the complex matrix refers to the qubit rho or , the integer refers to the number of collisions n, while the list of floats refers to the output entropy_list.

One might notice that [Matrix C] -> Matrix C -> Int -> [Float] doesn’t seem to make a clear distinction between inputs and outputs. This has to do with the concept of partial function application, or currying (also named after Haskell Curry).

Implicitly, what’s happening is the following:

where the function calc_entropies takes in [Matrix C] as its input, and returns a function as its output. The function then takes in Matrix C as the input and returns another function as the output. Finally, the function takes in Int as the input and returns [Float] as the final output. This means that functions in Haskell are indeed pure in that they only take in one input and return one output, and any functions that appear to take in multiple inputs are in fact taking in only one input and returning a function that also takes in one input as its output, and so on and so forth. This is called currying. Because of this, we can also apply the functions “partially”, for example:

f a b = a + b
g = f 5

where we only provided one argument to f when it is expecting two, to create a new function g. This means that f 5 10 and g 10 would give the same output of 15. Currying or partial function application can be a powerful tool for the abstraction and expressiveness of your code.

TipExample of the usefulness of currying

Unitary operations are common in quantum mechanics, and are how quantum computers perform computations on quantum states or qubits. For example, the unitary can act on a quantum state as follows:

We can define a function unitary_oper to implement this.

• Python
• Haskell

def unitary_oper(U, ket):
    return U @ ket

unitary_oper :: Matrix C -> Matrix C -> Matrix C
unitary_oper u ket = u <> ket

There are many common unitaries used in quantum computations, referred to as quantum logic gates. For example there are the Pauli X gate and the Hadamard gate which are defined as

Currying or partial function application allows us to easily define these new gate operations on top of the existing unitary_oper function:

pauli_x = unitary_oper (2><2) [0, 1, 0, 1]
hadamard = unitary_oper (cmap (/ sqrt 2) (2><2) [1, 1, 1, -1])

We can then easily apply the Pauli X and Hadamard gates on a qubit with pauli_x (2><1) [1, 0] and hadamard (2><1) [1, 0]. This can make the code more concise and clearer.

Lazy evaluation

Moving on to the function itself:

calc_entropies ks rho n = map entropy rho_list
  where
    rho_list = take n (iterate (collision ks) rho)

The first line features the function map, which is the main tool of the functional programmer. It simply apply a function to every element of a list:

and has the corresponding Python code of

entropy_list = [entropy(rho) for rho in rho_list]

# or alternatively
entropy_list = []
for rho in rho_list:
    entropy_list.append(entropy(rho))

Finally, in the last line we have

which gives rho_list = [rho, collision(rho), collision(collison(rho)),...] up till n number of elements in the list.

Also note that we can reduce the number of parenthesis by using $ instead, e.g., rho_list = take n $ iterate (collision ks) rho.

It might be quite surprising that the iterate function returns an infinite-sized list. For example, iterate add1 10 gives [11, 12, 13, 14, 15, ...] to infinity, where the function add1 is applied on 10 ad infinitum. If we were to write the corresponding Python code for rho_list = take n (iterate (collision ks) rho), it might look something like

rhos = []
while True:
    rhos.append(rho)
    rho = collision(ks, rho)

rho_list = rhos[:n]

which runs forever and result in a list of infinite size. However, this is not a problem in Haskell, thanks to the fact that Haskell is lazy-evaluated. This means that Haskell only evaluates values when required, and so since we only require the first n elements of the infinite list, Haskell only evaluate that first n elements.

If this Python code is lazy-evaluated like in Haskell, one might imagine that the program looks ahead and saw that it only require the first n elements as stated in rho_list = rhos[:n], and so it stops the while True loop after only running n times.

Conclusion

Overall, I find Haskell’s expressions to be much more concise and clearer than imperative statements in Python or most ALGOL family of languages. Of course, if one is unfamiliar with higher-order functions such as map, iterate, foldl, or even combinators etc., then Haskell definitely look less concise and less clear, but this is just the standard experience of learning a new language.

It is also often said that learning Haskell will change the way you write code even in other programming languages, and will make you a better programmer in general, e.g., favoring small and pure composable functions, preferring immutable data structures, or embracing “higher-order thinking”. In other words, learning Haskell is more than just picking up new syntax; it reshapes how you approach programming.