Detecting Phase Transitions in the Transverse Field Ising Model (TFIM) using Neural Networks

Group members: Jan Basalaj, Jessey De Roek, Jean-Victor Bendixen-Fernex de Mongex, Matías Santacruz Vallejo.

Project Description

This project investigates the quantum phase transition in the 1D transverse field Ising model (TFIM) using machine learning techniques. Specifically, we use NetKet, an open-source package built to study quantum systems with artificial neural networks and machine learning techniques. Using NetKet, we built a simple, reproducable neural network to study phase transition in the TFIM, specifically we:

• Identify the critical point of the quantum phase transition for finite-size systems
• Approximate the ground state wavefunction of the system
• Compute observables such as magnetization, entropy, and correlation functions from the approximated wavefunction

We do this by training neural networks to represent quantum state and optimizing them to minimize the energy expectation value under the TFIM Hamiltonian.

Theoretical Background

The TFIM Hamiltonian in 1D is given by:

$$ H = -J \sum_{i} \sigma_i^z \sigma_{i+1}^z - h \sum_i \sigma_i^x $$

The first term favors ferromagnetic order (aligned spins along the z-axis), while the second introduces quantum fluctuations, favoring spin alignment along the x-axis (paramagnetism). These competing interactions lead to a quantum phase transition at a critical field strength $h_c$. For infinite chains, $h_c = 1$. In this project, we study how $h_c$ shifts for finite systems.

We define the order parameter as the average magnetization in the x-direction:

$$ \langle \sigma^x \rangle = \frac{1}{L} \sum_{i=1}^L \langle \psi | \sigma_i^x | \psi \rangle $$

To approximate the ground state $|\psi\rangle$, we use a variational wavefunction $\psi_\theta(s)$ modeled by a neural network. The goal is to minimize:

$$ E(\theta) = \frac{\langle \psi_\theta | H | \psi_\theta \rangle}{\langle \psi_\theta | \psi_\theta \rangle} $$

This approach avoids the exponential scaling of direct diagonalization by representing $\psi_\theta(s)$ with a compact, trainable neural ansatz.

Project Goals

1. Detect the quantum critical point for finite-size TFIM chains using neural network observables.
2. Train neural networks to approximate the ground state wavefunction.
3. Extract and analyze physical observables including:
   • Magnetization $\langle \sigma^z \rangle$,
   • Correlation functions $\langle \sigma_i^z \sigma_j^z \rangle$,
   • Entanglement entropy.

Project Files

The Results.ipynb Notebook

The Results.ipynb notebook contains all of our findings. Each sections follows a general structure:

1. Imports and Setup: Load necessary libraries including NetKet and JAX.
2. Underlying physics theory
3. Model Definition: Construct the TFIM Hamiltonian using NetKet.
4. Neural Network Ansatz: Define the neural architecture for $\psi_\theta(s)$.
5. Training Loop: Optimize network parameters using variational Monte Carlo to minimize the energy.
6. Phase Transition data generation
7. Visualization: Plot the observables vs. $h$ and highlight signatures of the phase transition.

Reproducibility

The script neural_TFIM.py is our streamlined workflow which can be run via two helper functions: magnetizations() and entropies(), which calculate the average magnetization in all orthogonal directions and the entanglement entropy of any TFIM system, respecively. They take as an input a neural network model, hyperparameters, and the range of systems sizes and transverse field strengths of interest, and automatically plot the average expectation values of these observables vs the transverse field strength:

Their usage is showcased in the Workflow_Example.ipynb notebook, which can reproduce all the findings in Results.ipynb using the neural_TFIM.py script. Additionally, it provides a way to feed any other NetKet compatible custom neural network. For example, you could test the performance of a deeper feed forward network:

class DeepFFN(nn.Module):
    @nn.compact
    def __call__(self, x):
        x = nn.Dense(32)(x)
        x = nn.tanh(x)
        x = nn.Dense(32)(x)
        x = nn.tanh(x)
        x = nn.Dense(1)(x)
        return x.squeeze() + 0.0j

Member Contributions

Matías

I worked to establish a working foundation for the theoretical basis of the project, and wrote the basis code for finding the wavefunction from which the final $\langle \sigma^x \rangle$ observable could be measured. My contributions include writing a markdown file to aid other member's understanding of the physical and ML approaches (including the Variational Monte Carlo sampling, and a neural network wavefunction inspired from Jan's approach) that would be part of the project going forward. Moreover, I streamlined and merged the code from other members into a cohesive repository and the Results.ipynb notebook. I also helpef refine the final workflow with the theory, and wrote the neural_TFIM.py script and the Workflow_Example.ipynb notebook using mine and Jessey's code to easily reproduce all of our results with a custom network architecture. I also worked on the documentation of the repository (the README.md file) and improved its readability.

Jan

In this project, on top of studying the Transverse Ising Model, I implemented a custom neural network wavefunction using JAX and Flax (nnx) to study the ground state of the 1D Transverse Field Ising Model. Instead of using NetKet’s built-in models, I designed my own feed-forward network to approximate the quantum state. I measured the average values of $\langle \sigma^z \rangle$ and $\langle \sigma^x \rangle$ across varying transverse fields to identify the quantum phase transition. By analyzing these results, I estimated the critical point where the system transitions from ordered to disordered. This code, with the help of Matias, was then in turn transformed to form the basis of the final project.

Jean

In this project, I investigated an observable called Two-Body correlation. Building on my fellow teammates hard work, I recycled relevant optimization codes and used handy netket operators to construct two functions which initializes a new states and a function which efficiently (and vectorized as much as possible) generates the correlation matrices based on the correlation equation (see markdown). This observable is handy when trying to localize a phase transition and see how a site's spin is correlated to neighbouring sites. The initial plan was to only investigate the correlation in $\sigma^z$ but here I tried to implement it for $\sigma^x$ aswell.

As Matías' results indicated, a model comparison is relevant for magnetizations so one has also been conducted here. This is done to see if our simplified model could handle correlations. I also fixed some other plots to make them more efficient and esthetic (slay).

Jessey

I investigated how the entanglement entropy can provide deeper insights into the quantum phase transition in the transverse-field Ising model. Motivated by the idea that entropy captures quantum correlations beyond traditional observables like magnetization, I implemented a function to compute the von Neumann entanglement entropy for a subsystem of the spin chain.

Using a Variational Monte Carlo (VMC) approach with a Restricted Boltzmann Machine (RBM) as the wavefunction ansatz, I optimized the ground state of the system. I then computed and plotted the entanglement entropy across different system sizes and transverse field values.

The results clearly show a notable drop in entropy beyond the critical field value $h = 1$, aligning with theoretical expectations of a quantum phase transition.