Documents Live, a web authoring and publishing system
If you see this, something is wrong
Table of contents
First published on Tuesday, Jun 2, 2026 and last modified on Wednesday, Jun 10, 2026 by François Chaplais.
WebMagic
The purpose of this demonstration is to build some documentation about Physics-Informed Neural Networks, or PINNs. These are presented in the introduction below.
You can also consult the Wikipedia page on the subject.
1 Introduction
The content of this section is directly imported from the following two documents:
Any change in the original documents will be reflected in this document after HTML export.
1.1 Presentation
PINNs, or Physics-Informed Neural Networks, are neural networks trained not only on data, but also on the physical laws that govern a system.
Basic idea
Normally, a neural network learns from input-output examples:
- input → output
A PINN does that too, but adds another requirement:
- the predicted output must also satisfy a physics equation, usually a differential equation like:
- heat equation
- wave equation
- Navier–Stokes equations
- Schrödinger equation
So instead of learning only from data, the model learns from:
- observed data
- boundary/initial conditions
- physical constraints
Why “physics-informed”?
Because the training process is “informed” by known physics.
For example, suppose you want to model temperature \( u(x,t)\) over space and time.
A regular neural network might try to fit temperature data points.
A PINN says:
- predict \( u(x,t)\)
- and make sure this prediction satisfies the heat equation
For example:
The neural network outputs \( u(x,t)\) , and using automatic differentiation, we compute:
- \( u_t\)
- \( u_{xx}\)
Then we penalize the network if:
How it works
A PINN usually has a loss function with several parts:
1.3.1 1. Data loss
Matches known observations.
1.3.2 2. Physics loss
Enforces the differential equation.
where \( f(x,t)\) is the residual of the PDE.
Example:
1.3.3 3. Boundary/initial condition loss
Makes sure the solution satisfies known constraints.
Total loss:
Why are PINNs useful?
They are useful when:
- data is scarce
- the system is governed by known physics
- solving the equation directly is hard
- you want a smooth function over space and time
Applications include:
- fluid dynamics
- heat transfer
- materials science
- finance
- biological systems
- inverse problems
Forward vs inverse problems
1.5.1 Forward problem
You know the equation and parameters, and want the solution.
Example:
- known heat equation
- find temperature field
1.5.2 Inverse problem
You know some observations, but want to infer unknown parameters.
Example:
- estimate diffusion coefficient \( \alpha\) from data
PINNs are especially attractive for inverse problems.
Main advantage
They combine:
- machine learning
- scientific computing
- differential equations
This means they can work even with limited data because physics gives extra guidance.
Main limitations
PINNs are powerful, but not perfect.
Common problems:
- training can be slow
- hard PDEs can be difficult to optimize
- balancing different loss terms is tricky
- may struggle with sharp discontinuities or turbulence
- often not always better than classical numerical solvers like FEM or FDM
So PINNs are not a universal replacement for traditional methods.
Simple intuition
Think of a normal neural network as a student who memorizes examples.
A PINN is a student who:
- sees examples
- but also knows the laws of physics
So it gives answers that are not only close to the data, but also physically consistent.
If you want, I can also give you:
- a very simple code example of a PINN, or
- a visual/intuitive explanation with diagrams in words.
1.2 A sample code
Here’s a very simple PINN example in PyTorch for the 1D ODE
The exact solution is:
This is simpler than a full PDE PINN, but it shows the main idea clearly.
What the network does
We train a neural network \( u_\theta(x)\) such that:
- it satisfies the physics:
- it satisfies the boundary condition:
We use automatic differentiation to compute \( du/dx\) .
Simple PyTorch code
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
# -----------------------------
# Neural network
# -----------------------------
class PINN(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(1, 20),
nn.Tanh(),
nn.Linear(20, 20),
nn.Tanh(),
nn.Linear(20, 1)
)
def forward(self, x):
return self.net(x)
# -----------------------------
# Create model
# -----------------------------
model = PINN()
# Optimizer
optimizer = optim.Adam(model.parameters(), lr=0.01)
# -----------------------------
# Training loop
# -----------------------------
for epoch in range(5000):
optimizer.zero_grad()
# Collocation points inside the domain [0, 1]
x_phys = torch.rand(100, 1, requires_grad=True)
# Network prediction
u = model(x_phys)
# Compute du/dx using autograd
du_dx = torch.autograd.grad(
u,
x_phys,
grad_outputs=torch.ones_like(u),
create_graph=True
)[0]
# Physics residual: u' + u = 0
physics_residual = du_dx + u
physics_loss = torch.mean(physics_residual**2)
# Boundary condition u(0) = 1
x_bc = torch.tensor([[0.0]])
u_bc = model(x_bc)
bc_loss = (u_bc - 1.0)**2
# Total loss
loss = physics_loss + bc_loss
loss.backward()
optimizer.step()
if epoch print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
# -----------------------------
# Test and plot
# -----------------------------
x_test = torch.linspace(0, 1, 100).reshape(-1, 1)
u_pred = model(x_test).detach().numpy()
u_exact = torch.exp(-x_test).numpy()
plt.plot(x_test.numpy(), u_pred, label="PINN prediction")
plt.plot(x_test.numpy(), u_exact, "--", label="Exact solution")
plt.legend()
plt.xlabel("x")
plt.ylabel("u(x)")
plt.title("PINN solving u'(x) = -u(x), u(0)=1")
plt.show()
How this code works
1.3.1 1. Neural network
The model takes one input:
- \( x\)
and outputs one value:
- \( u(x)\)
1.3.2 2. Physics loss
We want:
So we compute:
-
u = model(x_phys) -
du_dx = autograd(...)
Then the residual is:
physics_residual = du_dx + uIf the network is perfect, this should be zero everywhere.
1.3.3 3. Boundary condition loss
We also enforce:
with:
x_bc = torch.tensor([[0.0]])
u_bc = model(x_bc)
bc_loss = (u_bc - 1.0)**2
1.3.4 4. Total loss
We combine both:
loss = physics_loss + bc_lossSo the network is trained to:
- satisfy the differential equation
- satisfy the boundary condition
Why this is a PINN
Because the network is not trained from labeled data pairs like:
- \( x \to u(x)\)
Instead, it is trained from:
- the equation itself
- the boundary condition
That is exactly the key idea of a Physics-Informed Neural Network.
Expected result
After training, the prediction should look close to:
even though we never directly gave the network the true solution values as training targets.
If you want to go one step further
The next simple example would be a PINN for the 1D heat equation:
That would show:
- two inputs \( (x,t)\)
- partial derivatives
- initial and boundary conditions
If you want, I can give you that next.
2 Proposed bibliography
We have stored here the links to a few arXiv papers.
- PINNs Failure Modes are Overfitting
- Cosmo-PINN: A Physics-Informed Neural Network for Cosmological Reconstruction
- Alt-CC-PINN: An Alternating Optimization Framework with Implicit Neural Representation for Microwave Inverse Scattering Imaging
- Mitigating Gradient Pathology in PINNs through Aligned Constraint
- Overcoming "Physics Shock" in Earth Observation A Heteroscedastic Uncertainty Framework for PINN-based Flood Inference
- When and Why Adversarial Training Improves PINNs: A Neural Tangent Kernel Perspective
- Chebyshev Center-Based Direction Selection for Multi-Objective Optimization and Training PINNs
- Differentiable Chemistry in PINNs for Solving Parameterized and Stiff Reaction Systems
You can get the source of the articles by visiting the links and select "TeX source" in the upper right corner of the page.
We have already imported some.
3 The plan
3.1 Import a new document from the list
We are going to proceed as follows.
- Import a document.
- Read it and grab some interesting section references.
- In this very document, create a new section devoted to the new document.
- In this new section explain the purpose of the article and insert the section references that we have collected.
- Go back to the new article, prepare it for AI and ask the AI for a summary, and copy the LaTeX code for the answer into the document.
The document will be Differentiable Chemistry in PINNs for Solving Parameterized and Stiff Reaction Systems .
Here is the BibTeX entry.
@misc{babić2026differentiablechemistrypinnssolving,
title={Differentiable Chemistry in PINNs for Solving Parameterized and Stiff Reaction Systems},
author={Miloš Babić and Franz M. Rohrhofer and Stefan Posch},
year={2026},
eprint={2605.04708},
archivePrefix={arXiv},
primaryClass={cs.LG},
url={https://arxiv.org/abs/2605.04708},
}3.2 Display some data about PINNs
The data comes from Kaggle . Here is what the author says about the data.
The dataset was designed to support the development, training, and validation of physics-informed graph neural network (PI-GNN) models for electrochemical CO2 reduction (eCO2R) reactors. Its primary purpose is to bridge the gap between high-fidelity multiphysics simulations, limited experimental measurements, and data-efficient machine learning, enabling accurate prediction, scale-up analysis, and optimization of electrochemical reactors under realistic operating conditions. The dataset structure explicitly reflects the graph-based representation of reactor domains, where each graph corresponds to a discretized reactor instance with variable resolution (500–5,000 nodes), accommodating differences in reactor geometry, mesh density, and operating regime.
We will upload the CSV data and insert a dynamic table built around this CSV data.