Overview

The bioreactor has been redesigned as single modular units instead of the four bioreactor units that I was designing before. This is to facilitate individual temperature and gas control and in anticipation of building networked ecosystems of bioreactors. In addition the software was rewritten and now includes sensors that can measure gas composition (CO2 and O2 currently). A gas control system has been built that can run the bioreactors in controlled, elevated carbon dioxide environments by mixing CO2 and air in different proportions. Finally, a pumping system than can support up to 8 pumps has been integrated, and a two pump system (feed/waste) has been programmed with a turbidostat mode that tracks growth rate in real time using an estimator based on the extended Kalman filter  [1].

Improved Temperature Control System

An improved temperature control system was designed and constructed. The temperature control system consists of the same DS18B20 thermometer, but the liquid cooling system has been replaced with a solid-state Peltier element cooling system driven by a Cytron motor driver and a custom machined aluminium block that sits around the lower 20mm of the vial. The block is designed to enclose as much of the vial as possible leaving room above for the optics above. The aluminum block was designed to be twenty millimeters deep but to accommodate a 40mm Peltier element. This block was designed in Autodesk Fusion and machined by eMachineShop. Temperature measurements for the PID controller take place in a hole at the front of the aluminium block and with the DS18B20 temperature probe placed in contact with the glass vial. The Pioreactor base was modified to create a custom base plate that attached to the aluminium block via M3x4mm screws. The CAD file for this can be found here. This facilitates connecting the Pioreactor optics sleeve to the aluminium block.

To characterise how quickly the Peltier block can move the vial between temperature setpoints, I used the temperature_profile schedule from the yeast_ekf.py EKF job that produced this dataset: 25 °C for the first 3 hours, then 27.5 °C for 3 hours, then 30 °C. That gives two commanded shifts — at 180 min and 360 min — and the figure below overlays the two transients aligned to the moment each setpoint was changed. Settling time is defined as the first time enters and stays below a 0.1 °C band for at least 60 s.

Code

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

CSV_URL = ("https://raw.githubusercontent.com/livingphysics/bioreactor_v3/"
           "main/src/bioreactor_data/bioreactor_data.csv")
df = pd.read_csv(CSV_URL)

t_min = df['elapsed_time'].values.astype(float) / 60.0
T = df['temperature_C'].values.astype(float)

# Setpoint schedule from examples/yeast_ekf.py (temperature_profile):
#   stage 1: 0 → 180 min  @ 25.0 °C
#   stage 2: 180 → 360 min @ 27.5 °C
#   stage 3: 360 min → end @ 30.0 °C
profile = [(0.0, 25.0), (180.0, 27.5), (360.0, 30.0)]
transitions = [(profile[k][0], profile[k - 1][1], profile[k][1])
               for k in range(1, len(profile))]

WINDOW_BEFORE = 5.0
WINDOW_AFTER  = 45.0
TOL = 0.1
HOLD = 1.0

fig, ax_t = plt.subplots(1, 1, figsize=(7.5, 4.5))
colors = ['#1976D2', '#D32F2F', '#388E3C', '#7B1FA2']

for k, (t0, T_before, T_after) in enumerate(transitions):
    mask = (t_min >= t0 - WINDOW_BEFORE) & (t_min <= t0 + WINDOW_AFTER)
    tt = t_min[mask] - t0
    TT = T[mask]
    c = colors[k % len(colors)]

    err = np.abs(TT - T_after)
    after = tt >= 0
    tt_a = tt[after]; err_a = err[after]
    settle_t = np.nan
    within = err_a <= TOL
    for j in range(len(tt_a)):
        if not within[j]:
            continue
        j_end = np.searchsorted(tt_a, tt_a[j] + HOLD)
        if j_end <= len(tt_a) and np.all(within[j:j_end]):
            settle_t = tt_a[j]
            break

    settle_txt = f'{settle_t:.1f} min' if np.isfinite(settle_t) else '—'
    label = f'{T_before:.1f} → {T_after:.1f} °C  (settle: {settle_txt})'
    ax_t.plot(tt, TT, '-', color=c, linewidth=1.2, label=label)
    ax_t.axhline(T_before, color=c, linestyle=':',  linewidth=0.7, alpha=0.5)
    ax_t.axhline(T_after,  color=c, linestyle='--', linewidth=0.7, alpha=0.7)
    if np.isfinite(settle_t):
        ax_t.axvline(settle_t, color=c, linestyle='-', linewidth=0.8, alpha=0.5)
        ax_t.plot(settle_t, T_after, 'o', color=c, markersize=6,
                  markeredgecolor='black', markeredgewidth=0.6)

ax_t.axvline(0, color='grey', linewidth=0.8, alpha=0.6)
ax_t.set_xlabel('Time since setpoint shift (min)')
ax_t.set_ylabel('Temperature (°C)')
ax_t.legend(loc='lower right', fontsize=9)
ax_t.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Kalman Filter Based Turbidostat Mode

The turbidostat is driven by an extended Kalman filter (EKF) that tracks two hidden states — the optical density of the culture and a per-cycle multiplicative growth rate — from the noisy photodiode voltage measured each cycle. The state transition is multiplicative, with , which the filter linearises through the Jacobian The measurement model observes OD directly (), so the growth rate is inferred only through the predicted and measured OD. From the updated rate estimate the doubling time is reported as , with its uncertainty propagated from the corresponding entry of the covariance matrix. The full implementation lives in turbidostat_ekf_mode in src/utils.py; when no active turbidostat job is running the same predict/update step is run passively each time the sensors are logged, so that growth rate is always available in the CSV output.

The filter follows the design in  [1], including their treatment of dilution events. Each pump firing causes a step drop in OD that the multiplicative process model cannot account for, and if left untreated this drives spurious corrections into the growth-rate estimate. Instead, the moment a pump fires the OD prediction is reset to the raw measurement, the OD variance is inflated to a “distrust” value (10× the measurement noise by default), and the off-diagonal covariance terms are zeroed so that the dilution transient cannot leak into . The filter then re-converges over the next ten cycles. A second guard rejects single-sample sensor glitches: if an innovation exceeds five standard deviations the off-diagonal terms are again zeroed and the OD variance is reset to the squared residual, which prevents a stray reading from poisoning the growth-rate estimate.

The turbidostat job itself is scheduled like any other periodic task on the bioreactor (typically every 10 s). Each cycle reads the most recent OD from the live CSV, runs the EKF update, and — if the filtered OD estimate has crossed the user-supplied setpoint — fires the inflow pump for a fixed duration and the outflow pump for 1.1× that duration via independent_flow. The filter is initialised from the first valid OD reading with (no growth), and the measurement noise , growth-rate process noise , pump-distrust covariance and distrust-cycle count are all exposed as job arguments. To make tuning these tractable, the ekf_tuning_gui.py tool replays a historical run through the same filter code with log-scale sliders for each parameter, so the effect of a change on the OD estimate, growth rate and doubling time can be seen immediately against real data.

The figure below replays a ~9 hour turbidostat run for a yeast culture in which the temperature setpoint was stepped through three values, applying the same EKF used online. The raw photodiode trace shows the characteristic sawtooth of dilution events, the filtered OD tracks through them via the pump-distrust mechanism, and the inferred doubling time settles to a different steady value at each temperature plateau. This is able to resolve at leas 20 minute differences in generation time for the yeast culture.

Code

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

CSV_URL = ("https://raw.githubusercontent.com/livingphysics/bioreactor_v3/"
           "main/src/bioreactor_data/bioreactor_data.csv")
df = pd.read_csv(CSV_URL)

times = df['elapsed_time'].values.astype(float)
measurements = df['Eyespy_sct_V'].values.astype(float)
pump_cum = df['pump_inflow_time_s'].values.astype(float)
pump_events = np.zeros(len(times), dtype=bool)
pump_events[1:] = np.diff(pump_cum) > 0


def run_ekf_replay(times, measurements, pump_events,
                   R=0.001, Q_growth_rate=5e-12,
                   initial_growth_rate=1.0, initial_P_r=0.0005**2,
                   pump_distrust_cycles=10, pump_distrust_P_od=None):
    n = len(times)
    if pump_distrust_P_od is None:
        pump_distrust_P_od = 10.0 * R
    od_est = np.full(n, np.nan); growth_rate = np.full(n, np.nan)
    doubling_time_s = np.full(n, np.nan); od_std = np.full(n, np.nan)
    r_std = np.full(n, np.nan); dt_std = np.full(n, np.nan)

    x = np.array([measurements[0], initial_growth_rate])
    P = np.array([[R, 0.0], [0.0, initial_P_r]])
    distrust_counter = 0
    last_time = times[0]
    dt_median = np.median(np.diff(times))
    od_est[0] = x[0]; growth_rate[0] = x[1]
    od_std[0] = np.sqrt(R); r_std[0] = np.sqrt(initial_P_r)
    I2 = np.eye(2); H_vec = np.array([1.0, 0.0])

    for i in range(1, n):
        z_k = measurements[i]
        if np.isnan(z_k):
            od_est[i] = od_est[i-1]; growth_rate[i] = growth_rate[i-1]
            doubling_time_s[i] = doubling_time_s[i-1]
            od_std[i] = od_std[i-1]; r_std[i] = r_std[i-1]; dt_std[i] = dt_std[i-1]
            continue
        last_time = times[i]
        if pump_events[i]:
            distrust_counter = pump_distrust_cycles

        od_k, r_k = x
        x_pred = np.array([od_k * r_k, r_k])
        F = np.array([[r_k, od_k], [0.0, 1.0]])
        Q_mat = np.array([[0.0, 0.0], [0.0, Q_growth_rate]])
        P_pred = F @ P @ F.T + Q_mat

        if pump_events[i] or distrust_counter > 0:
            P_pred[0, 0] = pump_distrust_P_od
            P_pred[0, 1] = 0.0; P_pred[1, 0] = 0.0
            x_pred[0] = z_k
            if not pump_events[i]:
                distrust_counter -= 1

        y = z_k - x_pred[0]
        S = P_pred[0, 0] + R
        K = P_pred[:, 0] / S
        x_updated = x_pred + K * y
        P_updated = (I2 - np.outer(K, H_vec)) @ P_pred

        if abs(z_k - x_pred[0]) > 5.0 * np.sqrt(R):
            P_updated[0, 1] = 0.0; P_updated[1, 0] = 0.0
            P_updated[0, 0] = (x_updated[0] - z_k) ** 2

        x, P = x_updated, P_updated
        od_est[i] = x[0]; growth_rate[i] = x[1]
        od_std[i] = np.sqrt(P[0, 0]); r_std[i] = np.sqrt(P[1, 1])

        r_est = x[1]
        if r_est > 1.0:
            ln_r = np.log(r_est)
            dt_val = dt_median * np.log(2.0) / ln_r
            if dt_val <= 86400.0:
                doubling_time_s[i] = dt_val
                dt_std[i] = dt_median * np.log(2.0) * r_std[i] / (r_est * ln_r ** 2)

    return dict(od_est=od_est, growth_rate=growth_rate,
                doubling_time_s=doubling_time_s,
                od_std=od_std, r_std=r_std, dt_std=dt_std)


result = run_ekf_replay(times, measurements, pump_events, Q_growth_rate=5e-12)

t_h = times / 3600.0
mask = t_h <= 9.0
t_h = t_h[mask]
raw_od = measurements[mask]
ekf_od = result['od_est'][mask]
od_sd = result['od_std'][mask]
dt_min = result['doubling_time_s'][mask] / 60.0
dt_sd_min = result['dt_std'][mask] / 60.0
temp = df['temperature_C'].values.astype(float)[mask]
pump_times = t_h[pump_events[mask]]

fig, (ax_od, ax_dt, ax_temp) = plt.subplots(3, 1, figsize=(11, 7.5), sharex=True)
fig.subplots_adjust(hspace=0.12)

ax_od.plot(t_h, raw_od, '.', color='#cccccc', markersize=2, label='Raw OD', zorder=1)
ax_od.plot(t_h, ekf_od, '-', color='#2196F3', linewidth=1.2, label='EKF OD est', zorder=3)
ax_od.fill_between(t_h, ekf_od - od_sd, ekf_od + od_sd, color='#2196F3', alpha=0.15, zorder=2)
for pt in pump_times:
    ax_od.axvline(pt, color='#FF5722', alpha=0.3, linewidth=0.8)
ax_od.set_ylabel('OD (V)')
ax_od.legend(loc='upper left', fontsize=9)
ax_od.grid(True, alpha=0.3)

dt_upper = np.where(np.isfinite(dt_min) & np.isfinite(dt_sd_min), dt_min + dt_sd_min, np.nan)
dt_lower = np.where(np.isfinite(dt_min) & np.isfinite(dt_sd_min),
                    np.maximum(dt_min - dt_sd_min, 0), np.nan)
ax_dt.plot(t_h, dt_min, '-', color='#9C27B0', linewidth=1.2, label='Doubling time')
ax_dt.fill_between(t_h, dt_lower, dt_upper, color='#9C27B0', alpha=0.15)
for pt in pump_times:
    ax_dt.axvline(pt, color='#FF5722', alpha=0.3, linewidth=0.8)
finite_vals = dt_min[np.isfinite(dt_min)]
if len(finite_vals):
    p5, p95 = np.percentile(finite_vals, [5, 95])
    margin = (p95 - p5) * 0.15
    ax_dt.set_ylim(max(0, p5 - margin), p95 + margin)
ax_dt.set_ylabel('Doubling time (min)')
ax_dt.legend(loc='upper left', fontsize=9)
ax_dt.grid(True, alpha=0.3)

ax_temp.plot(t_h, temp, '-', color='#E65100', linewidth=1.2, label='Temperature')
ax_temp.set_ylabel('Temperature (°C)')
ax_temp.set_xlabel('Elapsed time (hours)')
ax_temp.legend(loc='upper left', fontsize=9)
ax_temp.grid(True, alpha=0.3)
plt.show()

Overview

This note presents some initial cell learning results using the rewired “Gal-His” yeast previously constructed. In a variety of conditions, we can observe adaptation of the rewired strain. When grown in galactose without leucine or histidine, the strain grows well, using galactose as its carbon source and making histidine using the His3 enzyme transcribed from the Gal1/10 promoter as well as leucine from the Leu2 gene transcribed from its native Leu2 promoter. In addition the Gal promoter also drives expression of the green fluorescent protein (GFP). In galactose the yeast exhibit green fluorescence (with blue illumination). Adaptation has been shown in two different types of assays. Cells grown in liquid culture assay show a characteristic “double-logistic” growth curve when switched from galactose to glucose media without histidine or leucine (+gal-his-leu). We observe this phenomena in cultures grown in both the v1 version of hte bioreactor and the v2 version. Before adaptation, cells strongly express genes from the Gal promoter, as observed by strong GFP fluorescence. A few hours after switching into glucose, expression is undetectable by GFP fluorescence. After adaptation, low levels of promoter activity can be detected, but not comparable to the levels under galactose induction. In addition to the liquid culture assays, colonies were grown on plates and time-lapse photo micrographs were recorded. These show the adaptation process as colonies initially repress the promoter, showing low GFP fluorescence, but later adapt and are able to de-repress the gal promoter in glucose conditions.

Results

“Double-Logistic” Growth in Liquid Culture

When grown in the galactose, the Gal promoter is active, transcribing and expressing both His3 and GFP. When cells are diluted in to glucose media, the presence of glucose strongly represses expression from the Gal promoter. At this time, no new HIS3 or GFP mRNAs are produced. Existing mRNAs can still be translated, however mRNAs in the yeast cell have an average half-life of 22 minutes  [1]. The median half-life of proteins is about 8.8 hours  [2], but without new synthesis, proteins are also diluted out during cell division². After transfer to Glucose, cells are able to maintain growth using existing stores of histidine and existing HIS3 protein until stores are exhausted by dilution from growth and degradation. At this time, growth stops, however, after a period of time, cultures are able to adapt to this new condition and resume growth. This results in a characteristic “double-logistic” growth curve. This is consistent with three-phase growth of colonies observed on plates in  [3] and in liquid culture in  [4]. I carried out a series of experiments putting rewired yeast that had never been adapted to glucose before (“naive rewired”) cells into media without histidine and leucine and 2% glucose (-his -leu +glu). Experiments on 2 different days were carried out in this way, and in between, an experiment growing naive-rewired cells in minimal media (-his -leu +gal), which did not show the characteristic double logistic behavior. These experiments were done in the V1 bioreactor with Formedium’s complete supplement mixture DCS0469 without histidine and leucine. This media is not exactly what Braun et al.  [4,5], so I carried out a second experiment using the media they did, recreating it from Formedium’s Kaiser synthetic complete media DSCK1027 without histidine, leucine, tryptophan, or uracil and adding 6mg/l trp and 3mg/l uracil.

Code

using CSV
using DataFrames
using Plots
using HTTP

url_base = "https://raw.githubusercontent.com/livingphysics/RPi-Biosensor/refs/heads/main/data/"
file_names = ["250827_yeast_galhis_csm-his-leu-glu.csv", "250829_naive_galhis_csm-his-leu-gal.csv", "250901_naive_galhis_csm-his-leu-glu.csv"]
plots_array = []
for k in 1:3
    response = HTTP.get(url_base * file_names[k])
    data = CSV.read(response.body, DataFrame)

    # Get elapsed time in hours
    t_run = data.elapsed ./ 3600

    # Extract OD columns (columns 2-5)
    OD = [data[:, i+1] for i in 1:4]

    # Find maximum OD value
    od_max = maximum(maximum.(OD))
    OD_f = 0

    # Create subplot
    p = plot()
    t_mid = zeros(4)

    for i in 1:4
        # Normalize OD
        norm_od = (od_max .- OD[i]) ./ (od_max - OD_f)

        plot!(p, t_run, norm_od,
            linestyle=:dash,
            label="OD $i")
    end

    # Set plot properties
    title_text = if k == 2
        "2% Galactose"
    elseif k == 1
        "2% Glucose Run 1"
    else
        "2% Glucose Run 2"
    end

    plot!(p,
        title=title_text,
        xlabel="time (h)",
        ylabel="Relative OD",
        xlims=(0, 50),
        guidefontsize=12,
        titlefontsize=12,
        legendfontsize=10,
        framestyle=:box)

    push!(plots_array, p)
end

# Combine all subplots
final_plot = plot(plots_array...,
    layout=(3, 1),
    size=(800, 900),
    theme=:dark)

savefig(final_plot, "thumbnail.png")
display(final_plot)

GKS: cannot open display - headless operation mode active

Code

using CSV
using DataFrames
using Plots
using HTTP

url_base = "https://raw.githubusercontent.com/livingphysics/Bioreactor_v2/refs/heads/main/bioreactor_data/"
file_names = ["20250901_131355_bioreactor_data.csv"]
plots_array = []
for k in 1
    response = HTTP.get(url_base * file_names[k])
    data = CSV.read(response.body, DataFrame)

    # Get elapsed time in hours
    t_run = data.time ./ 3600

    # Extract OD colums (columns 2-5)
    OD = [data[:, i+5] for i in 1:4]

    # Find maximum OD value
    od_max = maximum(maximum.(OD))
    OD_f = 0

    # Create subplot
    p = plot()
    t_mid = zeros(4)

    for i in 1:4
        # Normalize OD
        norm_od = (od_max .- OD[i]) ./ (od_max - OD_f)

        plot!(p, t_run, norm_od,
            linestyle=:dash,
            label="OD $i")
    end
    plot!(p,
        title="2% Glucose",
        xlabel="time (h)",
        ylabel="Relative OD",
        xlims=(0, 90),
        guidefontsize=12,
        titlefontsize=12,
        legendfontsize=10,
        framestyle=:box)

    push!(plots_array, p)
end

# Combine all subplots
final_plot = plot(plots_array...,
    layout=(2, 1),
    size=(800, 300),
    theme=:dark)

display(final_plot)

Before adaptation rewired yeast were grown in galactose media. In this condition we expect that the gal promoter will be activated, expressing both GFP and HIS3. In this case, we expect that the cells will glow brightly green when excited with blue light. Figure 3 shows rewired cells pre and post adaptation. Expression from the Gal promoter (as visualized by GFP expression) is very strong prior to the switch to glucose. After adaptation, expression is much less (but not completely absent). At the same exposure (0.5 seconds) it is difficult to see the fluorescent signal, but at longer exposure some fluorescence is visible.

Colony Growth on Plates

Liquid culture is convenient for measuring the growth dynamics using continuous optical density measurements, however, liquid cultures generally start from tens of thousands of cells, and it is difficult to quantify pre-existing population variation that may influence the subsequent dynamics of adaptation. In contrast, growing colonies on plates allow the observation of the populations that start from single cells but is more inconvenient, as special care must be taken to ensure time-lapse images taken over the course of days remain in focus an that the plates do not dry out.

One possibility is that in a large population fo yeast cells, previous cell growth and division has introduced a variety of mutations into the population. This standing genetic variation can then provide a palette from which beneficial mutations can be selected. If this were the case, we would expect a few things.

1. That the cells harboring the pre-existing beneficial mutation would have a growth advantage immediately
2. That not every cell in the population would harbor the beneficial mutation (in fact only a few) cells should have it.
3. The descendants of the original mutant cell would inherit the growth advantage.

These considerations reflect those that Luria and Delbruck  [6] put into their arguments which showed that bacteria do not induce adaptive mutations for phage resistance.

In this case, we would expect to see many arrested cells on the plate, and only a few colonies that grow robustly. This is not what we observe. Rather, we see the majority down regulate the Gal promoter and turn off the expression of GFP and HIS3. The colonies continue to grow but GFP fluorescence is absent. At some point during this initial growth phase, some cells withing the colonie figure out how to resume expression from teh Gal locus, re-expressing GFP (and presumably HIS3). When this happens the colony growth rate increases. These are the three phases of growth observed in the previous experiments and correspond to the double logistic growth curves in liquid culture. A more careful analysis of the colony growth rate can be carried out to estimate the average cell division time during the adaptation period. In addition, the optics can be improves to get better resolution data for the re-expression dynamics of the GFP.

Overview

This note outlines the build of our second generation bioreactor. This version of the bioreactor includes Temperature Control and a Pump System for exchanging media. It can be run as a batch reaction with the pumps tuned off, or as a Turbidostat or a Chemostat. This is not a sealed system as in Bioreactor_v1 so there are no pressure measurements for this system.

import pandas as pd
import matplotlib.pyplot as plt

# If file is local (after downloading from GitHub)
# df = pd.read_csv("20250901_131355_bioreactor_data.csv")

# Or load directly from GitHub raw link (requires internet access)
url = ("https://raw.githubusercontent.com/livingphysics/Bioreactor_v2/refs/heads/main/bioreactor_data/20250901_131355_bioreactor_data.csv")
df = pd.read_csv(url)
df = df.iloc[2000:]
# Compute difference
df['temp_diff'] = df['vial_D_temp'] - 27
data = df['vial_D_temp'] - 27
data = data.dropna()
std_dev = data.std()

# Plot histogram
plt.figure(figsize=(8, 5))
plt.hist(df['temp_diff'].dropna(), bins=12, density=True, edgecolor='black')
plt.xlabel('vial_D_temp − set_point(27) (°C)')
plt.ylabel('Probability Density')
plt.title(f'Histogram of Temperature Deviation\nStd Dev = {std_dev:.3f} °C')
plt.grid(True, linestyle='--', alpha=0.5)
plt.show()

A goal for the future would be to determine the extent of knowledge the cell has of itself and how it uses that knowledge in a thoughtful manner when challenged.

(McClintock 1984)

This note describes how I am recreating the strain from the Braun lab  [1] used to demonstrate adaptive reprogramming to novel challenges in the yeast Saccharomyces cerevisiae Unfortunately the strain and plasmid were lost due to a freezer fault. This document is written informally but should be understandable to a reasonably interested secondary school student. For brevity, the main document uses standard scientific terminology, but these terms are explained in detail in the Procedures section.

Given a simple chemical reaction

Recall from the previous note the simple conversion reaction with dynamics given by:

Some of the formulas I presented without derivation in the previous notes were derived from looking at the eigen-decomposition of the Laplacian. This gives us the eigenvector matrix We can use this transformation to define new set of uncoupled coordinates If we define then we now have a dynamical system of 2 variables that do not interact (compare to the original sytem which has interactions) Thus: which gives Noting that and , which is how I derived the observable function in the note Introduction and Motivations for a Projection Operator Approach. represents the total (probability) mass and reflects conservation of (probability) mass.

We’ve carried out this eigen-decomposition because the natural dynamics of ad can be represented as a linear combination of the uncoupled dynamics of and . In the language I have been developing in the last few notes, I would say that and are the basis functions and the dynamics of and are projections onto these basis functions.

It is clear in this simple example that the basis functions are defined by the eigenvalues and the projection is defined by the eigenvectors. Thus if we change the eigenvalues without changing the eigenvectors we adjust the basis functions and if we change the eigenvectors while keeping constant eigenvalues we change the projection.

Lets now consider the action of an enzyme which lowers the activation energy barrier for the reaction. This results in a proportional increase in both and The eigenvector associated with the 0 eigenvalue is then , and is thus unchanged. However, the non-zero eigenvalue is now . This results in the second basis function changing to Because the dynamics of and are linear combinations of and and the dynamics of are now much faster (by a factor of ) the resulting dynamics of a and b will be faster, but the resulting steady state concentrations of and will be unchanged. This matches our intuition based on activation energy changes in equilibrium systems.

Alternatively, in this simple system, we can adjust the projections without changing the basis functions. We do this by adjusting and such that their sum stays constant. This corresponds to a process which maintains the total flux in the system but adjusts the flux balance¹ (this necessarily corresponds to binding energy differences here). This changes the steady state ratio of and but leaves the kinetics unchanged. This is because the basis functions are unchanged: This uncoupling of the dynamics into independent observable functions is always possible for Laplacian dynamics. To connect it to some of the concepts introduced in previous notes, we can think of the functions as observable functions of the natural coordinates and , where each observable function has dynamics that are closed on its own 1D subspace (this is a restatement of the uncoupling condition). We can also think of the dynamics of and as being projections onto the basis functions defined by . Interestingly the basis functions define a spectrum of time-scales for the dynamics because the dynamics of the molecular concentrations will be linear combinations of the basis functions defined by the eigenvalue spectrum. In the next note I will explore how these notions can be applied to larger networks, and look at some connections to kinetic regime vs energetic regime proofreading, building finally to connections to orthogonality.

Overview

This note describes an upgrade to the first generation bioreactor to increase the sensitivity and long-term reliability of the optical density measurements. The optical density measurements are done using a combination of infrared photodiodes and infrared LEDs.

Quarto is a

An open-source scientific and technical publishing system

based on markdown that allows for equations and code to be easily embedded into posts. This guide provides an excellent overview of setting up a quarto notes site and how to author individual posts as well as the basics of markdown. I referred to this to set up the website, the different notes sections, the main index, and the RSS feed. This site is separately hosted from the my main website, which I wrote mostly in html and is hosted on github pages with a custom domain.

project:
  type: website
  output-dir: docs

Host    Type    Priority    Data
notes   CNAME   ---         app_ip_address.ondigitalocean.app

Overview

This note describes the design and construction of a RaspberryPi based 4-bioreactor system that has external illumination, external temperature recording, and magnetic stirring. The system monitors internal temperature and pressure using the BME280 series sensor and monitors turbidity via Infrared absorbance ( ) and scattering (). This system is based on the sealed long-term ecosystems designed by the Kuehn Lab [1].

1. Observable functions are sets of functions of underlying state variables.

2. These sets can be much smaller than the underlying dynamical system of which they are functions. This leads to concentration of dimension and can be formalized as a projection operator.

3. Closed observable subspaces are sets of observable functions whose dynamics are (approximately) self determined, that is that they can be expressed as functions of the observables themselves.

At this point I hope you are comfortable with the concentration of dimension via function projection, in this note, I want to explore the expansion of dimension by observable functions. The main reason we would expand dimensionality is that it can make some computations easier, and that it can linearize a non-linear dynamical system. Consider the following example¹

This is a 2D non-linear dynamical system because of the term. Lets propose a set of observable functions with the goal of linearizing the system.

Now lets look at the dynamics of

giving, The observable functions for this particular system also have the closure property I mentioned in the last note. We have expanded the dimensionality of the system, but the new system of observable functions has dynamics which are only functions the the themselves. This need not be the case. For example, lets look at the example of the following 1D nonlinear dynamics. If we try the same trick here,

We have Unfortunately here we see a problem, is not a linear function of our set of observables. , so we would need to add this to our observable functions, with Again we have a term that is not in our current observable set . We can however continue this process for an infinite number of terms, if we introduce to account for the constant term, we can write these dynamics with a matrix of the form:

So we have in infinite dimensional linear operator which has the same dynamics as our non-linear system. In fact, we are guaranteed to always be able find such an infinite dimensional linear operator²

Why is this useful though? We have traded non-linear dynamics for infinite dimensional linear dynamics. Other than control theory applications, its not clear why linear dynamics are important, and also, any real control system is finite dimensional. At this point the connection to orthogonality is hopefully emerging. The Laplacian dynamics from our master equation formulation is a linear operator. It is finite dimensional, but we saw in the last note how we can concentration dimension with projection operators. We can do this as well with the infinite dimensional operators like the one above. The Galerkin projection, that is the one that simply ignores most of the dimensions, is easiest, but like the example in the previous note, if the subspace onto which you are projecting is not closed, the dynamics floats off over time. In other words, the projection does not exactly recapitulate the dynamics, but rather is an approximation. Can chemical reaction networks use their Laplacian dynamics as such an approximation? The questions that I will try to answer in the next few notes are

1. Can a chemical reaction network can use its dynamics as a finite dimensional linear approximation of an arbitrary dynamical system.
2. If so, what are the “natural basis functions” of Laplacian dynamics
3. How does a physical system use thermodynamics to perform these operations without a notion of explicitly approximating the non-linear dynamics.

As a teaser, lets go back to the one dimensional dynamical system that we needed an infinite expansion to represent.
With our naive choice of observable functions, we saw that we needed an infinite dimensional dynamical linear dynamics to represent it in that set of observables. In fact any finite Galerkin projection in that basis is a pretty bad approximation, but what if we are more clever with the basis functions we select. The form of this equation is written in this way for a reason. Lets go back to the simple chemical reaction network from the previous note with its linear dynamics If I choose an observable function of this dynamics to be the ratio of the two species then the dynamics of are given by So it turns out that the dynamics of this non-linear system can in fact be recapitulated by a closed linear system, generated by a Laplacian chemical reaction network. If our observable function is the ratio of two species.

At this point I hope you feel comfortable. 1) Reducing dimensionality with projection operators. Sometimes this projection can be exactly preserving for closed, invariant subspaces. Otherwise its an approximation 2) Expanding dimensionality through the use of observable functions. Sometimes we need to expand infinitely to get linear dynamics. But linear dynamics may not be the appropriate end goal. Ultimately I’m interested in observable dynamics that can be recapitulated with observables realizable by chemical reaction networks. These may be linear, Linearity is nice for our Laplacian dynamics, but even these are approximations based on time scale separation³ 3) Although I didn’t explain it in detail in the last note (I will in a companion note) The transformation I used to find a closed projection was based on the eigen-decomposition of the linear dynamics given by . This is another nice property of linearized dynamics, we can find eigenfunctions which have characteristic time scales and which are uncoupled (if this is unclear stay tuned for the next note). These eigen-decompositions as dimension preserving rotations of the dynamics.

So now we can take dynamical systems, expand their dimensionality, contract their dimensionality, and rotate their representations at will. The math here is not new or that difficult, but the new part (I hope) will be in seeing how chemical reaction networks can do this using only local information in a self organized way.

The basic premise of the projection operator approach begins with a complex, high dimensional dynamical system. In statistical mechanics this is often taken to be Hamilton’s equations of motion (so-called Hamiltonian Dynamics) for a large number of particles. The take home message of this section is that the projection operator framework provides a rigorous mathematical derivation, given some important and carefully chosen assumptions, of how to ignore almost all of the order degrees of freedom in such a system and find dynamics of effective variables that satisfy some useful properties, the most useful of which is closure. Closure is the ideal that the dynamics of the effective variables can be written only in terms of the effective variables themselves. To make this a bit more concrete think of the concentration observable function. We know we can write the diffusion equation as:

Where the dynamics of the concentration is a function of only the concentration itself. Concentration is clearly coupled to the positional degrees of freedom of the full dynamical system (which are coupled to the velocity degrees of freedom), but we can ignore all of these with some well chosen assumptions (many of these are convenient assumptions about near equilibrium behavior or about time scale separations that allow appropriate averages to be taken analytically).

As an aside these is also a connection here to work I did studying C. elegans behavior (can we find equations of motion for posture that are functions of only posture itself, despite the fact that posture is coupled to many microscopic degrees of freedom (neural dynamics, neuro-muscular dynamics, hormones, neuro-chemical dynamics, etc). It also came up in my thinking about how robustness and flexibility manifest simultaneously in biological systems and its relation to concentration of dimension and fluctuation dissipation like relations in development. The details are reserved for another note [[Canalization and Plasticity]]

Returning to projection operators, recall from my previous note about An interesting connection between “sloppy model analysis” and projection operators that function space projection is essentially what we are talking about here, and that Fourier analysis is still the clearest mental model I have of projection. In this context, if we have a large time scale separation between the fast and slow dynamics of a noisy oscillation, we can project the dynamics onto the slow modes (the signal) and treat the fast modes as noise. In general, I am not trying to estimate anything myself with projection operators, and I don’t know that biological systems are necessarily trying to estimate anything any more than diffusion is trying estimate anything in a purely physical process. I am more willing to say that

1. emergent effective variables exist (because stat mech gives existence proofs)

2. these effective variables are useful and biological systems take advantage of them (we have many examples of process that use concentrations, e.g. in developmental dynamics)

3. and this is the most speculative, that networks of biomolecules can organize themselves to generate effective variables and reorganize to find new (and better in some sense) effective variables on which to base their macroscopic dynamics.

   • This process of finding new basis functions for expressing dynamics could be related to achieving better estimates of some process that the cell is trying model. Its not until this level that I imagine “estimation” coming into play

In general, despite evidence that projections may be the best way to understand system dynamics, the underlying systems are too heterogeneous in my opinion to offer an path forward toward rigorous treatments, The case of chemical reaction networks is the exception! In this system, I think if we restrict ourselves to mass action kinetics (a reasonable restriction based on everything we know about chemistry that nevertheless does not not limit expressivity) we can figure out both what the basis functions are and how the system projects onto them (inspired by our orthogonality work). To motivate this lets start with the simplest example, a two species chemical reaction.
We can write the Laplacian dynamics for this system as where .

This is a two dimensional dynamical system with couple degrees of freedom and . Now if we wanted to reduce the dimensionality of the could do a Galerkin projection onto only one of the degrees of freedom and just simply ignore the other, for example for a we would have . This is dynamics of a only in terms of a, but these dynamics clearly diverge from the true dynamics significantly. This is probably not a very useful projection

Code

using Plots
using LinearAlgebra

# Define parameters
λ = 0.5
ν = 1.5
L = [-λ ν; λ -ν]

# Create initial conditions
n = 4
tmp = range(0, 1, length=n)
x0 = hcat([vcat(tmp[i], 1-tmp[i]) for i in 1:n]...)

# Function to integrate linear system (you'll need to implement this)
function integrate_linear(x0, L, dt, T)
    t = 0:dt:T
    x = zeros(length(x0), length(t))
    x[:, 1] = x0
    
    for i in 2:length(t)
        x[:, i] = x[:, i-1] + dt * (L * x[:, i-1])
    end
    
    return x, t
end

# Create plot with dark theme
theme(:dark)
plot(background_color=:black, 
     foreground_color=:white,
     legend=:topright,
     xlabel="time",
     ylabel="[a]",
     fontfamily="Computer Modern",
     grid=false)

# Plot true dynamics
for i in 1:n
    x, t = integrate_linear(x0[:, i], L, 0.01, 5)
    plot!(t, x[1, :], linewidth=2, label=i == 1 ? "True Dynamics" : "",color=i)
end

# Plot projected dynamics
for i in 1:n
    t = 0:0.1:5  # Using larger time steps for dashed lines
    projected = x0[1, i] * exp.(-λ * t)
    plot!(t, projected, linestyle=:dash, linewidth=2,
          label=i == 1 ? "Projected Dynamics" : "", color=i)
end

# Calculate eigenvectors and transform initial conditions
F = eigen(L)
v = F.vectors
z0 = inv(v) * x0

# Style adjustments
plot!(framestyle=:box,
      fontsize=14,
      margin=5Plots.mm)
savefig("thumbnail.png")
current()

GKS: cannot open display - headless operation mode active

Is there a more useful one dimensional projection of this two dimensional system? What if we measured an observable function of and ?. I will present such a function here and show how I determined it later. Assume for now that we first compute an observable of the system and then do a one dimensional projection onto this carefully chosen observable. The observable function is given as Lets look at the dynamics of this observable function

So we have found an observable function that satisfies our closure property! that is, its dynamics, which are determined by the underlying two-dimensional dynamical system, are self-determined. We do not need knowledge of and explicitly to predict or model the dynamics of , only knowledge of itself.

Code

using Plots
using LinearAlgebra

# Define parameters
λ = 0.5
ν = 1.5
L = [-λ ν; λ -ν]

# Create initial conditions
n = 4
tmp = range(0, 1, length=n)
x0 = hcat([vcat(tmp[i], 1-tmp[i]) for i in 1:n]...)

# Function to integrate linear system (you'll need to implement this)
function integrate_linear(x0, L, dt, T)
    t = 0:dt:T
    x = zeros(length(x0), length(t))
    x[:, 1] = x0
    
    for i in 2:length(t)
        x[:, i] = x[:, i-1] + dt * (L * x[:, i-1])
    end
    
    return x, t
end

# Create plot with dark theme
theme(:dark)
plot(background_color=:black, 
     foreground_color=:white,
     legend=:topright,
     xlabel="time",
     ylabel="[a]",
     fontfamily="Computer Modern",
     grid=false)
# Calculate eigenvectors and transform initial conditions
F = eigen(L)
v = F.vectors
z0 = inv(v) * x0

# Plot true dynamics
for i in 1:n
    x, t = integrate_linear(x0[:, i], L, 0.01, 5)
    tmp_data = inv(v)*x;
    plot!(t,tmp_data[1, :], linewidth=2, label=i == 1 ? "True Dynamics" : "",color=i)
end

# Plot projected dynamics
for i in 1:n
    t = 0:0.5:5  # Using larger time steps for dashed lines
    projected = hcat(exp.(-(λ + ν) * t), zeros(length(t)))
    tmp_data = projected * z0[:, i]
    scatter!(t, tmp_data, 
            marker=:square,
            markersize=2,
            linewidth=3,
            label=i == 1 ? "Projected Dynamics" : "",
            color=i)
end


# Style adjustments
plot!(framestyle=:box,
      fontsize=14,
      margin=5Plots.mm)

his is a simplified example but the principle is general. Sometimes, carefully chosen observable functions allow you to reduce the dimensionality of a dynamical system. Ideally the dynamics on the lower dimensional observables will be closed, that is they stay on some subspace of the full Hilbert space.

The utility of projection may not be obvious when going form 2 to 1 dimensions, but when reducing from thousands of dimensions to a few the implications for controllability and robustness are clearer as the effective dynamics no longer explicitly depend on all the microscopic degrees of freedom.

At the end of this I hope that you have a very clear idea of three concepts which I will build on later when I make a connection between projection operator theory and our orthogonality work building up to finally describing the connection between orthogonality and the steady state to flux relationship .

1. Observable functions are sets of functions of underlying state variables.

2. These sets can be much smaller than the underlying dynamical system of which they are functions. This leads to concentration of dimension and can be formalized as a projection operator¹.

3. Closed observable subspaces are sets of observable functions whose dynamics are (approximately) self determined², that is that they can be expressed as functions of the observables themselves.

Lets derive with projections (this is the best nth degree polynomial approximation of a function f)

by definition of the norm in terms of the inner product. remembering that we are minimizing with respect to . We can find the minimum by solving , the first term is zero, lets expand the second term

It is a bit more complicated, but So we have and thus,

Finally, In general the matrix is called the Gram matrix and it depends only on the basis functions . Thus in general, the “best approximation” of in the basis is given by

Function approximation is a useful tool, it is no coincidence that artificial neural networks of the multilayer feedforward variety ^{1 2} are provably universal function approximators. Projection in a Hilbert space of functions is one method of function approximation. A familiar example of a Hilbert space projection methods is Fourier analysis, where an arbitrary function is represented by its projection onto a basis set of functions, in this case sinusoids. Function projection relies on having an inner product on the function space, and in this case we will use the inner product defined as, With an increasing number of terms in the Fourier series, we can approximate a given function to arbitrary accuracy. Truncating the series is a form of projection, where we are projecting the infinite dimensional vector that represents the function onto the subspace spanned by only a finite set of modes, for example onto the lower frequency modes. The projection need not be a frequency cutoff, one could choose arbitrarily some subspace on which to project the function, for example, a custom compression for that function might choose the n modes with the highest power. This is an example of what I call “Concentration of Dimension”³ and may provide a basis for understanding the emergence of low-dimensionality in biological systems and in particular how these systems are capable of both canalization and plasticity.

In general we can represent an arbitrary function in any basis by projecting it onto the span of the subspace of those basis functions. It is easiest if those functions comprise an orthonormal basis, as they do in the Fourier series example, but this is not necessary, in fact we don’t even have to orthogonalize the basis first if we can compute and invert the Gram Matrix (the matrix of inner products between the basis functions). This is the basic idea behind regularization in function approximation and techniques such as kernel regression. This should sound eerily familiar re: Orthogonality!

At this point I would like to present a simple example which will also highlight the connection to sloppy model analysis. Taylor series approximation is a well known example of function approximation in a polynomial basis, usually motivated as a local equivalence between the n derivatives of the function and those of the polynomial approximation. However we can also view polynomial approximation as a projection onto polynomial basis functions. For example, the second order Taylor approximation of a function can be viewed as the projection of the function onto the subspace spanned by , , and . In a procedure similar to what we did wth orthogonality, we can first compute the projection onto the basis functions even though the basis functions are not orthonormal. For this example lets use and the interval to match the conditions in Sethna’s work. As a reminder, we are going to use function space projection to find the coefficients in the nth order polynomial approximation . For the polynomial approximation, this can be written as minimization problem noting that

and using the inner product defined above, we can derive the Projection in terms of the Gram Matrix with the projection is given by

with the Gram matrix given as the matrix of inner products between the basis functions. If the basis functions form an orthonormal basis, then the Gram matrix is equal to the identity matrix, and it is equal to its own inverse. However, this need to be true and in general the Gram matrix is given as

With our definition of the inner product and the monomial basis functions, we can compute this gram Matrix explicitly for polynomial projection.

So in this case, the final weights are given by

Which gives the following results:

Code

using Plots
using QuadGK

t = range(0, 1, length=100)

p = plot(
    xlabel="time", ylabel="y",
    title="y = sin(t)",
    legend=true,
    background_color=:black,
    background_color_outside=:black,
    fg_color=:white,
    titlefontcolor=:white,
    guidefontcolor=:white,
    tickfontcolor=:white
)

plot!(p,t,sin.(t),label="sin(t)")

plot!(p,t,sin(0).+cos(0).*t-sin(0)/2.0.*t.^2,label="Taylor series")

t1 = range(0, 1, length=10)
f1(t) = sin(t) * 1  # This is just sin(t)
f2(t) = sin(t) * t
f3(t) = sin(t) * t^2

# Create a vector of functions
functions = [f1, f2, f3]

# Calculate the definite integrals from 0 to 1 for each function
integrals = map(f -> quadgk(f, 0, 1)[1], functions)
x = [1, 2, 3]  # You can change these values as needed
V = [1/(i+j-1) for i in 1:3, j in 1:3]
coeffs = inv(V)*integrals

plot!(p,t1,coeffs[1].+coeffs[2].*t1.+coeffs[3].*t1.^2,marker=(:circle, 5),label="Projection Operator")

plot!(p, xlim=(0.0, 1.1))
savefig(p, "thumbnail.png")
p

GKS: cannot open display - headless operation mode active

Polynomial fits using either Taylor series approximation or the optimal projection

Now let us look at the the general Gram matrix in this case, we obtain the Hilbert matrix. The fact that this matrix is ill conditioned means that the inverse greatly magnifies small differences in the input. I was struck when this matrix appeared because I had seen it before in the Sloppy model literature⁴ but derived in a very different context. In sloppy model analysis, we are interested in the looking at the parameter sensitivity of a continuous least squares regression. This sensitivity is captured by the Hessian of the fit function with respect to the parameters at the best fit point, so in this case, we are looking at the matrix given by

Surprising to me, this gives the exact same matrix as the Gram matrix for the projection operator.

This leads me to believe that I am on the right track thinking about my worm developmental biology project, my worm behavior project, and our non equilibrium stuff in terms of projection operator theory (a convergence which emerged very unexpectedly at three different scales of inquiry)