Motivación

En la entrada anterior de esta bitácora por-que-existe-esta-bitacora advertí que los modelos de lenguaje (LLMs) son particularmente peligrosos cuando producen una derivación que luce correcta pero está mal en un factor de , en un signo o en una convención. La única defensa que conozco es hacer el cálculo uno mismo y tratar la respuesta del modelo como una hipótesis a verificar.

El problema es que, para muchos problemas de física teórica, “verificar” a mano consume tanto tiempo como hacer el cálculo original. El flujo de trabajo tradicional es, en la práctica, oracular: preguntas al modelo, te da una respuesta, y luego debes confiar o rehacer. Lo que propongo aquí es un flujo de trabajo constructivo:

1. No le pidas al LLM la respuesta final.
2. Pídele que escriba el código (SymPy) que produce la respuesta.
3. Ejecuta ese código en un sistema de álgebra computacional (CAS).
4. Verifica explícitamente las identidades que el CAS puede comprobar: condiciones de tadpole, autovalores de Goldstone, masas físicas, coincidencia con ecuaciones publicadas.

El CAS no elimina la responsabilidad del físico; la cambia de lugar: de “hacer el cálculo a mano” a “escribir un arnés de verificación que el CAS evalúa simbólicamente”. Este es el mismo espíritu que se ve en trabajos recientes como Hell y Thiele (2026), donde los LLMs se usan como traductores de intención a código simbólico, no como oráculos.

El caso de prueba: minimización del potencial escalar del DLRSM

El modelo es el Doublet Left-Right Symmetric Model (DLRSM), descrito en Zeleny-Mora et al. (2026). El sector escalar contiene un bidoblete y dos dobletes con los VEVs

El potencial escalar, tomado de Senjanović (1979) y usado en Zeleny-Mora et al. (2026), es con

Definiciones: del potencial a las masas

El cálculo de las masas de los escalares a partir de sigue una cadena estándar de cuatro pasos, que el CAS verificará en cada eslabón.

1. Expansión alrededor del vacío. Cada escalar se escribe como su VEV más una fluctuación, por ejemplo El potencial se desarrolla entonces al orden cuadrático en las fluctuaciones; la parte bilineal define el espectro de masas.

2. Condiciones de tadpole (estacionariedad). Los VEVs se fijan exigiendo que el vacío sea un extremo: Cuando estas condiciones se satisfacen, los términos lineales en el desarrollo de —las tadpoles— se anulan idénticamente.

3. Matriz de masa (Hessiano del potencial). La matriz de masa al cuadrado es el Hessiano de evaluado en el vacío. Para los escalares neutros (componentes reales ), Para el sector cargado los campos son complejos, y se usa la convención de Wirtinger donde y se tratan como variables independientes. Las condiciones de tadpole se sustituyen en para eliminar los parámetros de masa .

4. Bosones de Goldstone y masas físicas. Por el teorema de Goldstone, cada generador gauge roto espontáneamente produce un modo de masa nula que se convierte en la polarización longitudinal de un bosón de gauge masivo. En el sector cargado del DLRSM, el rompimiento de a deja dos Goldstones cargados —absorbidos por y —, de modo que debe tener exactamente dos autovalores nulos. Los autovalores no nulos restantes son las masas al cuadrado de los Higgs cargados físicos .

El problema concreto que le plantearé al LLM es: deriva las cuatro condiciones de tadpolo, la matriz de masa de los escalares cargados en el límite , y las masas físicas de los Higgs cargados.

Camino A: respuesta directa de un chat

Usé el modelo Gemini 3.1 Pro el 2026-08-02 con el siguiente prompt (el mismo que aparece en el Apéndice del post):

Consider the Doublet Left-Right Symmetric Model with a bidoublet with and doublets with . The scalar potential is where [potencial completo]. Derive: (a) the four tadpole conditions; (b) the charged scalar mass matrix in the basis in the limit ; (c) the physical charged Higgs masses.

La respuesta es impresionante a primera vista: estructura correcta, combinaciones de parámetros plausibles, y las masas físicas finales son las mismas que aparecen en la literatura. Transcribo aquí los resultados principales (abreviados; el texto completo está en el bloque plegado):

La respuesta es superficialmente correcta: las masas finales coinciden con las ecuaciones publicadas en Zeleny-Mora et al. (2026, Eq. (13)). El problema es que, como lector, no puedo saber si la estructura de la matriz es correcta sin rehacer el cálculo. Los errores que el modelo comete son del tipo más difícil de detectar: no son errores gramaticales ni inconsistencias obvias; son errores silenciosos que se esconden en una estructura que parece correcta.

Camino B: LLM + CAS con SymPy

El mismo problema se le plantea al LLM en un modo diferente: “no me des la respuesta; escríbeme el código SymPy que la calcula”. El código se muestra en la celda siguiente (plegado) y se ejecuta como parte del post. La tabla relaciona cada paso teórico de la sección Definiciones con la construcción de SymPy que lo implementa y la comprobación que realiza el CAS:

Paso teórico	En el código	Qué verifica el CAS
0. Codificar el potencial	campos como objetos Matrix; trace(...) construye	—
1. Expansión alrededor del vacío	V.subs(VEV_all) fija ,	—
2. Condiciones de tadpole	sp.diff(V0, k1), … sobre los cuatro VEVs	coincide con la Eq. (9) de Zeleny-Mora et al. (2026)
3. Matriz de masa (Hessiano de Wirtinger)	sp.diff(V, c_plus[i], c_minus[j]); eliminadas con las condiciones de tadpole	estructura de en el límite
4. Goldstones y masas físicas	M_charged.charpoly(lam)	: dos modos nulos + Eq. (13)

Dos decisiones de diseño reflejan la teoría directamente. Primera: cada campo complejo y su conjugada se declaran como símbolos reales independientes — phi1m y phi1mc, chiL y chiLc, … Esto es exactamente la prescripción de Wirtinger del paso 3: y son variables independientes, de modo que el Hessiano sp.diff(V, c_plus[i], c_minus[j]) deriva respecto a un campo y su conjugada como si no estuvieran relacionados. Segunda: la comprobación de Goldstone del paso 4 no le pide a SymPy autovalores — los autovalores simbólicos de una matriz pueden ser radicales ingobernables — sino que compara el polinomio característico con , una identidad polinomial que simplify puede decidir exactamente, convirtiendo “¿hay exactamente dos modos nulos?” en álgebra. Cada assert es una comprobación de este tipo; si falla, la celda lanza una excepción en lugar de producir una respuesta silenciosamente incorrecta.

import sympy as sp
from sympy import symbols, Matrix, simplify, factor, trace, expand
from IPython.display import display, Math

# --- Símbolos ---------------------------------------------------------------
# Trabajamos con variables reales para cada campo complejo y su conjugada.
phi10, phi10c = symbols('phi10 phi10c', real=True)   # phi_1^0, phi_1^{0*}
phi20, phi20c = symbols('phi20 phi20c', real=True)   # phi_2^0, phi_2^{0*}
phi1m, phi1mc = symbols('phi1m phi1mc', real=True)   # phi_1^-, phi_1^+
phi2m, phi2mc = symbols('phi2m phi2mc', real=True)   # phi_2^-, phi_2^+
chiL, chiLc     = symbols('chiL chiLc', real=True)   # chi_L^+, chi_L^-
chiR, chiRc     = symbols('chiR chiRc', real=True)   # chi_R^+, chi_R^-
chiLn, chiLnc  = symbols('chiLn chiLnc', real=True) # chi_L^0, chi_L^{0*}
chiRn, chiRnc  = symbols('chiRn chiRnc', real=True) # chi_R^0, chi_R^{0*}

mu1sq, mu2sq = symbols('{{\\mu_{1}^2}} {{\\mu_{2}^2}}', positive=True)
lam1, lam2, lam3, lam4, lam5, lam6 = symbols('lambda_1 lambda_2 lambda_3 lambda_4 lambda_5 lambda_6', real=True)
rho1, rho2 = symbols('rho1 rho2', real=True)
alpha1, alpha2, alpha3 = symbols('alpha1 alpha2 alpha3', real=True)

k1, k2, vL, vR = symbols('k_1 k_2 v_L v_R', positive=True)

# --- Matrices del bidoblete y dobletes --------------------------------------
# Phi = [phi_1, i*sigma2*phi_2^*]
Phi = Matrix([
    [phi10, phi2mc],
    [phi1m, -phi20c]
])
Phi_dag = Matrix([
    [phi10c, phi1mc],
    [phi2m,  -phi20]
])

I = sp.I
sigma2 = Matrix([[0, -I], [I, 0]])
Phi_star = Matrix([[phi10c, phi2m], [phi1mc, -phi20]])
tilde_Phi = sigma2 * Phi_star * sigma2
tilde_Phi_dag = sigma2 * Phi.T * sigma2

chi_L = Matrix([[chiL], [chiLn]])
chi_L_dag = Matrix([[chiLc, chiLnc]])
chi_R = Matrix([[chiR], [chiRn]])
chi_R_dag = Matrix([[chiRc, chiRnc]])

# --- Potencial escalar -------------------------------------------------------
V_Phi = (
    -mu1sq * trace(Phi_dag * Phi)
    + lam1 * trace(Phi_dag * Phi)**2
    + lam2 * trace(Phi_dag * Phi * Phi_dag * Phi)
    + sp.Rational(1,2) * lam3 * (trace(Phi_dag * tilde_Phi) + trace(tilde_Phi_dag * Phi))**2
    + sp.Rational(1,2) * lam4 * (trace(Phi_dag * tilde_Phi) - trace(tilde_Phi_dag * Phi))**2
    + lam5 * trace(Phi_dag * Phi * tilde_Phi_dag * tilde_Phi)
    + sp.Rational(1,2) * lam6 * (trace(Phi_dag * tilde_Phi * Phi_dag * tilde_Phi)
                               + trace(tilde_Phi_dag * Phi * tilde_Phi_dag * Phi))
)

V_chi = (
    -mu2sq * (chi_L_dag.dot(chi_L) + chi_R_dag.dot(chi_R))
    + rho1 * (chi_L_dag.dot(chi_L)**2 + chi_R_dag.dot(chi_R)**2)
    + rho2 * (chi_L_dag.dot(chi_L)) * (chi_R_dag.dot(chi_R))
)

V_Phi_chi = (
    alpha1 * trace(Phi_dag * Phi) * (chi_L_dag.dot(chi_L) + chi_R_dag.dot(chi_R))
    + alpha2 * (chi_L_dag * Phi * Phi_dag * chi_L + chi_R_dag * Phi_dag * Phi * chi_R)[0]
    + alpha3 * (chi_L_dag * tilde_Phi * tilde_Phi_dag * chi_L
                + chi_R_dag * tilde_Phi_dag * tilde_Phi * chi_R)[0]
)

V = expand(V_Phi + V_chi + V_Phi_chi)

# --- Tadpole: verificación contra la Eq. (9) del artículo -----------------
VEV_all = {
    phi10: k1, phi10c: k1, phi20: k2, phi20c: k2,
    phi1m: 0, phi1mc: 0, phi2m: 0, phi2mc: 0,
    chiL: 0, chiLc: 0, chiR: 0, chiRc: 0,
    chiLn: vL, chiLnc: vL, chiRn: vR, chiRnc: vR
}
V0 = V.subs(VEV_all)

lam12 = lam1 + lam2
lam1356 = lam1 + 4*lam3 + lam5 + lam6
alpha12 = alpha1 + alpha2
alpha13 = alpha1 + alpha3

paper_tadpoles = {
    'k1': 2*k1*(-mu1sq + 2*k1**2*lam12 + 2*k2**2*lam1356 + (vL**2 + vR**2)*alpha13),
    'k2': 2*k2*(-mu1sq + 2*k1**2*lam1356 + 2*k2**2*lam12 + (vL**2 + vR**2)*alpha12),
    'vL': 2*vL*(-mu2sq + 2*rho1*vL**2 + rho2*vR**2 + k1**2*alpha13 + k2**2*alpha12),
    'vR': 2*vR*(-mu2sq + 2*rho1*vR**2 + rho2*vL**2 + k1**2*alpha13 + k2**2*alpha12),
}

tadpoles = {
    'k1': sp.diff(V0, k1),
    'k2': sp.diff(V0, k2),
    'vL': sp.diff(V0, vL),
    'vR': sp.diff(V0, vR),
}

for key in tadpoles:
    diff = simplify(tadpoles[key] - paper_tadpoles[key])
    assert diff == 0, f"Tadpole {key} no coincide con la literatura: {diff}"

print("✓ Condiciones de tadpole: coinciden con la Eq. (9) de Zeleny-Mora et al. (2026)\n")
for label, key in [(r"k_1", "k1"), (r"k_2", "k2"), (r"v_L", "vL"), (r"v_R", "vR")]:
    display(Math(rf"\frac{{\partial V}}{{\partial {label}}} = " + sp.latex(factor(tadpoles[key]))))

# --- Solución para mu1^2 y mu2^2 en el límite vL = k2 = 0 ------------------
mu1sq_sol = sp.solve(sp.Eq(tadpoles['k1'].subs({k2:0, vL:0}), 0), mu1sq)[0]
mu2sq_sol = sp.solve(sp.Eq(tadpoles['vR'].subs({k2:0, vL:0}), 0), mu2sq)[0]

assert simplify(mu1sq_sol - (2*k1**2*lam12 + vR**2*alpha13)) == 0
assert simplify(mu2sq_sol - (2*rho1*vR**2 + k1**2*alpha13)) == 0
print("✓ Parámetros de masa en el límite $v_L = k_2 = 0$:\n")
display(Math(r"\mu_1^2 = " + sp.latex(mu1sq_sol)))
display(Math(r"\mu_2^2 = " + sp.latex(mu2sq_sol)))

# --- Matriz de masa cargada -------------------------------------------------
# Base c+ = (phi2+, chiL+, phi1+, chiR+)
# Correspondencia: phi2+ = phi2mc, chiL+ = chiL, phi1+ = phi1mc, chiR+ = chiR
c_plus = [phi2mc, chiL, phi1mc, chiR]
c_minus = [phi2m, chiLc, phi1m, chiRc]

M_charged = Matrix([[sp.diff(V, c_plus[i], c_minus[j]) for j in range(4)] for i in range(4)])

VEV_charged = {
    phi10: k1, phi10c: k1, phi20: 0, phi20c: 0,
    phi1m: 0, phi1mc: 0, phi2m: 0, phi2mc: 0,
    chiL: 0, chiLc: 0, chiR: 0, chiRc: 0,
    chiLn: 0, chiLnc: 0, chiRn: vR, chiRnc: vR
}
M_charged = M_charged.subs(VEV_charged).subs({mu1sq: mu1sq_sol, mu2sq: mu2sq_sol})
M_charged = simplify(M_charged)

print("\nMatriz de masa cargada (base $c^+ = (\\phi_2^+, \\chi_L^+, \\phi_1^+, \\chi_R^+)$):")
display(Math(r"M_+^2 = " + sp.latex(M_charged)))

# --- Verificación física: masas y Goldstones ---------------------------------
alpha23 = alpha2 - alpha3
rho21 = rho2 - 2*rho1

# Masas físicas esperadas de la Eq. (13)
mH1_sq = k1**2*alpha23 + vR**2*rho21
mH2_sq = alpha23*(k1**2 + vR**2)

# Verificación física: dos Goldstones y dos masas físicas correctas.
# El polinomio característico debe ser lambda^2 * (lambda - mH1^2) * (lambda - mH2^2).
# Este es un test más robusto que contar autovalores nulos de forma simbólica,
# porque SymPy puede devolver una expresión complicada que simplifica a cero.
lam = symbols('lam')
char_poly = M_charged.charpoly(lam).as_expr()
expected_poly = lam**2 * (lam - mH1_sq) * (lam - mH2_sq)
assert simplify(expand(char_poly - expected_poly)) == 0
print("\n✓ Polinomio característico: $\\lambda^2 (\\lambda - m^2_{H_L})(\\lambda - m^2_{H_R})$")
print("  → dos autovalores nulos (Goldstones) y dos masas físicas\n")
print("Masas físicas cargadas:")
display(Math(r"m^2_{H_L^\pm} = " + sp.latex(mH1_sq)))
display(Math(r"m^2_{H_R^\pm} = " + sp.latex(mH2_sq)))

✓ Condiciones de tadpole: coinciden con la Eq. (9) de Zeleny-Mora et al. (2026)

✓ Parámetros de masa en el límite $v_L = k_2 = 0$:

Matriz de masa cargada (base $c^+ = (\phi_2^+, \chi_L^+, \phi_1^+, \chi_R^+)$):

✓ Polinomio característico: $\lambda^2 (\lambda - m^2_{H_L})(\lambda - m^2_{H_R})$
  → dos autovalores nulos (Goldstones) y dos masas físicas

Masas físicas cargadas:

Comparación de los dos caminos

La diferencia es sutil pero decisiva. El modelo de chat entrega una respuesta que pasa una revisión rápida: las masas finales son correctas y la notación es la del artículo. Sin embargo, la respuesta tiene las propiedades que hacen peligrosa a un LLM en física:

• Es opaca. No hay un camino reproducible para llegar a ella. Para saber si está bien, el lector debe rehacer todo el álgebra.
• Es frágil en la estructura. Aunque las masas finales coincidan, la asignación de los campos a los estados físicos (Goldstone vs. Higgs) depende de la estructura exacta de la matriz. Sin el CAS, un signo, un intercambio de columnas o un factor de 2 pueden pasar desapercibidos.
• No se puede auditar. No hay un botón “reproducir”.

En contraste, el flujo LLM+CAS produce:

• Transparencia total. El código es el cálculo; cualquiera puede ejecutarlo.
• Verificación automática. Cada assert es una comprobación que el CAS evalúa simbólicamente. Si el LLM hubiera escrito un código con un signo incorrecto, la celda habría fallado con un mensaje de error, no habría producido una respuesta plausible.
• Trazabilidad. La relación entre el potencial, las condiciones de tadpole, la matriz de masa y las masas físicas es explícita y legible.

Hacia el flujo de trabajo del físico teórico en la era de los LLMs

Mostrar el código de la figura

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch

paper, ink, accent, grey = "#fcfcfa", "#22262b", "#3a5a7a", "#8a8f96"
red, green = "#9e4a4a", "#2a6f68"

plt.rcParams.update({
    "font.family": "serif",
    "font.size": 10,
    "axes.edgecolor": ink,
    "axes.linewidth": 0.8,
    "figure.facecolor": paper,
    "axes.facecolor": paper,
    "savefig.facecolor": paper,
})

fig, ax = plt.subplots(figsize=(7.2, 5.2))
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.axis("off")

def box(x, y, w, h, text, color=accent, text_color=paper):
    rect = FancyBboxPatch((x, y), w, h, boxstyle="round,pad=0.05,rounding_size=0.2",
                          facecolor=color, edgecolor=ink, linewidth=1.2)
    ax.add_patch(rect)
    ax.text(x + w/2, y + h/2, text, ha="center", va="center", color=text_color,
            fontsize=8, weight="bold", wrap=True)

def arrow(x1, y1, x2, y2, color=ink, style="->"):
    ax.annotate("", xy=(x2, y2), xytext=(x1, y1),
                arrowprops=dict(arrowstyle=style, color=color, lw=1.2))

# --- Camino A: respuesta directa ---------------------------------------------
ax.text(1.5, 9.3, "A. Respuesta directa del chat", fontsize=11, weight="bold", color=ink)
box(0.5, 7.2, 2.2, 1.0, "Pregunta\n(DLRSM)", accent)
box(3.2, 7.2, 2.0, 1.0, "LLM", "#6b4c7a")
box(5.7, 7.2, 2.6, 1.0, "Respuesta\n(derivación)", "#b45f06")
box(8.7, 7.2, 1.2, 1.0, "¿?", red)
arrow(2.7, 7.7, 3.2, 7.7)
arrow(5.2, 7.7, 5.7, 7.7)
arrow(8.3, 7.7, 8.7, 7.7)
ax.text(5.0, 6.8, "Verificación manual, opaca, propensa a errores silenciosos",
        ha="center", fontsize=9, color=red, style="italic")

# --- Camino B: LLM + CAS -----------------------------------------------------
ax.text(1.5, 5.9, "B. Flujo LLM + CAS", fontsize=11, weight="bold", color=ink)
box(0.5, 3.8, 2.2, 1.0, "Pregunta\n(DLRSM)", accent)
box(3.2, 3.8, 2.0, 1.0, "LLM →\nSymPy", "#6b4c7a")
box(5.7, 3.8, 2.0, 1.0, "SymPy\n(ejecuta)", green)
box(8.2, 3.8, 1.4, 1.0, "asserts\nOK/FAIL", "#b45f06")
box(5.7, 1.8, 4.2, 1.0, "Físico revisa\ny aprueba", accent)

arrow(2.7, 4.3, 3.2, 4.3)
arrow(5.2, 4.3, 5.7, 4.3)
arrow(7.7, 4.3, 8.2, 4.3)
# Feedback loop
arrow(8.9, 3.8, 8.9, 2.8, color=grey)
arrow(8.2, 2.3, 5.7, 2.3, color=grey, style="<-")
ax.text(5.0, 1.1, "Verificación simbólica automática, reproducible, auditable",
        ha="center", fontsize=9, color=green, style="italic")

plt.tight_layout()

El caso del DLRSM es un ejemplo limpio del patrón más general. El CAS no reemplaza al físico; define una división de responsabilidades:

Este patrón escala de varias formas. Hoy SymPy cubre el álgebra polinomial del sector escalar; para cálculos de un lazo con funciones de Passarino–Veltman, el mismo flujo apunta a herramientas como FeynCalc, Package-X o LoopTools, con el LLM como orquestador entre ellas. Ahí es donde entran trabajos como Hell y Thiele (2026), que exploran exactamente esa frontera: no un LLM que resuelva el problema, sino un LLM que escribe el código que el CAS ejecuta y que el físico verifica.

El cambio más profundo es cultural. En el futuro próximo, un estudiante de doctorado en física teórica probablemente dedique menos tiempo a reescribir a mano productos de matrices y más tiempo a:

1. Formular el modelo y el protocolo de verificación.
2. Pedirle a un LLM que genere el código CAS.
3. Ejecutar el código, revisar los assert y analizar los casos límite.
4. Decidir si el resultado tiene sentido físico.

La derivación no desaparece; se convierte en código. Y el código, a diferencia de una respuesta de chat, puede ser ejecutado, auditado y corregido.

Límites honestos

El flujo no es infalible. El CAS solo verifica lo que le pedimos verificar. Si el LLM escribe un código que tipea correctamente pero codifica la física equivocada —por ejemplo, usando el invariante incorrecto en el potencial— el assert pasará y el resultado físico será malo. El CAS no sustituye el juicio físico; lo formaliza.

También hay limitaciones prácticas:

• Contexto y longitud: para potenciales con decenas de parámetros, el prompt puede volverse engorroso.
• Rendimiento de SymPy: integrales de lazo reales o matrices muy grandes escapan fácilmente de lo que SymPy puede hacer en tiempo razonable.
• Convenciones: el LLM puede mezclar convenciones de signo para , o cargas. El arnés de verificación debe incluir al menos una comprobación de invariancia gauge o de un límite conocido.

El punto no es que el LLM+CAS lo haga todo. El punto es que convierte la incertidumbre del modelo en una excepción del CAS, que es mucho más fácil de diagnosticar que una respuesta plausiblemente incorrecta.

Apéndice: prompt completo a Gemini 3.1 Pro

El prompt se envió el 2026-08-02 al modelo Gemini 3.1 Pro. El texto de la respuesta se abrevió en el cuerpo del post; aquí se reproduce el prompt completo para que cualquiera pueda repetirlo:

Consider the Doublet Left-Right Symmetric Model (DLRSM) with a bidoublet where , and . The model also contains two doublets and with and . The scalar potential is where Derive: (a) the four tadpole conditions; (b) the charged scalar mass matrix in the basis in the limit ; (c) the physical charged Higgs masses.

Motivation

In the previous post of this log why-this-log-exists I warned that large language models (LLMs) are particularly dangerous when they produce a derivation that looks correct but is wrong by a factor of , a sign, or a convention. The only defense I know is to do the calculation yourself and treat the model’s output as a hypothesis to be tested.

The problem is that, for many theoretical-physics problems, “verifying” by hand takes as much time as doing the original calculation. The traditional workflow is, in practice, oracular: you ask the model, it gives an answer, and then you either trust it or redo it. What I propose here is a constructive workflow:

1. Do not ask the LLM for the final answer.
2. Ask it to write the code (SymPy) that produces the answer.
3. Run that code in a computer algebra system (CAS).
4. Explicitly verify the identities the CAS can check: tadpole conditions, Goldstone eigenvalues, physical masses, agreement with published equations.

The CAS does not remove the physicist’s responsibility; it shifts it: from “do the calculation by hand” to “write a verification harness that the CAS evaluates symbolically”. This is the same spirit as recent work such as Hell and Thiele (2026), where LLMs are used as translators of intent into symbolic code, not as oracles.

The test case: scalar-potential minimization in the DLRSM

The model is the Doublet Left-Right Symmetric Model (DLRSM), described in Zeleny-Mora et al. (2026). The scalar sector contains a bidoublet and two doublets with VEVs

The scalar potential, taken from Senjanović (1979) and used in Zeleny-Mora et al. (2026), is with

Definitions: from the potential to the masses

The computation of the scalar masses from follows a standard four-step chain, which the CAS will verify at every link.

1. Expansion around the vacuum. Each scalar is written as its VEV plus a fluctuation, for example The potential is then expanded to quadratic order in the fluctuations; the bilinear part defines the mass spectrum.

2. Tadpole conditions (stationarity). The VEVs are fixed by requiring the vacuum to be an extremum: When these are satisfied, the linear terms in the expansion of — the tadpoles — vanish identically.

3. Mass matrix (Hessian of the potential). The squared-mass matrix is the Hessian of evaluated at the vacuum. For the neutral scalars (real components ), For the charged sector the fields are complex, and the Wirtinger convention is used: where and are treated as independent variables. The tadpole conditions are substituted into to eliminate the bare mass parameters .

4. Goldstone bosons and physical masses. By Goldstone’s theorem, each spontaneously broken gauge generator produces a massless mode that becomes the longitudinal polarization of a massive gauge boson. In the charged sector of the DLRSM, the breaking of down to leaves two charged Goldstones — eaten by and — so must have exactly two zero eigenvalues. The remaining non-zero eigenvalues are the squared masses of the physical charged Higgs bosons .

The concrete problem I will pose to the LLM is: derive the four tadpole conditions, the charged-scalar mass matrix in the limit , and the physical charged Higgs masses.

Arm A: direct answer from a chat

I used the model Gemini 3.1 Pro on 2026-08-02 with the following prompt (also in the post’s Appendix):

Consider the Doublet Left-Right Symmetric Model with a bidoublet with and doublets with . The scalar potential is where [full potential]. Derive: (a) the four tadpole conditions; (b) the charged scalar mass matrix in the basis in the limit ; (c) the physical charged Higgs masses.

The answer is impressive at first sight: correct structure, plausible parameter combinations, and final physical masses that match the literature. I transcribe the main results here (abbreviated; the full text is in the folded block):

The answer is superficially correct: the final masses agree with the published equations in Zeleny-Mora et al. (2026, Eq. (13)). The problem is that, as a reader, I cannot tell whether the matrix structure is correct without redoing the algebra. The model’s errors are of the hardest kind to detect: not grammatical mistakes or obvious inconsistencies, but silent errors hidden inside a structure that looks right.

Arm B: LLM + CAS with SymPy

The same problem is posed to the LLM in a different mode: “do not give me the answer; write me the SymPy code that computes it”. The code is shown in the following cell (folded) and is executed as part of the post. The table maps each theoretical step of the Definitions section to the SymPy idiom that implements it and the check the CAS performs:

Theory step	In the code	What the CAS verifies
0. Encode the potential	fields as Matrix objects; trace(...) builds	—
1. Expansion around the vacuum	V.subs(VEV_all) sets ,	—
2. Tadpole conditions	sp.diff(V0, k1), … over the four VEVs	matches Eq. (9) of Zeleny-Mora et al. (2026)
3. Mass matrix (Wirtinger Hessian)	sp.diff(V, c_plus[i], c_minus[j]); eliminated via the tadpoles	structure of in the limit
4. Goldstones and physical masses	M_charged.charpoly(lam)	: two zero modes + Eq. (13)

Two design choices mirror the theory directly. First, each complex field and its conjugate are declared as separate real symbols — phi1m and phi1mc, chiL and chiLc, … This is precisely the Wirtinger prescription of step 3: and are independent variables, so the Hessian sp.diff(V, c_plus[i], c_minus[j]) differentiates with respect to a field and its conjugate as if unrelated. Second, the step-4 Goldstone check does not ask SymPy for eigenvalues — symbolic eigenvalues of a matrix can be unruly radicals — but compares the characteristic polynomial against , a polynomial identity that simplify can decide exactly, turning “are there exactly two zero modes?” into algebra. Every assert is such a check; if one fails, the cell throws an exception instead of producing a silently wrong answer.

import sympy as sp
from sympy import symbols, Matrix, simplify, factor, trace, expand
from IPython.display import display, Math

# --- Symbols ----------------------------------------------------------------
# We use real variables for each complex field and its conjugate.
phi10, phi10c = symbols('phi10 phi10c', real=True)   # phi_1^0, phi_1^{0*}
phi20, phi20c = symbols('phi20 phi20c', real=True)   # phi_2^0, phi_2^{0*}
phi1m, phi1mc = symbols('phi1m phi1mc', real=True)   # phi_1^-, phi_1^+
phi2m, phi2mc = symbols('phi2m phi2mc', real=True)   # phi_2^-, phi_2^+
chiL, chiLc     = symbols('chiL chiLc', real=True)   # chi_L^+, chi_L^-
chiR, chiRc     = symbols('chiR chiRc', real=True)   # chi_R^+, chi_R^-
chiLn, chiLnc  = symbols('chiLn chiLnc', real=True) # chi_L^0, chi_L^{0*}
chiRn, chiRnc  = symbols('chiRn chiRnc', real=True) # chi_R^0, chi_R^{0*}

mu1sq, mu2sq = symbols('{{\\mu_{1}^2}} {{\\mu_{2}^2}}', positive=True)
lam1, lam2, lam3, lam4, lam5, lam6 = symbols('lambda_1 lambda_2 lambda_3 lambda_4 lambda_5 lambda_6', real=True)
rho1, rho2 = symbols('rho1 rho2', real=True)
alpha1, alpha2, alpha3 = symbols('alpha1 alpha2 alpha3', real=True)

k1, k2, vL, vR = symbols('k_1 k_2 v_L v_R', positive=True)

# --- Bidoublet and doublet matrices -----------------------------------------
# Phi = [phi_1, i*sigma2*phi_2^*]
Phi = Matrix([
    [phi10, phi2mc],
    [phi1m, -phi20c]
])
Phi_dag = Matrix([
    [phi10c, phi1mc],
    [phi2m,  -phi20]
])

I = sp.I
sigma2 = Matrix([[0, -I], [I, 0]])
Phi_star = Matrix([[phi10c, phi2m], [phi1mc, -phi20]])
tilde_Phi = sigma2 * Phi_star * sigma2
tilde_Phi_dag = sigma2 * Phi.T * sigma2

chi_L = Matrix([[chiL], [chiLn]])
chi_L_dag = Matrix([[chiLc, chiLnc]])
chi_R = Matrix([[chiR], [chiRn]])
chi_R_dag = Matrix([[chiRc, chiRnc]])

# --- Scalar potential ---------------------------------------------------------
V_Phi = (
    -mu1sq * trace(Phi_dag * Phi)
    + lam1 * trace(Phi_dag * Phi)**2
    + lam2 * trace(Phi_dag * Phi * Phi_dag * Phi)
    + sp.Rational(1,2) * lam3 * (trace(Phi_dag * tilde_Phi) + trace(tilde_Phi_dag * Phi))**2
    + sp.Rational(1,2) * lam4 * (trace(Phi_dag * tilde_Phi) - trace(tilde_Phi_dag * Phi))**2
    + lam5 * trace(Phi_dag * Phi * tilde_Phi_dag * tilde_Phi)
    + sp.Rational(1,2) * lam6 * (trace(Phi_dag * tilde_Phi * Phi_dag * tilde_Phi)
                               + trace(tilde_Phi_dag * Phi * tilde_Phi_dag * Phi))
)

V_chi = (
    -mu2sq * (chi_L_dag.dot(chi_L) + chi_R_dag.dot(chi_R))
    + rho1 * (chi_L_dag.dot(chi_L)**2 + chi_R_dag.dot(chi_R)**2)
    + rho2 * (chi_L_dag.dot(chi_L)) * (chi_R_dag.dot(chi_R))
)

V_Phi_chi = (
    alpha1 * trace(Phi_dag * Phi) * (chi_L_dag.dot(chi_L) + chi_R_dag.dot(chi_R))
    + alpha2 * (chi_L_dag * Phi * Phi_dag * chi_L + chi_R_dag * Phi_dag * Phi * chi_R)[0]
    + alpha3 * (chi_L_dag * tilde_Phi * tilde_Phi_dag * chi_L
                + chi_R_dag * tilde_Phi_dag * tilde_Phi * chi_R)[0]
)

V = expand(V_Phi + V_chi + V_Phi_chi)

# --- Tadpole: verification against Eq. (9) of the paper ---------------------
VEV_all = {
    phi10: k1, phi10c: k1, phi20: k2, phi20c: k2,
    phi1m: 0, phi1mc: 0, phi2m: 0, phi2mc: 0,
    chiL: 0, chiLc: 0, chiR: 0, chiRc: 0,
    chiLn: vL, chiLnc: vL, chiRn: vR, chiRnc: vR
}
V0 = V.subs(VEV_all)

lam12 = lam1 + lam2
lam1356 = lam1 + 4*lam3 + lam5 + lam6
alpha12 = alpha1 + alpha2
alpha13 = alpha1 + alpha3

paper_tadpoles = {
    'k1': 2*k1*(-mu1sq + 2*k1**2*lam12 + 2*k2**2*lam1356 + (vL**2 + vR**2)*alpha13),
    'k2': 2*k2*(-mu1sq + 2*k1**2*lam1356 + 2*k2**2*lam12 + (vL**2 + vR**2)*alpha12),
    'vL': 2*vL*(-mu2sq + 2*rho1*vL**2 + rho2*vR**2 + k1**2*alpha13 + k2**2*alpha12),
    'vR': 2*vR*(-mu2sq + 2*rho1*vR**2 + rho2*vL**2 + k1**2*alpha13 + k2**2*alpha12),
}

tadpoles = {
    'k1': sp.diff(V0, k1),
    'k2': sp.diff(V0, k2),
    'vL': sp.diff(V0, vL),
    'vR': sp.diff(V0, vR),
}

for key in tadpoles:
    diff = simplify(tadpoles[key] - paper_tadpoles[key])
    assert diff == 0, f"Tadpole {key} does not match the literature: {diff}"

print("✓ Tadpole conditions: match Eq. (9) of Zeleny-Mora et al. (2026)\n")
for label, key in [(r"k_1", "k1"), (r"k_2", "k2"), (r"v_L", "vL"), (r"v_R", "vR")]:
    display(Math(rf"\frac{{\partial V}}{{\partial {label}}} = " + sp.latex(factor(tadpoles[key]))))

# --- Solve for mu1^2 and mu2^2 in the vL = k2 = 0 limit ----------------------
mu1sq_sol = sp.solve(sp.Eq(tadpoles['k1'].subs({k2:0, vL:0}), 0), mu1sq)[0]
mu2sq_sol = sp.solve(sp.Eq(tadpoles['vR'].subs({k2:0, vL:0}), 0), mu2sq)[0]

assert simplify(mu1sq_sol - (2*k1**2*lam12 + vR**2*alpha13)) == 0
assert simplify(mu2sq_sol - (2*rho1*vR**2 + k1**2*alpha13)) == 0
print("✓ Mass parameters in the $v_L = k_2 = 0$ limit:\n")
display(Math(r"\mu_1^2 = " + sp.latex(mu1sq_sol)))
display(Math(r"\mu_2^2 = " + sp.latex(mu2sq_sol)))

# --- Charged scalar mass matrix ---------------------------------------------
# Basis c+ = (phi2+, chiL+, phi1+, chiR+)
# Mapping: phi2+ = phi2mc, chiL+ = chiL, phi1+ = phi1mc, chiR+ = chiR
c_plus = [phi2mc, chiL, phi1mc, chiR]
c_minus = [phi2m, chiLc, phi1m, chiRc]

M_charged = Matrix([[sp.diff(V, c_plus[i], c_minus[j]) for j in range(4)] for i in range(4)])

VEV_charged = {
    phi10: k1, phi10c: k1, phi20: 0, phi20c: 0,
    phi1m: 0, phi1mc: 0, phi2m: 0, phi2mc: 0,
    chiL: 0, chiLc: 0, chiR: 0, chiRc: 0,
    chiLn: 0, chiLnc: 0, chiRn: vR, chiRnc: vR
}
M_charged = M_charged.subs(VEV_charged).subs({mu1sq: mu1sq_sol, mu2sq: mu2sq_sol})
M_charged = simplify(M_charged)

print("\nCharged scalar mass matrix (basis $c^+ = (\\phi_2^+, \\chi_L^+, \\phi_1^+, \\chi_R^+)$):")
display(Math(r"M_+^2 = " + sp.latex(M_charged)))

# --- Physical verification: masses and Goldstones ---------------------------
alpha23 = alpha2 - alpha3
rho21 = rho2 - 2*rho1

# Physical masses expected from Eq. (13)
mH1_sq = k1**2*alpha23 + vR**2*rho21
mH2_sq = alpha23*(k1**2 + vR**2)

# Physical verification: two Goldstones and two correct physical masses.
# The characteristic polynomial must be lambda^2 * (lambda - mH1^2) * (lambda - mH2^2).
# This is more robust than counting zero eigenvalues symbolically,
# because SymPy may return a complicated expression that simplifies to zero.
lam = symbols('lam')
char_poly = M_charged.charpoly(lam).as_expr()
expected_poly = lam**2 * (lam - mH1_sq) * (lam - mH2_sq)
assert simplify(expand(char_poly - expected_poly)) == 0
print("\n✓ Characteristic polynomial: $\\lambda^2 (\\lambda - m^2_{H_L})(\\lambda - m^2_{H_R})$")
print("  → two zero eigenvalues (Goldstones) and two physical masses\n")
print("Physical charged masses:")
display(Math(r"m^2_{H_L^\pm} = " + sp.latex(mH1_sq)))
display(Math(r"m^2_{H_R^\pm} = " + sp.latex(mH2_sq)))

✓ Tadpole conditions: match Eq. (9) of Zeleny-Mora et al. (2026)

✓ Mass parameters in the $v_L = k_2 = 0$ limit:

Charged scalar mass matrix (basis $c^+ = (\phi_2^+, \chi_L^+, \phi_1^+, \chi_R^+)$):

✓ Characteristic polynomial: $\lambda^2 (\lambda - m^2_{H_L})(\lambda - m^2_{H_R})$
  → two zero eigenvalues (Goldstones) and two physical masses

Physical charged masses:

Comparing the two arms

The difference is subtle but decisive. The chat model returns an answer that passes a quick review: the final masses are correct and the notation matches the paper. However, the answer has the properties that make an LLM dangerous in physics:

• It is opaque. There is no reproducible path to it. To know if it is correct, the reader must redo all the algebra.
• It is fragile in structure. Even when the final masses agree, the assignment of fields to physical states (Goldstone vs. Higgs) depends on the exact matrix structure. Without a CAS, a sign, a column swap, or a factor of 2 can go unnoticed.
• It is not auditable. There is no “reproduce” button.

In contrast, the LLM+CAS workflow gives:

• Full transparency. The code is the calculation; anyone can run it.
• Automatic verification. Every assert is a check the CAS evaluates symbolically. If the LLM had written code with a wrong sign, the cell would have failed with an error message, not produced a plausible-looking answer.
• Traceability. The relation between the potential, the tadpole conditions, the mass matrix, and the physical masses is explicit and readable.

Toward the theoretical physicist’s workflow in the LLM era

Show the figure code

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch

paper, ink, accent, grey = "#fcfcfa", "#22262b", "#3a5a7a", "#8a8f96"
red, green = "#9e4a4a", "#2a6f68"

plt.rcParams.update({
    "font.family": "serif",
    "font.size": 10,
    "axes.edgecolor": ink,
    "axes.linewidth": 0.8,
    "figure.facecolor": paper,
    "axes.facecolor": paper,
    "savefig.facecolor": paper,
})

fig, ax = plt.subplots(figsize=(7.2, 5.2))
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.axis("off")

def box(x, y, w, h, text, color=accent, text_color=paper):
    rect = FancyBboxPatch((x, y), w, h, boxstyle="round,pad=0.05,rounding_size=0.2",
                          facecolor=color, edgecolor=ink, linewidth=1.2)
    ax.add_patch(rect)
    ax.text(x + w/2, y + h/2, text, ha="center", va="center", color=text_color,
            fontsize=8, weight="bold", wrap=True)

def arrow(x1, y1, x2, y2, color=ink, style="->"):
    ax.annotate("", xy=(x2, y2), xytext=(x1, y1),
                arrowprops=dict(arrowstyle=style, color=color, lw=1.2))

# --- Arm A: direct chat answer ----------------------------------------------
ax.text(1.5, 9.3, "A. Direct chat answer", fontsize=11, weight="bold", color=ink)
box(0.5, 7.2, 2.2, 1.0, "Question\n(DLRSM)", accent)
box(3.2, 7.2, 2.0, 1.0, "LLM", "#6b4c7a")
box(5.7, 7.2, 2.6, 1.0, "Answer\n(derivation)", "#b45f06")
box(8.7, 7.2, 1.2, 1.0, "?", red)
arrow(2.7, 7.7, 3.2, 7.7)
arrow(5.2, 7.7, 5.7, 7.7)
arrow(8.3, 7.7, 8.7, 7.7)
ax.text(5.0, 6.8, "Manual verification, opaque, prone to silent errors",
        ha="center", fontsize=9, color=red, style="italic")

# --- Arm B: LLM + CAS -------------------------------------------------------
ax.text(1.5, 5.9, "B. LLM + CAS workflow", fontsize=11, weight="bold", color=ink)
box(0.5, 3.8, 2.2, 1.0, "Question\n(DLRSM)", accent)
box(3.2, 3.8, 2.0, 1.0, "LLM →\nSymPy", "#6b4c7a")
box(5.7, 3.8, 2.0, 1.0, "SymPy\n(runs)", green)
box(8.2, 3.8, 1.4, 1.0, "asserts\nOK/FAIL", "#b45f06")
box(5.7, 1.8, 4.2, 1.0, "Physicist reviews\nand signs off", accent)

arrow(2.7, 4.3, 3.2, 4.3)
arrow(5.2, 4.3, 5.7, 4.3)
arrow(7.7, 4.3, 8.2, 4.3)
# Feedback loop
arrow(8.9, 3.8, 8.9, 2.8, color=grey)
arrow(8.2, 2.3, 5.7, 2.3, color=grey, style="<-")
ax.text(5.0, 1.1, "Automatic symbolic verification, reproducible, auditable",
        ha="center", fontsize=9, color=green, style="italic")

plt.tight_layout()

The DLRSM case is a clean example of the broader pattern. The CAS does not replace the physicist; it defines a division of responsibilities:

This pattern scales in several directions. Today SymPy covers the polynomial algebra of the scalar sector; for one-loop calculations with Passarino–Veltman functions, the same workflow points to tools like FeynCalc, Package-X, or LoopTools, with the LLM acting as an orchestrator between them. This is where work such as Hell and Thiele (2026) explores the frontier: not an LLM that solves the problem, but an LLM that writes the code the CAS runs and the physicist verifies.

The deepest change is cultural. In the near future, a PhD student in theoretical physics will likely spend less time rewriting matrix products by hand and more time on:

1. Formulating the model and the verification protocol.
2. Asking an LLM to generate the CAS code.
3. Running the code, checking the assert, and analyzing the limiting cases.
4. Deciding whether the result makes physical sense.

The derivation does not disappear; it becomes code. And code, unlike a chat answer, can be run, audited, and fixed.

Honest limits

The workflow is not infallible. The CAS only checks what we ask it to check. If the LLM writes code that typechecks but encodes the wrong physics—for example, using the wrong invariant in the potential—the assert will pass and the physical result will be wrong. The CAS does not replace physical judgment; it formalizes it.

There are also practical limitations:

• Context and length: for potentials with dozens of parameters, the prompt can become unwieldy.
• SymPy performance: real loop integrals or very large matrices quickly exceed what SymPy can do in reasonable time.
• Conventions: the LLM may mix up sign conventions for , , or charges. The verification harness should include at least a gauge-invariance check or a known limit.

The point is not that LLM+CAS does everything. The point is that it converts the model’s uncertainty into a CAS exception, which is much easier to diagnose than a plausibly wrong answer.

Appendix: full prompt to Gemini 3.1 Pro

The prompt was sent on 2026-08-02 to the Gemini 3.1 Pro model. The response text was abbreviated in the body of the post; the full prompt is reproduced here so anyone can repeat it:

Consider the Doublet Left-Right Symmetric Model (DLRSM) with a bidoublet where , and . The model also contains two doublets and with and . The scalar potential is where Derive: (a) the four tadpole conditions; (b) the charged scalar mass matrix in the basis in the limit ; (c) the physical charged Higgs masses.

The calculation still done by hand

Theoretical particle physics is, to nobody’s surprise, a discipline where most calculations are done by hand. This is neither a defect nor nostalgia: it is how a researcher internalizes a model’s behavior, detects subtle cancellations, and develops physical intuition. That skill is not going away, nor should it. Manual derivation remains the core training of the trade.

But it is not the only way to work. For decades, computational tools have existed specifically to automate parts of the process: FeynRules and SARAH for model building and vertex derivation; MadGraph for collider amplitudes and simulations; SPheno and micrOMEGAs for observables; FeynCalc and Package-X for amplitude computation, tensor reduction, and loop calculations. The list is long. And yet, the routine use of these tools is far from universal. Many groups keep doing by hand what a computer could do in seconds, not because they distrust the result, but because the barrier to entry for the tool is higher than the barrier to output of the manual calculation.

The problem, in my experience, is threefold:

1. Scarce or opaque documentation. Manuals that assume the user already knows the package’s internal architecture; tutorials that break at the first update; examples that cover the trivial case but not the one you need.
2. Steep learning curves. Installing, configuring, and producing a first useful result with SARAH or FeynRules can take days. Each tool has its own input language, its own conventions, its own cryptic error messages.
3. Lack of bridges between tools. The output of one is manually converted into the input of another, in incompatible formats, through ad-hoc scripts that each group maintains independently.

Even when a tool works, its output arrives as a black box — a Lagrangian or a set of Feynman rules produced by an opaque internal pipeline. To use that output in a loop calculation, a theorist needs to trust it down to the sign conventions. The only way to earn that trust is to derive it independently, which erases much of the time the tool was supposed to save. Hand derivation isn’t just pedagogical: it’s a verification step that automated tools don’t replace, they just relocate — now you have to verify the tool’s output against your own derivation anyway.

The cost of learning the tool frequently exceeds the cost of doing the calculation by hand (which is largely clear in the literature and the craft). And so, powerful tools remain underutilized.

What changed with LLMs

This is, I believe, the most genuine and least publicized contribution of language models to theoretical physics. It is not — or not yet — that they derive better than a human. It is that they translate natural-language intent into the concrete invocation of a tool, its documentation, or its input code. An LLM can:

• Read a Lagrangian in standard notation and produce the corresponding model file for FeynRules or SARAH, with the correct conventions.
• Explain an obscure SPheno error message in terms of the model you are building.
• Generate a MadGraph script for a specific process from a natural-language description, including cuts and output formats.
• Write the glue between two tools — the script that takes the output of one and converts it into the input of the other — avoiding the phase of reading two separate manuals.

The barrier LLMs are lowering is not the one between the physicist and physics, but between the physicist and the computational tools already on their machine. And the evidence that this is happening is not anecdotal: in the last two years a body of literature has emerged that is worth reviewing in some detail.

What has been built (2022–2026)

What follows is a survey of recent work that, in one way or another, uses LLMs to bridge the gap between the theoretical physicist and the computational tools of the trade. It is not exhaustive; it is representative. Figure 1 summarizes the timeline: theoretical-physics publications using LLMs (bottom axis) cluster with a two- to three-year lag behind the milestones of the models themselves (top axis) — the time it takes the community to absorb each new capability as a research tool.

Show the code

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from datetime import datetime, timedelta

# --- Academic styling to match the site ---------------------------------------
paper, ink, accent, grey = "#fcfcfa", "#22262b", "#3a5a7a", "#8a8f96"
colors = {
    "model":    "#2a6f68",  # teal
    "symbolic": "#b45f06",  # amber
    "qft":      "#6b4c7a",  # muted purple
    "analysis": "#9e4a4a",  # muted red
    "roadmap":  accent,     # slate
}
plt.rcParams.update({
    "font.family": "serif",
    "font.size": 10,
    "axes.edgecolor": ink,
    "axes.linewidth": 0.8,
    "figure.facecolor": paper,
    "axes.facecolor": paper,
    "savefig.facecolor": paper,
})

# --- Data ---------------------------------------------------------------------
llm_events = [
    (datetime(2020, 6, 11),  "GPT-3"),
    (datetime(2022, 11, 30), "ChatGPT"),
    (datetime(2023, 3, 14),  "GPT-4"),
    (datetime(2023, 7, 19),  "Llama 2"),
    (datetime(2024, 3, 14),  "Claude 3"),
    (datetime(2024, 12, 6),  "Gemini 2 / o1"),
    (datetime(2025, 9, 17),  ""),  # manual label below
]
phys_events = [
    (datetime(2025, 1, 9),  "Barman (LPMs)",          "roadmap"),
    (datetime(2025, 2, 7),  "v. Hippel (IBP)",        "symbolic"),
    (datetime(2026, 3, 30), "Albert",                 "model"),
    (datetime(2026, 4, 1),  "Yu (QFT/strings)",       "qft"),
    (datetime(2026, 4, 20), "Woodward (QFT)",         "qft"),
    (datetime(2026, 5, 6),  "Hell & Thiele\n(LLM+CAS)", "symbolic"),
    (datetime(2026, 6, 9),  "DarkAgents",             "model"),
    (datetime(2026, 6, 11), "AgentRivet",             "analysis"),
    (datetime(2026, 6, 17), "Bom (DE)",               "model"),
    (datetime(2026, 6, 19), "bsm_agent",              "model"),
]
events_2025 = [e for e in phys_events if e[0].year == 2025]
events_2026 = [e for e in phys_events if e[0].year == 2026]

# --- Figure: broken axis on the bottom panel ----------------------------------
fig = plt.figure(figsize=(7.2, 5.4))
gs = fig.add_gridspec(2, 2, height_ratios=[0.7, 1.3], width_ratios=[0.30, 0.70])

# Top panel: LLM milestones
ax_top = fig.add_subplot(gs[0, :])
ax_top.axhline(0, color=grey, lw=0.8, alpha=0.5, zorder=1)
for i, (date, label) in enumerate(llm_events):
    ax_top.vlines(date, -0.08, 0.08, color=grey, lw=1.2, zorder=2)
    ax_top.plot(date, 0.08, "o", color=ink, markersize=4, zorder=3)
    if i % 2 == 0:
        ax_top.text(date, 0.12, label, rotation=25, ha="left", va="bottom",
                    fontsize=8.5, color=ink, zorder=3)
    else:
        ax_top.text(date, -0.12, label, rotation=25, ha="left", va="top",
                    fontsize=8.5, color=ink, zorder=3)
# Last milestone label, right-aligned so it fits
ax_top.text(datetime(2025, 9, 17), 0.12, "Reasoning\nmodels",
            rotation=0, ha="right", va="bottom", fontsize=8.5, color=ink, zorder=3)
ax_top.text(datetime(2019, 9, 1), 0, "LLMs", ha="right", va="center",
            fontsize=10, color=ink, weight="bold")
ax_top.set_ylim(-0.38, 0.38)
ax_top.set_yticks([])
ax_top.xaxis.set_major_locator(mdates.YearLocator())
ax_top.xaxis.set_major_formatter(mdates.DateFormatter("%Y"))
ax_top.xaxis.set_minor_locator(mdates.MonthLocator(interval=6))
plt.setp(ax_top.get_xticklabels(), rotation=0, ha="center", fontsize=9)
ax_top.tick_params(axis="x", colors=ink, length=4)
for s in ["left", "right", "top"]:
    ax_top.spines[s].set_visible(False)
ax_top.spines["bottom"].set_color(ink)
ax_top.set_xlim(datetime(2019, 8, 1), datetime(2026, 9, 1))

# Bottom-left panel: 2025
ax_l = fig.add_subplot(gs[1, 0])
ax_l.axhline(0, color=accent, lw=0.8, alpha=0.5, zorder=1)
ax_l.axvspan(datetime(2025, 1, 1), datetime(2025, 3, 1),
             color=accent, alpha=0.06, zorder=0)
for i, (date, label, cat) in enumerate(events_2025):
    c = colors[cat]
    side = 1 if i % 2 == 0 else -1
    y_dot = side * 0.15
    y_text = side * 0.23
    ax_l.vlines(date, 0, y_dot, color=c, lw=1.2, zorder=2)
    ax_l.plot(date, y_dot, "o", color=c, markersize=4, zorder=3)
    va = "bottom" if side == 1 else "top"
    ax_l.text(date + timedelta(days=3), y_text, label, rotation=0, ha="left", va=va,
              fontsize=7.5, color=c, zorder=3)
ax_l.set_ylim(-0.30, 0.30)
ax_l.set_yticks([])
ax_l.xaxis.set_major_locator(mdates.MonthLocator())
ax_l.xaxis.set_major_formatter(mdates.DateFormatter("%b"))
plt.setp(ax_l.get_xticklabels(), rotation=0, ha="center", fontsize=8)
ax_l.tick_params(axis="x", colors=ink, length=3)
ax_l.set_xlim(datetime(2024, 11, 1), datetime(2025, 4, 1))
for s in ["left", "right", "top"]:
    ax_l.spines[s].set_visible(False)
ax_l.spines["bottom"].set_color(ink)

# Bottom-right panel: 2026 enlarged (with labels)
ax_r = fig.add_subplot(gs[1, 1])
ax_r.axhline(0, color=accent, lw=0.8, alpha=0.5, zorder=1)
ax_r.axvspan(datetime(2026, 3, 15), datetime(2026, 6, 30),
             color=accent, alpha=0.06, zorder=0)
zoom_levels = [
    (0.20,  1,  0),  # Albert
    (0.20, -1,  0),  # Yu
    (0.38,  1,  0),  # Woodward
    (0.38, -1,  0),  # Hell
    (0.56,  1,  8),  # DarkAgents
    (0.56, -1, -8),  # AgentRivet
    (0.74,  1, -8),  # Bom
    (0.74, -1,  8),  # bsm_agent
]
for (date, label, cat), (lvl, side, xoff) in zip(events_2026, zoom_levels):
    c = colors[cat]
    y_dot = side * lvl
    y_text = side * (lvl + 0.08)
    x_text = date + timedelta(days=xoff)
    ax_r.vlines(date, 0, y_dot, color=c, lw=1.2, zorder=2)
    ax_r.plot(date, y_dot, "o", color=c, markersize=3.5, zorder=3)
    va = "bottom" if side == 1 else "top"
    ha = "left" if xoff >= 0 else "right"
    ax_r.text(x_text, y_text, label, rotation=0, ha=ha, va=va,
              fontsize=7.0, color=c, zorder=3)
ax_r.set_ylim(-0.95, 0.95)
ax_r.set_yticks([])
ax_r.xaxis.set_major_locator(mdates.MonthLocator())
ax_r.xaxis.set_major_formatter(mdates.DateFormatter("%b"))
plt.setp(ax_r.get_xticklabels(), rotation=0, ha="center", fontsize=8)
ax_r.tick_params(axis="x", colors=ink, length=3)
ax_r.set_xlim(datetime(2026, 3, 10), datetime(2026, 8, 5))
for s in ["left", "right", "top"]:
    ax_r.spines[s].set_visible(False)
ax_r.spines["bottom"].set_color(ink)

# Break marks at the junction of the two bottom axes
kw = dict(transform=ax_l.transAxes, color=ink, clip_on=False, lw=0.8)
ax_l.plot((0.96, 0.99), (-0.018, 0.012), **kw)
ax_l.plot((0.96, 0.99), (0.012, -0.018), **kw)
kw = dict(transform=ax_r.transAxes, color=ink, clip_on=False, lw=0.8)
ax_r.plot((0.01, 0.04), (-0.018, 0.012), **kw)
ax_r.plot((0.01, 0.04), (0.012, -0.018), **kw)

# Bottom axis label
fig.text(0.02, 0.30, "Theoretical physics", ha="left", va="center",
         fontsize=10, color=accent, weight="bold", rotation=90)

# Category legend
from matplotlib.lines import Line2D
legend_elements = [
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["model"],
           markersize=6, label="Model building"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["symbolic"],
           markersize=6, label="Symbolic / CAS"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["qft"],
           markersize=6, label="QFT"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["analysis"],
           markersize=6, label="Experimental analysis"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["roadmap"],
           markersize=6, label="Roadmap"),
]
ax_top.legend(handles=legend_elements, loc="lower left", fontsize=6.8,
            frameon=True, facecolor=paper, edgecolor=grey,
            ncol=5, bbox_to_anchor=(0.0, -0.31))

fig.tight_layout(rect=[0.04, 0, 1, 1])
plt.show()

What all of this means

The common thread of the works above is not “LLMs solve theoretical physics.” It is more specific and, I think, more interesting: LLMs are turning tools that already existed but were difficult to use into tools accessible via natural language. The pattern repeats:

• bsm_agent: natural language symbolic backend.
• DarkAgents: natural language compute pipeline + audit.
• Hell & Thiele: natural language + examples Maple code.
• funsearch + IBP: natural language (via code generation) heuristics evaluated by solver.
• AgentRivet: published paper Rivet routine.

In each case, the correct physics is guaranteed by a deterministic layer external to the LLM. The LLM solves the interface problem.

This has practical implications. The community does not need, for now, a model that derives on its own — it probably wouldn’t be trustworthy even if it existed. What is needed is investment in documentation, APIs, and wrappers that make existing tools accessible to an LLM, because the LLM already knows — in the statistical sense — how to use them. A SARAH with a well-designed API and machine-readable documentation would be immediately more useful, via LLM, than a SARAH without any of that but coupled to a larger generative model.

But lowering the technical barrier is not enough if physicists cannot cross the one that is already low. To the extent that LLMs turn natural language into tool invocations, the next bottleneck is not the interface — it is the user’s ability to read, audit, and correct what the model produces. Theoretical-physics training should include, in the near future, basic software skills: reading source code, version control, debugging symbolic packages. Not to turn physicists into programmers, but so that verification — which remains the central step of the craft — does not depend on a skill set that most theory PhDs do not receive today.

As theoretical physics evolves and new tools, methods, or theories emerge, building a deterministic layer external to the LLM — one that guarantees the correct application of the physics — will be the most important part for the community to reliably harness LLMs.

What is missing

I end with three directions that this survey leaves open and that probably deserve their own entries in this log:

1. A concrete case study. Take one of the patterns above and run it end-to-end on a real BSM model (with unpublished details withheld), measuring time saved and errors encountered.
2. Operational comparison between models. All the cited works treat “the LLM” as an interchangeable black box. The reality is that different models fail in different ways, and characterizing that for theoretical-physics tasks is a pending contribution.
3. The verification problem. Almost all the systems described delegate correctness to a deterministic layer. But what happens when the deterministic layer does not exist or is itself hard to verify? That is the hardest use case, and it is only beginning to be explored.

References

La cuenta que todavía se hace a mano

La física teórica de partículas es, para sorpresa de nadie, una disciplina donde la mayor parte de los cálculos se hacen a mano. Esto no es un defecto ni una nostalgia: es la forma en que un investigador internaliza el comportamiento de un modelo, detecta cancelaciones sutiles y desarrolla intuición física. Esa habilidad no va a desaparecer, ni debería. La derivación a pulso sigue siendo el entrenamiento central del oficio.

Pero no es la única forma de trabajar. Desde hace décadas existen herramientas computacionales diseñadas precisamente para automatizar partes del proceso: FeynRules y SARAH para construir modelos y derivar vértices; MadGraph para amplitudes y simulaciones en colisionadores; SPheno y micrOMEGAs para observables; FeynCalc y Package-X para computo de amplitudes, reducción tensorial y de lazos. La lista es larga. Y sin embargo, el uso rutinario de estas herramientas está lejos de ser universal. Muchos grupos siguen haciendo a mano lo que una computadora podría hacer en segundos, no porque desconfíen del resultado, sino porque la barrera de entrada a la herramienta es más alta que la barrera de salida del cálculo manual.

El problema, en mi experiencia, es triple:

1. Documentación escasa u opaca. Manuales que asumen que el usuario ya conoce la arquitectura interna del paquete; tutoriales que se rompen con la primera actualización; ejemplos que cubren el caso trivial pero no el que uno necesita.
2. Curvas de aprendizaje empinadas. Instalar, configurar y producir un primer resultado útil con SARAH o FeynRules puede tomar días. Cada herramienta tiene su propio lenguaje de entrada, sus propias convenciones, sus propios mensajes de error crípticos.
3. Falta de puentes entre herramientas. El resultado de una se convierte manualmente en la entrada de otra, en formatos incompatibles, mediante scripts ad-hoc que cada grupo mantiene por separado.

Incluso cuando una herramienta funciona, su resultado llega como caja negra —un Lagrangiano o un conjunto de reglas de Feynman producido por un pipeline interno opaco—. Para usar ese resultado en un cálculo a lazos, un teórico necesita creerlo hasta en las convenciones de signos. La única forma de conseguir esa confianza es derivarlo independientemente, lo cual borra buena parte del tiempo que la herramienta debía ahorrar. La derivación a mano no es solo pedagógica: es un paso de verificación que las herramientas automatizadas no reemplazan, solo reubican —ahora hay que verificar la salida de la herramienta contra la derivación propia de todas formas—.

El costo de aprender la herramienta frecuentemente supera el costo de hacer la cuenta a mano (lo que se encuentra mayormente claro en la literatura y el oficio). Y así, herramientas poderosas se subutilizan.

Lo que cambió con los LLMs

Esta es, creo, la contribución más genuina y menos publicitada de los modelos de lenguaje a la física teórica. No es —o no es todavía— que deriven mejor que un humano. Es que traducen la intención en lenguaje natural a la invocación concreta de una herramienta, su documentación o su código de entrada. Un LLM puede:

• Leer un Lagrangiano en notación estándar y producir el archivo de modelo correspondiente para FeynRules o SARAH, con las convenciones correctas.
• Explicar un mensaje de error oscuro de SPheno en términos del modelo que uno está construyendo.
• Generar el script de MadGraph para un proceso específico a partir de una descripción en lenguaje natural, incluyendo cortes y formatos de salida.
• Escribir el pegamento entre dos herramientas —el script que toma la salida de una y la convierte en la entrada de la otra— evitando la fase de leer dos manuales distintos.

La barrera que los LLMs están bajando no es entre el físico y la física, sino entre el físico y las herramientas computacionales que ya están en su máquina. Y la evidencia de que esto está ocurriendo no es anecdótica: en los últimos dos años ha aparecido un cuerpo de literatura que vale la pena repasar con algún detalle.

Lo que se ha construido (2022–2026)

Lo que sigue es un recorrido por trabajos recientes que, de una forma u otra, usan LLMs para tender puentes entre el físico teórico y las herramientas computacionales del oficio. No es exhaustivo; es representativo. La Figura 1 resume la cronología: las publicaciones de física teórica con LLMs (eje inferior) se agrupan con un retraso de dos a tres años respecto a los hitos de los propios modelos (eje superior) —el tiempo que tarda la comunidad en asimilar cada nueva capacidad como herramienta de investigación—.

Mostrar el código

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from datetime import datetime, timedelta

# --- Estilo académico, paleta del sitio ---------------------------------------
paper, ink, accent, grey = "#fcfcfa", "#22262b", "#3a5a7a", "#8a8f96"
colors = {
    "model":    "#2a6f68",  # teal
    "symbolic": "#b45f06",  # amber
    "qft":      "#6b4c7a",  # muted purple
    "analysis": "#9e4a4a",  # muted red
    "roadmap":  accent,     # slate
}
plt.rcParams.update({
    "font.family": "serif",
    "font.size": 10,
    "axes.edgecolor": ink,
    "axes.linewidth": 0.8,
    "figure.facecolor": paper,
    "axes.facecolor": paper,
    "savefig.facecolor": paper,
})

# --- Datos --------------------------------------------------------------------
llm_events = [
    (datetime(2020, 6, 11),  "GPT-3"),
    (datetime(2022, 11, 30), "ChatGPT"),
    (datetime(2023, 3, 14),  "GPT-4"),
    (datetime(2023, 7, 19),  "Llama 2"),
    (datetime(2024, 3, 14),  "Claude 3"),
    (datetime(2024, 12, 6),  "Gemini 2 / o1"),
    (datetime(2025, 9, 17),  ""),  # etiqueta manual más abajo
]
phys_events = [
    (datetime(2025, 1, 9),  "Barman (LPMs)",          "roadmap"),
    (datetime(2025, 2, 7),  "v. Hippel (IBP)",        "symbolic"),
    (datetime(2026, 3, 30), "Albert",                 "model"),
    (datetime(2026, 4, 1),  "Yu (QFT/strings)",       "qft"),
    (datetime(2026, 4, 20), "Woodward (QFT)",         "qft"),
    (datetime(2026, 5, 6),  "Hell & Thiele\n(LLM+CAS)", "symbolic"),
    (datetime(2026, 6, 9),  "DarkAgents",             "model"),
    (datetime(2026, 6, 11), "AgentRivet",             "analysis"),
    (datetime(2026, 6, 17), "Bom (DE)",               "model"),
    (datetime(2026, 6, 19), "bsm_agent",              "model"),
]
events_2025 = [e for e in phys_events if e[0].year == 2025]
events_2026 = [e for e in phys_events if e[0].year == 2026]

# --- Figura: eje quiebrado en el panel inferior -------------------------------
fig = plt.figure(figsize=(7.2, 5.4))
gs = fig.add_gridspec(2, 2, height_ratios=[0.7, 1.3], width_ratios=[0.30, 0.70])

# Panel superior: hitos de LLMs
ax_top = fig.add_subplot(gs[0, :])
ax_top.axhline(0, color=grey, lw=0.8, alpha=0.5, zorder=1)
for i, (date, label) in enumerate(llm_events):
    ax_top.vlines(date, -0.08, 0.08, color=grey, lw=1.2, zorder=2)
    ax_top.plot(date, 0.08, "o", color=ink, markersize=4, zorder=3)
    if i % 2 == 0:
        ax_top.text(date, 0.12, label, rotation=25, ha="left", va="bottom",
                    fontsize=8.5, color=ink, zorder=3)
    else:
        ax_top.text(date, -0.12, label, rotation=25, ha="left", va="top",
                    fontsize=8.5, color=ink, zorder=3)
# Etiqueta del último hito arriba, alineada a la derecha para no salirse
ax_top.text(datetime(2025, 9, 17), 0.12, "Modelos de\nrazonamiento",
            rotation=0, ha="right", va="bottom", fontsize=8.5, color=ink, zorder=3)
ax_top.text(datetime(2019, 9, 1), 0, "LLMs", ha="right", va="center",
            fontsize=10, color=ink, weight="bold")
ax_top.set_ylim(-0.38, 0.38)
ax_top.set_yticks([])
ax_top.xaxis.set_major_locator(mdates.YearLocator())
ax_top.xaxis.set_major_formatter(mdates.DateFormatter("%Y"))
ax_top.xaxis.set_minor_locator(mdates.MonthLocator(interval=6))
plt.setp(ax_top.get_xticklabels(), rotation=0, ha="center", fontsize=9)
ax_top.tick_params(axis="x", colors=ink, length=4)
for s in ["left", "right", "top"]:
    ax_top.spines[s].set_visible(False)
ax_top.spines["bottom"].set_color(ink)
ax_top.set_xlim(datetime(2019, 8, 1), datetime(2026, 9, 1))

# Panel inferior izquierdo: 2025
ax_l = fig.add_subplot(gs[1, 0])
ax_l.axhline(0, color=accent, lw=0.8, alpha=0.5, zorder=1)
ax_l.axvspan(datetime(2025, 1, 1), datetime(2025, 3, 1),
             color=accent, alpha=0.06, zorder=0)
for i, (date, label, cat) in enumerate(events_2025):
    c = colors[cat]
    side = 1 if i % 2 == 0 else -1
    y_dot = side * 0.15
    y_text = side * 0.23
    ax_l.vlines(date, 0, y_dot, color=c, lw=1.2, zorder=2)
    ax_l.plot(date, y_dot, "o", color=c, markersize=4, zorder=3)
    va = "bottom" if side == 1 else "top"
    ax_l.text(date + timedelta(days=3), y_text, label, rotation=0, ha="left", va=va,
              fontsize=7.5, color=c, zorder=3)
ax_l.set_ylim(-0.30, 0.30)
ax_l.set_yticks([])
ax_l.xaxis.set_major_locator(mdates.MonthLocator())
ax_l.xaxis.set_major_formatter(mdates.DateFormatter("%b"))
plt.setp(ax_l.get_xticklabels(), rotation=0, ha="center", fontsize=8)
ax_l.tick_params(axis="x", colors=ink, length=3)
ax_l.set_xlim(datetime(2024, 11, 1), datetime(2025, 4, 1))
for s in ["left", "right", "top"]:
    ax_l.spines[s].set_visible(False)
ax_l.spines["bottom"].set_color(ink)

# Panel inferior derecho: 2026 ampliado (con etiquetas)
ax_r = fig.add_subplot(gs[1, 1])
ax_r.axhline(0, color=accent, lw=0.8, alpha=0.5, zorder=1)
ax_r.axvspan(datetime(2026, 3, 15), datetime(2026, 6, 30),
             color=accent, alpha=0.06, zorder=0)
zoom_levels = [
    (0.20,  1,  0),  # Albert
    (0.20, -1,  0),  # Yu
    (0.38,  1,  0),  # Woodward
    (0.38, -1,  0),  # Hell
    (0.56,  1,  8),  # DarkAgents
    (0.56, -1, -8),  # AgentRivet
    (0.74,  1, -8),  # Bom
    (0.74, -1,  8),  # bsm_agent
]
for (date, label, cat), (lvl, side, xoff) in zip(events_2026, zoom_levels):
    c = colors[cat]
    y_dot = side * lvl
    y_text = side * (lvl + 0.08)
    x_text = date + timedelta(days=xoff)
    ax_r.vlines(date, 0, y_dot, color=c, lw=1.2, zorder=2)
    ax_r.plot(date, y_dot, "o", color=c, markersize=3.5, zorder=3)
    va = "bottom" if side == 1 else "top"
    ha = "left" if xoff >= 0 else "right"
    ax_r.text(x_text, y_text, label, rotation=0, ha=ha, va=va,
              fontsize=7.0, color=c, zorder=3)
ax_r.set_ylim(-0.95, 0.95)
ax_r.set_yticks([])
ax_r.xaxis.set_major_locator(mdates.MonthLocator())
ax_r.xaxis.set_major_formatter(mdates.DateFormatter("%b"))
plt.setp(ax_r.get_xticklabels(), rotation=0, ha="center", fontsize=8)
ax_r.tick_params(axis="x", colors=ink, length=3)
ax_r.set_xlim(datetime(2026, 3, 10), datetime(2026, 8, 5))
for s in ["left", "right", "top"]:
    ax_r.spines[s].set_visible(False)
ax_r.spines["bottom"].set_color(ink)

# Marcas de quiebre en la unión de los dos ejes inferiores
kw = dict(transform=ax_l.transAxes, color=ink, clip_on=False, lw=0.8)
ax_l.plot((0.96, 0.99), (-0.018, 0.012), **kw)
ax_l.plot((0.96, 0.99), (0.012, -0.018), **kw)
kw = dict(transform=ax_r.transAxes, color=ink, clip_on=False, lw=0.8)
ax_r.plot((0.01, 0.04), (-0.018, 0.012), **kw)
ax_r.plot((0.01, 0.04), (0.012, -0.018), **kw)

# Etiqueta del eje inferior
fig.text(0.02, 0.30, "Física teórica", ha="left", va="center",
         fontsize=10, color=accent, weight="bold", rotation=90)

# Leyenda de categorías (a nivel de figura, centrada entre paneles inferiores)
from matplotlib.lines import Line2D
legend_elements = [
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["model"],
           markersize=6, label="Model building"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["symbolic"],
           markersize=6, label="Simbólico/ CAS"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["qft"],
           markersize=6, label="QFT"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["analysis"],
           markersize=6, label="Análisis experimental"),
    Line2D([0], [0], marker="o", color="w", markerfacecolor=colors["roadmap"],
           markersize=6, label="Roadmap"),
]
ax_top.legend(handles=legend_elements, loc="lower left", fontsize=6.8,
            frameon=True, facecolor=paper, edgecolor=grey,
            ncol=5, bbox_to_anchor=(0.0, -0.31))

fig.tight_layout(rect=[0.04, 0, 1, 1])
plt.show()

Qué significa todo esto

El hilo conductor de los trabajos anteriores no es “los LLMs resuelven física teórica”. Es más específico y, creo, más interesante: los LLMs están convirtiendo herramientas que ya existían pero eran difíciles de usar en herramientas accesibles mediante lenguaje natural. El patrón se repite:

• bsm_agent: lenguaje natural backend simbólico.
• DarkAgents: lenguaje natural pipeline de cómputo + auditoría.
• Hell & Thiele: lenguaje natural + ejemplos código de Maple.
• funsearch + IBP: lenguaje natural (vía generación de código) heurísticas evaluadas por solver.
• AgentRivet: paper publicado rutina de Rivet.

En todos los casos, la física correcta la garantiza una capa determinista externa al LLM. El LLM resuelve el problema de interfaz.

Esto tiene implicaciones prácticas. La comunidad no necesita, por ahora, un modelo que derive de manera autónoma —probablemente no sería confiable aunque existiera—. Lo que se requiere es inversión en documentación, APIs y wrappers que hagan accesibles las herramientas existentes a un LLM, porque el LLM ya sabe —en el sentido estadístico— cómo utilizarlas. Un SARAH con una API bien diseñada y documentación legible para la máquina sería inmediatamente más útil, vía LLM, que un SARAH sin esos recursos pero acoplado a un modelo generativo más grande.

Pero bajar la barrera técnica no basta si los físicos no pueden cruzar la que ya está baja. En la medida en que los LLMs convierten el lenguaje natural en invocaciones de herramientas, el siguiente cuello de botella no es la interfaz — es la capacidad del usuario para leer, auditar y corregir lo que el modelo produce. La formación en física teórica deberá incluir, en el futuro cercano, habilidades básicas de software: lectura de código fuente, control de versiones, depuración de paquetes simbólicos. No para convertir a los físicos en programadores, sino para que la verificación —que sigue siendo el paso central del oficio— no dependa de habilidades que la mayoría de los doctorados en teoría no reciben hoy.

A medida que la física teórica evolucione y surjan nuevas herramientas, métodos o teorías, la construcción de una capa determinista externa al LLM —que garantice la correcta aplicación de la física— será la parte más importante para que la comunidad pueda aprovechar los LLMs de manera confiable.

Lo que falta

Termino con tres direcciones que este recorrido deja abiertas y que probablemente merezcan entradas propias en esta bitácora:

1. Un estudio de caso concreto. Tomar uno de los patrones anteriores y ejecutarlo de extremo a extremo en un modelo BSM real (con los detalles no publicados reservados), midiendo tiempo ahorrado y errores encontrados.
2. Comparación operativa entre modelos. Todos los trabajos citados usan “el LLM” como una caja negra intercambiable. La realidad es que modelos distintos fallan de modos distintos, y caracterizar eso para tareas de física teórica es una contribución pendiente.
3. El problema de la verificación. Casi todos los sistemas descritos delegan la corrección a una capa determinista. Pero ¿qué pasa cuando la capa determinista no existe o es ella misma difícil de verificar? Ése es el caso de uso más duro, y apenas empieza a explorarse.

Referencias

Por qué inicio esta bitácora

Uso modelos de lenguaje en mi investigación cotidiana, y me he cansado de dos narrativas igualmente inútiles: la que dice que los LLMs están a punto de hacer física por nosotros, y la que los trata como loros estocásticos inútiles para cualquier cosa seria. Ninguna corresponde con lo que realmente experimento en el escritorio.

Lo que experimento es más interesante y más mundano: una herramienta genuinamente útil para ciertas subtareas, poco fiable para otras, y ocasionalmente equivocada con seguridad de formas que cuestan tiempo real. La única manera de saber cuál es cuál es llevar un registro. Así que esto es ese registro — una libreta de laboratorio para un tipo particular de instrumento.

El público que tengo en mente son otros investigadores, particularmente en física teórica y de partículas. Si trabajas en fenomenología BSM — sectores escalar o de gauge extendidos, mecanismos de masa de neutrinos, materia oscura, sabor, signaturas en colisionadores — espero que algunas de estas notas te ahorren el trabajo de redescubrir los mismos modos de fallo que yo.

Dónde ayudan los LLMs actualmente (y dónde no)

Esta es una instantánea de mi opinión actual y revisable. Parte del punto de la bitácora es hacer estos reclamos responsables con el tiempo.

Dónde me ayudan hoy:

• Código boilerplate y de pegamento. Parsear salida SLHA, cablear barridos, reorganizar datos para gráficas, andamiaje de matplotlib/pandas. Rápido de escribir, rápido de verificar.
• Traducir entre herramientas y formalismos. Bosquejar un fragmento de modelo en FeynRules o SARAH, convertir un término del Lagrangiano en un vértice aproximado, mover un fragmento entre Mathematica y Python.
• Triaje y orientación en la literatura. Obtener un primer mapa de un rincón desconocido de la literatura, o reformular un resultado recordado a medias en términos buscables — siempre como un apuntador, nunca como una cita.
• Rubber-ducking de derivaciones. Recorrer verbalmente una contracción de índices, una reducción de integral de lazo o un argumento de simetría, donde sigo siendo yo quien revisa cada línea.

Dónde (aún) no ayudan:

• Cualquier cosa que requiera una derivación garantidamente correcta. Signos, factores de 2, convenciones de y sutilezas de son justamente donde la salida que suena fluida es más peligrosa.
• Valores numéricos y citas. Razones de ramificación o listas de referencias fabricadas con seguridad siguen siendo un riesgo real.
• Construcción de modelos genuinamente novedosa. Recombinan lo conocido bien; no producen de forma fiable la restricción en la que no había pensado.

Un ejemplo concreto de la trampa: un LLM producirá felizmente una contribución a un lazo que parece correcta — estructura correcta, prefactor plausible — y estará mal por un signo o un . La expresión se compone bonitamente:

y la única defensa es derivarla uno mismo y tratar la versión del modelo como una hipótesis a verificar, no como una respuesta.

Qué esperar aquí

• Tareas reales, no demos de juguete. Cada entrada es algo que realmente necesitaba hacer.
• El flujo de trabajo completo, incluyendo los prompts y los callejones sin salida — no una selección de momentos estelares limpiada.
• Reportes honestos de fracasos. Cuando un modelo pierde una hora, eso también es una entrada; a menudo son las más útiles.
• Estimaciones de tiempo ahorrado, declaradas tan honestamente como pueda, con la salvedad de que el tiempo de verificación es parte del balance.
• Notas de reproducibilidad. Donde puedo, cada entrada enlaza a código o un cuaderno para que puedas ejecutarlo tú mismo. Donde no puedo, diré por qué.
• Sin exageraciones. Si un LLM no ayudó, la entrada lo dirá claramente.

Una nota sobre resultados no publicados

Parte de este trabajo toca proyectos en curso. Los detalles ligados a resultados no publicados — modelos específicos, puntos de parámetro, hallazgos numéricos — se reservarán hasta que el preprint correspondiente sea público. En esos casos documentaré el método y flujo de trabajo (que es la parte transferible) reteniendo el resultado en sí, y actualizaré la entrada con un enlace una vez que el preprint salga. El material de reproducibilidad solo apuntará a cosas que esté en libertad de compartir.

Esa es la carta de intención. La siguiente entrada será una tarea real.

Why I’m starting this log

I use large language models in my day-to-day research, and I’ve grown tired of two equally unhelpful narratives: the one where LLMs are about to do physics for us, and the one where they’re stochastic parrots useless for anything serious. Neither matches what I actually experience at the desk.

What I experience is more interesting and more mundane: a tool that is genuinely useful for specific sub-tasks, unreliable for others, and occasionally confidently wrong in ways that cost real time. The only way to know which is which is to keep records. So this is that record — a lab notebook for a particular kind of instrument.

The audience I have in mind is other researchers, particularly in theoretical and particle physics. If you work in BSM phenomenology — extended scalar or gauge sectors, neutrino mass mechanisms, dark matter, flavour, collider signatures — I hope some of these notes save you the trouble of rediscovering the same failure modes I do.

Where LLMs currently help (and where they don’t)

This is a snapshot of my current, revisable opinion. Part of the point of the log is to hold these claims accountable over time.

Where they help me today:

• Boilerplate and glue code. Parsing SLHA output, wiring up scans, reshaping data for plots, matplotlib/pandas scaffolding. Fast to write, fast to verify.
• Translating between tools and formalisms. Sketching a FeynRules or SARAH model fragment, converting a Lagrangian term to a rough vertex, moving a snippet between Mathematica and Python.
• Literature triage and orientation. Getting a first map of an unfamiliar corner of the literature, or rephrasing a half-remembered result into searchable terms — always as a pointer, never as a citation.
• Rubber-ducking derivations. Talking through an index contraction, a loop integral reduction, or a symmetry argument, where I remain the one who checks every line.

Where they don’t (yet):

• Anything requiring a guaranteed-correct derivation. Signs, factors of 2, conventions, and subtleties are exactly where fluent-sounding output is most dangerous.
• Numerical values and citations. Confidently fabricated branching ratios or reference lists remain a real hazard.
• Genuinely novel model building. They recombine the known well; they do not reliably produce the constraint I hadn’t thought of.

A concrete example of the trap: an LLM will happily produce a one-loop contribution that looks right — correct structure, plausible prefactor — and be wrong by a sign or a . The expression typesets beautifully:

and the only defence is to derive it yourself and treat the model’s version as a hypothesis to be checked, not an answer.

What you can expect here

• Real tasks, not toy demos. Every post is something I actually needed done.
• The whole workflow, including the prompts and the dead ends — not a cleaned-up highlight reel.
• Honest failure reports. When a model wastes an hour, that’s a post too; those are often the most useful ones.
• Time-saved estimates, stated as honestly as I can, with the caveat that verification time is part of the accounting.
• Reproducibility notes. Where I can, each post links to code or a notebook so you can run it yourself. Where I can’t, I’ll say why.
• No hype. If an LLM didn’t help, the post will say so plainly.

A note on unpublished results

Some of this work touches ongoing projects. Details tied to unpublished results — specific models, parameter points, numerical findings — will be withheld until the corresponding preprint is public. In those cases I’ll document the method and workflow (which is the transferable part) while holding back the result itself, and I’ll update the post with a link once the preprint is out. Reproducibility material will only ever point to things I’m free to share.

That’s the charter. The next post will be an actual task.