Everyday Is A School Day

Cross-Validation From Scratch and a Surprise at n=100

Wed, 05 Aug 2026 00:00:00 +0000

Textbooks say LOOCV has the lowest bias but highest variance compared to 10 and 5-fold. Coded a K-Fold CV from scratch for learning to test that on simulated data 🔍📊 — and at n=1000 it holds up. At n=100? Not so much. 🤔

The above image was generated via chatGPT. Uploaded all the text of this blog post and asked it to generate a cartoon. Very impressive! It used to be spelling error and gibberish of text in the past, but now cohesive words on image. Just wow.

Motivations

Crossvalidation is such a crucial step in Machine Learning (and traditional methods) that nowadays is incorporated in easy to use sklearn or tidymodels without us needing to build one from scratch. As with my other learning experience, the best way to learn the concept (other than learning the concept 🤣) is to code it from the ground up and see how it works! In K-Fold CV, the training data is split into K chunks; the model is trained K times, each time holding out a different chunk. Performance is averaged across all K folds, giving a more stable estimate. A special case is Leave-One-Out CV (LOOCV), where each individual observation serves as its own validation set. It’s thorough but computationally expensive. I was told that, bias LOOCV < 10-fold < 5-fold; whereas variance LOOCV > 10-fold > 5-fold. Is that true? Also, what’s with the repeats, does that really reduce variance? Let’s check them out.

Objectives:

Simulate Data

library(tidyverse)

set.seed(1)
n <- 1000
x <- rnorm(n)
w <- rnorm(n)
y <- 0.5*x^2 + -0.5*w + 0.3*w*x + rnorm(n)
df <- tibble(x,y,w)
idx <- sample(1:n, size=0.8*n)
train <- df[idx, ]
test <- df[-idx, ]

The above code simulates a dataset with 1000 observations, where the response variable y is generated based on a known data-generating process involving predictors x and w. The dataset is then split into a training set (80%) and a test set (20%). Let’s visualize.

df |>
  mutate(w_cut = cut_interval(w, n=5)) |>
  ggplot(aes(x=x, y=y, color=w_cut, group=w_cut)) +
  geom_point(alpha=0.5) +
  theme_bw() +
  geom_smooth(method = "gam", se=F)

Wow, very interesting visualization where the relationships are definitely not linear here. It’s some form of interaction between x and w. Let’s see if we can recover the underlying data-generating process using K-Fold Cross-Validation.

K-Fold Cross-Validation From Scratch

folds <- 5
segment_portion <- nrow(train)/folds
formula_list <- list(as.formula("y~x"),as.formula("y~I(x^2)"),as.formula("y~I(x^2)+w+w:x"),as.formula("y~I(x^3)+w+w:x"),
                     as.formula("y~w:x"),as.formula("y~w"),as.formula("y~x+w+x:w"),as.formula("y~I(x^2)+w:x"),
                     as.formula("y~I(x^2)+w"))

cv_log <- tibble()

for (formula in formula_list) {
print(formula)
predict_log <- y_log <- vector(mode="numeric",length=segment_portion*folds)
start <- 1
end <- segment_portion 

for (fold in 1:folds) {
    val_i <- train[start:end,]
    train_i <- train[-c(start:end),]
    model_i <- lm(formula,train_i)
    predict_i <- predict(model_i, val_i)
    predict_log[start:end] <- predict_i
    y_log[start:end] <- val_i$y
    start <- end + 1
    end <- start + segment_portion - 1
}

val_df <- tibble(predict=predict_log,y=y_log) |>
  mutate(formula=deparse(formula))
cv_log <- cv_log |>
  bind_rows(val_df)
}

## y ~ x
## y ~ I(x^2)
## y ~ I(x^2) + w + w:x
## y ~ I(x^3) + w + w:x
## y ~ w:x
## y ~ w
## y ~ x + w + x:w
## y ~ I(x^2) + w:x
## y ~ I(x^2) + w

Alright, what we’ve done above is a manual implementation of K-Fold Cross-Validation. We loop through each formula in our list, and for each formula, we split the training data into 5 folds. For each fold, we train the model on the other 4 folds and validate it on the current fold. We store the predictions and actual values for later evaluation.

We basically want to see which formula has the lowest RMSE across the folds. Let’s calculate that next. From the DGP formula, we know that the best model should be y~I(x^2)+w+w:x. Let’s see if we can recover that using K-Fold CV.

Assessing RMSE

cv_log |>
  group_by(formula) |>
  summarize(rmse = sqrt(mean((y-predict)^2))) |>
  arrange(rmse) |>
  mutate(rmse = format(rmse, digits = 8))

## # A tibble: 9 × 2
##   formula              rmse     
##   <chr>                <chr>    
## 1 y ~ I(x^2) + w + w:x 1.0397338
## 2 y ~ I(x^2) + w       1.1008693
## 3 y ~ I(x^2) + w:x     1.1607225
## 4 y ~ I(x^2)           1.2144857
## 5 y ~ x + w + x:w      1.2826723
## 6 y ~ I(x^3) + w + w:x 1.2912046
## 7 y ~ w                1.3578304
## 8 y ~ w:x              1.3732478
## 9 y ~ x                1.4451807

Here our loss function is RMSE since y is a continuous data and we’re trying to predict that. The formula with the lowest RMSE is indeed y~I(x^2)+w+w:x, which matches the underlying data-generating process. OK at least, right now we are able to recover the underlying DGP using 5-Fold Cross-Validation. But is there a difference between 5 fold, 10 fold, or even LOOCV? If there is a difference, how do we even assess that? In the past we were able to assess bias and variance based on a true ATE, but what on earth is a true RMSE !?!

To check whether the textbook claim (bias LOOCV < 10-fold < 5-fold; variance LOOCV > 10-fold > 5-fold) holds up, we ran a small simulation with help from Claude Sonnet 5. Since we control the data-generating process, we can compare the “correct formula” (assuming the correct formula has the lowest RMSE as above) with 500 different simulated dataset against a “true” RMSE estimated from a large test set (n=10000) — large enough, by the law of large numbers, to treat as ground truth. Averaging across simulations gives bias (how far off CV runs from the true error) and variance (how much CV’s estimate swings from sample to sample) for each method. Is this legit? 🤔 If the textbook claim is correct, we should be able to observe bias LOOCV < 10-fold < 5-fold; variance LOOCV > 10-fold > 5-fold. Let’s see if we can observe that in the simulation below.

Compare Candidate Models

# set.seed(1)

# k-fold CV RMSE for a given formula and dataset (k = n gives LOOCV)
cv_rmse <- function(data, formula, k) {
  n <- nrow(data)
  folds <- sample(rep(1:k, length.out = n))
  preds <- numeric(n)
  for (i in 1:k) {
    train_i <- data[folds != i, ]
    val_i   <- data[folds == i, ]
    model_i <- lm(formula, train_i)
    preds[folds == i] <- predict(model_i, val_i)
  }
  sqrt(mean((data$y - preds)^2))
}

# "true" RMSE: fit on train, evaluate on a large fresh draw from the DGP
true_rmse <- function(train, formula, n_test = 10000) {
  x <- rnorm(n_test); w <- rnorm(n_test)
  y <- 0.5*x^2 - 0.5*w + 0.3*w*x + rnorm(n_test)
  test <- tibble(x, y, w)
  model <- lm(formula, train)
  sqrt(mean((test$y - predict(model, test))^2))
}

formula_true <- as.formula("y ~ I(x^2) + w + w:x")
n_sim   <- 500
n_train <- 100

results <- vector("list", n_sim)

for (s in 1:n_sim) {
  x <- rnorm(n_train); w <- rnorm(n_train)
  y <- 0.5*x^2 - 0.5*w + 0.3*w*x + rnorm(n_train)
  train_s <- tibble(x, y, w)

  results[[s]] <- tibble(
    sim      = s,
    true_err = true_rmse(train_s, formula_true),
    loocv    = cv_rmse(train_s, formula_true, k = n_train),
    cv5      = cv_rmse(train_s, formula_true, k = 5),
    cv10     = cv_rmse(train_s, formula_true, k = 10)
  )
}

sim_df <- bind_rows(results)

sim_long <- sim_df |>
  pivot_longer(cols = c(loocv, cv5, cv10), names_to = "method", values_to = "cv_estimate")

sim_long |>
  group_by(method) |>
  summarize(
    mean_cv_estimate = mean(cv_estimate),
    mean_true_error   = mean(true_err),
    bias     = mean(cv_estimate - true_err),
    variance = var(cv_estimate),
    .groups  = "drop"
  ) |>
  arrange(bias) |>
  mutate(variance = format(variance, digit = 8))

## # A tibble: 3 × 5
##   method mean_cv_estimate mean_true_error     bias variance     
##   <chr>             <dbl>           <dbl>    <dbl> <chr>        
## 1 loocv              1.00            1.00 0.000703 0.00053227867
## 2 cv10               1.00            1.00 0.000945 0.00053192050
## 3 cv5                1.00            1.00 0.00124  0.00053176441

Wow, looking at the results, we can see that the textbook claim holds up. LOOCV has the lowest bias, but the highest variance. 10-fold CV is in between, and 5-fold CV has the highest bias but lowest variance. But, noticed that we had to increase our digit to 8 to see the difference in variance, it’s really miniscule. Mainly because our n=1000 is already quite large, so the variance is already quite small. If we reduce n to 100, how would that look?

## # A tibble: 3 × 5
##   method mean_cv_estimate mean_true_error     bias variance    
##   <chr>             <dbl>           <dbl>    <dbl> <chr>       
## 1 loocv              1.02            1.02 -0.00400 0.0063905148
## 2 cv10               1.02            1.02 -0.00138 0.0065753049
## 3 cv5                1.03            1.02  0.00244 0.0068098389

!?!?!?!?! 🤷‍♂️ with n=100, the bias and variance order heuristics no longer hold up? Why is this? I don’t know. If you do, please let me know. I even increased the n_sim to 1000, but still same patern. Intersting how I had to push the n up to 850 in order to observe the textbook variance order again, though again it’s quite miniscule.

Verify On Test Set

test |>
  mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test)) |>
  mutate(residual = y-predict) |>
  mutate(res_square = residual^2) |>
  pull(res_square) |>
  mean() |>
  sqrt()

## [1] 1.018281

Alright! The RMSE on test set is quite similar to our average validation sets! 🙌 Let’s visualize the predicted and actual y of the model on test set.

test |>
  mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test)) |>
  ggplot(aes(x=predict, y=y)) +
  geom_point(alpha=0.5) +
  theme_bw() +
  geom_smooth(method = "lm") +
  labs(title="Predicted vs Actual y on Test Set", x="Predicted y", y="Actual y")

summary(lm(y ~ predict, data=test |> mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test))))

## 
## Call:
## lm(formula = y ~ predict, data = mutate(test, predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), 
##     train), test)))
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -2.98185 -0.61410 -0.05514  0.62883  2.28837 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  0.08581    0.08390   1.023    0.308    
## predict      0.80885    0.07562  10.696   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 1.007 on 198 degrees of freedom
## Multiple R-squared:  0.3662,	Adjusted R-squared:  0.363 
## F-statistic: 114.4 on 1 and 198 DF,  p-value: < 2.2e-16

Slope here is 0.81, not 1 — even with the correct formula, coefficients are still estimated from a finite, noisy sample, so predict is really “true signal + estimation error.” Regressing y on a noisy version of itself pulls the slope below 1 — a known effect called attenuation (same idea as errors-in-variables bias). More training data shrinks that estimation error, so the slope should creep closer to 1. Intercept stays near 0 because the estimation error isn’t systematically biased in one direction — just noisy — so predictions still center correctly on average. If this is true, then if we increase our n to 10000, we should see slope is closer to 1 and intercept closer to 0. Let’s test this theory out.

set.seed(1)
n <- 10000
x <- rnorm(n)
w <- rnorm(n)
y <- 0.5*x^2 + -0.5*w + 0.3*w*x + rnorm(n)
df <- tibble(x,y,w)
idx <- sample(1:n, size=0.8*n)
train <- df[idx, ]
test <- df[-idx, ]
formula <- as.formula("y ~ I(x^2) + w + w:x")
folds <- 10
segment_portion <- nrow(train)/folds
predict_log <- y_log <- vector(mode="numeric",length=segment_portion*folds)
start <- 1
end <- segment_portion 

for (fold in 1:folds) {
    val_i <- train[start:end,]
    train_i <- train[-c(start:end),]
    model_i <- lm(formula,train_i)
    predict_i <- predict(model_i, val_i)
    predict_log[start:end] <- predict_i
    y_log[start:end] <- val_i$y
    start <- end + 1
    end <- start + segment_portion - 1
}

val_df <- tibble(predict=predict_log,y=y_log) 

val_df |>
  summarize(rmse = sqrt(mean((y-predict)^2))) |>
  arrange(rmse) |>
  mutate(rmse = format(rmse, digits = 8))

## # A tibble: 1 × 1
##   rmse     
##   <chr>    
## 1 1.0126176

test |>
  mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test)) |>
  mutate(residual = y-predict) |>
  mutate(res_square = residual^2) |>
  pull(res_square) |>
  mean() |>
  sqrt()

## [1] 0.9884315

test |>
  mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test)) |>
  ggplot(aes(x=predict, y=y)) +
  geom_point(alpha=0.5) +
  theme_bw() +
  geom_smooth(method = "lm") +
  labs(title="Predicted vs Actual y on Test Set", x="Predicted y", y="Actual y")

summary(lm(y ~ predict, data=test |> mutate(predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), train), test))))

## 
## Call:
## lm(formula = y ~ predict, data = mutate(test, predict = predict(lm(as.formula("y ~ I(x^2) + w + w:x"), 
##     train), test)))
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -3.08711 -0.67088  0.01239  0.69015  2.86620 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  0.02778    0.02527   1.099    0.272    
## predict      0.96577    0.02369  40.762   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 0.9884 on 1998 degrees of freedom
## Multiple R-squared:  0.454,	Adjusted R-squared:  0.4538 
## F-statistic:  1662 on 1 and 1998 DF,  p-value: < 2.2e-16

There you have it! The RMSE on test set is quite similar to our average validation sets! 🙌 The slope is now 0.97, much closer to 1, and the intercept is 0.02, much closer to 0. This confirms our theory that with more training data, the estimation error decreases, leading to better predictions.

Opportunities For Improvement

apply crossvalidation from scratch on hyperparameter tuning such as xgboost hyperparam, lasso/ridge/elasticnet/glmnet
learn about nested resampling that uses an additional layer of resampling that separates the tuning activities from the process used to estimate the efficacy of the model. see here
learn to code grouped and stratified cv from scratch
learn a bit more on time-series CV
need to try n_sim of 10000 and see if the bias and variance order holds up for n=100, since the simulation is quite slow, I didn’t run it to completion. Update: I did complete an n_sim of 10000 of n=100 and LOOCV still had the lowest variance.

Lessons learnt

Learnt that we have to use I to indicate that we want to include polynomial terms in the formula, otherwise R will interpret them as interaction terms.
Learnt deparse is useful to convert a formula object into a character string for logging purposes.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning Amino Acids Part 1: Non-Polar Amino Acids, Rodrigues Rotation, and Lennard-Jones Potential

Sun, 07 Jun 2026 00:00:00 +0000

🧬 Back to basics! Learning non-polar amino acids, what zwitterions actually are, and dipping into the applied math — Rodrigues rotation and Lennard-Jones potential. Slowly building toward optimal phi/psi!

Motivations

We’ve explored quite a bit lately in molecular dynamic simulation and then protein-protein docking as well the last time. There is still so much to learn. I’ve decided to go back to basics, revisiting our old friends amino acids and try to understand the natural properties behind each one and see if that will make more sense in the future when we’re exploring more. While making notes for myself of all the amino acids, I’ll also try to understand some of the basic math behind the structures. Are you ready !? Lol, I’m not, but let’s go anyway! 🤣

Objectives:

Amino Acids

Amino acids are the building blocks of proteins, each sharing a common backbone: a central α-carbon bonded to an amino group (–NH₂), a carboxyl group (–COOH), a hydrogen atom, and a variable side chain (R group) that defines each amino acid’s identity and chemistry.

Non-polar amino acids

Non-polar amino acids have hydrophobic side chains — they avoid water and tend to cluster in the interior of folded proteins, forming the hydrophobic core that drives protein stability. Understanding each one’s shape and bulk is directly relevant to how they pack, how they constrain backbone flexibility, and how substitutions affect enzyme active sites.

library(tibble)
library(kableExtra)

aa_nonpolar <- tribble(
  ~aa,  ~aa3,  ~name,           ~functional_group,  ~smiles_sidechain,    ~charge_ph7, ~mw_da, ~pka,     ~md_note,                                                                                ~main_function,
  "G",  "Gly", "Glycine",       "H (none)",         "[H]",                "Neutral",   75.03,  NA_real_, "Minimal VDW radius; unrestricted phi/psi; near-zero excluded volume",                  "Conformational flexibility; tight turns; active site geometry",
  "A",  "Ala", "Alanine",       "Methyl",           "C",                  "Neutral",   89.09,  NA_real_, "Low steric perturbation; high alpha-helix propensity in force fields",                 "Helix former; hydrophobic core; alanine-scanning mutagenesis",
  "V",  "Val", "Valine",        "Isopropyl",        "CC(C)",              "Neutral",   117.15, NA_real_, "Beta-branching restricts psi; favors extended beta-sheet; large gamma-carbons",        "Beta-sheet core; hydrophobic packing; sickle-cell HbS Glu6Val",
  "L",  "Leu", "Leucine",       "Isobutyl",         "CCC(C)C",            "Neutral",   131.17, NA_real_, "Flexible chi2; common rotamers at -65/-65 and -65/175; high hydrophobic SASA",         "Hydrophobic core; leucine zippers; most abundant non-polar in proteomes",
  "I",  "Ile", "Isoleucine",    "sec-Butyl",        "CCC(C)",             "Neutral",   131.17, NA_real_, "Beta-branching + gamma-branch; most restricted chi1/chi2; large buried SASA",          "Hydrophobic core; beta-barrel interiors; transmembrane helices",
  "P",  "Pro", "Proline",       "Pyrrolidine ring", "C1CCNC1",             "Neutral",   115.13, NA_real_, "Fixed phi ~-60; no backbone NH donor; cis/trans isomerism at Xaa-Pro bond",            "Helix breaker; beta-turns; collagen Gly-Pro-X repeats",
  "F",  "Phe", "Phenylalanine", "Benzyl",           "Cc1ccccc1",          "Neutral",   165.19, NA_real_, "Rigid aromatic ring; pi-pi stacking and cation-pi in MD energy decomposition",         "Hydrophobic core; aromatic clusters; ligand binding pockets",
  "W",  "Trp", "Tryptophan",    "Indolylmethyl",    "Cc1c[nH]c2ccccc12", "Neutral",   204.23, NA_real_, "Indole NH can H-bond; amphipathic at membrane interface; strong 280nm absorbance",     "Membrane anchoring; fluorescence probe; ligand binding; rarest standard AA",
  "M",  "Met", "Methionine",    "Thioether",        "CCSC",               "Neutral",   149.20, NA_real_, "Flexible sulfur geometry; oxidizable to sulfoxide in long MD runs; check reactive FF", "Translation initiation; hydrophobic core; redox sensing"
)

aa_nonpolar |>
  dplyr::select(aa:mw_da) |>
  kbl()

aa	aa3	name	functional_group	smiles_sidechain	charge_ph7	mw_da
G	Gly	Glycine	H (none)	[H]	Neutral	75.03
A	Ala	Alanine	Methyl	C	Neutral	89.09
V	Val	Valine	Isopropyl	CC(C)	Neutral	117.15
L	Leu	Leucine	Isobutyl	CCC(C)C	Neutral	131.17
I	Ile	Isoleucine	sec-Butyl	CCC(C)	Neutral	131.17
P	Pro	Proline	Pyrrolidine ring	C1CCNC1	Neutral	115.13
F	Phe	Phenylalanine	Benzyl	Cc1ccccc1	Neutral	165.19
W	Trp	Tryptophan	Indolylmethyl	Cc1c[nH]c2ccccc12	Neutral	204.23
M	Met	Methionine	Thioether	CCSC	Neutral	149.20

aa_nonpolar |>
  dplyr::select(aa,aa3,md_note,main_function) |>
  kbl()

aa	aa3	md_note	main_function
G	Gly	Minimal VDW radius; unrestricted phi/psi; near-zero excluded volume	Conformational flexibility; tight turns; active site geometry
A	Ala	Low steric perturbation; high alpha-helix propensity in force fields	Helix former; hydrophobic core; alanine-scanning mutagenesis
V	Val	Beta-branching restricts psi; favors extended beta-sheet; large gamma-carbons	Beta-sheet core; hydrophobic packing; sickle-cell HbS Glu6Val
L	Leu	Flexible chi2; common rotamers at -65/-65 and -65/175; high hydrophobic SASA	Hydrophobic core; leucine zippers; most abundant non-polar in proteomes
I	Ile	Beta-branching + gamma-branch; most restricted chi1/chi2; large buried SASA	Hydrophobic core; beta-barrel interiors; transmembrane helices
P	Pro	Fixed phi ~-60; no backbone NH donor; cis/trans isomerism at Xaa-Pro bond	Helix breaker; beta-turns; collagen Gly-Pro-X repeats
F	Phe	Rigid aromatic ring; pi-pi stacking and cation-pi in MD energy decomposition	Hydrophobic core; aromatic clusters; ligand binding pockets
W	Trp	Indole NH can H-bond; amphipathic at membrane interface; strong 280nm absorbance	Membrane anchoring; fluorescence probe; ligand binding; rarest standard AA
M	Met	Flexible sulfur geometry; oxidizable to sulfoxide in long MD runs; check reactive FF	Translation initiation; hydrophobic core; redox sensing

Claude generated most of the above information. We’ll add onto the md_note section as we encounter certain things during our MD sims.

What’s Zwitterion?

A zwitterion is a molecule that has both positive and negative charges but is overall electrically neutral. In amino acids, the amino group (–NH₂) can accept a proton to become positively charged (–NH₃⁺), while the carboxyl group (–COOH) can lose a proton to become negatively charged (–COO⁻). At physiological pH (~7.4), most amino acids exist as zwitterions, with the amino group protonated and the carboxyl group deprotonated. This dual charge allows amino acids to interact with both polar and non-polar environments, contributing to their solubility in water and their ability to form various interactions in proteins.

What Does Non-polar Actually Mean?

It is worth clarifying what “non-polar” actually refers exclusively to the side chain (R group) — specifically that it consists largely of carbon and hydrogen bonds with no net dipole and no ionizable groups, making it hydrophobic and largely indifferent to water. It says nothing about the backbone, which is the same for all amino acids and always carries polar bonds (C=O, N–H). In fact, as mentioned above, all amino acids including non-polar ones exist as zwitterions at physiological pH — a property that comes entirely from the backbone, not the side chain.

Note to self: All amino acids’ backbones are zwitterions; the R-side chain determines polarity and hydrophobicity. Also, net charge neutral == overall charges equals zero, does not mean the molecule is non-polar.

Rodriguez Rotation Formula

Rodrigues’ rotation formula is a method for rotating a 3D vector in space around a specified axis by a given angle. The formula is expressed as:

$v_{rotation} = v.\cos(\theta) + \sin(\theta)(k \times v) + (1 - \cos(\theta))(k(k \cdot v))$

where v is the original vector, k is the unit vector along the axis of rotation, and θ is the angle of rotation in radians.

This formula apparently is very popular in computer graphics and robotics, but I can see how it can be useful in molecular dynamics as well when we want to rotate a molecule or a part of it around an axis. Especially when we want to estimate the least energy conformation of a molecule. The direction application of this formula in amino acid sequence would be in rearranging the atoms based on phi and psi which are the angles of rotations around the N-Cα and Cα-C bonds of the amino acid backbone, respectively. By applying Rodrigues’ rotation formula, we can calculate the new positions of the atoms in the amino acid after rotating them by the specified angles, allowing us to explore different conformations of the molecule. How I remember which angle is which is Nancy Phi (sounds like some detective show and also N->C) and C C Psi (All with S sound, also Carbon to carbon). We’ll leave the hand calculation until next time, but let’s learn how to rotate a coordinate based on an axis with Rodriguez!

Below I’ll write the code first, then explain. Please feel free to use your mouse to hover over the plotly object and check out the coordinates.

library(plotly)
library(pracma)

#### Let's start simple
x1 <- c(0,0,0)
x2 <- c(1,1,1)
x3 <- c(1,2,1)

rodrigues <- function(v, k, theta) {
  k <- k / sqrt(sum(k^2))
  cos(theta)*v + sin(theta)*pracma::cross(k, v) + (1 - cos(theta))*sum(k*v)*k
}

k <- x2 - x1
v <- x3 - x1

result <- rodrigues(v,k,pi/2) #notice this, pi/2 == 90 degrees

pts <- data.frame(
  x = c(x1[1],x2[1],x3[1]),
  y = c(x1[2],x2[2],x3[2]),
  z = c(x1[3],x2[3],x3[3]),
  label = c("x1","x2","x3")
)

pts_rs <- data.frame(
  x = c(x1[1],x2[1],result[1]),
  y = c(x1[2],x2[2],result[2]),
  z = c(x1[3],x2[3],result[3]),
  label = c("x1","x2","x3_new")
)

plot_ly() |>
  add_trace(data=pts, x=~x, y=~y, z=~z,
            type="scatter3d", mode="lines+markers+text",
            text=~label,
            marker=list(size=8, color="blue", opacity=0.5),
            line=list(width=4, color="blue", dash="solid")) |>
  add_trace(data=pts_rs, x=~x, y=~y, z=~z,
            type="scatter3d", mode="lines+markers+text",
            text=~label,
            marker=list(size=8, color="red", opacity=0.5),
            line=list(width=4, color="red", dash="dash"))

So with the above, we want to start off with 3 points, x1, x2, x3. they all represent their xyz coordinates.

Funny thing is, xyz coordinate here is different from what I learnt xyz as. I’ve always thought x is horizontal, y is vertical and z is depth. But in this case, x is depth, y is horizontal and z is vertical. I guess it depends on how you look at it.

Then we want to rotate x3 around the axis defined by x1 and x2 by 90 degrees (pi/2 radians). The rodrigues function takes in the vector v (which is the vector from x1 to x3), the axis k (which is the vector from x1 to x2), and the angle theta (which is pi/2). It returns the new coordinates of x3 after rotation.

Finally, we plot the original points and the rotated point using plotly. The original points are in blue, and the rotated point is in red. You can hover over the points to see their coordinates.

Now if we were to maneuver the 3d plot and align both x1 and x2 into a dot, we can clearly see that it moved 90 degrees anti-clockwise!

Now there is a pretty cool rule to know where the rotation should occur anti-clockwise vs clockwise is by using your hand !!! Remember this from high school?

It would be really cool to derive the above formula. There are a lot of videos that have done this. I’m still trying to conceptualize it, let’s leave that for another blog! It sounds interesting and may be a good exercise, especially when we’re venturing into 3d spaces.

Lennard-Jones Potential Energy

The Lennard-Jones potential energy formula is a mathematical model used to describe the interaction between a pair of neutral atoms or molecules. It is given by the equation:

$V(r) = 4\epsilon \left[ \left( \frac{\sigma}{r} \right)^{12} - \left( \frac{\sigma}{r} \right)^6 \right]$

Where:

$V(r)$ is the potential energy as a function of the distance $r$ between the two particles.
$\epsilon$ is the depth of the potential well, representing the strength of the attractive interaction.
$\sigma$ is the finite distance at which the inter-particle potential is zero, representing the effective diameter of the particles.
The term $\left( \frac{\sigma}{r} \right)^{12}$ represents the repulsive part of the potential, which dominates at short distances due to the Pauli exclusion principle.
The term $\left( \frac{\sigma}{r} \right)^6$ represents the attractive part of the potential, which dominates at longer distances due to van der Waals forces.

The Lennard-Jones potential is widely used in molecular dynamics simulations to model the interactions between non-bonded atoms or molecules, particularly in the context of van der Waals forces. It helps to predict the behavior of particles in a system, such as their equilibrium positions and the energy landscape of molecular interactions.

Wow there are a bunch of terms and word above! I’m getting dizzy just to keep track of what is what. Let’s push through this. To use the above formula, we’d have to have some understanding of the parameters epsilon and sigma. These parameters are typically derived from experimental data or quantum mechanical calculations and are specific to the types of atoms or molecules involved in the interaction. Where to get these parameters? Here you go - openbabel:: gaff.dat

When you opened gaff.dat there are bunch of numbers! Let’s find the numbers that are meaningful for us. All the below are separated by new lines as you scroll down.

Bond Stretch

The column names should be: type mass(g/mol) polarizability(Å³) source

Bond Angle

The column names should be: types K r0 source count rmsd

Proper Dihedral

The column names should be: types div barrier phase periodicity

Non-bonded

The column names should be: type R*(Å) ε(kcal/mol)

We are purely interested in the non-bonded section where R* is our sigma = R* × 2 / 2^(1/6) and ε is our epsilon. With the above parameters, we can then calculate the Lennard-Jones potential energy between any two atoms in a molecule. Let’s do a simple calculation for ethanol.

Calculating LJ

library(tidyverse)
library(igraph)
# Coordinates (x, y, z) in Angstroms, according to pubchem ethanol molecule
coords <- rbind(
  O   = c( -1.1712,   0.2997,   0.0000),
  C2  = c( -0.0463,  -0.5665,   0.0000),
  C1  = c(  1.2175,   0.2668,   0.0000),
  H4  = c( -0.0958,  -1.2120,   0.8819),
  H5  = c( -0.0952,  -1.1938,  -0.8946),
  H1  = c(  2.1050,  -0.3720,  -0.0177),
  H2  = c(  1.2426,   0.9307,  -0.8704),
  H3  = c(  1.2616,   0.9052,   0.8886),
  H6  = c( -1.1291,   0.8364,   0.8099)
)

# AMBER GAFF parameters (sigma Å, epsilon kcal/mol)
Rstar_to_sigma <- function(Rstar) 2 * Rstar / 2^(1/6)

sigma <- c(
  C1=Rstar_to_sigma(1.9080), C2=Rstar_to_sigma(1.9080),
  O=Rstar_to_sigma(1.7210),
  H1=Rstar_to_sigma(1.4870), H2=Rstar_to_sigma(1.4870),
  H3=Rstar_to_sigma(1.4870), H4=Rstar_to_sigma(1.4870),
  H5=Rstar_to_sigma(1.4870), H6=0.0000
)

epsilon <- c(
  C1=0.1094, C2=0.1094, O=0.2104,
  H1=0.0157, H2=0.0157, H3=0.0157,
  H4=0.0157, H5=0.0157, H6=0.0000
)

# Bonds 
bonds <- tribble(
  ~from, ~to,
  "C1", "C2",
  "C2", "O",
  "O", "H6",
  "C1", "H1",
  "C1", "H2",
  "C1", "H3",
  "C2", "H4",
  "C2", "H5"
)

# count bonds between two atoms
g <- graph_from_data_frame(bonds, directed = FALSE)
g_dist <- distances(g)

# LJ function
lj <- function(r, eps, sig) 4 * eps * ((sig/r)^12 - (sig/r)^6)

# Loop all pairs
atoms <- rownames(coords)
pairs <- combn(atoms, 2, simplify=FALSE) # combn so we don't repeat
total_V <- vector(mode = "numeric", length = length(pairs)) 
 
for (i in 1:length(pairs)) {
  
  # each pair
  p <- pairs[[i]]
  from <- p[1]
  to <- p[2]
  num_bond <- g_dist[from, to]
  
  if (num_bond <= 2) next                   
  
  # params needed for LJ
  r   <- sqrt(sum((coords[from,] - coords[to,])^2))
  sig <- (sigma[from] + sigma[to]) / 2
  eps <- sqrt(epsilon[from] * epsilon[to])
  
  # scale if num bond is 3 (4 atoms)
  scale <- if (num_bond == 3) 0.5 else 1.0
  
  # LJ calc
  V <- scale * lj(r, eps, sig)

  cat(from, "-", to, " num of bonds=", num_bond, " r=", r, " V=", V, "\n")
  total_V[i] <- V
}

## O - H1  num of bonds= 3  r= 3.344395  V= -0.02733269 
## O - H2  num of bonds= 3  r= 2.642383  V= 0.110613 
## O - H3  num of bonds= 3  r= 2.659841  V= 0.09535471 
## C1 - H6  num of bonds= 3  r= 2.546942  V= 0 
## H4 - H1  num of bonds= 3  r= 2.521587  V= 0.01461147 
## H4 - H2  num of bonds= 3  r= 3.074579  V= -0.007593085 
## H4 - H3  num of bonds= 3  r= 2.514978  V= 0.01576022 
## H4 - H6  num of bonds= 3  r= 2.295394  V= 0 
## H5 - H1  num of bonds= 3  r= 2.507028  V= 0.01720963 
## H5 - H2  num of bonds= 3  r= 2.510736  V= 0.01652426 
## H5 - H3  num of bonds= 3  r= 3.070262  V= -0.007612401 
## H5 - H6  num of bonds= 3  r= 2.845344  V= 0 
## H1 - H6  num of bonds= 4  r= 3.550289  V= 0 
## H2 - H6  num of bonds= 4  r= 2.908137  V= 0 
## H3 - H6  num of bonds= 4  r= 2.392984  V= 0

cat("\nTotal V_LJ:", sum(total_V), "kcal/mol\n")

## 
## Total V_LJ: 0.2275351 kcal/mol

Alright, the above we basically were trying to calculate all pairwise atoms that is more than 3 bonds (if it’s exactly 3 bonds, we scale it by half). Alright, now that we know how to do that on simple molecular, next time we can use this to minimize on as we’re seeking optimal phi and psi!

Opportunities For Improvement

Derive Rodriguez Rotation formula
put both Rodriguez rotation formula and LJ calculation into action to find the optimal phi and psi of amino acid sequence of a protein!
need to include secondary/tertiary structure interactions too

Lessons learnt

refreshed on rotation and vectors
learnt rodriguez rotation formula
learnt LJ formula
learnt what gaff.dat actually contains.
learnt about phi and psi and what they actually mean.
learnt about net charge == total charge; polar vs non-polar is R-chain dependent.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Exploring the CovR/S Two-Component System in Streptococcus pyogenes

Sat, 16 May 2026 00:00:00 +0000

Exploring the CovR/S two-component system in Group A Strep 🧫 — from genome annotation with Bakta & BaktFold, to AlphaFold confidence metrics, and a first attempt at protein docking with Haddock3. Learning as we go! 🙌

Motivations

Since the last ampC adventure, I’m really curious about the mechanism of some of these bacterial virulence. Remember how chromosomal ampC organisms use ampG, ampD, and then ampR to repress class C beta lactamase gene? It’s such an orchestrated endeavor. What about streptococcus pyogenes and its virulence? How can it be a colonizer on one end and then virulence on the other that caused a number of devastating infection? Let’s learn a bit of the mechanism, and of course why not use this opportunity too to learn some other bioinformatic tools along the way? And see if we can use existing knowledge to make it more fun and educational! I’m looking forward to this! Join me in exploring the mechanism of the CovR/S two-component system in streptococcus pyogenes, aka Group A strep!

Objectives:

What is CovR/S Two-component System?

The CovR/S (Control of Virulence) system functions as a sophisticated environmental sensor that integrates multiple host-derived signals to orchestrate the transition from colonization to invasive disease. The evidence reveals three primary environmental triggers that modulate this master regulatory system. Simplistically, CovS (Sensor) senses first -> gets activated -> trigger CovR (Regulator) -> downstream repression. Breakage of such system will de-repress the virulence factors.

Magnesium Levels: The Baseline Sensor High extracellular magnesium concentrations (typical of healthy tissue) activate CovS kinase activity, leading to increased CovR phosphorylation and repression of virulence genes. This creates a colonization-friendly state where GAS maintains low virulence factor expression suitable for asymptomatic carriage.
LL-37 Antimicrobial Peptide: The Invasion Signal LL-37 cathelicidin peptide — released by neutrophils and epithelial cells during inflammation — directly binds to the extracellular domain of CovS and inhibits its kinase activity. This creates a paradoxical host-pathogen interaction where the host’s antimicrobial defense actually triggers bacterial virulence. LL-37 binding to CovS reduces CovR phosphorylation, leading to derepression of multiple virulence factors including pyrogenic exotoxin A, DNase Sda1, streptolysin O, and hyaluronic acid capsule. Critically, LL-37 signaling converts GAS from a colonizing to an invasive phenotype, with marked increases in resistance to opsonophagocytic killing by human leukocytes.
Acidic Stress: The Tissue Environment Sensor Acidic conditions (pH < 7.0, typical of infected or inflamed tissue) enhance CovR/S-dependent gene repression through activation of the covR/S promoter itself. This creates a negative feedback loop where tissue acidosis increases CovR/S expression, which then more strongly represses virulence factors.

Below is an image referenced directly from source that depicts the mechanism of CovR/S system in streptococcus pyogenes.

Let’s Look A Where Does It Show in NCBI

Let’s go to here. I picked out streptococcus pyogenes reference genome annotation and search for cov and this popped up.

There you go! CovS and CovR. Sometimes these system can also be known as CsrR/CsrS (Capsule Synthesis Regulator). There may have been 2 different research groups discovered these identical gene and called it differently?

It’s also so interesting that these 2 genes are so close to each other. 🤔

What If We Have WGS? How to Annotate?

Alright, let’s pick a random streptococcus pyogenes and see if we can use bakta to help us annotate. Let’s look at this one.

Install Bakta, see here

#make sure you use the environment name you created
conda activate bakta_env 

bakta \
  --db /path/to/bakta_db \
  --output rabdom_bakta_output \
  --prefix random \
  --threads 8 \
  --skip-crispr \
  --force \
  random.fna

After it is done, when you look in the folder, you will see something like this

When we look at the annotated gff3 file, we can see that there are 2 features annotated as two-component system response regulator and two-component system sensor histidine kinase. These are likely to be CovR and CovS.

library(ape)
library(tidyverse)

readLines("random.gff3") |> str_detect("FASTA") |> which() #found fasta, apparently bakta has ###FASTA inserted and ape cannot handle

## [1] 2025

tmp <- tempfile()
readLines("random.gff3")[1:2024] |> writeLines(tmp)
gff <- read.gff(tmp, GFF3 = T)
gff |>
  filter(str_detect(attributes, "[Cc][Oo][Vv]"))

##        seqid    source type  start    end score strand phase
## 331 contig_1 Pyrodigal  CDS 303144 303830    NA      +     0
## 332 contig_1 Pyrodigal  CDS 303836 305338    NA      +     0
##                                                                                                                                                                                                                             attributes
## 331           ID=EEBJGP_00327;Name=two-component system response regulator CovR;locus_tag=EEBJGP_00327;product=two-component system response regulator CovR;Dbxref=BlastRules:WP_002991052,SO:0001217,UniRef:UniRef50_Q49XM7;gene=covR
## 332 ID=EEBJGP_00328;Name=two-component system sensor histidine kinase CovS;locus_tag=EEBJGP_00328;product=two-component system sensor histidine kinase CovS;Dbxref=BlastRules:WP_002991036,SO:0001217,UniRef:UniRef50_D3KVE8;gene=covS

There you go! We found them after annotation. Wait a minute… what are those hypotheticals on our folder? Why are they there? Are they important? Let’s find out.

What Are Hypothetical?

Hypotheticals are those proteins that we don’t know what they do. They are annotated as “hypothetical protein” because they are predicted to be proteins based on the DNA sequence, but we have no experimental evidence of their function. They are often annotated as “hypothetical” because they have no known homologs in other organisms, or because they have no known domains or motifs that can be used to predict their function.

When we take a peek at the random.hypotheticals.tsv, it looks like this:

Let’s check how many hypotheticals we have here for this genome

tmp <- tempfile()
readLines("random.hypotheticals.tsv")[3:194] |> writeLines(tmp)
hypo <- read_tsv(tmp)
nrow(hypo)

## [1] 191

OK we have 191 of hypotheticals. Let’s see if a new tool on the block will be able to add some annotation to these hypotheticals and see if we can find anything interesting. We could also use filter and see if we can see those hypotheticals

gff |>
  filter(str_detect(attributes,"hypothetical protein")) |>
  nrow()

## [1] 192

Hmm.. they don’t tally. But let’s move on.

A New Tool Called BaktFold

BaktFold is a new tool that uses AlphaFold to predict the structure of proteins and then uses that structure to predict the function of the protein. It is a very powerful tool that can be used to annotate hypothetical proteins. Check out their paper

baktfold run \
  -i random.json \
  -o random_baktfold_output \
  -d /path/to/baktfold_db \
  -t 8 \
  -f

readLines("baktfold.gff3") |> str_detect("FASTA") |> which() #found fasta, apparently bakta has ###FASTA inserted and ape cannot handle

## [1] 2025

tmp <- tempfile()
readLines("baktfold.gff3")[1:2024] |> writeLines(tmp)
gff_baktfold <- read.gff(tmp, GFF3 = T)
gff_baktfold |>
  filter(str_detect(attributes,"hypothetical protein")) |>
  nrow()

## [1] 106

Wow, this is really cool! We can see that we have much less hypotheticals! About 86 less! Let’s take a look what were previous hypotheticals and what they are annotated now and how?

gff_hypo <- gff |>
  filter(str_detect(attributes,"hypothetical protein")) |>
  pull(start)

new_df <- tibble(start = gff_hypo, temp = NA)

gff_baktfold_hypo <- gff_baktfold |>
  right_join(new_df) |>
  mutate(temp = case_when(
    !str_detect(attributes,"hypothetical protein") ~ attributes,
    TRUE ~ temp
  ))

## Joining with `by = join_by(start)`

Take a look at the image above, if you see temp column with NA, that would be hypotheticals from bakta. If you see it filled, it means baktfold was able to identify it across one or more databases. It’s interesting how baktfold work, it conducts sequential protein structure-based searches against four complementary structure databases (SwissProt, Alphafold Cluster Database, PDB, CATH). Protein sequences are transformed into Foldseek 3Di tokens via the ProstT5 protein language model and subsequently searched against structure databases via Foldseek. Pretty cool! Also, interestingly, when comparing a few of the baktfold predicted functional proteins with NCBI’s annotation, we sometimes do see some baktfold-annotated functions whereas NCBI labeled them as uncharacterized gene. This is not an exhaustive or thorough comparison by any means, but interesting to note.

Speaking of AlphaFold, we’ve always wanted to know a bit more about AlphaFold confidence. When we look at the predicted structure of a protein, how do we know if we can trust it? What is an acceptable AlphaFold confidence? Let’s learn a bit more.

What Is An Acceptable AlphaFold Confidence?

**These are edited responses from back-and-forth Claude Sonnet 4.6 query, **

AlphaFold reports per-residue confidence as per-residue confidence as pLDDT (predicted local distance difference test), scored 0–100:

pLDDT	Interpretation
> 90	High confidence — trust side-chain positions
70–90	Good — backbone reliable, some side-chain uncertainty
50–70	Low — treat as a rough scaffold only
< 50	Likely disordered or misfolded prediction

It tells you how well-placed AlphaFold thinks each amino acid is relative to nearby residues. Crucially, it is not a measure of experimental validation — it is the model’s self-assessed confidence.

For docking, pLDDT is essentially a proxy for how much you can trust the binding pocket geometry. Active site residues need pLDDT ≥ 90 ideally, with ≥ 70 as a minimum. Second-shell residues within ~8 Å should also clear 70, and any low-confidence loops capping the binding site entrance are a red flag even if the catalytic residues themselves look fine. Meaning, might be a good idea to visualize with B factor in ChimeraX to ensure the binding sites are acceptable.

For MD, it seems to be a bit more forgiving. Regions scoring 70–90 will generally equilibrate fine — the force field redistributes strain and lets uncertain side chains settle. Regions in the 50–70 band need longer equilibration (100+ ns) and staged restraint release to avoid unphysical collapse (interesting area to explore). Below 50, MD often can’t rescue the geometry — these regions should either be truncated if non-essential, cross-checked against other databases, or explored with enhanced sampling methods. 🤔 OK what about PAE on their website?

PAE (predicted aligned error) is the second major confidence metric AlphaFold produces, and it tells you something fundamentally different from pLDDT. Where pLDDT is a per-residue score asking “how confident am I in this residue’s local geometry,” PAE is a pairwise score asking “how confident am I in the relative position and orientation of residue A with respect to residue B.” It’s an N×N matrix where every cell (i,j) contains the expected position error in Å for residue j when residue i is used as the alignment reference.

Why it matters? pLDDT can look great across an entire protein — every residue scores above 80 — but if the PAE between two domains is high, that confident-looking structure is misleading. The two domains are individually well-folded, but AlphaFold is telling you it has no idea how they pack against each other. For docking, check the PAE within the domain containing your binding site — you want a dark block there, confirming the domain’s internal geometry is reliable as a unit. For MD, high inter-domain PAE is a heads-up that you may need enhanced sampling to explore the conformational space between domains rather than assuming the AlphaFold pose is the dominant one.

Two metrics before trusting AlphaFold. pLDDT is local — want ≥ 70 at active site, ≥ 90 for catalytic residues. PAE is pairwise — dark green means confident relative positioning between any two residues. Single-chain: check diagonal at binding site. Multi-chain: off-diagonal blocks tell you if the predicted interface is real. Check both before docking or MD.

Do All Streptococcus Pyogenes Have CovR/S Two-component System?

Interestingly, after downloaded 2840 Streptococcus pyogenes refseq annotation feature (gff3), I found 99.96% (2839/2840) of these contain CovR/S genes. Why not 100%? Turns out to be this GCF_005472355.1 that doesn’t have CovR/S listed in the annotation. I used Bakta to annotate it, and still no luck. Then used Baktfold to further annotate, couldn’t find it either. Used tblastn to look for CovR/S protein, the best return was 42% identity. Wow, does this isolate really have absent gene for those 2? 🤔

Note: Expand below to see the utility of using –dehydrate and then rehydrate for downloading and annotating large number of genomes.

code in terminal

datasets download genome taxon "Streptococcus pyogenes" \
  --annotated \
  --assembly-source refseq \
  --include gff3 \
  --dehydrated \
  --filename strep_pyogenes_refseq_gff3.zip

datasets rehydrate --directory strep_pyogenes_refseq_gff3/ --max-workers 10

Do Other Streptococcus species Have CovR/S Two-component System?

We’ve seen what other streptococcus can do clinically, I wonder if they have similar system when compared to streptococcus pyogenes. Let’ download all reference gene of streptococcus genus and see if we can find it in their annotations.

code

#### Terminal

datasets download genome taxon "Streptococcus" \
  --reference \
  --include gff3 \
  --assembly-source RefSeq \
  --dehydrated \
  --filename strep_dehydrated.zip

unzip strep_dehydrated.zip

datasets rehydrate --directory strep_dehydrated

Downloaded the above gff3, then used claude code to find covS and covR in their annotation and output to a csv, since these are reference genes, it should be quite reliable.

R

df_cov <- read_csv("covr_covs_annotation.csv")

df_cov_single <- df_cov |>
  filter(covR_present == "yes" & covS_present == "no") |> 
  pull(organism) 

df_cov |> head(10)

## # A tibble: 10 × 8
##    accession  organism covR_present covS_present covR_gene_names covS_gene_names
##    <chr>      <chr>    <chr>        <chr>        <chr>           <chr>          
##  1 GCF_00002… Strepto… no           no           <NA>            <NA>           
##  2 GCF_00016… Strepto… no           no           <NA>            <NA>           
##  3 GCF_00018… Strepto… no           no           <NA>            <NA>           
##  4 GCF_00018… Strepto… no           no           <NA>            <NA>           
##  5 GCF_00018… Strepto… yes          no           covR            <NA>           
##  6 GCF_00018… Strepto… yes          no           covR            <NA>           
##  7 GCF_00022… Strepto… no           no           <NA>            <NA>           
##  8 GCF_00025… Strepto… no           no           <NA>            <NA>           
##  9 GCF_00037… Strepto… no           no           <NA>            <NA>           
## 10 GCF_00037… Strepto… no           no           <NA>            <NA>           
## # ℹ 2 more variables: covR_annotation <chr>, covS_annotation <chr>

Wow, amonng the streptococcus species (n=153) streptococcus pyogenes appears to be the ONLY species that contains both CovR/S two-component system?

Interestingly, there were 17 that have covR but not covS.

These are Streptococcus parauberis NCFD 2020, Streptococcus ictaluri 707-05, Streptococcus didelphis DSM 15616, Streptococcus castoreus DSM 17536, Streptococcus iniae, Streptococcus phocae, Streptococcus bovimastitidis, Streptococcus catagoni, Streptococcus equi subsp. zooepidemicus, Streptococcus dysgalactiae, Streptococcus halichoeri, Streptococcus penaeicida, Streptococcus hongkongensis, Streptococcus porcinus, Streptococcus uberis, Streptococcus canis, Streptococcus pseudoporcinus. How curious! 🧐

What Does CovR Look Like?

Let’s take a look at Alpha Fold Database. Looking at CovR active site, mutation of D53A showed no dimerization of CoVR, which means that is a phosphylation site. Dimerization means that another phosphorylated CovR molecule is binding to another phosphorylated CovR, which is the active form of CovR. Which then binds to the DNA and represses the virulence genes.

The above shows both the PAE, plDDT and the predicted structure. The PAE is pretty good, the plDDT is also pretty good, with most of the residues above 70. The predicted structure also looks pretty reasonable, with the active site D53 highlighted in red.

What would a Phosphorylated CovR Look like?

Apparently for a CovR with D53E mutation (so it mimics the phosphorylated state), the structure is quite different from the wild type. The D53E mutation causes a conformational change that allows CovR to dimerize and bind to DNA, even in the absence of phosphorylation. Let’s visualize a D53E CovR predicted by AF3.

We can see that the highlighted portion is glutamine which is E. I’m not sure if I can tell the difference between wild-type and D53E. Let’s plug it into R and see if we can see differences in RMSD

library(bio3d)

covr_wt <- read.pdb("AF-D3KVK6-F1-model_v6.pdb")
covr_d53e <- read.pdb("covr_d53e_chainA.pdb")
covr_wt_idx <- atom.select(covr_wt, "calpha")
covr_d53e_idx <- atom.select(covr_d53e, "calpha")
fit <- fit.xyz(fixed = covr_wt$xyz, 
               mobile = covr_d53e$xyz, 
               fixed.inds  = covr_wt_idx$xyz,
                mobile.inds = covr_d53e_idx$xyz)

n_res <- length(covr_wt_idx$atom)
n_res_seq <- seq(1,n_res*3,3)

rmsd_vec <- vector(mode = "numeric", length=length(covr_wt_idx$atom))

for (i in 1:n_res) {
  idx <- c(n_res_seq[i]:(n_res_seq[i]+2))
  rmsd_vec[i] <- rmsd(covr_wt$xyz[covr_wt_idx$xyz][idx], fit[covr_d53e_idx$xyz][idx])
}

df <- tibble(
  residue = covr_wt$atom$resno[covr_wt_idx$atom],
  aa = covr_wt$seqres,
  rms = rmsd_vec
)

df |>
  ggplot(aes(x=residue,y=rms)) +
  geom_line() +
  geom_label(aes(label=aa),size=2) +
  theme_bw()

Alright, what this tells us is that certain residues actually didn’t vary much, but if we start seeing higher rmsd such as residue 180s, those are really high rmsd. Later on after hoddock, we’ll see if we can correlate these high RMSD residues to residues in protein-protein complex that interacted.

Next we’ll take a look at using Haddock3 for the first time and we see what we get. Our assessment is to evaluate the haddock score and body surface area (BSA) to see if a dimerization of 2 of the same covr (D53 vs D53E) would be more favorable in comparison. Since we’ve never done this before, we had Claude Code set up for us. This is mainly for my notes purposes so in the future when I review back I can reference and modify accordingly. The steps are:

Prepare the input files: Duplicate the CovR pdb but change the chain to A and B.
Set up the haddock input files: Create a text file of active and passive residue, then use haddodck3-restratins to genereate tbl file. The text file will look something like this

we can create the actpass_A.txt file with the following content:

create actpass_A.txt

87 88 89 90 91 98 99 100 101 106 107 108 109 110 111 112 113 114 115 116 117 118 120 121
81 82 83 84 85 86 93 94 102 103 104 105 119 122 123 124 125 126

With the above of alpha4-beta5-alpha5 the first row are active residues - solve-exposed residues; the 2nd row is passive residues - surface-exposed neighbors surrounding the active patch. Then we use haddock-restraint

Generate tbl file

conda run --name haddock3 haddock3-restraints active_passive_to_ambig \
      actpass_A.txt actpass_A.txt \
      --segid-one A --segid-two B \
      > ambig_covr_dimer.tbl

This basically tells haddock3 that residue 87 in chain A should interact with residue 87, 88, etc. in chain B with a distance of 2.0 Å and a weight of 1.0. which looks something like this

assign (resi 87 and segid A)
  (
         (resi 87 and segid B)
          or
         (resi 88 and segid B)
          or
         ...
  ) 2.0 2.0 0.0

Create a covr_dimer_workflow.toml file to specify the parameters for the docking run.

Create covr_dimer_workflow.toml

  run_dir = "run_covr_dimer"
  mode = "local"
  ncores = 4
  postprocess = true

  molecules = [
      "covr_d53e_chainA.pdb",
      "covr_d53e_chainB.pdb",
  ]

  [topoaa]
  autotoppar = false
  delenph = true

  [rigidbody]
  ambig_fname = "ambig_covr_dimer.tbl"
  sampling = 200
  sym_on = true
  nc2sym = 1
  c2sym_sta1_1 = 1
  c2sym_end1_1 = 228
  c2sym_seg1_1 = "A"
  c2sym_sta2_1 = 1
  c2sym_end2_1 = 228
  c2sym_seg2_1 = "B"

  [seletop]
  select = 100
  
  [flexref]
  ambig_fname = "ambig_covr_dimer.tbl"
  sym_on = true
  nc2sym = 1
  c2sym_sta1_1 = 1
  c2sym_end1_1 = 228
  c2sym_seg1_1 = "A"
  c2sym_sta2_1 = 1
  c2sym_end2_1 = 228
  c2sym_seg2_1 = "B"

  [emref]
  ambig_fname = "ambig_covr_dimer.tbl"
  sym_on = true
  nc2sym = 1
  c2sym_sta1_1 = 1
  c2sym_end1_1 = 228
  c2sym_seg1_1 = "A"
  c2sym_sta2_1 = 1
  c2sym_end2_1 = 228
  c2sym_seg2_1 = "B"

  [clustfcc]
  plot_matrix = true

  [seletopclusts]
  top_models = 4

  [emscoring]

The above you would have to change some of the settings and param including your tbl, pdb files. And change your ncore accordingly

Run Haddock: Use the command line to run Haddock with your input files. For example:

conda install - c bioconda -n haddock3 haddock3
conda activate haddock3
haddock3 -i it1.pdb -r it1.tbl -o haddock_output

What does Haddock3 do? Haddock3 is a flexible docking software that allows you to model the interaction between two or more biomolecules (like proteins) based on experimental data or predicted interactions. It uses a combination of rigid-body docking, semi-flexible refinement, and scoring to predict the most likely binding modes between the molecules. The workflow of Haddock3 goes like this rigid pose -> flexible refinement -> scoring -> clustering.

Look at the analysis results

result_d53 <- read_tsv("capri_ss_d53.tsv") |> arrange(caprieval_rank) |> mutate(prot="d53") |> slice_head(n=5)
result_d53e <- read_tsv("capri_ss_d53e.tsv") |> arrange(caprieval_rank) |> mutate(prot="d53e") |> slice_head(n=5)
compare_result <- rbind(result_d53,result_d53e) |>
  select(score,bsa,total,prot) |>
  pivot_longer(cols = c(score:total), names_to = "param", values_to = "values") 

compare_result |>
  ggplot(aes(x=prot,y=values,fill=prot)) +
  geom_boxplot(alpha=0.2,width=0.3) +
  geom_violin(alpha=0.5) +
  facet_wrap(.~param, scale="free_y") +
  theme_bw()

Among the top 5 ranked docking models, the phosphomimetic D53E mutant demonstrated consistently superior HADDOCK3 scores (median −138.1 vs −117.4 kcal/mol) and substantially larger buried surface area (median 2,567 vs 2,161 Ų, +18.8%), supporting enhanced dimerization propensity. Energy decomposition revealed that D53E gains its advantage primarily through van der Waals interactions (median −86.3 vs −32.7 kcal/mol, ~2.6×), despite weaker electrostatic contributions (median −335.7 vs −514.1 kcal/mol). Not really sure what this means. 🤔 But let’s visualize our rank 1 pdb!

Note to self: BSA is calculated by taking the sum of the solvent-accessible surface areas (SASA) of the two individual proteins and subtracting the SASA of the complex. A larger BSA indicates a more extensive interface between the two proteins, which often correlates with stronger binding affinity. In this case, the D53E mutant’s larger BSA suggests it forms a more stable dimer compared to the wild-type D53, consistent with its role as a phosphomimetic that promotes dimerization and activation of CovR.

Let’s see which residues of these 2 chains interact!

haddock_d53e_d53e <- read.pdb("emscoring_1.pdb")

chainA <- atom.select(haddock_d53e_d53e, chain = "A")
chainB <- atom.select(haddock_d53e_d53e, chain = "B")
dist_matrix <- dist.xyz(chainA$xyz, chainB$xyz)
  
get_interface <- function(pdb, cutoff = 5.0) {
  
  chainA <- atom.select(pdb, chain = "A")
  chainB <- atom.select(pdb, chain = "B")
  
  # Get coordinates as matrices
  coordA <- matrix(pdb$xyz[chainA$xyz], ncol = 3, byrow = TRUE)
  coordB <- matrix(pdb$xyz[chainB$xyz], ncol = 3, byrow = TRUE)
  
  # Find contacting atom indices
  contact_i <- c()
  contact_j <- c()
  
  for (i in 1:nrow(coordA)) {
    dists <- sqrt(rowSums(sweep(coordB, 2, coordA[i,])^2))
    hits <- which(dists < cutoff)
    if (length(hits) > 0) {
      contact_i <- c(contact_i, rep(i, length(hits)))
      contact_j <- c(contact_j, hits)
    }
  }
  
  # Map back to residues
  resA <- pdb$atom[chainA$atom[unique(contact_i)], ] |>
    as_tibble() |>
    distinct(resno, resid) |>
    mutate(chain = "A")
  
  resB <- pdb$atom[chainB$atom[unique(contact_j)], ] |>
    as_tibble() |>
    distinct(resno, resid) |>
    mutate(chain = "B")
  
  bind_rows(resA, resB)
}

cont <- get_interface(haddock_d53e_d53e) |>
  filter(chain == "A") |> 
  select(residue=resno, aa=resid) |>
  mutate(contact = 1)

df |>
  left_join(cont, by = c("residue","aa")) |>
  mutate(contact = case_when(
    is.na(contact) ~ 0,
    TRUE ~ contact
  )) |>
  ggplot(aes(x=residue,y=rms)) +
  geom_line() +
  ggrepel::geom_label_repel(aes(label=aa,fill=as.factor(contact)),alpha=0.5,size=2) +
  theme_bw() +
  theme(legend.position = "none")

I couldn’t easily find a function in bio3d to look for closer contact between the 2 chains, hence got Claude to produce a code to filter out anything less 5 Angstrom and map it back to our RMSD df. Wow, interesting! Not all high rmsd are close contact residues, and not all close contact residues are high in rmsd. 🤔

Final Thoughts

Wow, all of the above took a long time! But it was quite interesting to learn several things here. We learnt quite a few things here. It’s our first time running a protein-protein docking! 🙌 Even though I don’t deeply understand the method and the results, it’s a good start! Let’s keep at it and learn some more next time! If you notice something wrong here, please feel free to let me know!

Opportunities For Improvement

Need to explore Prots5 and Foldseek in the future, the concept is quite interesting. Turning 3D coordinates into one dimention, very latent spacey.
Need to understand haddock3 a bit more, the method and its output
Need to understand how alpha helices and beta sheets occur, the math behind it and see if we can reproduce that from scratch
Need to figure out how to reproduce a phosphorylated CovR structure instead of using a phosphomimetic
Need to learn pymol

Lessons learnt

learnt CovR/S two-component system in streptococcus pyogenes
learnt what hypotheticals are, and what other methods we can use to further identify these hypotheticals
learnt strep pyogenes is the only strep species (reference gene only) that has CovR/S, some other strep species have CovR but no CovS.
learnt Baktfold
learnt the bare basics of haddock3
learnt RMSD, BSA, haddock score, angstrom unit (just eucleadian distance of xyz)

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning & Exploring Survival Analysis Part 1 - A Note To Myself

Sat, 02 May 2026 00:00:00 +0000

A note to myself on survival analysis — KM curves, log-rank tests & Cox models 🧮 If I wrote it the way I understood it, maybe I’ll actually remember it 🤞

Motivations

We see survival analysis or more generally called time-to-event analysis almost all the time when we review journals articles on NEJM etc. Even though we understand the heuristic in interpreting some of the simpler result, I realized that I need to look at this a bit closer to full understand the works and math behind it. There was a recent project that made me feel that my understanding of this is not as competent as I had hoped after talking to one of my statistician colleagues, who also so happen to wrote this blog. Please take a look at Emily’s blog for a better, and a more accurate survival analysis tutorial. This blog is more for my learning so that I can refer back the fundamental when I need a refresher in the future. Also, if I were to write it the way I understood it, maybe that might increase the probably of me recollecting what I understood before. What are we waiting for? Let’s time-to-event this analysis!

Objectives:

= Time-to-event Analysis

Time-to-event Analysis

The name “survival analysis” is a bit misleading if you first encounter it outside of clinical research. The “survival” doesn’t necessarily mean staying alive — it means surviving without experiencing the event. But that even does not necessarily have to be mortality. It could be an unwanted event etc. Outside of clinical research, an event could be the time when a waymo arrives at your doorstep or someone flaked out. 🤣 Hence time-to-event analysis appears to be more a better terminology, in my opinion.

This is different from the good ol regression is because time is the outcome, not only that it occurred or not (binary), but when! Now then if you’re like me, that’s just negative binomial regression, right? Not quite. Because, there is an additional special feature to time-to-event analysis called censoring.

Censoring can mean that the event did not occur, but it can also mean that we lost track of the patient, or the study ended before the event occurred.

I don’t know about you. But for me, censoring has a negative connotation. It sounds like we’re hiding something. But in survival analysis, censoring is actually a good thing. It means we have partial information about the time to event, even if we don’t know the exact time. So, think of censoring as the last time we noticed that the event DID NOT happen, and it’s usually coded as 0. In good ol regression, we usually will either do a complete case analysis (throw out missing data) or impute. But, imputing outcome is a tad odd, in most cases except here. The common censoring is right censoring, meaning we lose track of someone on the right side of the timeline.

Survival Function

The survival function, written S(t), answers one simple question: “What is the probability that a person has NOT yet experienced the event by time t?”. At t=0, everyone is event-free, so S(0) = 1 (100%). As time goes on, people experience the event, and S(t) decreases.

Let’s Calculate By Hand

patient	time (months)	status
A	2	1 (event)
B	3	0 (censored)
C	5	1 (event)
D	6	1 (event)
E	8	0 (censored)

Alright, the above looks quite self-explanatory. We have 5 patients, and we are tracking their time to event in months. Patient A experienced the event at 2 months, while patient B was censored at 3 months (we lost track of them). Patient C had the event at 5 months, patient D at 6 months, and patient E was censored at 8 months. Now let’s do some calculation.

Formula: $$ \hat{S}(t) = \prod_{i:, t_i \leq t} \left(1 - \frac{d_i}{n_i}\right) $$

$\hat{S}(t)$: The estimated survival function; the probability of surviving beyond time $t$.
$\prod_{i:\, t_i \leq t}$: Product over all event times $t_i$ that are less than or equal to $t$.
$t_i$: The $i$-th observed event (death/failure) time.
$d_i$: The number of events (deaths/failures) that occurred at time $t_i$.
$n_i$: The number of individuals at risk (still alive and under observation) just before time $t_i$.
$\frac{d_i}{n_i}$: The estimated probability of the event occurring at time $t_i$.
$1 - \frac{d_i}{n_i}$: The estimated probability of surviving through time $t_i$.

or simplistically:

$S(t) = S(t-1).(1-d/n)$

Let’s calculate by hand:

time	at risk (n)	event (d)	S(t)
0	5	0	1
2	5	1	1*(1-1/5)=0.8
3	5-1=4	0	0.8*(1-0)=0.8
5	4-1=3	1	0.8*(1-1/3)=0.5333
6	3-1=2	1	0.5333*(1-1/2)=0.2667
8	2-1=1	0	0.2667*(1-0)=0.2667

That’s interesting! I don’t think I’ve calcualte these by hand before and that’s very helpful in just doing a simple example and observing the result. Alright, when we read articles, there typically is a group factor, how do they then use KM to generate 2 survival curves or survival estimate for each group? They just do the same thing but only for the subset of the data that belongs to that group. So, if we have a treatment and control group, we would calculate S(t) separately for each group, and then we can compare the two survival curves to see if there is a difference in survival between the groups. How? We can use the log-rank test to compare the survival curves, or we can use a Cox proportional hazards model to estimate the hazard ratio between the groups. Now, things are starting to look a tad more familiar. Let’s use R and some simple example and see if we can get to log-rank test on just simple KM etimator.

library(tidyverse)

simple_df <- tribble(
  ~time, ~status, ~treatment,
  5,1,1,
  2,1,0,
  6,0,1,
  1,1,0,
  2,0,1,
  2,0,0,
  7,1,1,
  3,1,0,
  7,1,1,
  2,1,0,
  1,1,0,
  6,1,1
) |>
  mutate(subject = row_number()) 

treatment_df <- simple_df |>
  filter(treatment == 1) |>
  arrange(time)

treatment <- tibble()
time <- treatment_df |> distinct(time) |> pull()
at_risk <- nrow(treatment_df)
S_t <- 1

for (i in time) {
  df_i <- treatment_df |>
    filter(time == i)
  status <- df_i |> pull(status) |> sum()
  n <- df_i |> pull(status) |> length()
  S_t <- S_t * (1 - status/at_risk)
  treatment <- treatment |>
    bind_rows(tibble(time=i,at_risk=at_risk,S_t=S_t,treatment=1))
  at_risk <- at_risk - n
}

(treatment)

## # A tibble: 4 × 4
##    time at_risk   S_t treatment
##   <dbl>   <int> <dbl>     <dbl>
## 1     2       6   1           1
## 2     5       5   0.8         1
## 3     6       4   0.6         1
## 4     7       2   0           1

no_treatment_df <- simple_df |>
  filter(treatment == 0) |>
  arrange(time)

no_treatment <- tibble()
time <- no_treatment_df |> distinct(time) |> pull()
at_risk <- nrow(no_treatment_df)
S_t <- 1

for (i in time) {
  df_i <- no_treatment_df |>
    filter(time == i)
  status <- df_i |> pull(status) |> sum()
  n <- df_i |> pull(status) |> length()
  S_t <- S_t * (1 - status/at_risk)
  no_treatment <- no_treatment |>
    bind_rows(tibble(time=i,at_risk=at_risk,S_t=S_t,treatment=0))
  at_risk <- at_risk - n
}

(no_treatment)

## # A tibble: 3 × 4
##    time at_risk   S_t treatment
##   <dbl>   <int> <dbl>     <dbl>
## 1     1       6 0.667         0
## 2     2       4 0.333         0
## 3     3       1 0             0

Visualize

rbind(treatment,no_treatment) |>
  bind_rows(tibble(
    time=c(0,0), status=c(0,0), treatment=c(1,0), subject=c(0,0), at_risk=c(6,6), S_t=c(1,1)  #add initial phase 
  )) |>
  ggplot(aes(x=time,y=S_t,color=as.factor(treatment))) +
  geom_step() +
  theme_bw()

Wow, since we created this simpel dataset, knowing treatment extended the time event, whereas no treatment didn’t, we can nicely see that when creating 2 KM plots stratified by the treatment group and plot it all they look very different. Now let’s quickly look at log rank test with survival package and then calculate by hand and see if we can reproduce the same p value.

## log-rank test
(log_rank_test <- survival::survdiff(Surv(time, status) ~ treatment, data = simple_df))

## Call:
## survival::survdiff(formula = Surv(time, status) ~ treatment, 
##     data = simple_df)
## 
##             N Observed Expected (O-E)^2/E (O-E)^2/V
## treatment=0 6        5     1.97      4.68      9.02
## treatment=1 6        4     7.03      1.31      9.02
## 
##  Chisq= 9  on 1 degrees of freedom, p= 0.003

Alright! It looks like a chi-square test and has a p val of 0.003. Let’s see if we can reproduce that. And it also looked like they use (O-E)^2/V as opposed to sum of (O-E)^2/E like the usual chi-square test to get the chisq statistic. Interesting.

V (variance) = n_0 * n_1 * d * (n - d) / (n^2 * (n - 1))

Click Here For Calculated Details

## log-rank test by hand
n0 <- 6
n1 <- 6

### time 1
simple_df |>
  filter(time == 1) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 1 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         0     2     2

(t_1 <- tibble(n0=n0, n1=n1, d0=2, d1=0) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     6     6     2     0    12     2 0.455     1   2.2

n0 <- n0 - 2
n1 <- n1 - 0

### time 2
simple_df |>
  filter(time == 2) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 2 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         0     3     2
## 2         1     1     0

(t_2 <- tibble(n0=n0, n1=n1, d0=2, d1=0) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     4     6     2     0    10     2 0.427   0.8  3.37

n0 <- n0 - 3
n1 <- n1 - 1

### time 3
simple_df |>
  filter(time == 3) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 1 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         0     1     1

(t_3 <- tibble(n0=n0, n1=n1, d0=1, d1=0) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     1     5     1     0     6     1 0.139 0.167     5

n0 <- n0 - 1
n1 <- n1 - 0

### time 5
simple_df |>
  filter(time == 5) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 1 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         1     1     1

(t_5 <- tibble(n0=n0, n1=n1, d0=0, d1=1) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     0     5     0     1     5     1     0     0   NaN

n1 <- n1 - 1

### time 6
simple_df |>
  filter(time == 6) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 1 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         1     2     1

(t_6 <- tibble(n0=n0, n1=n1, d0=0, d1=1) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     0     4     0     1     4     1     0     0   NaN

n1 <- n1 - 2

### time 7
simple_df |>
  filter(time == 7) |>
  group_by(treatment) |>
  summarize(n = n(),
            d = sum(status))

## # A tibble: 1 × 3
##   treatment     n     d
##       <dbl> <int> <dbl>
## 1         1     2     2

(t_7 <- tibble(n0=n0, n1=n1, d0=0, d1=2) |>
  mutate(n = n0 + n1) |>
  mutate(d = d0 + d1) |>
  mutate(V = n0 * n1 * d * (n - d) / (n^2 * (n - 1))) |>
  mutate(E0 = (n0 /n) * d) |>
  mutate(chi_i = (d0-E0)^2/V))

## # A tibble: 1 × 9
##      n0    n1    d0    d1     n     d     V    E0 chi_i
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1     0     2     0     2     2     2     0     0   NaN

n1 <- n1 - 2

Alright, lots of back and forth sanity check but I think we did it! Now, let’s replace those NaN to 0, do some calculation and check our final chi square statistic

bind_rows(t_1, t_2, t_3, t_5, t_6, t_7) |>
  mutate(V = replace_na(V, 0),
         E0 = replace_na(E0, 0)) |>
  summarise(
    O0 = sum(d0),
    E0 = sum(E0),
    V  = sum(V)
  ) |>
  mutate(chi_sq = (O0 - E0)^2 / V)

## # A tibble: 1 × 4
##      O0    E0     V chi_sq
##   <dbl> <dbl> <dbl>  <dbl>
## 1     5  1.97  1.02   9.02

pchisq(q = 9.02, df = 1, lower.tail = F)

## [1] 0.002670414

🙌🙌🙌 We got it! If we round it up, it’s exactly 0.003 just like from survival.

Notice that we used E0, but you can use E1 and it would should return the same chi square statistic. Click below for details.

Click to expand

bind_rows(t_1, t_2, t_3, t_5, t_6, t_7) |>
  mutate(E1 = (n1 / n) * d) |>
  summarise(
    O1 = sum(d1),
    E1 = sum(E1),
    V = sum(V)
  ) |>
  mutate(chi_sq = (O1-E1)^2/V)

## # A tibble: 1 × 4
##      O1    E1     V chi_sq
##   <dbl> <dbl> <dbl>  <dbl>
## 1     4  7.03  1.02   9.02

Take note that KM estimator can only estimate survival function and you can only compare the survival curves with log-rank test, but you can’t add more variables to adjust for confounding. Which means, we assume that there isn’t any confounding factors between treatment groups.

If any adjustment that’s needed, that’s where Cox proportional hazard model comes in. Now if we were to add age and run cox model, we would get a different hazard ratio and p value, but the log-rank test would still be the same because log-rank test is only comparing the survival curves without adjusting for any covariates. Let’s see that in action. Click below to expand, you’re going to see an interesting warning, complete separation.

Click to Expand

simple_df <- tribble(
  ~time, ~status, ~treatment, ~age,
  5,1,1,30,
  2,1,0,80,
  6,0,1,35,
  1,1,0,85,
  2,0,1,32,
  2,0,0,30,
  7,1,1,25,
  3,1,0,90,
  7,1,1,98,
  2,1,0,98,
  1,1,0,89,
  6,1,1,20
) |>
  mutate(subject = row_number()) 

survival::coxph(Surv(time,status) ~ treatment+age, data = simple_df)

## Warning in coxph.fit(X, Y, istrat, offset, init, control, weights = weights, :
## Loglik converged before variable 1 ; coefficient may be infinite.

## Call:
## survival::coxph(formula = Surv(time, status) ~ treatment + age, 
##     data = simple_df)
## 
##                 coef  exp(coef)   se(coef)      z     p
## treatment -2.202e+01  2.729e-10  1.937e+04 -0.001 0.999
## age        2.275e-03  1.002e+00  1.192e-02  0.191 0.849
## 
## Likelihood ratio test=10.61  on 2 df, p=0.004959
## n= 12, number of events= 9

Notice how our treatment has high p val, and high SE? Since our mock data has a clear separation between treatment and age, where all the treated patients are young and all the untreated patients are old, the model is having a hard time estimating the effect of treatment because it’s confounded by age. This is called complete separation, and it leads to infinite estimates for the coefficients, which is why we see those warnings. In real world data, we might not have such a clear separation, but we might still have some degree of separation that can lead to unstable estimates. That’s why it’s important to check for separation and consider using penalized regression methods if we encounter this issue.

Let’s simulate the data so that we can estimate a more accurate hazard ratio with cox model and see how it compares to the true hazard ratio that we set in the simulation.

Simulation

library(survival)
library(survminer)

# simulate data of HR 0.55 (95%CI 0.442-0.674)
set.seed(1)
n <- 350
base_event <- 25
base_rate <- 1/base_event
treatment_event <- base_event + 20
treatment_rate <- 1/treatment_event
hr <- treatment_rate/base_rate
coef <- log(hr)
confounder <- rbinom(n,1,0.5)
treatment <- rbinom(n, 1, plogis(0.5*confounder))
true_time <- rexp(n, rate = base_rate*exp(coef*treatment+0.5*confounder))
cens_time <- runif(n, min = 0, max = treatment_event)         

df <- tibble(true_time, cens_time) |>
  mutate(time = pmin(true_time, cens_time),
         status = case_when(
           true_time <= cens_time ~ 1,
           TRUE ~ 0
         )) |>
  mutate(confounder = confounder) |>
  mutate(treatment = treatment |> as.factor())

head(df)

## # A tibble: 6 × 6
##   true_time cens_time  time status confounder treatment
##       <dbl>     <dbl> <dbl>  <dbl>      <int> <fct>    
## 1     13.0      42.3  13.0       1          0 0        
## 2      8.83      2.60  2.60      0          0 0        
## 3      4.49     13.7   4.49      1          1 0        
## 4     61.4      10.8  10.8       0          1 1        
## 5     47.7      17.3  17.3       0          0 1        
## 6     11.6      34.3  11.6       1          1 1

The above simulation, we set the true hazard ratio to be 0.55, which means that the treatment group has a 45% reduction in the hazard of the event compared to the control group. We then simulate the true time to event using an exponential distribution, and we also simulate a censoring time using a uniform distribution. The observed time is the minimum of the true time and the censoring time, and the status variable indicates whether the event was observed (1) or censored (0).

Simulating the above is helpful because we then know the true rate was derived from exponential function based on base rate multiplied by the hazard ratio, so we can then compare the estimated hazard ratio from the Cox model to the true hazard ratio we set in the simulation. The part that connects intuitively is how the exp(coef\*treatment+coef2\*confounder) is similar to the linear regression. If you noticed that we use base_rate*exp(...), it’s essentialy the same as exp(log(base_rate)+coef\*treatment+coef2\*confounder) which is the same as exp(intercept + coef\*treatment + coef2\*confounder), where the intercept is log(base_rate). So, in a way, the Cox model is modeling the log of the hazard function as a linear combination of the covariates, which is similar to how linear regression models the mean of the outcome as a linear combination of the covariates. The difference is that in Cox model, we are modeling the hazard function, which is the instantaneous rate of event occurrence at time t, whereas in linear regression, we are modeling the mean of the outcome variable.

Kaplan-Meier Estimator

(survdiff(Surv(time,status) ~ treatment, data = df))

## Call:
## survdiff(formula = Surv(time, status) ~ treatment, data = df)
## 
##               N Observed Expected (O-E)^2/E (O-E)^2/V
## treatment=0 149       74     62.3      2.20      3.61
## treatment=1 201       87     98.7      1.39      3.61
## 
##  Chisq= 3.6  on 1 degrees of freedom, p= 0.06

km_fit <- survfit(Surv(time, status) ~ treatment, data = df)

the log-rank test did show a difference between the two groups, though not statistically significant (likely not adequate n), which is expected since we set a true hazard ratio of 0.55 in the simulation. The Kaplan-Meier estimator will give us the estimated survival curves for each group, and we can visually compare them to see the difference in survival between the treatment and control groups.

Cox Proportional Hazard Model

cox_fit <- coxph(Surv(time, status) ~ treatment + confounder, data = df, x = T)
summary(cox_fit)

## Call:
## coxph(formula = Surv(time, status) ~ treatment + confounder, 
##     data = df, x = T)
## 
##   n= 350, number of events= 161 
## 
##               coef exp(coef) se(coef)      z Pr(>|z|)   
## treatment1 -0.3730    0.6887   0.1603 -2.327  0.01999 * 
## confounder  0.5024    1.6526   0.1605  3.130  0.00175 **
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
##            exp(coef) exp(-coef) lower .95 upper .95
## treatment1    0.6887     1.4521     0.503    0.9429
## confounder    1.6526     0.6051     1.207    2.2635
## 
## Concordance= 0.582  (se = 0.024 )
## Likelihood ratio test= 13.34  on 2 df,   p=0.001
## Wald test            = 13.34  on 2 df,   p=0.001
## Score (logrank) test = 13.5  on 2 df,   p=0.001

# plot
ggsurvplot(
  fit = km_fit,
  data = df,
  # pval = TRUE,
  conf.int = TRUE,
  risk.table = TRUE,
  legend.labs = c("Control", "Treatment"),
  title    = "Kaplan-Meier Survival Curves"
)

Notice how the estimated hazard ratio from the Cox model is close to the true hazard ratio of 0.55 that we set in the simulation, our HR is 0.595 (95% CI 0.44-0.81). The Kaplan-Meier plot showed us the survival curves for each group, and we can visually see the difference in survival between the treatment and control groups.

Note: survdiff calculates log-rank test, survfit estimates the survival function, and coxph estimates the hazard ratio adjusting for covariates

There is an interesting article by Hernán that cautioned the use of unadjusted HR and the use unadjusted survival curve (which we did, because it’s based off KM estimator). He also mentioned that first, a single average HR across the entire follow-up can be misleading because the true effect may vary over time. Let’s see if we can apply that to our current plot. Let’s use adjustedCurves and see if it looks different.

library(adjustedCurves)

adjust_curve <- adjustedsurv(
  data = df, 
  ev_time = "time", 
  event = "status", 
  variable = "treatment", 
  method = "direct", 
  outcome_model = cox_fit, 
  conf_int = T)

plot(adjust_curve, conf_int = T)

Interesting. They do look different! Though the paper didn’t directly use this package. He also proposed a solution to more accurately estimate time-varying HR using pooled logistic regression and spline on time as feature. Let’s try this next time! So much to learn! On Emily Zabor’s blog, she did mention there is survival::cox.zph() function which allows us to check the assumption of proportional hazards.

Acknowledgement

Thanks to Emily Zabor’s tutorial and also personal advice on practical usage of survival analysis! Her blog contains so much more advanced topics and some functions and packages I’m planning to use in the future. It’s truly one of the more comprehensive and yet easy to understand tutorials I’ve seen on survival analysis. Thanks Emily!

Also thanks to John Blishak for pointing out some of the typos and url error. I’ve made those changes as well. Thanks, John! I was telling him that LLM wouldn’t have made those rookie error lol.

Opportunities For Improvement

learn competing risk analysis with fine-gray model
learn to customize ggsurvplot
use gtsummary::tbl_regression(exp = TRUE) to further beautify aHR
test out Hernán’s proposed solution to calculate HR
let’s test out other dataset such as BMT from SemiCompRisks, Melanoma from MASS,

Lessons learnt

calculating by hand is helpful because I just realized we can’t just calculate at_risk with one row at a time because of the time occurs at the same time, it would be calculated at the same time, that’s why we used for loop for clarity
survdiff calculates log-rank test, survfit estimates the survival function, and coxph estimates the hazard ratio adjusting for covariates
censor is usually a good thing, but it could also mean lost to follow up.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Exploring and Learning Quantum Computing Part 1

Wed, 29 Apr 2026 00:00:00 +0000

Dipping my toes into quantum computing 🌊 — circuits, gates, superposition. Still very much a beginner, but hands-on experiments with qiskit + R’s reticulate made it click a little more. Baby steps!

Motivations

Alright, we’ve done molecular dynamic simulation and then the post-processing part where we used PBSA/GBSA. I was told that quantum mechanics can more accurately estimate the interaction between these interacting molecules. What an opportunity to dive into quantum computing! It’s going to a bumpy ride because my knowledge for all of these are very limited, let’s break these into small pieces and learn! In this blog, why don’t we program a “Hello World” version and see if we can understand it a bit better. The main language this was programmed in is in Python, but you know me, let’s bring this over to R with reticulate and see if we can have fun with it!

Objectives:

Quantum Computing

Quantum computing is a new type of computing that uses the principles of quantum mechanics — the physics of tiny particles like electrons and photons — to process information in fundamentally different ways than regular computers. While a normal computer stores information as bits (either a 0 or a 1), a quantum computer uses qubits, which can be 0, 1, or both at the same time thanks to a property called superposition. On top of that, qubits can be entangled, meaning two qubits can be linked so that the state of one instantly affects the other, no matter the distance. This lets quantum computers explore many possible solutions to a problem simultaneously, rather than one at a time — making them potentially incredibly powerful for specific tasks like breaking encryption, simulating molecules for drug discovery, or optimizing complex systems. Think of it this way: a regular computer tries every door in a maze one by one, while a quantum computer can try all the doors at once. Spooky! 👻

I’ll be honest, I still don’t understand all these. But that’s OK, let’s do some Hello World programming in quantum computer lanauge and see if we can retro-learn the fundamentals! Even better, let’s take a look at classic computing simulation and see if we can use that to “understand” what’s underneath the quantum computing package.

Learn Quantum Computing with Classic Simulation

Installation

library(reticulate)
library(tidyverse)

py_install("qiskit")
py_install("qiskit_aer")

Pretty straightforward, let’s install these.

First Simple Example

library(reticulate)
library(tidyverse)

QuantumCircuit <- import("qiskit")$QuantumCircuit
AerSimulator <- import("qiskit_aer")$AerSimulator

qubit <- 10
n <- 1000
p <- 0.5 
qc <- QuantumCircuit(qubit)

for (i in c(0:(qubit-1))) {
  qc$h(qubit=as.integer(i))
}

qc$measure_all()
qc$draw()

##          ┌───┐ ░ ┌─┐                           
##     q_0: ┤ H ├─░─┤M├───────────────────────────
##          ├───┤ ░ └╥┘┌─┐                        
##     q_1: ┤ H ├─░──╫─┤M├────────────────────────
##          ├───┤ ░  ║ └╥┘┌─┐                     
##     q_2: ┤ H ├─░──╫──╫─┤M├─────────────────────
##          ├───┤ ░  ║  ║ └╥┘┌─┐                  
##     q_3: ┤ H ├─░──╫──╫──╫─┤M├──────────────────
##          ├───┤ ░  ║  ║  ║ └╥┘┌─┐               
##     q_4: ┤ H ├─░──╫──╫──╫──╫─┤M├───────────────
##          ├───┤ ░  ║  ║  ║  ║ └╥┘┌─┐            
##     q_5: ┤ H ├─░──╫──╫──╫──╫──╫─┤M├────────────
##          ├───┤ ░  ║  ║  ║  ║  ║ └╥┘┌─┐         
##     q_6: ┤ H ├─░──╫──╫──╫──╫──╫──╫─┤M├─────────
##          ├───┤ ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐      
##     q_7: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫─┤M├──────
##          ├───┤ ░  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐   
##     q_8: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───
##          ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐
##     q_9: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├
##          └───┘ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘
## meas: 10/═════════╩══╩══╩══╩══╩══╩══╩══╩══╩══╩═
##                   0  1  2  3  4  5  6  7  8  9

simulator = AerSimulator()
job = simulator$run(qc, shots=n)
result = job$result()
counts = result$get_counts()
df <- tibble(pattern=names(counts), freq=map_dbl(.x = pattern, .f=~counts[[.x]]))
df |>
  mutate(total = map_dbl(.x=df$pattern, .f=~str_split(.x, "") |> unlist() |> as.numeric() |> sum())) |>
  group_by(total) |>
  summarize(freq = sum(freq))

## # A tibble: 9 × 2
##   total  freq
##   <dbl> <dbl>
## 1     1    11
## 2     2    30
## 3     3   125
## 4     4   208
## 5     5   228
## 6     6   229
## 7     7   116
## 8     8    45
## 9     9     8

rbinom(n,qubit,p) |> table()

## 
##   1   2   3   4   5   6   7   8   9 
##   9  39 118 219 250 192 117  48   8

Wow, lots of code. Let’s break it down. First, we create a quantum circuit with 10 qubits. Then we apply the Hadamard gate (h) to each qubit, which puts them into a superposition state where they have an equal probability of being measured as 0 or 1. After that, we measure all the qubits and run the simulation using the Aer simulator. Finally, we get the counts of the measurement outcomes and summarize them by the total number of 1s in the output pattern. We also compare this with a binomial distribution to see if the results match our expectations. 🙌 They did!

Hadamard gate basically puts all those qubits (you saw my for loop) to superposition state, which means that each qubit has a 50% chance of being measured as 0 or 1. In this case, since we have 10 qubits, the total number of 1s in the output pattern can range from 0 to 10, and we expect to see a distribution that follows a binomial distribution with parameters n=10 and p=0.5.

Let’s look at the 10 raw results:

num <- names(counts)

for (i in num[1:10]) {
  print(paste0(i, ": ", counts[i]))
}

## [1] "0000000001: 1"
## [1] "0000000011: 2"
## [1] "0000000100: 3"
## [1] "0000000101: 3"
## [1] "0000000110: 2"
## [1] "0000000111: 1"
## [1] "0000001011: 1"
## [1] "0000001110: 3"
## [1] "0000001111: 1"
## [1] "0000010000: 1"

Here is the interesting thing, this simulation stores the pattern of the simulation. For example, there were 1 count of 0000000001, and 2 counts for 0000000010, 2 counts for 0000000011 etc. So you actually know what exact patterns it produced when we’re measuring it! This is super cool. This is just a peek under the hood type of practice. Just curious what each variables contain etc.

If we were to draw the circuit out, it would look like this :

qc$draw(output='text',fold=60)

##          ┌───┐ ░ ┌─┐                           
##     q_0: ┤ H ├─░─┤M├───────────────────────────
##          ├───┤ ░ └╥┘┌─┐                        
##     q_1: ┤ H ├─░──╫─┤M├────────────────────────
##          ├───┤ ░  ║ └╥┘┌─┐                     
##     q_2: ┤ H ├─░──╫──╫─┤M├─────────────────────
##          ├───┤ ░  ║  ║ └╥┘┌─┐                  
##     q_3: ┤ H ├─░──╫──╫──╫─┤M├──────────────────
##          ├───┤ ░  ║  ║  ║ └╥┘┌─┐               
##     q_4: ┤ H ├─░──╫──╫──╫──╫─┤M├───────────────
##          ├───┤ ░  ║  ║  ║  ║ └╥┘┌─┐            
##     q_5: ┤ H ├─░──╫──╫──╫──╫──╫─┤M├────────────
##          ├───┤ ░  ║  ║  ║  ║  ║ └╥┘┌─┐         
##     q_6: ┤ H ├─░──╫──╫──╫──╫──╫──╫─┤M├─────────
##          ├───┤ ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐      
##     q_7: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫─┤M├──────
##          ├───┤ ░  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐   
##     q_8: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───
##          ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐
##     q_9: ┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├
##          └───┘ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘
## meas: 10/═════════╩══╩══╩══╩══╩══╩══╩══╩══╩══╩═
##                   0  1  2  3  4  5  6  7  8  9

On a real quantum computer, all qubits are measured simultaneously in a single shot — when measure_all() is called, every qubit collapses to a 0 or 1 at the same time, producing one complete bitstring (like 0110101001) per shot. No qubit’s result influences another’s within the same measurement. In our example, since we only applied Hadamard gates with no entanglement, each qubit’s outcome is truly independent — which is why our results neatly follow a binomial distribution. If qubits were entangled, measuring one would constrain the others, even though the measurement still happens all at once.

For educational purposes, |0> means the qubit is in the state of 0, and |1> means the qubit is in the state of 1. It is read as “ket 0” and “ket 1”. The | symbol is called a “bra-ket” notation, which is a standard way to represent quantum states. The “ket” part (|>) represents a column vector in a complex vector space, which is how quantum states are mathematically described. So |0> and |1> are the basic states of a qubit, where |0> corresponds to the state where the qubit is in the 0 state, and |1> corresponds to the state where the qubit is in the 1 state.

But what good is it that we can only do simple 50% probability of 0 and 1? Can we change the probability of measuring 0 and 1? Yes, we can!

Probability In Degrees

In Hadamard gate, we’re essentially making the probability of 0 and 1 50% as we mentioned above. The magnitude/amplitude is formulated as a * |0> + b * |1> , where by a^2 + b^2 = 1. Also, P(|0>) = a^2, and P(|1>) = b^2. So if we want to change the probability of 0 and 1, we can use the Ry gate, which rotates the qubit around the Y-axis of the Bloch sphere. The angle of rotation (theta) determines the probabilities of measuring 0 or 1. Specifically, if we set theta such that sin²(theta/2) = p, then the probability of measuring |1> will be p, and the probability of measuring |0> will be 1-p. So by adjusting theta, we can control the probabilities of our measurement outcomes.

p <- 0.25
theta <- 2 * asin(sqrt(p))

qc <- QuantumCircuit(qubit)

for (i in c(0:(qubit-1))) {
     qc$ry(theta=theta, qubit=as.integer(i))
}

qc$measure_all()
qc$draw()

##          ┌─────────┐ ░ ┌─┐                           
##     q_0: ┤ Ry(π/3) ├─░─┤M├───────────────────────────
##          ├─────────┤ ░ └╥┘┌─┐                        
##     q_1: ┤ Ry(π/3) ├─░──╫─┤M├────────────────────────
##          ├─────────┤ ░  ║ └╥┘┌─┐                     
##     q_2: ┤ Ry(π/3) ├─░──╫──╫─┤M├─────────────────────
##          ├─────────┤ ░  ║  ║ └╥┘┌─┐                  
##     q_3: ┤ Ry(π/3) ├─░──╫──╫──╫─┤M├──────────────────
##          ├─────────┤ ░  ║  ║  ║ └╥┘┌─┐               
##     q_4: ┤ Ry(π/3) ├─░──╫──╫──╫──╫─┤M├───────────────
##          ├─────────┤ ░  ║  ║  ║  ║ └╥┘┌─┐            
##     q_5: ┤ Ry(π/3) ├─░──╫──╫──╫──╫──╫─┤M├────────────
##          ├─────────┤ ░  ║  ║  ║  ║  ║ └╥┘┌─┐         
##     q_6: ┤ Ry(π/3) ├─░──╫──╫──╫──╫──╫──╫─┤M├─────────
##          ├─────────┤ ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐      
##     q_7: ┤ Ry(π/3) ├─░──╫──╫──╫──╫──╫──╫──╫─┤M├──────
##          ├─────────┤ ░  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐   
##     q_8: ┤ Ry(π/3) ├─░──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───
##          ├─────────┤ ░  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐
##     q_9: ┤ Ry(π/3) ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├
##          └─────────┘ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘
## meas: 10/═══════════════╩══╩══╩══╩══╩══╩══╩══╩══╩══╩═
##                         0  1  2  3  4  5  6  7  8  9

simulator = AerSimulator()
job = simulator$run(qc, shots=n)
result = job$result()
counts = result$get_counts()
df <- tibble(pattern=names(counts), freq=map_dbl(.x = pattern, .f=~counts[[.x]]))
df |>
  mutate(total = map_dbl(.x=df$pattern, .f=~str_split(.x, "") |> unlist() |> as.numeric() |> sum())) |>
  group_by(total) |>
  summarize(freq = sum(freq))

## # A tibble: 9 × 2
##   total  freq
##   <dbl> <dbl>
## 1     0    47
## 2     1   181
## 3     2   303
## 4     3   239
## 5     4   164
## 6     5    46
## 7     6    18
## 8     7     1
## 9     8     1

rbinom(n,qubit,p) |> table()

## 
##   0   1   2   3   4   5   6   7 
##  58 186 290 256 132  55  18   5

Alright! We can change the probability, just like classic simulation!

The math behind the probability needs a little calculus jujitsu, but the key idea is that the Ry gate allows us to manipulate the state of the qubit in such a way that we can achieve any desired probability distribution for the measurement outcomes. By setting theta appropriately, we can create a superposition state that gives us the exact probabilities we want when we measure the qubit.

Bloch sphere is a geometrical representation of the state of a qubit. It is a unit sphere where any point on the surface represents a possible state of the qubit. The north pole of the sphere corresponds to the state |0>, while the south pole corresponds to the state |1>. The points on the equator represent superposition states where the qubit has equal probabilities of being measured as 0 or 1. The angle theta that we use in the Ry gate corresponds to a rotation around the Y-axis of the Bloch sphere, which allows us to move from the north pole (|0>) towards the south pole (|1>) and create superposition states with different probabilities.

The Ry rotation gate rotates around the Y-axis of the Bloch sphere. The probability of measuring |1> is:

P(|1>) = sin²(theta/2)

Angle (degrees)	P(\|1⟩)
0°	0.00
30°	0.07
45°	0.15
60°	0.25
90°	0.50
180°	1.00

Alright, let’s verify with our p = 0.25, did we get theta (angle) of 30 degrees?

theta

## [1] 1.047198

Oppps, remember that theta is in radians, so we need to convert it to degrees:

theta * (180 / pi)

## [1] 60

phew! 😮‍💨 it checked out.

Gates

CNOT

The CNOT (Controlled NOT) gate is a two-qubit gate that flips the state of the target qubit (from |0> to |1> or from |1> to |0>) if and only if the control qubit is in the state |1>. If the control qubit is in the state |0>, the target qubit remains unchanged. This gate is essential for creating entanglement between qubits, which is a key feature of quantum computing that allows for complex correlations between qubits. Let’s check it out.

Without Hadamard and CNOT

qc <- QuantumCircuit(2)
qc$measure_all()
simulator <- AerSimulator()
qc$draw()

##          ░ ┌─┐   
##    q_0: ─░─┤M├───
##          ░ └╥┘┌─┐
##    q_1: ─░──╫─┤M├
##          ░  ║ └╥┘
## meas: 2/════╩══╩═
##             0  1

job <- simulator$run(qc, shots=1000)
(counts <- job$result()$get_counts())

## {'00': 1000}

As we can see, we didn’t set anything, hence but qubits returned zero. And exacttly 1000 times.

Without Hadamard but With CNOT

qc_cnot <- QuantumCircuit(2)
invisible(qc_cnot$cx(0L,1L))
qc_cnot$measure_all()
qc_cnot$draw()

##               ░ ┌─┐   
##    q_0: ──■───░─┤M├───
##         ┌─┴─┐ ░ └╥┘┌─┐
##    q_1: ┤ X ├─░──╫─┤M├
##         └───┘ ░  ║ └╥┘
## meas: 2/═════════╩══╩═
##                  0  1

simulator <- AerSimulator()
job <- simulator$run(qc_cnot, shots=1000)
(counts <- job$result()$get_counts())

## {'00': 1000}

Now, even when we inserted CNOT gate, but because the control qubit (qubit 0) is in the state |0>, the target qubit (qubit 1) remains unchanged, resulting in the same output as before, where both qubits are measured as |00> with a count of 1000. Simplistic speaking, if our first qubit is 0, the CNOT gate does nothing to the second qubit, so we still get |00> every time.

With X Gate and CNOT

qc_x <- QuantumCircuit(2)
invisible(qc_x$x(0L))
invisible(qc_x$cx(0L, 1L))
qc_x$measure_all()
qc_x$draw()

##         ┌───┐      ░ ┌─┐   
##    q_0: ┤ X ├──■───░─┤M├───
##         └───┘┌─┴─┐ ░ └╥┘┌─┐
##    q_1: ─────┤ X ├─░──╫─┤M├
##              └───┘ ░  ║ └╥┘
## meas: 2/══════════════╩══╩═
##                       0  1

simulator <- AerSimulator()
job <- simulator$run(qc_x, shots=1000)
(counts <- job$result()$get_counts())

## {'11': 1000}

Now, if qubit 0 is now |1>, X gate basically turns the current state to the opposite, so qubit 0 is now |1>. When we apply the CNOT gate, it checks the state of qubit 0 (the control qubit). Since qubit 0 is now |1>, the CNOT gate flips the state of qubit 1 (the target qubit) from |0> to |1>. As a result, we get the output state |11> with a count of 1000.

What if our qubit 0 is |0> but our qubit 1 is |1>. apply CNOT with control on qubit 0 and target on qubit 1? What would happen? |01> = 1000 ?

qc_x <- QuantumCircuit(2)
invisible(qc_x$x(1L))
invisible(qc_x$cx(0L, 1L))
qc_x$measure_all()
qc_x$draw()

##                    ░ ┌─┐   
##    q_0: ───────■───░─┤M├───
##         ┌───┐┌─┴─┐ ░ └╥┘┌─┐
##    q_1: ┤ X ├┤ X ├─░──╫─┤M├
##         └───┘└───┘ ░  ║ └╥┘
## meas: 2/══════════════╩══╩═
##                       0  1

simulator <- AerSimulator()
job <- simulator$run(qc_x, shots=1000)
(counts <- job$result()$get_counts())

## {'10': 1000}

WAIT A MINUTE !?! Why is it not |01> ???!?! That is because the output is read right-to-left !!! Now what if we use CNOT with qubit 1 as control, and qubit 0 as target? What do you think will happen? It should be |11> = 1000, right?

qc_x <- QuantumCircuit(2)
invisible(qc_x$x(1L))
invisible(qc_x$cx(1L, 0L))
qc_x$measure_all()
qc_x$draw()

##              ┌───┐ ░ ┌─┐   
##    q_0: ─────┤ X ├─░─┤M├───
##         ┌───┐└─┬─┘ ░ └╥┘┌─┐
##    q_1: ┤ X ├──■───░──╫─┤M├
##         └───┘      ░  ║ └╥┘
## meas: 2/══════════════╩══╩═
##                       0  1

simulator <- AerSimulator()
job <- simulator$run(qc_x, shots=1000)
(counts <- job$result()$get_counts())

## {'11': 1000}

Cool beans! Now, if it’s truly read right-to-left, if we place qubit 0 as |1> and qubit 1 as |0> with CNOT control on qubit 1 and target on qubit 0, we should see |01> = 1000 !!! Let’s examine.

qc_x <- QuantumCircuit(2)
invisible(qc_x$x(0L))
invisible(qc_x$cx(1L, 0L))
qc_x$measure_all()
qc_x$draw()

##         ┌───┐┌───┐ ░ ┌─┐   
##    q_0: ┤ X ├┤ X ├─░─┤M├───
##         └───┘└─┬─┘ ░ └╥┘┌─┐
##    q_1: ───────■───░──╫─┤M├
##                    ░  ║ └╥┘
## meas: 2/══════════════╩══╩═
##                       0  1

simulator <- AerSimulator()
job <- simulator$run(qc_x, shots=1000)
(counts <- job$result()$get_counts())

## {'01': 1000}

🙌 !!!

Now, let’s do another experiment. If we set both qubit 0 and 1 as |1> and assigned a CNOT with control via qubit 1 and target via qubit 0. We should see that it will turn qubit 0’s |1> to |0>. And again, if we were to starts from right to left, we should see |10>, right?

qc_x <- QuantumCircuit(2)
invisible(qc_x$x(0L))
invisible(qc_x$x(1L))
invisible(qc_x$cx(1L, 0L))
qc_x$measure_all()
qc_x$draw()

##         ┌───┐┌───┐ ░ ┌─┐   
##    q_0: ┤ X ├┤ X ├─░─┤M├───
##         ├───┤└─┬─┘ ░ └╥┘┌─┐
##    q_1: ┤ X ├──■───░──╫─┤M├
##         └───┘      ░  ║ └╥┘
## meas: 2/══════════════╩══╩═
##                       0  1

simulator <- AerSimulator()
job <- simulator$run(qc_x, shots=1000)
(counts <- job$result()$get_counts())

## {'10': 1000}

🙌🙌🙌 !!!

With Hadamard and CNOT (Bell State)

qc_bell <- QuantumCircuit(2)
qc_bell$h(0L)

## <qiskit.circuit.instructionset.InstructionSet object at 0x133a2e380>

qc_bell$cx(0L, 1L)

## <qiskit.circuit.instructionset.InstructionSet object at 0x133a2e440>

qc_bell$draw()

##      ┌───┐     
## q_0: ┤ H ├──■──
##      └───┘┌─┴─┐
## q_1: ─────┤ X ├
##           └───┘

qc_bell$measure_all()
simulator <- AerSimulator()
job <- simulator$run(qc_bell, shots=1000)
(counts <- job$result()$get_counts())

## {'11': 489, '00': 511}

This is where the magic happens. The Hadamard gate puts the first qubit into a superposition state, which means it has an equal probability of being measured as |0> or |1>. When we apply the CNOT gate, it creates an entangled state between the two qubits. As a result, when we measure the qubits, we get either |00> or |11> with equal probability (approximately 500 counts each), and we never get |01> or |10>. This is a demonstration of quantum entanglement, where the state of one qubit is directly correlated with the state of another qubit, even though they are measured independently.

Cheat Sheet

Gate	Name	Matrix	Effect on l0⟩	Effect on l1)
X	NOT/Pauli-X	[[0,1],[1,0]]	l1⟩	l0⟩	Bit flip
H	Hadamard	[[1,1],[1,-1]]/√2	(l0⟩+l1⟩)/√2	(l0⟩-l1⟩)/√2	Superposition

Two-Qubit Gates

Gate	Name	Effect
CNOT	Controlled-NOT	If control=1, flip target

Common Circuits

Circuit	Gates	Result
Bell State	H, CNOT	(l00⟩+l11⟩)/√2

Learning In Progress

Obviously my understanding of quantum computing is at best very surface. However, able to visualize the circuits, experiment with turning qubits and adding gates and test my understanding is truly remarkable for my learning! I don’t think I’d be able to get that kind of feedback just by reading. I think the insight I got from doing these simple exercises is that my learning style requires me to be hands on and experiment with the response/answers and ask lots and lots of simple questions. 🙌 Or maybe sometimes I’ll call it the illusion of understanding lol. Till next time! We’ll explore common more a bit more complex circuits like oracle, grover, and then slowly, and hopefully venture into VQE which is where it will be helpful with post-molecular dynamic energy sampling assessment.

Opportunities For Improvement

learn about other single gates like identity, pauli-y, pauli-z, phase, etc. Other two-qubit gates such as cz, swap. Other common circuits like bell state Y+, GHZ, oracle, and add to cheat sheet as I learn more
Should try the real thing with IBM instances
learn oracle
learn Grover’s algorithm and Shor’s algorithm
learn VQE and QAOA
learn quantum machine learning

Lessons learnt

learnt some simple qiskit functions
learnt how to simulate classic probabilities in quantum computing lingo
learnt Dirac notation
explored the quantum circuits via qiskit
had to use invisible to hide python object printing on rmarkdown

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning Chromosomal AmpC beta-lactamase Producing Organisms And Its Mechanics

Thu, 02 Apr 2026 00:00:00 +0000

🦠 Made up my own memory tricks — Gatekeeper, Dumpster, Repressor — to understand AmpC mechanics. Discovered Serratia has 2 recyclers (AmpD + AmiD2) making derepression harder, and E. coli lacks AmpR so AmpC stays silent! Probably not textbook, but it helped me learn 🙌

AmpC beta-lactamase of Enterobacter cloacae generated by AlphaFold and ChimeraX

Motivations

We’ve learnt about ESBL and CRE. Let’s explore AmpC mechanics. This is going to be interesting because it’s not a straightforward constitutive gene that produces via plasmid. It contains downstream mechanics that controls (aka repress) the AmpC gene (in chromosome). Let’s take a look ourselves! Here we will also use some associative terms that we understand to solidify our understanding and the actual mechanics. Let’s go!

Disclaimer

I am not a microbiologist. This is purely for educational purpose. Also, please take note that my lingo preference of AmpG (Gatekeeper), AmpD (Dumpster), AmpR (Repressor) is purely for my own memory association and its function, not a true scientific label. If some of them are as such, it’s pure coincidence.

Objectives:

How Is AmpC So Different From Other Beta-lactamase Genes?

This is an interesting bit about class C beta-lactamase AmpC, even though the gene exists, it’s actually repressed and regulated by a few other genes. Let’s take a look.

AmpG : inner membrane permease that transports anhydromuropeptides (cell wall breakdown products) from the periplasm into the cytoplasm. So, let’s say beta lactam antibiotic increases the cell wall breakdown, we get a lot of these products. This protein then transports these prodcuts into cytoplasm. To remember all these code words, let’s think of AmpG as gatekeeper.

AmpD : cytoplasmic amidase that recycles these anhydromuropeptides back into the cell wall synthesis pathway. Wow, it’s a recycler! Let’s think of AmpD as dumpster.

AmpR : transcriptional regulator that controls ampC gene expression, but when it binds anhydromuropeptides, it switches from a repressor to an activator. So, it’s a switch that can turn on ampC production when it senses the signal of cell wall stress (the anhydromuropeptides). Just imagine that if there is an increase in cell wall destruction, our AmpD cannot efficiently recycler all those byproducts, these byproducts then are able to bind to AmpR, hence essentially turning AmpR into an activator and hence AmpC beta-lactamase would be transcribed. Let’s think of AmpR as repressor.

The above natural mechanics is called induction, which is a reversible process. When you remove the antibiotic, the cell wall stress goes away, AmpD can catch up with recycling, the anhydromuropeptides are cleared, AmpR returns to repressor mode, and AmpC production stops. There is another mechanics that involves mutation of AmpD, rendering it useless in recycling, or mutation of AmpR, rendering it permanently in activator mode. This is called derepression, which is an irreversible process. The mutation is in the DNA, and it’s passed to all daughter cells, hence you get constitutive high-level production of AmpC beta-lactamase regardless of whether antibiotic is present or not. 🙌

There is a lot of cartoons out there that help to depict the process above. Let’s view one of them from A Primer on AmpC β-Lactamases: Necessary Knowledge for an Increasingly Multidrug-resistant World

Note that this blog does not touch on plasmid-mediated class C beta-lactamase. We’re only looking at chromosomal genes. It’s important to note this because plasmid-mediated AmpC can be transferred between organisms, whereas chromosomal AmpC is generally not transferable and is regulated by the host’s genetic machinery. In other words, there is usually no proteins that repress the expression of plasmid-mediated AmpC, hence the presence of plasmid-mediated AmpC is usually associated with high level of beta-lactam resistance. Whereas with chromosomal AmpC, the presence of the gene does not necessarily mean high level of beta-lactam resistance, because it may be repressed and regulated by the host’s genetic machinery.

Look at IDSA AMR Guideline 2024 Section 2: AmpC β-Lactamase-Producing Enterobacterales for other references of why these bacteria produce AmpC beta lactamase and the types. Very informative! From clinical standpoint, the derepressed AmpC (mutation of AmpD or AmpR where AmpC gene is always activated) or plasmid-mediated AmpC will usually prefer itself phenotypically, hence we usually would know from susceptibility testing. The tricky part is the inducible portion, because phenotypically it will show that it is ceftriaxone susceptible, but when ceftriaxone is used, it will induce AmpC beta lactamase production rendering ceftriaxone resistance. Though we don’t have to worry too much of this nowadays because most lab would automatically hide these antibiotics regardless of the susceptibility. 🙌 Maybe not in uncomplicated UTI isolates? But, we have to beware that basal production of AmpC beta-lactamase renders these organisms intrinsically resistant to ampicillin, amoxicillin-clavulanate, and 1st and 2nd generation cephalosporins.

Let’s Take A Look At NCBI

Alright, now that we’ve got some basics of the regulatory mechanisms, let’s look at where to find the actual genes in NCBI.

Go to NCBI Genome.
Look for Enterobacter cloacae.
Select the reference gene
Select View Annotated Genes.
On filter, type “amp”. And we’ll see.

Alright! All those AmpG (Gatekeeper), AmpD (Dumppster), AmpR (Repressor) protein genes are there! 🙌 Now let’s take a look at AmpC Beta Lactamase by looking for lactamase.

Notice that it didn’t say ampC but this is the class C beta-lactamase that comes with reference E. cloacae.

Also, note that Usually the AmpC beta-lactamase gene is adjacent to AmpR gene and in opposite direction. Take a look at their position and orientation. 🤔 The end of CMH class C beta lactamase is 405766, the beginning of AmpR is 405899. And their orientations are opposite as well! 🙌 Let’s take a look at another Enterobacter cloacae complex.

Looking at Enterobacter asburiae.

Notice the Ampc-AmpR positions and orientation? Same same? 🙌

What Are The Typical Organisms Of Clinical Significance?

According IDSA AMR Guidelines, Enterobacter cloacae complex, Klebsiella aerogenes, and Citrobacter freundii (we’ll call it the big 3) are the most common Enterobacterales at moderate risk for clinically significant inducible AmpC production. Clinical reports suggest that the emergence of resistance after exposure to an agent like ceftriaxone may occur in approximately 20% of infections caused by these organisms. Other organisms such as Serratia marcescens, Morganella morganii, and Providencia spp., are significantly less likely to overexpress ampC based on both in vitro analysis. Other less common pathogen such as Hafnia alvei, Citrobacter youngae, Yersinia enterocolitica that carry inducible chromosomal ampC genes do not have too robust of data to support or refute the risk of ampC induction.

Interestingly when reading IDSA AMR Guidelines, citrobacter koseri does not have ampC beta-lactamase, let’s verify this on NCBI. Wow, it’s true! It has class A beta-lactamase, not class C! Also, we need to note that, just because certain organisms have class C beta-lactamase gene, it doesn’t mean it will be overexpressed. It is also quite interesting that even with the right machinery like the big 3, it’s ~20% of infections with emergence of resistance, interesting… 🤔 but why? What happened to the other 80%? Also, we’ll see other examples below of other low risk organisms.

Why Is It That Serratia marcescens Not a High Risk for AmpC?

Why Serratia Marcensens has all the genes but yet not a high risk ampC depression? Apparently, S. marcescens has 2 amidohydrolases (ampD and amiD2) and the deletion of both of these 2 is necessary for AmpC de-repression! Two dumpster proteins! Alright, let’s find it if we can! Here, they used Serratia marcescens ATCC 13880.

Umm, OK, we see AmpD, but there are a lot of other amidase and we do not see AmiD2 as stated from the paper. Highlighted in red are AmpD and amidases that were not labeled specifically, maybe it’s one of them?

Thankfully the paper provided forward and reverse primer for deletion of amiD2. This means that the primers are designed to exclude the amiD2 gene. Hence, if we use the 5’ primer as a forward primer, and then the 3’ primer as a reverse primer, we should be able to locate the positions of amiD2 which should be in bettween or around the vicinity. Let’s see which one this is.

library(Biostrings)
library(tidyverse)

genome <- readDNAStringSet(
  "smatcc/ncbi_dataset/data/GCA_017654245.1/GCA_017654245.1_ASM1765424v1_genomic.fna"
)                                                                             
chr <- genome[1]

fwd <- DNAString("CGTAAAGTCCCTCTCTCGCT")                          
rev <- DNAString("ATGCCGAAACCGCCGCCGTT")                          
rev_rev <- reverseComplement(rev)

(fwd_hits <- vmatchPattern(fwd, chr, max.mismatch = 0))           
(rev_hits <- vmatchPattern(rev_rev, chr, max.mismatch = 0))

Awesome! We see that we have EXACT match for forward primer on our sequence, which makes sense because it should bind to the minus strand and move rightward to make copies away from the active gene amiD. Then the reverse gene should bind to plus strand (our sequence) and copy leftward. This also make sense because according to the picture above of al the annotated amidase. Let’s interpret this, our gene should be between the higher and lower positions of these 2 patterns 5035405 and 5036140. Alright! We do have one that is between or around this vicinity! We found it!

Huzzah! So Serratia marcenses do have 2 recylcers! Cool! 😎 Let’s use AlphaFold to visualize them side by side. Left is AmpD, right is AmiD2.

Wow, they look very different! Maybe?

Note: After much poking around, with the help of multiple Claude chats and probes, we finally found out that the primers were actually to exclude the gene as opposed to make copies of the gene. Which makes total sense! Because the forward primer binds to the minus strand (the strand that carries the amiD2 gene) and it seems to copy rightward away from the gene. Took me a while to figure out why that is! Also, conventionally, all fasta are in plus strand. Hence we were able to use this information to identify AmiD2 gene! 🙌

Now, let’s take a look at other organisms that we normally don’t think of AmpC related.

Let’s Look At Ecoli

Now, we’ve looked at Enterobacter Cloaecae complex and verified that they do have all the machinery and AmpC to produce the enzyme. What about Ecoli? It can’t have it, right? Else we should be hearing more about this. Let’s take a look at one of the Ecoli reference gene.

WAHTHTHAT ?! they have these genes too !?!? AmpG, AmpD, AmpC too !?!?! I’m so confused !!! 😵‍💫

Looking at the literature, apparently they lack AmpR which is the switch that turns on the production of AmpC. So, even though they have AmpC gene, they do not have the machinery to turn it on. Hence, they do not produce clinically significant amount of AmpC beta-lactamase. Wow! Very interesting!

Cefepime and AmpC Beta-Lactamase

Cefepime is the preferred antibiotics for AmpC producing organisms. Does that mean that there should be a low or no affinity of AmpC to Cefepime? Let’s perform some molecular dynamic simulation on this! Code not documents, but approach is the same as this and this

Looking at all of the plots above it looks like AmpC beta-lactamase binds to Cefepime !!! 🤔 So I was wrong! Looking at the literature, in fact, AmpC beta-lactamase can bind to Cefepime and form a rather stable acyl enzyme complexes that make it relatively resistant to hydrolysis compared to other cephalosporins! Wow, how about that! This is very interesting! Also a fun learning too! Wait a minute, does that also mean it occupies the AmpC Beta-lactamases rendering them inactivate against other cephalosporins !?! Unfortunately not, these bonds will eventually undergo deacylation making the enzymes free again for binding. Also Cefepime is a weak AmpC inducer. What does that actually mean?

What Does It Mean That Cefepime Is A Weak AmpC Inducer?

This means that Cefepime is less likely to trigger the induction of AmpC beta-lactamase production compared to other cephalosporins. Does that mean whatever mechanism cefepime acts on the cell wall, with whatever downstream effect to have less products that trigger AmpR derepression? Does antibiotics affecting PBP4 has anything to do with this? Cefepime acts on PBP1-4, could that be why it’s a weak inducer? 🤷‍♂️ What do you think?

How Similar Are The Genes for AmpG/D/R Between Species?

You know how when we assess CTX-M-15, KPC-1, they all share the same nucleotide sequence and hence we can perform exact match on any bacteria to see if they possess such genetic element? I wonder if that’s the case for AmpG, AmpD, AmpR? Or do they have different sequences in different organisms? Let’s look at heatmap.

sample code

library(pwalign)

gene <- c("ampG","ampD","ampR")

for (gene_i in gene) {
ampd <- readDNAStringSet(paste0(gene_i".fasta"))
  mat <- matrix(0, nrow = 13, ncol = 13)
  for (i in 1:13) {
    for (j in 1:13) {
      pair <- pairwiseAlignment(ampd[i], ampd[j])
      mat[i,j] <- pair@score
    }
  }
  
  rownames(mat) <- names(ampd)
  colnames(mat) <- names(ampd)
  heatmap(mat, symm = T)
}

AmpG

AmpD

AmpR

Interpretation

Wow, they are in fact very different! Let’s focus on cloacae and ludwigii. They appear to cluster together on AmpG and AmpD, but look at AmpR, they are not! We can genus clusters together, citrobacter freundii and klebsiella aerogenes are closer to each other than enterobacter cloacae complex. Even if they are close, they’re relatively far apart. This is fascinating because even though they are labeled as the same protein (e.g. AmpG), they are different in nucleotides! This means that if we want to do an exact match for AmpG, we may not be able to use the same sequence for different organisms. We may have to use different sequences for different organisms. And of course, this includes AmpC beta lactamases. This is very interesting! This also means that if we’re attempting to locate or annotate such protein producing genes, we need species specific reference and can’t just pull an off the shelf sequence for annotation or detection. Very different from our prior plasmids experiences.

Opportunities For Improvement

learn about AmpE, AmpH, AmpF?
learn about porin mutation next
learn the different type of PBPs and the antibiotics that bind to them and which organisms contain these PBPs.

Lessons learnt

apparently some AmpR genes were not annotated as such, but it seems like majority are adjacent to ampC gene.
learnt how to put image side by side
learnt the direction of forward and reverse primers
AmpC beta-lactamase can bind to Cefepime and form a rather stable acyl enzyme complexes that make it relatively resistant to hydrolysis compared to other cephalosporins
learnt citrobacter koseri doesn’t actually possess class C beta-lactamase!
learnt Serratia marsecens has 2 recyclers (AmpD and AmiD2)!
learnt AmpC mechanics and its genes/proteins are species specific if we want to detect or annotate.

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Navigating Financial Statement And The Story It Tells Us - A Note To Myself

Sun, 29 Mar 2026 00:00:00 +0000

📊 Dipping my toes into financial statements — income, balance sheet & cash flow. Still don’t fully get it, but slowly piecing together the story these numbers tell. Warren Buffett makes it look easy 😅 Baby steps! 🌱

Motivations

I’ve always wanted to learn financial statement, what it means, what it tells us, what Warren Buffett sees in them. Following the book Warren Buffett and the Interpretation of Financial Statements: The Search for the Company with a Durable Competitive Advantage and Datacamp: Analyzing Financial Statement in Python, I’ve made some notes for myself and also create the metrics functions, so that I can use and view them easily in the future. I’ll be honest, I still don’t fully understand it, but at least I can refer back to this as I look at these statements more frequently.

Disclaimer:

This is purely for educational purposes. This is not a financial advice, nor am I a financial advisor. This is a note to myself. If you find any mistakes or error, please let me know. Thanks! Also, there are a lot of information on each section, I won’t be covering all of them, just mostly the metrics from the book and also points I found interesting.

Objectives:

The Skeleton of Financial Statements

A financial statement is a formal record that shows a company’s financial activities and position, typically consisting of three core components: the income statement (which shows revenues earned and expenses incurred to calculate profit or loss over a period), the balance sheet (which presents what the company owns as assets, what it owes as liabilities, and the difference between them as equity at a specific point in time), and the cash flow statement (which tracks the actual movement of cash in and out of the business through operating activities, investing activities, and financing activities). The income statement reveals profitability, and the cash flow statement shows liquidity and how money actually moves through the business.

If we were to think of a kid’s lemonaid shop, the income statement would show how much money the shop made from selling lemon tea and how much it spent on ingredients, paying Johnny hourly to sell (salary) to calculate the profit. The balance sheet would list the shop’s assets (like cash in the register, inventory of lemons, sugar, and any equipment) and liabilities (like loans or unpaid bills - money your parent you borrowed from to buy all of the above) to show the net worth of the business at a given moment. The cash flow statement would track the actual cash coming in from customers and going out for expenses, giving insight into whether the shop has enough liquidity to cover its day-to-day operations.

It sounds simple, in the big picture, but these are just the basic skeleton of financial statements. There are many nuances and details that we need to understand to really grasp the story that these statements are telling us.Each section has its own items and some of these items are good at forming different metrics to tell the story of how the lemonaid business is doing. Below is just a snapshot of Apple’s financial statement.

Income Statement

Balance Sheet

Cash Flow

Let’s Take An Example

Let’s go to Alpha Vantage and create a free api key and then pull Apple’s 10 year financial statement and go through as an exercise.

https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm#i719388195b384d85a4e238ad88eba90a_181

library(httr)
library(jsonlite)
library(tidyverse)

api_key <- "your_api_key_here" # Use .Renviron to be safer like below combine_all code

## Create a function to pull data
get_data <- function(fx,ticker) {
  raw <- GET(paste0(
    "https://www.alphavantage.co/query?function=",fx,
    "&symbol=",ticker,"&apikey=", api_key
  )) %>%
    content(as = "text", encoding = "UTF-8") %>%
    fromJSON()
  
  df <- raw$annualReports |> 
    as_tibble() |> 
    mutate(across(-c(fiscalDateEnding, reportedCurrency), as.numeric)) |>
    mutate(fiscalDateEnding = as.Date(fiscalDateEnding)) |>
    arrange(fiscalDateEnding)

  return(df)
}

## financial statement
income <- get_data("INCOME_STATEMENT","AAPL")
balance <- get_data("BALANCE_SHEET","AAPL")
cashflow <- get_data("CASH_FLOW","AAPL")

Let’s visualize the income statement

Income Statement

Alright, here we go! Income statement tells the story of how the goods and services are doing in the market, how much it costs to produce and sell them, and how much profit is left after all expenses are accounted for. It is a dynamic statement that shows the flow of money over a period of time, typically a quarter or a year. It is like a movie that tells the story of the company’s operations and profitability. Below are some ratios and heuristics of which companies have a durable competitive advantage, according to Warren Buffett.

Gross Profit Margin

$Gross Profit Margin = Gross Profit / Total Revenue$

In the book, we are looking for consistent, as a general rule, above 40% to consider a company to have a durable competitive advantage. Gross profit here is basically Total Revenue - Cost of Revenue, does not take into account of R&D, admin etc. Gross profit margin is a measure of how much profit a company makes from its core operations, before accounting for other expenses. A higher gross profit margin indicates that the company has a strong competitive position in the market and is able to generate more profit from its sales.

So on Apple, you can see that in the sales section, there is product and service. I assume product is the hardware and service is like the cloud storage etc. The cost of revenue section has the same sections, that depicts how much cost to make these products/services. Again, remember this is all just about the goods, does not take into account of the R&D, office that manages these, administrative etc, I think. 🤔

Depreciation

Apparently this is a non-cash expense that reflects the reduction in value of a company’s assets over time. It is an accounting method used to allocate the cost of tangible assets (like machinery, equipment, buildings) and intangible assets (like patents, copyrights) over their useful lives. Depreciation allows companies to spread out the expense of an asset over several years, rather than recognizing the entire cost in the year it was purchased.

A quick ratio in the book is

$Depreciation / Gross Profit$

which should be low ~5-7% which indicates that the company is not heavily reliant on physical assets that may lose value over time. Warren stated that EBITDA (Earnings Before Depreciation, Taxes, and Amortization) is something Wall Street loves, but in Warren’s eyes, depreciation is a real expanse. Why is it that he said EBITDA is something Wall Street love? Because it shows a higher profit by excluding non-cash expenses like depreciation, which can make a company look more profitable than it actually is… interesting. 🤔

Interest Payment to Operating Income

$Interest Payment / Operating Income$

should be less than 15%. This ratio indicates that the company is not overly burdened by debt and has a healthy balance between its operating income and interest expenses. A lower ratio suggests that the company is generating sufficient operating income to cover its interest payments, which is a positive sign of financial stability.

Operating Income = Total Revenue - Cost of Revenue - Operating Expenses. And Operating Expenses = R&D + Selling, General and Administrative Expenses. Wow, so many terminologies and I still don’t fully understand them, but at least I can refer back to this when I look at these statements.

Income Before Tax

This is a value that Warren uses when he calculates the return that he is getting when he a whole business.

Income After Tax

This is a value is the truth test of a business. What is reported with SEC should reflect the pre-tax income reported on the income statement. Apparently some companies like to report higher values than the the truth? was what the book said 🤔

Net Earnings

$Net Earning / Total Revenue$

The heuristic for this is we should look for more than 20% which indicates that the company is able to generate a significant amount of profit from its total revenue, hence a long term competitive advantage.

Net Earnings = Operating Income - Interest Expense - Taxes. This is the bottom line of the income statement, which represents the company’s total profit after all expenses have been deducted from total revenue. It is a key indicator of a company’s profitability and financial performance. A higher net earnings figure indicates that the company is generating more profit from its operations, which can be a sign of a strong competitive position in the market.Interest Expense - Taxes`.

This is something Warren wants to see consistent increment over time.

This is calculated by: $EPS = Net Income/Outstanding Share$

Does that mean if net income is negative, we’ll have negative share? 🤔

Operating Margin

$Operating Margin = Operating Income / Total Revenue$

This is a measure of a company’s profitability that indicates how much profit it generates from its operations relative to its total revenue. A higher operating margin suggests that the company is more efficient at converting revenue into profit, which can be a sign of a strong competitive position in the market. Though I’m unsure what is a good heuristic for this, we’ll use more than 10%. What do you think?

Metrics

income_metric <- function(df) {
  df_i <- df |>
    mutate(grossProfitMargin = grossProfit / totalRevenue,
           depreciationToGrossProfit = depreciationAndAmortization / grossProfit,
           interestExpenseToOperatingIncome = interestExpense / operatingIncome,
           netEarningMargin = netIncome / totalRevenue,
           operatingMargin = operatingIncome / totalRevenue)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "grossProfitMargin", 0.4, "red", 
    "depreciationToGrossProfit", 0.07, "blue",
    "interestExpenseToOperatingIncome", 0.15, "blue",
    "netEarningMargin", 0.2, "red",
    "operatingMargin", 0.1, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_i |>
    select(fiscalDateEnding, grossProfitMargin:operatingMargin) |>
    pivot_longer(cols = c(grossProfitMargin:operatingMargin), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

income_metric(income)

Balance Sheet

$Asset = Liability + Shareholder Equity$

Reminded me of Full Metal Alchemist famous phrase “tōka kōkan”, equivalent exchange.

Current Assets

Current asset is any asset that can be reasonably expected to be converted into cash within one year. This includes cash and cash equivalents, accounts receivable, inventory, and other short-term assets. Current assets are important because they provide insight into a company’s liquidity and ability to meet its short-term obligations.

Net Receivables To Gross Sale Ratio

$Net Receivables / Gross Sale$

If a company consistently has a lower ratio (? 5% or less), it may indicate that the company is efficient in collecting payments from customers and has a lower risk of bad debts. A higher ratio may suggest that the company is having difficulty collecting payments, which could lead to cash flow issues and potential losses from uncollected receivables.

The Current Ratio

$Current Ratio = Total Current Assets / Total Current Liabilities$

The current ratio is a liquidity ratio that measures a company’s ability to pay off its short-term liabilities with its short-term assets. A current ratio of 1 or higher is generally considered good, indicating that the company has enough assets to cover its liabilities. A current ratio below 1 may indicate that the company may have difficulty meeting its short-term obligations. This makes sense.

Property, Plant, and Equipment

This is the value of a company’s physical assets, such as land, buildings, machinery, and equipment. It is important to consider the value of PPE when evaluating a company’s financial health and potential for growth. A company with a significant amount of PPE may have a competitive advantage in its industry, as it may be able to produce goods or services more efficiently than its competitors. However, it is also important to consider the age and condition of the PPE, as well as any potential liabilities associated with it. In the title of this chapter, it says For Warren Not Having Them Is A Good Thing 🤣

Short Term Debt

From Warren’s perspective, when it comes to investing in financial institutions, he’s always shied away from companies who are bigger borrowers in short-term than long-term.

$Short Term Debt/ Long Term Debt$

Not really sure what the heuristic threshold is, but let’s use less than 1 as a good indicator?

Long Term Debt

As a general rule, a company with durable competitve edge, will have no or little long term debt to maintain their business operation. Let’s ensure this is not an uptrend on visualization

Retained Earnings

Retained earnings is the portion of a company’s net income that is retained and not distributed as dividends to shareholders. It represents the accumulated profits that a company has reinvested in its business over time. Retained earnings can be used for various purposes, such as funding research and development, expanding operations, paying off debt, or acquiring other companies. It is an important metric for investors to consider when evaluating a company’s financial health and growth potential, as it indicates how much profit the company has generated and how it has been utilized to support its long-term success.

$Growth Rate = (Ending Retained Earnings/Beginning Retained Earnings)^{1/years}-1$

Treasury Stock

Treasury stock refers to shares that a company has repurchased from its shareholders. These shares are held in the company’s treasury and are not considered outstanding shares. Treasury stock can be used for various purposes, such as to increase shareholder value, to have shares available for employee compensation plans, or to prevent hostile takeovers. When a company repurchases its own shares, it reduces the number of outstanding shares in the market, which can increase the value of the remaining shares and potentially boost earnings per share (EPS). However, it is important for investors to consider the reasons behind a company’s decision to buy back its own stock and how it may impact the company’s financial health and long-term growth prospects.

Return On Shareholders’ Equity

$Return On Shareholders' Equity = Net Income / Shareholders' Equity$

According to the book, high ROSE means come play 🤣 How about stop and smell the rose? 🌹 The book did not tell us exactly what the threshold is, but the companies of choice has about ~30-35%

Metrics

balance_metric <- function(df, income) {
  df_b <- df |>
    mutate(currentRatio = totalCurrentAssets / totalCurrentLiabilities,
           netReceivablesToGrossSale = currentNetReceivables / income$grossProfit,
           shortToLongTermDebt = shortTermDebt / longTermDebt,
           growthRateRetainedEarnings = (retainedEarnings / lag(retainedEarnings))^(1/n()) - 1,
           returnOnShareholdersEquity = income$netIncome / totalShareholderEquity)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "currentRatio", 1, "red", 
    "netReceivablesToGrossSale", 0.05, "blue",
    "shortToLongTermDebt", 1, "blue",
    "growthRateRetainedEarnings", 0.05, "red",
    "returnOnShareholdersEquity", 0.3, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_b |>
    select(fiscalDateEnding, currentRatio:returnOnShareholdersEquity) |>
    pivot_longer(cols = c(currentRatio:returnOnShareholdersEquity), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

balance_metric(balance, income)

Cash Flow

Operating Income

Cash flow from operating income starts with net income and then add back depreciation and amortization. This is because depreciation and amortization are non-cash expenses that reduce net income but do not actually involve a cash outflow. By adding them back, we can get a better picture of the actual cash generated by the company’s operations.

Capital Expenditure

Also known as CapEx, refers to the funds that a company uses to acquire, upgrade, and maintain physical assets such as property, buildings, technology, equipment, or machinery. CapEx is an important metric for investors to consider when evaluating a company’s financial health and growth potential, as it indicates how much the company is investing in its long-term success.

If we were to look at Apple’s cash flow statement, CapEx is payments for acquisition of proptery, plant, and equipment.

$Capital Expenditure/Net Earning$

And the heuristic is ~50% or less.

Stock Buyback

Stock buyback, also known as share repurchase, refers to a company’s practice of buying back its own shares from the open market. This can be done for various reasons, such as to increase shareholder value, to have shares available for employee compensation plans, or to prevent hostile takeovers. When a company repurchases its own shares, it reduces the number of outstanding shares in the market, which can increase the value of the remaining shares and potentially boost earnings per share (EPS).

On the Apple cash flow statement, stock buyback is listed as repurchase of common stocks. Others might use issuance of (retirement) stocks.

Metrics

cashflow_metric <- function(df) {
  df_c <- df |>
    mutate(operatingCashFlow = netIncome + depreciationDepletionAndAmortization,
           capitalExpenditureToNetEarning = capitalExpenditures / netIncome,
           stockBuybackToNetEarning = abs(proceedsFromRepurchaseOfEquity / netIncome))
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "operatingCashFlow", 0, "red", 
    "capitalExpenditureToNetEarning", 0.5, "blue",
    "stockBuybackToNetEarning", 0.5, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_c |>
    select(fiscalDateEnding, operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning) |>
    pivot_longer(cols = c(operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw()
  
  return(plot)
}

cashflow_metric(cashflow)

Use key valuation metrics (P/E, EV/EBITDA, P/B, P/S, etc) to determine how cheap or expensive a stock is.

Combine All Metrics

code

library(httr)
library(jsonlite)
library(tidyverse)
library(ggpubr)

api_key <- Sys.getenv("avkey")

## Create a function to pull data
get_data <- function(fx,ticker,share=F) {
  raw <- GET(paste0(
    "https://www.alphavantage.co/query?function=",fx,
    "&symbol=",ticker,"&apikey=", api_key
  )) %>%
    content(as = "text", encoding = "UTF-8") %>%
    fromJSON()
  
  if (share==T) {
    df <- raw$annualEarnings |>
      select(fiscalDateEnding, reportedEPS) |>
      mutate(fiscalDateEnding = ymd(fiscalDateEnding))
  } else {
  df <- raw$annualReports |> 
    as_tibble() |>
    mutate(fiscalDateEnding = as.Date(fiscalDateEnding)) |>   
    mutate(across(where(is.character), as.numeric)) |>        
    arrange(fiscalDateEnding)
  }

  return(df)
}

income_metric <- function(df) {
  df_i <- df |>
    mutate(grossProfitMargin = grossProfit / totalRevenue,
           depreciationToGrossProfit = depreciationAndAmortization / grossProfit,
           interestExpenseToOperatingIncome = interestExpense / operatingIncome,
           netEarningMargin = netIncome / totalRevenue,
           operatingMargin = operatingIncome / totalRevenue)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "grossProfitMargin", 0.4, "red", 
    "depreciationToGrossProfit", 0.07, "blue",
    "interestExpenseToOperatingIncome", 0.15, "blue",
    "netEarningMargin", 0.2, "red",
    "operatingMargin", 0.1, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_i |>
    select(fiscalDateEnding, grossProfitMargin:operatingMargin) |>
    pivot_longer(cols = c(grossProfitMargin:operatingMargin), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Income Statement Metrics")
  
  return(plot)
}

share_metric <- function(df) {
    plot <- df |>
      mutate(reportedEPS = as.numeric(reportedEPS)) |>
      ggplot(aes(x = fiscalDateEnding, y = reportedEPS)) +
      geom_line() +
      geom_smooth() +
      theme_bw() +
      ggtitle("Share Metrics")
    return(plot)
}

balance_metric <- function(df, income) {
  df_b <- df |>
    mutate(currentRatio = totalCurrentAssets / totalCurrentLiabilities,
           netReceivablesToGrossSale = currentNetReceivables / income$grossProfit,
           shortToLongTermDebt = shortTermDebt / longTermDebt,
           growthRateRetainedEarnings = (retainedEarnings / lag(retainedEarnings))^(1/n()) - 1,
           returnOnShareholdersEquity = income$netIncome / totalShareholderEquity)
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "currentRatio", 1, "red", 
    "netReceivablesToGrossSale", 0.3, "blue",
    "shortToLongTermDebt", 1, "blue",
    "growthRateRetainedEarnings", 0.05, "red",
    "returnOnShareholdersEquity", 0.3, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_b |>
    select(fiscalDateEnding, currentRatio:returnOnShareholdersEquity) |>
    pivot_longer(cols = c(currentRatio:returnOnShareholdersEquity), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |>
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Balance Sheet Metrics")
  
  return(plot)
}

cashflow_metric <- function(df, income) {
  df_c <- df |>
    mutate(operatingCashFlow = netIncome + depreciationDepletionAndAmortization,
           capitalExpenditureToNetEarning = capitalExpenditures / netIncome,
           stockBuybackToNetEarning = case_when(
             proceedsFromRepurchaseOfEquity < 0 ~ -proceedsFromRepurchaseOfEquity / income$netIncome,
             income$netIncome < 0 & proceedsFromRepurchaseOfEquity > 0 ~ NA_real_,
             income$netIncome < 0 & proceedsFromRepurchaseOfEquity < 0 ~-proceedsFromRepurchaseOfEquity / income$netIncome))
  
  hline <- tribble(
    ~param, ~hline_value, ~color2,
    "operatingCashFlow", 0, "red", 
    "capitalExpenditureToNetEarning", 0.5, "blue",
    "stockBuybackToNetEarning", 0.5, "red"
  ) |>
    mutate(
      param = factor(param),
      ymin = ifelse(color2 == "red", -Inf, hline_value),
      ymax = ifelse(color2 == "red", hline_value, Inf)
    )
  
  columns <- hline$param
  
  plot <- df_c |>
    select(fiscalDateEnding, operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning) |>
    pivot_longer(cols = c(operatingCashFlow, capitalExpenditureToNetEarning, stockBuybackToNetEarning), 
                 names_to = "param", values_to = "values") |>
    mutate(param = factor(param, levels = columns)) |> 
    ggplot(aes(x = fiscalDateEnding, y = values)) +
    geom_rect(
      data = hline,
      aes(ymin = ymin, ymax = ymax, fill = color2),
      xmin = -Inf, xmax = Inf,
      alpha = 0.15,
      inherit.aes = FALSE
    ) +
    geom_line() +
    facet_wrap(. ~ param, scale = "free_y") +
    scale_fill_identity() +
    theme_bw() +
    ggtitle("Cash Flow Metrics")
  
  return(plot)
}

show_all <- function(name) {
  income <- get_data("INCOME_STATEMENT",name)
  share <- get_data("EARNINGS",name,share=T)
  balance <- get_data("BALANCE_SHEET",name)
  cashflow <- get_data("CASH_FLOW",name)
  plot1 <- income_metric(income) 
  plot2 <- share_metric(share)
  plot3 <- balance_metric(balance, income)
  plot4 <- cashflow_metric(cashflow, income)
  stacked_plot <- ggarrange(plot1,plot3,nrow=2)
  squished_plot <- ggarrange(plot4,plot2,ncol=2, widths = c(2,1))
  combineplot <- ggarrange(plotlist = list(stacked_plot,squished_plot), nrow = 2, heights = c(2,1))
  return(combineplot)
}

Let’s Look At Another Example

As a heuristics, we’ve made our dataviz where red is like lava, you want to stay above it. Blue is like the sky, you want to stay below it. The sweet zone is in between. 🤣 When there is a loess curve, we are trying to see if the share is consistently increasing.

Apple

show_all("AAPL")

Looking the income metrics, Apple seems to be doing pretty good. Gross profit margin, net earning margin, operating income margin are all above thresholds. Depreciation to gross profit ratio is appropriately below the threshold, which means there is no recent purchase of property, plants, machines, etc where these are the ones that will add to depreciation. There is also a low to no interest expense, which is good! No debt? Next we move on to balance sheet metrics, current ratio is not great, liquidity is not great, net receivable is ?OK, I guess it make sense, if your products are popular and provide some sort of finance option, you might have some receivables. Short term debt is much lower than long term debt, which is good. The ROSE is smelling pretty good there too! In terms of cash flow metrics, it’s looking really good, it has high cash flowing in, low CapEx, and consistently buying its own share from 2020 onwards.

Microsoft

show_all("MSFT")

As for Microsoft, now that we’re a bit more familiar with the sections, let’s just string our read instead of separating them. Good consistent profit for all profit, operating and net income. Interestingly, depreciation is high along with CapEx, did they buy property, plants or machine? Ah, they built data center? Interest expense is low, which is good. Good liquidity factor with current ratio above threshold, net receivables is OK same as Apple (a competitor), short/long debt is good as well. ROSE is close to the threshold (worth watching). Cash is flowing, not much stock buyback, but overall EPS is consistently increasing. With its investment in data centers for Azure, next few years we should be seeing a persistent depreciation to gross profit ratio, along with CapEx, right? I read somewhere where you can’t place all depreciation in a single year.

NVIDIA

show_all("NVDA")

Now let’s take a look at NVIDIA. Wow, gross profit, operating income, and net earning margin all really good, better than Apple and Microsoft! Well, make sense with all these data centers, they need GPUs from NVIDIA. Look at that depreciation and CapEx, barely any! That’s great, less to maintain and the current plants they have are adequate to supply the demand. Low interest expense too, not much debt interest. Liquidity is great with high current ratio! Net receivables is good too, these big companies are paying NVIDIA back! ROSE is also very fragrant! Cash is flowing through the roof. Not much stock buyback. Also exponential EPS! You know, Warren did say that be mindful of companies with R&D cost.

Intel

show_all("INTC")

Wow, first glance with the profits, we’re seeing lava red. We then see high rise in depreciation and CapEx. Did they buy more property, plants, or machines? Intel announces plans for an investment of more than $28 billion for two new chip factories in Licking County, Ohio. And maybe Germany and Arizona too? Interesting. Notice that the interest expense towards the end of 2025 was in 2 digit but negative? It’s because the the operating income was negative and a high interest expense. I wonder if I should make this absolute as opposed to keeping the negative. Anyway, this means that not only was Intel in the red but also paying quite a bit of interest from the debt, I assume. The current ratio looks pretty good, same goes with the net receivables. Short term debt is also much lower compared to long term. ROSE not so good. As for the cash flow, when we add depreciation and demortization back to net income, it brought the red back up. Notice how the EPS dropped significantly lately, and notice that the buyback of share is missing? We code it where if it’s a positive value of buyback, which means it’s issuing stock instead of repurchasing, hence NA. Wow, what do you think? Will they be able to turn this around? Do data centers use Intel chips or AMD’s threadripper?

AMD

show_all("AMD")

Interesting income statement metric results. Good gross profit margin, but the net earning is barely. Interesting depreciation trend, what happened in 2024, where CapEx didn’t budge? Great liquidity, pretty high net receivables. Wow, very high short-to-long term debt in ?2021-2022. ROSE is essentially 0. With cash flowing good towards 2025, and also high buybacks 2022 ish. Finally, uptrending EPS! This is an odd one. Pasting my observation onto Claude and wow, these findings are due to Xilinx acquisition. That makes sense! Didn’t build new plants, old property, plants, machines have already been amortized, hence low depreciation. The acquisition is funded by debt, hence high short-to-long term debt ratio. Very interesting, indeed! So, it could be true that data centers prefer AMD over Intel given the good profit?

Google

show_all("GOOG")

Very good profit of all 3 metrics. After 2020, depreciation downtrended which is good and so did CapEx. Not much debt. Downtrending current ratio but still good. Very good net receivables! ROSE is coming up. Great cash flow. There is buyback of equity. Rising EPS. All great signs for Google! Being an all-service (no hardware?) company, this is quite good and healthy!

3M

show_all("MMM")

Now on to 3M, not a tech company, but let’s see if our workflow of looking at financial statement will help us tell a story. Profit is not as great as other tech companies we looked at, though gross profit is above threshold, but the net earnings is in the lava. Notice both net earnings and operating margins dipped quite low in 2024? And then a pretty high interest expense to operating income ratio in 2025? I wonder if because of losing money, they borrowed long term, hence short-to-long term debt is not too high? Current ratio is acceptable, but why is net receivables so high for 3M? Clients were not able to pay 3M? ROSE is pretty good in 2024 and 2025 even when profits weren’t. But why? Cash flow with high variance last 3 years. There is stock buyback in 2025. And even though EPS downtrended past 2 years but still remained high. This is a very interesting one as well. 3M should be a company where there’s competitive advantage because they make lots of daily usables which doesn’t need a whole lot of R&D. But why the anomaly in 2024 requiring debt? What do you think?

Disney

show_all("DIS")

Alright, what about Disney? Profit doesn’t seem as good as I expected. Both gross profit and net earning margins were below threshold, except for operating income margin. Interesting, in 2021, there is increase in depreciation, CapEx, and interest expense with low short-to-long debt ratio. It almost looked like they borrowed some money to purchase something new? Did they rebuild a park or something? In terms of liquidity, it’s on the lava zone in 2025 and seemed like it downtrended for the past 3 years as well. Net receivables is OK? Though I would think it should be lower? ROSE is red. Cash flow looks good, this is interesting because whatever that caused the depreciation when added back now they have cash. Also interesting to note that from 2020 to 2024 they were issuing stock rather than buying back. Their EPS appear to be quite volatile for the pat 3 years.

Boeing

show_all("BA")

Last but not least, let’s look at Boeing. Three profit margin metrics in the lava zone. Spike of interest expense in 2021 along with depreciation. Something physical was bought with borrowed money that’s paid long term. Current ratio is good. Essentially no net receivables. Consistent floating ROSE on the red sea. Operating cash flow in the red for a few years then positive in 2025. CapEx spiked in 2025, ?what was spent in capital where it doesn’t really depreciate? Buyback stock is interesting, missing several past few years, essentially issuing stocks when we have NA data. EPS downtrend to the negatives.

Opportunities For Improvement

We need to recheck growth rate again, not sure if the code is correct
perhaps build this into an R package, and develop further
Learn about valuation metrics such as P/E, EV/EBITDA, P/B, P/S
Not really sure if short-to-long term debt ratio of 1 is a good threshold, seems too high.
include actual numbers on geom_label with ggrepel and reduce font size

Lessons learnt

Depreciation and CapEx seem to have strong correlation, which makes sense.
learnt Alpha Vantage API, quite straight forward
learnt to look at financial statement and its metrics

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Exploring Piperacillin/Tazobactam Probability of Target Attainment (PTA) in Pseudomonas

Sun, 15 Mar 2026 00:00:00 +0000

Exploring pip/tazo PTA for Pseudomonas using popPK simulation. Key finds: 30-min infusions fall short of 90% PTA at MIC 16; prolonged infusion helps, but neutropenic fever population sees the biggest drop in PTA. ~46% of susceptible PsA isolates carry blaOXA-2 — tazobactam matters more than I thought

Motivations

We’ve learnt a bit of PK/PD last time, here. Let’s apply that on Pip/tazo and Pseudomonas. An FDA statement Feb 2024 detailed that for susceptible dose dependent (SDD) breakpoint of 16 mcg/mL, we should utilize 4.5 g q6h over 3-hour infusion because the standard dosing of 4.5g IV every 6 hours over 0.5 hours do not adequate achieve > 90% PTA. There is also a mention on the limitation where the fT > mic of 50% was used to calculate PTA, which was not adequately validated for PsA. This is a great opportunity for us to take a look at this, now that we have a better understanding of what PTA and fT>mic mean from a data structure standpoint!

First, we’ll obtain the population PK parameters, make a model, and then perform the simulation, and visualize the PTA. We’ll be exploring A Pooled Pharmacokinetic Analysis for Piperacillin/Tazobactam Across Different Patient Populations: From Premature Infants to the Elderly. This model is more sophisticated than the previous one as it’s a pooled popPK model. We’ll then compare the PTA of the recommended dosing and infusion time, compared to standard dosing of 30 mins. And then look at some maximum amount of fT>mic used in the literature, and then explore the PTA given the threshold of fT>mic. Also, a curious question is, why do we need tazobactam for pseudomonas when piperacillin itself has activity against it? Could it be because of co-resistance of beta lactamase? Let’s take a look at all pseudomonas isolate that is pip/tazo susceptible and check for proportion of these beta lactamase genes in NCBI.

Disclaimer:

This is purely for educational purposes. Not a medical advice. If you find something wrong, please let me know so I can correct and continue to learn.

Objectives:

Piptazo Model

LLM code

library(mrgsolve)
library(tidyverse)

mod <- mcode(model = "piptazo", code = '
$PARAM
// --- Fixed effects (Table 3) ---
// Piperacillin
theta_V1_PIP  = 10.4,   // L/70kg
theta_CL_PIP  = 10.6,   // L/h/70kg
theta_V2_PIP  = 11.6,   // L/70kg
theta_Q2_PIP  = 15.2,   // L/h/70kg

// Tazobactam
theta_V1_TAZ  = 10.5,   // L/70kg
theta_CL_TAZ  = 9.58,   // L/h/70kg
theta_V2_TAZ  = 13.7,   // L/70kg
theta_Q2_TAZ  = 16.8,   // L/h/70kg

// Shared maturation-decline parameters
MAT50_wk      = 54.2,   // weeks PMA at 50% maturation (shared)
gamma1        = 3.35,   // shape: maturation
DEC50_PIP_yr  = 89.1,   // years PMA at 50% decline, PIP
DEC50_TAZ_yr  = 61.6,   // years PMA at 50% decline, TAZ
gamma2        = 1.92,   // shape: decline (shared)

// SCR effect on CL (shared PIP+TAZ, Eq. 4)
theta_SCR     = 0.346,  // dL/mg

// Protein binding / DBS corrections (Eqs. 23-25)
fUNB_PIP      = 0.645,  // fraction unbound piperacillin
fDBS_PIP      = 0.368,  // DBS:plasma ratio PIP
fDBS_TAZ      = 0.448,  // DBS:plasma ratio TAZ

// Study-specific corrections (Eqs. 21-22)
// Set to 1.0 for general non-Sime use; 1.73 for Sime et al. CL, 0.512 for Sime et al. V2
theta_CL_Sime = 1.0,
theta_V2_Sime = 1.0,

// Patient covariates (defaults: 70kg, 35yr, SCR 0.83 mg/dL reference adult)
TBW           = 70,     // kg
PMA_yr        = 35,     // postmenstrual age, years
SCR           = 0.83    // serum creatinine, mg/dL

$CMT CENT_PIP PERI_PIP CENT_TAZ PERI_TAZ

$MAIN
// --- Eq. 16: Size scaling relative to 70kg reference ---
double FSIZE = TBW / 70.0;

// --- Eq. 17: Maturation function (PMA in weeks) ---
double PMA_wk = PMA_yr * 52.1775;
double FMAT = pow(PMA_wk, gamma1) /
              (pow(PMA_wk, gamma1) + pow(MAT50_wk, gamma1));

// --- Eqs. 18-19: Decline functions (PMA in years) ---
double FDEC_PIP = 1.0 - pow(PMA_yr, gamma2) /
                        (pow(PMA_yr, gamma2) + pow(DEC50_PIP_yr, gamma2));

double FDEC_TAZ = 1.0 - pow(PMA_yr, gamma2) /
                        (pow(PMA_yr, gamma2) + pow(DEC50_TAZ_yr, gamma2));

// --- Eq. 20: Standardised SCR (Colin et al. equation) ---
double SCR_std = exp(1.42 - (1.17 + 0.203 * log(PMA_yr / 100.0)) /
                             sqrt(PMA_yr / 100.0));

// --- Eq. 4: SCR effect on CL (shared for PIP and TAZ) ---
double FSCR = exp(-theta_SCR * (SCR - SCR_std));

// --- Individual PK parameters ---
// ETA index key (Table 3 / Eqs. 6-14):
//   ETA(1) = V1  (shared PIP + TAZ)
//   ETA(2) = CL_PIP
//   ETA(3) = CL_TAZ
//   ETA(4) = V2  (shared PIP + TAZ)
//   ETA(5) = Q2  (shared PIP + TAZ)

// PIP (Eqs. 6-9)
double V1_PIP = theta_V1_PIP * FSIZE * exp(ETA(1));
double CL_PIP = theta_CL_PIP * pow(FSIZE, 0.75) * FMAT * FDEC_PIP * FSCR
                * theta_CL_Sime * exp(ETA(2));
double V2_PIP = theta_V2_PIP * FSIZE * theta_V2_Sime * exp(ETA(4));

// Eq. 9: compartmental allometry for Q2_PIP
// Q2_i ∝ (V2_i_individual / V2_i_typical)^0.75
double Q2_PIP = theta_Q2_PIP *
                pow(V2_PIP / (theta_V2_PIP * FSIZE * theta_V2_Sime), 0.75) *
                exp(ETA(5));

// TAZ (Eqs. 11-14)
double V1_TAZ = theta_V1_TAZ * FSIZE * exp(ETA(1));
double CL_TAZ = theta_CL_TAZ * pow(FSIZE, 0.75) * FMAT * FDEC_TAZ * FSCR
                * exp(ETA(3));
double V2_TAZ = theta_V2_TAZ * FSIZE * exp(ETA(4));

// Eq. 14: compartmental allometry for Q2_TAZ
double Q2_TAZ = theta_Q2_TAZ *
                pow(V2_TAZ / (theta_V2_TAZ * FSIZE), 0.75) *
                exp(ETA(5));

$OMEGA
// ETA(1): IIV V1 shared PIP+TAZ [42.6% CV -> omega2 = log(0.426^2 + 1)]
0.1537

$OMEGA
// ETA(2): IIV CL_PIP [43.2%]
0.1598

$OMEGA
// ETA(3): IIV CL_TAZ [41.5%]
0.1480

$OMEGA
// ETA(4): IIV V2 shared PIP+TAZ [85.4%]
0.5218

$OMEGA
// ETA(5): IIV Q2 shared PIP+TAZ [65.6%]
0.3598

$SIGMA
// EPS(1): PIP proportional error [30.2% -> sigma = 0.302^2]
0.0912

// EPS(2): PIP additive error [0.147 mg/L -> sigma = 0.147^2]
0.0216

// EPS(3): TAZ proportional error [28.5% -> sigma = 0.285^2]
0.0812

// EPS(4): TAZ additive error [0 FIX per Table 3]
0.0000

$ODE
dxdt_CENT_PIP = -(CL_PIP / V1_PIP) * CENT_PIP
                - (Q2_PIP / V1_PIP) * CENT_PIP
                + (Q2_PIP / V2_PIP) * PERI_PIP;

dxdt_PERI_PIP =  (Q2_PIP / V1_PIP) * CENT_PIP
                - (Q2_PIP / V2_PIP) * PERI_PIP;

dxdt_CENT_TAZ = -(CL_TAZ / V1_TAZ) * CENT_TAZ
                - (Q2_TAZ / V1_TAZ) * CENT_TAZ
                + (Q2_TAZ / V2_TAZ) * PERI_TAZ;

dxdt_PERI_TAZ =  (Q2_TAZ / V1_TAZ) * CENT_TAZ
                - (Q2_TAZ / V2_TAZ) * PERI_TAZ;

$TABLE
// Eq. 10: PIP total plasma (proportional + additive error, Table 3)
double Cp_PIP_total   = (CENT_PIP / V1_PIP) * (1.0 + EPS(1)) + EPS(2);

// PD-relevant: unbound PIP (Eq. 23: fUNB = 0.645 for non-Sukarnjanaset)
// No residual error on this — it is derived deterministically for simulation
double Cp_PIP_unbound = fUNB_PIP * (CENT_PIP / V1_PIP);

// Eq. 15: TAZ total plasma (proportional + additive error; additive = 0 FIX)
double Cp_TAZ_total   = (CENT_TAZ / V1_TAZ) * (1.0 + EPS(3)) + EPS(4);

// DBS concentrations (Eqs. 24-25), applied to total plasma
double Cp_PIP_DBS = fDBS_PIP * (CENT_PIP / V1_PIP);
double Cp_TAZ_DBS = fDBS_TAZ * (CENT_TAZ / V1_TAZ);

$CAPTURE
Cp_PIP_total Cp_PIP_unbound Cp_TAZ_total
Cp_PIP_DBS Cp_TAZ_DBS
V1_PIP CL_PIP V2_PIP Q2_PIP
V1_TAZ CL_TAZ V2_TAZ Q2_TAZ
FSIZE FMAT FDEC_PIP FDEC_TAZ FSCR SCR_std
')

Explaination:

$PARAM: the parameters of the model, which include the fixed effects (theta) and the patient covariates (TBW, PMA_yr, SCR). The fixed effects are the typical values of the PK parameters for a 70kg, 35yr, SCR 0.83 mg/dL reference adult. The patient covariates are the total body weight (TBW), postmenstrual age in years (PMA_yr), and serum creatinine (SCR).
$CMT: the compartments of the model, which include the central and peripheral compartments for both piperacillin (CENT_PIP, PERI_PIP) and tazobactam (CENT_TAZ, PERI_TAZ).
$MAIN: the main block where the individual PK parameters are calculated based on the fixed effects and the patient covariates. This includes size scaling (FSIZE), maturation function (FMAT), decline functions (FDEC_PIP and FDEC_TAZ), standardized SCR (SCR_std), and then the individual PK parameters for piperacillin (V1_PIP, CL_PIP, V2_PIP, Q2_PIP) and tazobactam (V1_TAZ, CL_TAZ, V2_TAZ, Q2_TAZ).
$OMEGA: the inter-individual variability (IIV) for the PK parameters, which are assumed to be log-normally distributed. The values are derived from the coefficients of variation (CV) reported in Table 3 of the paper.
$SIGMA: the residual unexplained variability (RUV) for the observed concentrations, which include proportional and additive error for both piperacillin and tazobactam.
$ODE: the ordinary differential equations that describe the change in drug amount in each compartment over time, based on the PK parameters.
$TABLE: the block where the output variables are defined, including the total plasma concentrations of piperacillin and tazobactam (with error), the unbound piperacillin concentration (which is relevant for PD), and the DBS concentrations.

Alright, the above was LLM generated, including the model! It’s quite good, but we have to verify it and recode from ground up and see if we understand it. The nice thing about this is that at least we have notes to compare and refer if we hit a road block. You can see mine below and I found starting from $MAIN is helpful and just add all the $PARAM and other equations as we build the model is very helpful! Also, we found out that the CRstd is from here and the equation is a bit different from the paper. We also found that the back-calculated IIV values were a bit different. But it’s a great draft overall! And we also noticed that there will be adjustments if we need to simualate neutropenic fever Sime et al or critically ill during early sepsis Sukarnjanaset et al. We’ll look at that in a bit.

my code

mod <- mcode(model = "piptazo_ken", code = '
$PARAM
theta_v1_pip = 10.4,
tbw = 70,
theta_cl_pip = 10.6, 
pma_year = 35,
gamma1 = 3.35,
gamma2 = 1.92,
scr = 0.82,
theta_scr = 0.346,
dec50_pip = 89.1,
theta_cl_sime = 1,
theta_v2_sime = 1,
funb_pip = 0.645,
fdbs_pip = 1,    // we are assuming we dont use dried bld sample
theta_v2_pip = 11.6,
theta_q2_pip = 15.2,
mat50 = 54.2


$CMT CENT_PIP PERI_PIP 

$MAIN
double fsize = tbw / 70;
double pma_week = pma_year * 52.17;
double fmat = pow(pma_week,gamma1) / (pow(pma_week,gamma1) + pow(mat50,gamma1));
double fdec_pip = 1 - (pow(pma_year, gamma2) / (pow(pma_year, gamma2) + pow(dec50_pip, gamma2)));
double scrstd = exp(1.42 - (1.17 + 0.203 * log(pma_year / 100.0)) / sqrt(pma_year / 100.0));
double fscr = exp(-theta_scr*(scr-scrstd));

double v1_pip = theta_v1_pip * fsize * exp(ETA(1));
double cl_pip = theta_cl_pip * pow(fsize, 0.75) * fmat * fdec_pip * fscr * theta_cl_sime * exp(ETA(2));
double v2_pip = theta_v2_pip * fsize * theta_v2_sime * exp(ETA(4));
double q2_pip = theta_q2_pip * pow(v2_pip/theta_v2_pip, 0.75) * exp(ETA(5));

$OMEGA
0.1667645 
0.1711123
0.1589037   // IIV CL for tazo ETA(3)
0.547726
0.3579094

$ODE
dxdt_CENT_PIP = -(cl_pip/v1_pip)*CENT_PIP - (q2_pip/v1_pip)*CENT_PIP + (q2_pip/v2_pip)*PERI_PIP;
dxdt_PERI_PIP = -(q2_pip/v2_pip)*PERI_PIP + (q2_pip/v1_pip)*CENT_PIP;

$TABLE
double free_pip = (CENT_PIP/v1_pip) * funb_pip;

$CAPTURE
free_pip')

Also, I only simulated piperacillin unbound concentration since the mic is focused mainly on that. And no point of including the proportional or additive residuals since we’re not estimating the variance of the test result. The model looks smaller than the LLM generated. That being said, still a great exercise! Especially the ODE part.

Probability of Target Attainment

Ok, let’s look at non critical care, non neutropenic febrile population with weight of 90kg and age 35 with Scr 0.83

For easier visualization, I placed a red dashed red horizontal line to indicate PTA of 90%, and also dashed black vertical line to indicate mic of 16, the highest mic to be classified as susceptible to piptazo. We can see that both the 30 min infusion regardless of 4g had less than 90% PTA. Now, what if we increase the age and Scr a little bit to represent average population who will need piptazo.

Age 50, Scr 1

OK, maybe on average, it might be OK with intermittent infusion as long as it’s 4g. What if we look at critically ill population with early sepsis

Critically Ill

Oh, that’s interesting, I would expect it to be worse but what’s showing here is the opposite. Looking at the calculation, it might be because of funb_pip == 1, which makes the free concentration higher. But in reality, this would also mean clearance is faster and higher as well. Since the way we code in the model doesn’t account that, I’m not sure if we can make sense of this result. But we’ll keep this because the paper actually questioned if fT > mic 50% might be too low for critically ill populations. We’ll explore that in a little bit.

Neutropenic Fever

Wow, this is very dramatic. Even prolonged infusion except for 4g (3hr) q6 infusions had barely above 90% PTA.

Maximum fT>mic used in the literature

According to some literature that ft> mic 50% is not suitable for PsA, though there is no consensus on what the optimal threshold should be. I found some papers that used 70% or even 100%. Let’s look at the PTA if we use these thresholds.

OK, we are seeing the PTA drops quite a bit if fT>mic is 100%. This is when the critically ill population parameter might come in handy. Some even said that this population may need fT>4xmic 100% to achieve optimal outcome. So let’s look at that as well.

fT > mic 100%

fT > 4 x mic 100%

Wow… 😵‍💫 When looking at the original paper, the number look quite similar to ours for extended infusion for both fT>mic 100% and fT>4xmic 100%.

Proportion of PsA in NCBI that would benefit from tazobactam

How are we going to do this? It might not be 100% but we tried filtering PsA of piptazo susceptible and the overlap it with piperacillin resistant, but there were zero overlap. What if we grab all PsA piptazo susceptible and check for beta lactamase genes with exact match?

Over here we search for allele:(blaTEM-1 blaTEM-2 blaTEM-3 blaTEM-4 blaTEM-5 blaTEM-6 blaTEM-7 blaTEM-8 blaTEM-9 blaTEM-10 blaTEM-12 blaTEM-26 blaSHV-1 blaSHV-2 blaSHV-5 blaSHV-12 blaCTX-M-1 blaCTX-M-2 blaCTX-M-3 blaCTX-M-9 blaCTX-M-14 blaCTX-M-15 blaCTX-M-27 blaPER-1 blaPER-2 blaVEB-1 blaVEB-9 blaGES-1 blaOXA-2 blaOXA-10 blaOXA-15 blaPSE-4) .

Then run through the same script as before. Let’s see what we find!

There were 212 isolates of PsA susceptible to piptazo, but only 124 isolates with assemblies. Of the 124 isolates we were able to grab the assemblies, we detected 46% (n=57) with blaOXA-2. Which means, there is a good chance that piperacillin would be hydrolyzed without the tazobactam!

Final Thought

Wow, these population PK and PK/PD studies are mathematically intense! High respect to those who were able to tease the signal out of the noise from all these studies. Definitely lots to learn! Now, I think I have a better understanding why CLSI and FDA had issued statements about mic 16 and piptazo dosing etc. This makes so much more sense now. 🙌

Opportunities For Improvement

get more literature on clinical outcomes and fT > mic of different thresholds, and same with PTA
does tazobactam mic matter in this setting?
does albumin matter much here?
what about cefepime PTA?

Lessons learnt

created an actual PTA plot of all the mics
learnt to recreate model based on popPK study, thank goodness they provide equations on the paper!
got a bit more comfortable with the model parameters in mrgsolve

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning PK/PD Simulation: A Beginner's Monte Carlo Analysis With mrgsolve in R

Mon, 09 Mar 2026 00:00:00 +0000

🧪 Diving into PK/PD for the first time — simulating ceftriaxone with mrgsolve in R. Free drug levels were… surprisingly high? Even pushed it to q48h dosing out of curiosity and the results left me with more questions than answers 🤔📈

Motivations

Learning pharmacokinetics (PK) and pharmocodynamics (PD) have always been an interest of mine. It’s always challenging to read through these population PK papers with all the numbers etc. What’s a better way of diving into the surface of these and see if we can at least know how to code a simulation to obtain the probability target attainment (PTA) of different minimal inhibitory concentration (mic) and learn the basics via code! Let’s dive on!

Disclaimer:

I am not a pharmacist and not an expert in PK/PD. This is a documentation for my own learning and for educational purposes only. Not a medical advice. If you noticed anything wrong here, please let me know! PLEASE BE ADVICE THAT THERE WAS AN ERROR IN MY MODEL WHEN CALCULATING FREE CEFTRIAXONE (MAKING SOME RESULTS INACCURATE), I LEFT THE MISTAKE IN THE SECTION AND SPECIFIED THE CORRECTION ON THE UPDATE SECTION.

Objectives:

What Is Population PK

Population pharmacokinetics (popPK) is a statistical approach that describes how medications behave in the body across groups of people, accounting for variability between individuals. Instead of studying one person intensively, popPK analyzes sparse data from many patients to understand typical medication behavior and why people differ in their medication exposure.

We’ll use Garot D et al Population pharmacokinetics of ceftriaxone in critically ill septic patients: a reappraisal as an example for learning.

What Are The Parameters of Interest On a Paper?

From the paper, we can see that there are a lot of parameters and numbers. But what are the parameters of interest? We will focus on the following parameters:

Looking at their table 3, we see these values:
CL = $\theta_1 + \theta_2 . (CL_{cr}/4.26)$
$\theta_1$ : Non-renal (baseline) clearance component
$\theta_2$ : Renal clearance scaling coefficient
V1 : Volume of distribution of the central compartment.
V2 : Volume of distribution of the peripheral compartment.
Q : Inter-compartmental clearance.
$\omega^2 (CL)$ : Between-subject variability of clearance.
$\omega^2 (V1)$ : Between-subject variability of volume of distribution of the central compartment.
$\omega^2 (V2)$ : Between-subject variability of volume of distribution of the peripheral compartment.

These are the parameters we’ll use in our mrgsolve model. I’ve always wondered what these parameters represent and it was a bit difficult to conceptualize until we dove into the code and finally understood the rationale! It’s a mixed effect model where the estimates were modeled as a function of the fixed effect (theta) and the random effect (eta), you will see this in the code later. The fixed effect represents the typical value of the parameter in the population, while the random effect represents the variability between individuals. The random effect is assumed to be normally distributed with a mean of zero and a variance of omega squared.

If we were to draw a flow chart of the above, it will look something like this:

One starts with medication being administered into the central compartment, and then it goes into either peripheral compartment (tissue etc) and medication clearance. Notice that the Q is a bidirectional flow between central and peripheral, whereas all other directions are either into central or out from central to clearance. This is very helpful for me to get a surface understanding of the distribution. Let’s get on with the code!

Let’s Code

library(mrgsolve)
library(tidyverse)

mod <- mcode(model = "ceftriaxone", code='
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = 4.26,   // median creatinine clearance of 68.5 ml min-1, hence ~4.26 L hr-1
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,  
fu     = 0.10  // fraction of unbound, picked a static value from package insert range

$CMT CENT PERI

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);  // technically we could use 0.88 as reported on their result section
double CLi = CL * exp(ETA(1));                  // ETA here means log normal distibution of mean 
double V1i = V1 * exp(ETA(2));     
double V2i = V2 * exp(ETA(3));

$OMEGA
0.24   // omega2(CL) from table
0.23
0.42

$SIGMA
0.0576   // √0.0576 = 0.24, 

$ODE
dxdt_CENT = -(CLi/V1i)*CENT - (Q/V1i)*CENT + (Q/V2i)*PERI;
dxdt_PERI =  (Q/V1i)*CENT   - (Q/V2i)*PERI;

$TABLE
double Cp_total = (CENT / V1i)*(1+EPS(1)); 
double Cp_free = fu * Cp_total;

$CAPTURE Cp_free
')

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

ETA in the above means the random effect, which is assumed to be normally distributed with a mean of zero and a variance of omega squared. ETA is a greek letter (eh-ta). EPS here is Epsilon.

For ev, amount is dosing in mg; rate is amount given per hour; ii is frequency; addl is number of additional doses; cmt is the compartment where the dose is given. In this case, we are giving 2000 mg of ceftriaxone as a 30 minute infusion every 24 hours for 3 doses (1 initial dose + 2 additional doses) into the central compartment.

We will then need to set seed for reproducibility, pipe in your initial model with dosing, then nid is number of individuals you want to simulate, end is the end time of the simulation in hours, and delta is the time interval for the simulation output in hours. In this case, we are simulating 1000 individuals for 72 hours with a time interval of 0.25 hours (15 minutes).

Next, we’ll calculate the probability of target attainment (PTA) for different minimal inhibitory concentration (MIC) values. The PTA is the probability that the free drug concentration exceeds the MIC for a certain percentage of the dosing interval.

MIC <- 1

print(paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull()))

## [1] "Probability of Target Attainment: 0.996"

sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw()

In the above we choose mic of 1, filtered off time after 48 hours for steady state, then calculate the average free ceftriaxone that is above the mic, then assess the mean of times where free ceftriaxone is above 50% per simulated subject. We can see that the probability of target attainment is around 99.6%. We can also visualize the free ceftriaxone concentration over time with a red line indicating the mic of 1. Not too shabby! Now let’s assess when there is a difference in CrCl and albumin. I’ll spare you the code.

Changes in CrCl

code

library(glue)

crcl_vec <- c(1.8,7.2,10.8)
crcl_vec_i <- c(30, 120, 180)

# 30 ml/min = 1.8 L/hr
# 120 ml/min = 7.2 L/hr
# 180 ml/min = 10.8 L/hr

for (crcl in crcl_vec) {

mod <- mcode(model = "ceftriaxone", code=glue('
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = {crcl},
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,  
fu     = 0.10  // fraction of unbound, picked a static value from package insert range

$CMT CENT PERI

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);  // technically we could use 0.88 as reported on their result section
double CLi = CL * exp(ETA(1));                  // ETA here means log normal distibution of mean 
double V1i = V1 * exp(ETA(2));     
double V2i = V2 * exp(ETA(3));

$OMEGA
0.24   // omega2(CL) from table
0.23
0.42

$SIGMA
0.0576   // √0.0576 = 0.24, 

$ODE
dxdt_CENT = -(CLi/V1i)*CENT - (Q/V1i)*CENT + (Q/V2i)*PERI;
dxdt_PERI =  (Q/V1i)*CENT   - (Q/V2i)*PERI;

$TABLE
double Cp_total = (CENT / V1i)*(1+EPS(1)); 
double Cp_free = fu * Cp_total;

$CAPTURE Cp_free
',crcl))

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull(), " ,CrCl: ", crcl_vec_i[crcl_vec==crcl], "ml/min")


plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw() +
  ggtitle(pta)

plot(plot)
}

That’s interesting! That makes sense, increased CrCl will increase clearance of ceftriaxone, hence decrease in PTA. It’s still pretty good though! Though, what is considered acceptable? 90%? 70%? 50%? Also, the above PTA is based on 50% of a time free ceftriaxone is above MIC. What is the acceptable number for that then? 🤷‍♂️ What if, since ceftriaxone is albumin bound, if we model albumin into the model as well?

Changes With Hypoalbuminemia

Note: Important update. DO NOT READ THIS WITHOUT LOOKING AT THE UPDATE SECTION DOWN BELOW. THE FORMULA PROVIDED HERE IS WRONG.

Notice that our initial model had a fixed fraction of unbound (fu) of 0.1, which is the middle of the range reported in the package insert. However, in critically ill patients, hypoalbuminemia is common and can lead to an increase in the fraction of unbound drug, which can affect the pharmacokinetics and pharmacodynamics of ceftriaxone. Let’s see how we can model this in our mrgsolve code. From the paper in method section, they used the formula below to estimate free ceftriaxone from total ceftriaxone:

We’ll add that to our model and adjust the np (total concentration of protein binding sites) according to estimate with lower albumin (np = 295), this number again was from the paper in the discussion portion where their median albumin were ~25g/L.

code

mod <- mcode(model = "ceftriaxone", code='
$PARAM
theta1 = 0.56,
theta2 = 0.32,
CLcr   = 4.26,
V1     = 10.3,
V2     = 7.35,
Q      = 5.28,
np     = 517,  
kaff   = 0.0367 

$OMEGA
0.24
0.23
0.42

$SIGMA
0.0576

$CMT CENT PERI

$GLOBAL
double solveFree(double CTOT, double np, double kaff) {
  double cf   = (-(np+1/kaff-CTOT)+sqrt(pow(np+1/kaff-CTOT,2.0)+(4.0*CTOT/kaff)));
  return cf > 0 ? cf : 0;
}

$MAIN
double CL  = theta1 + theta2 * (CLcr / 4.26);
double CLi = CL * exp(ETA(1));
double V1i = V1 * exp(ETA(2));
double V2i = V2 * exp(ETA(3));

$ODE
double CTOT  = CENT / V1i;           // renamed: avoid clash with $TABLE
double CFREE = solveFree(CTOT, np, kaff);

dxdt_CENT = -CLi * CFREE
            - (Q / V1i) * CENT
            + (Q / V2i) * PERI;

dxdt_PERI =  (Q / V1i) * CENT
            - (Q / V2i) * PERI;

$TABLE
double CTOTAL      = CENT / V1i;      // notice this is not CTOT
double Cp_free     = solveFree(CTOTAL, np, kaff);
double Cp_bound    = CTOTAL - Cp_free;
double FU          = Cp_free / (CTOTAL + 1e-9);
double Cp_obs      = CTOTAL * (1 + EPS(1));

$CAPTURE CTOTAL Cp_free Cp_bound FU Cp_obs
')

dosing <- ev(amt = 2000, rate = 4000, ii = 24, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  param(np = 295) |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 72, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("Probability of Target Attainment: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.50)) |>
  pull(),", Albumin: ~25g/L, CrCl: ~63 ml/min")

plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  # geom_text(aes(x=20,y=150,label=pta)) +
  theme_bw() +
  ggtitle(pta)

plot(plot)

Wow, that’s interesting! After we correctly fit in the free ceftriaxone estimation, it actually improved the PTA even when albumin is lower. What if we make albumin even lower to ~15g/L (np=~172), and increase our CrCl to 180 ml/min, and increase our fT >= 0.7 (more than 70% of the time free ceftriaxone is above mic), and see if we’ll be able to clear the medication faster?

PTA is still 100% !?!?! wow, ceftriaxone 2g really is a beast! Hmmm.. The free ceftriaxone is REALLY high, around ~200-300, can we simulate a q48h dosing and see what the PTA is like, even for our worse case scenario, low albumin, high CrCl, and stil cover ft>mic >= 70%?

?q48 Dosing

code

dosing <- ev(amt = 2000, rate = 4000, ii = 48, addl = 2, cmt = "CENT")

set.seed(1)
sims <- mod |>
  param(np = 172, CLcr = 10.8) |>
  ev(dosing) |>
  mrgsim(nid = 1000, end = 144, delta = 0.25) |>
  as_tibble()

MIC <- 1

pta <- paste0("PTA: ", sims |>
  filter(time >= 48) |>
  group_by(ID) |>
  summarise(fT = mean(Cp_free > MIC)) |>
  summarise(PTA = mean(fT >= 0.70)) |>
  pull(),", Albumin: ~15g/L, CrCl: ~180 ml/min, fT > mic >= 70%, q48h dosing")

plot <- sims |>
  ggplot(aes(x=time,y=Cp_free,group=ID)) +
  geom_line(alpha=0.01) +
  geom_hline(yintercept = MIC, color = "red") +
  theme_bw() +
  ggtitle(pta)

plot(plot)

Seriously!? PTA is still so high !? What does this actually mean? Is there literature on this? Maybe my code is not right… 🤔🤷‍♂️

Let’s look at fT > mic >= 99%.

## [1] "PTA: 0.979, Albumin: ~15g/L, CrCl: ~180 ml/min, fT > mic >= 99%, q48h dosing"

If you know anything about this, please let me know! this is for organism with mic <= 1, ceftriaxone 2g. Again, make note that this is purely for educational and learning purposes. The finding we got above is just a curious exploration. I wonder if there is some coding error on my part. Click the code above to expand for details. I also wonder if most of the trials we had before were based on higher mic, whereas the mic nowadays for ceftriaxone are mainly <= 1. 🤔

Update !!!

Apparently, our unit conversion above for free ceftriaxone was in mmol/L but the CENT/V1 was in mg/L. That will do it! Now let’s put the conversion in the model and see what we got?

😵‍💫 Ok. This looks more believable! The problem earlier on was because we did not convert mmol/L to mg/L. Kind of wished the article would have just used mg/L to begin with when calculating np (otal concentration of protein binding sites). Alright, all of our calculation with albumin were wrong!!! Let’s recalculate the others.

Looking at the above, q24h dosing is still pretty good! 👍

Wow, that’s good that we continue to be skeptical of a result that is “too good to be true” and continued to look into it. What I did was, I basically used Claude Code in a temp folder where it contains my blog content and also the pdf of the article we used and ask the question, “is the q48 dosing result robust?” and eventually Claude Code found the problem! I’m very impressed!

Opportunities For Improvement

Learn how they model popPK, this will really help us understand how they got those theta and omega estimates
I don’t quite understand the sigma portion yet, will dive into this the next time, especially when estimating these values
Try to learn other properties such as AUC/mic, Cmax/mic etc, and see how the PTA changes
Learn more from literature which is preferred regarding acceptable free medication level above mic and acceptable PTA
rewrite model in the future to include units in the comments, so that we don’t have the same mistake again

Lessons learnt

learnt some mrgsolve model coding (uses cpp)
learnt some basic pk/pd equations, popPK
learnt about the 2 compartments
found unexpected result for q48 dosing through simulation, still not sure if this is something real/true
learnt that thetas are not related to central/peripheral, rather theta1 is baseline clearance and theta2 is ?renal scaling
learnt big mistake in unit discordance causing erroneous results

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me

Learning Carbapenemase Producing Genes

Mon, 02 Mar 2026 00:00:00 +0000

Learnt major carbapenemase genes (KPC, NDM, OXA) using NCBI isolate data and molecular dynamics. Includes gene frequency trends, co-resistance patterns, and MM/PBSA binding comparisons of avibactam with KPC vs NDM to illustrate mechanistic differences 🧬

Motivations:

We’ve previously learnt about ESBL genes and took a peek under the hood of the nucleotides and explore NCBI library and assess their frequency. Why not let’s pick another AMR gene and learn! Let’s explore Carbapenemase producing organisms! In this blog, we’ll spare you the code, as we basically use the same workflow previous, change a few search keys and variables and out comes the result!

Objectives:

Which Are Carbapenemase Producing Genes?

These are the major carbapanemase:
class A - KPC.
class B Metallo-B-lactamases (MBLs) - NDM, VIM, IMP.
class D - OXA-48, OXA-181, OXA-232, OXA-244.

Carbapenemases are classified into three molecular classes based on their hydrolytic mechanism. Class A & D carbapenemases all utilizing a serine-based active site. Class B MBLs rely on zinc in their active site. This is interesting, because while Avibactam was developed to have activities against Class A, C, and D beta-lactamases. However, it does not work on Class B! 😵‍💫 Hence, before susceptibility result is back, knowing which carbapenemase exists would be ideal. In fact the NG-Test CARBA 5 (also called “Carba 5”) is a rapid immunochromatographic lateral flow assay that detects and differentiates the five most common carbapenemase families: KPC, NDM, VIM, IMP, and OXA-48-like. I heard it takes about 15 minutes to run one colony.

Interesting thing on MBL-producing Enterobacterales, the IDSA recommends either ceftazidime-avibactam + aztreonam combination therapy or cefiderocol monotherapy. The rationale for the combination is that aztreonam (a monobactam) is stable against metallo-β-lactamases, while avibactam inhibits the serine β-lactamases (ESBLs, AmpC, KPC, OXA-48-like) that frequently co-exist in MBL-producing organisms and would otherwise hydrolyze aztreonam.

How Are We Going To Do This?

Well, first of all, let’s get all NCBI bacterial isolates fasta with meropenem resistance here. Then download all carbapenemase producing genese, here, then insert this gene_family:(blaKPC blaNDM blaVIM blaIMP blaOXA-48 blaOXA-181 blaOXA-232 blaOXA-244) to the filter.

Then, run through the code we had previously here, assess exact match and visualize the frequency just like before! Assess what are the proportions of these fastas do not match our carbapenemase producing genes, as not all meropenem resistance is due to beta lactamases, some could be due to porin loss, overexpression of efflux pump, ESBL + porin loss, AmpC + porin loss!

After that, let’s visualize the distribution based on the submission dates.

Remember we mentioned that with MBLs we either need to use combination therapy of aztreonam + ceftaz/avibactam or cefidericol monotherapy due to co-existence of other resistance? Let’s take a look at all MBLs and see what other carbapenemase genes co-exist!

Lastly, lets test out our molecular dynamic experiment on KPC and NDM with avibactam! We should see a strong binding affinity for KPC and a very weak binding affinity for NDM! We’re going to include another post-simulation process called MM/PBSA and MM/GBSA as well. What that does it calculates the binding free energy of the ligand to the protein. The more negative the value, the stronger the binding affinity. This is a great way to quantify our results from our simulation and compare between different simulations!

Results

The Proportion of Carbapenemase producing Genes in Meropenem Resistant Organism?

We have a total of 1027 isolates, and 45.86% have detected carbapenamase genes! That’s with exact match, I did not check for low level mismatches.

The Frequency of Carbapanemase Genes

Wow, NDM-1 is at the top? I’ve always thought KPCs is more frequent. Note, these are the sequences that were submitted to NCBI, not necessarily resembling the actual distribution in the real world. But still, interesting to see that NDM-1 is more frequently submitted than KPCs.

Visualize Carbapanemase Gene Frequency By Year

Looking at the above, KPCs submissions were dominating up until 2018. In 2019, NDM-1 started to creep up to top 1. Since then, NDM-1 remained number one until 2025.

Do MBLs Frequently Have Co-resistance Of Other Carbapenamase?

primary_gene	gene	n
NDM-1	OXA-48	13
NDM-5	OXA-48	12
NDM-1	OXA-232	5
NDM-5	OXA-181	5
NDM-5	OXA-232	2
NDM-7	OXA-232	2
NDM-1	NDM-4	1
NDM-1	VIM-1	1
NDM-1	VIM-2	1

Interestingly when we look at MBL with co-resistance, it’s usually OXA-48 and OXA-48-like! But, when looking at all the MBLs (n=257) that were submitted, co-resistance with OXA is only 15.18% (n=39). There were 3 NDMs with another MBL. That makes sense to combine aztreonam and ceftaz/avibactam to counter OXA-48 beta lactamase. Note that we did not include ESBLs, ampC on our search.

Let’s Take a Look At Avibactam-KPC and Avibactam-NDM Molecular Dynamic Simulation

We’ll use the same pipeline as before, but this time we’ll add Molecular Mechanic / PBSA.

Installation

conda create -n gmxpbsa -c conda-forge gmx_mmpbsa ambertools
conda activate gmxpbsa

Write `mmpbsa.in`

You can use nano or nvim, then paste the below

&general
   startframe=1,
   endframe=500,
   interval=5,
   verbose=2,
/
&pb
   istrng=0.150,
   fillratio=4.0,
   inp=1,
   radiopt=0,
/

Note: Make sure to change the startframe and endframe to where the the protein rmsd and ligand rmsd is stable. Essentially sampling from the stable portion of the simulation.

When running MM/GBSA use the parameters below, maybe name is mmgbsa.in

&general
  startframe = 1,
  endframe = 500,
  interval = 1,
  verbose = 1,
  keep_files = 0,
/
&gb
  igb = 5,
  saltcon = 0.15,
/

To Run MM/PBSA or MM/GBSA

gmx_MMPBSA \
  -O \
  -i mmpbsa.in \
  -cs md.tpr \
  -ct md_noPBC.xtc \
  -ci index.ndx \
  -cg 1 13 \
  -cp topol.top \
  -o FINAL_RESULTS.dat \
  -eo FINAL_RESULTS.csv

Note: Make sure to write our regular pipeline first, create index etc, and leave the MM/PBSA or MM/GBSA until last.

Equation of the bond: Delta G_bind = Delta G_gas + Delta G_solv Where: Delta G_gas = gas-phase molecular mechanics energy (bonds, angles, dihedrals, van der Waals, electrostatics) BOND+ANGLE+DIHED+VDWAALS+EEL+1-4 VDW+1-4 EEL Delta G_solv = solvation free energy (how the molecule interacts with the surrounding water) EPB+ENPOLAR

Note: when you read the FINAL_RESULTS.csv, go to the last section, that’s the delta. Total = sum of all the columns except Total. Negative == 👍

KPC181-Avibactam

Alright, with the above, we have RMSD plateaud at around 20ns and RMSD ligand is pretty good and stable as well. Along with good H bonds and interaction energy, and reducing and converged minimal distance between protein and ligand and also distance between center of protein and ligand reduced and stablized as well. Let’s visualize the first frame and last frame to ensure before we run MM/PBSA and MM/GBSA.

Looks convincing! Let’s take a look at MM/PBSA and MM/GBSA.

Alright, we have quite a few columns in facets here, but most are not helpful since we have 0 data mainly because we used inp=1. But total binding energy is negative, which is good! You can see that on the TOTAL. The median (IQR) is -8.07(-16.79 - -1.29). Now what about GBPA ?

And the Median Total (IQR) is -10.615(-19.84 - -3.38) . Not too shabby!

NDM1-Avibactam

RMSD ligand seems quite big, hbond is intermittent, one of interaction energy crosses zero, the min distance variance is quite wide towards the end of simulation. From these numbers, it looked like it did not bind well, which is expected since avibactam does not work on MBLs. Let’s see visualize.

Wow, they’re not in the same position! It completely flipped! Usually in this setting, we shouldn’t need to perform MM/PBSA. But what if we did?

Wow, even though looking at TOTAL the median is in the negative, but you see significant fluctuations (large variance) with lots of zeros! Compare this to our previous MM/PBSA and MM/GBSA, you can see the difference!

What is interesting is that, I would imagine the ligand would have drifted away but it didn’t. Let’s investigate.

I think the ligand is stuck in the pocket as the protein was undergoing conformational change and stabilized after ~30ns, and I think it may have trapped the ligand in the pocket, hence it didn’t drift out of the pocket. I think 🤔 . Also, take note that the early simulation animation was without surface (only atoms), whereas the later one did have surface. With the matched protein and ligand of frame 0 and last frame proved that the initial pose was not optimal.

There you have it!

Note: While MM/PBSA provides relative binding estimates, these simulations do not capture full enzymatic hydrolysis dynamics and should be interpreted as comparative rather than absolute

Opportunities for improvement

need to learn ampC, porin loss, and other MDR genes
need to test our MM/PBSA and MM/GBSA more, adjust isp=2 and see how they look like
need to find a proper way to interpret/assess alphafold proteins prediction, which is considered good, which isn’t, and how to deal with them
need to dive into the math, physics, and organic chemistry of these simulations.
need to do replicates of 3, report seeds, and also include 2 other similar coordinate poses with high scores.
need to learnt covalent docking

Lessons Learnt

learnt carbapenemase genes
learnt MBLs may contain co-resistance of OXA, hence combo aztreonam
learnt MM/PBSA and MM/GBSA

If you like this article:

please feel free to send me a comment or visit my other blogs
please feel free to follow me on BlueSky, twitter, GitHub or Mastodon
if you would like collaborate please feel free to contact me