My Projects

Gravitational Interactions in the Earth-Jupiter-Sun System

Description: This project investigated how the gravitational influence of Jupiter affects Earth's orbit around the Sun. Using Python and numerical integration methods (Runge-Kutta and SciPy's odeint), we modeled two separate two-body systems before combining them into a full three-body simulation. By varying initial velocities and mass parameters, we examined how Jupiter's gravitational pull perturbs Earth's orbital shape, eccentricity, and semi-major axis over long timescales. The resulting plots and animations visualize orbital precession and instability, demonstrating the challenges of modeling non-linear celestial systems where no analytic solution exists.

Find here the required links to the report, the brief, and the code.

Black_Hole_Populations_VS_Accretion_Regions

Mapping JWST Black Hole Data To Predicted Optimal Growth Conditions

Description: This project explores how the first supermassive black holes observed by the James Webb Space Telescope could have formed so early in the universe. Using analytical models and Python simulations, we studied how black hole seeds grow under different physical conditions, focusing on factors like gas density, seed mass, and angular momentum. By combining these effects, we identified regions in parameter space where growth becomes highly efficient and compared them with current JWST detections.

The simulations, created with NumPy, SciPy, and Matplotlib, reproduced the theoretical conditions for optimal accretion and tracked black hole growth over time. We then mapped real JWST black hole data onto these models, showing which observations fit within the predicted high-efficiency growth zone and which appear to exceed current theoretical limits.

Find here the required links to the report, and the code.

Optimizing Lattice Constants for FCC Metals using Lennard-Jones Potentials

Description: In this project I reproduced results from Kanhaiya et al. (2021), which derived Lennard-Jones parameters capable of describing elastic and structural properties for a range of face-centred cubic metals. Using Python, I simulated ten FCC metals and iron to determine their equilibrium lattice constants by minimizing the total potential energy per atom.

I first verified the model on Argon using the standard 12-6 Lennard-Jones potential, confirming that the minimization correctly predicts the equilibrium spacing of a simple system. The main part of the project then extended this to the 9-6 potential, which better approximates metallic bonding. I generated periodic FCC supercells, calculated pairwise atomic interactions within a cutoff radius, and applied the Nelder-Mead optimization algorithm to locate the minimum-energy lattice constant for each element.

The calculated values were compared to experimental lattice parameters, showing good agreement and validating the ability of the Lennard-Jones potential to capture key trends in metallic bonding despite its simplicity. This work provided practical insight into how interatomic potentials can be used to model and understand bulk metallic systems at the atomistic level.

Find the full code and results here in my GitHub Repository.

Predicting Potential Energies for Water Molecules using Neural Networks

Description: This project explores how a neural network can learn to predict the potential energy of water molecules directly from their atomic coordinates. Using TensorFlow and Keras, the model was trained to map molecular geometry to total energy, bridging quantum chemistry and modern machine learning techniques.

The dataset included rotated and unrotated configurations of H₂O, with total energies provided in .ENER files. After preprocessing and feature scaling, a feed-forward neural network with two hidden layers of 64 neurons (ReLU activation) was trained using the Adam optimizer and mean squared error loss. Early stopping was implemented to ensure stable convergence and prevent overfitting.

The trained model achieved low prediction error and smooth validation performance, demonstrating how data-driven methods can replicate potential energy surfaces without explicit quantum mechanical computation. This work highlights the intersection between computational physics and machine learning in molecular modeling.

Find the full report here, and the code is available in this GitHub Repository.

Optimising Quantum Gate Fidelity in Non-Markovian Open Systems

This research project formed the basis of my Master's thesis, where I investigated how quantum gates can be executed reliably in open systems that interact with an environment. In realistic quantum devices, these interactions lead to decoherence — the gradual loss of quantum information. However, when the environment retains memory of past interactions, known as non-Markovian dynamics, lost information can temporarily flow back into the system, potentially improving gate performance.

The work focused on building and simulating open quantum systems using the OQuPy framework (Open Quantum Python), a package that enables process-tensor-based simulations of non-Markovian dynamics. My goal was to reconstruct the effective quantum channel produced by a time-dependent Hamiltonian, compare it against a target unitary gate, and measure the resulting gate fidelity.

Superoperator to Choi transformation diagram

To achieve this, I evolved a complete basis of input density matrices through the simulated dynamics to reconstruct the system's superoperator. This operator fully describes how any quantum state transforms over time. The superoperator was then reshaped into a Choi matrix, a representation that preserves both input and output correlations and allows extraction of Kraus operators — the key mathematical objects that describe how noise acts on the system.

By performing an eigendecomposition of the Choi matrix, I derived the Kraus operators numerically and computed the average gate fidelity by comparing the noisy channel to an ideal target gate. This process, based on the formalism outlined in Wood et al. (2022) and Pedersen et al. (2007), provided a robust way to quantify how closely real open-system dynamics can reproduce ideal quantum logic.

The core of the simulation relied on the process tensor — a higher-order object that encodes the influence of the environment across multiple timesteps. Each tensor index represents a past system-environment interaction, meaning that past control actions can directly influence future evolution. This framework allowed me to capture memory effects that are invisible in traditional Markovian master equations.

Using this approach, I simulated systems under both Markovian and non-Markovian conditions by varying the bath correlation time parameter. The results revealed that as the environment's memory length increases, coherence revivals begin to emerge, producing oscillatory behaviour in the fidelity. This confirmed that non-Markovianity enables partial recovery of information lost to the environment.

Fidelity comparison for Markovian vs non-Markovian dynamics

The fidelity plots below compare quantum gate performance under different environmental models. The orange curve shows a Markovian regime, where fidelity decays monotonically due to irreversible decoherence. The green curve, corresponding to a non-Markovian regime, shows clear oscillations — a signature of information backflow. This behaviour highlights the potential to use environmental memory as a stabilising resource in quantum computation.

Finally, I implemented a simple form of control optimisation, tuning the system Hamiltonian parameters to minimise fidelity loss over time. These optimised simulations achieved near-unit fidelity for short timescales, demonstrating how non-Markovian feedback can be harnessed to enhance quantum gate robustness.

Read the full Thesis here, or explore all simulation code and analysis notebooks in my GitHub Repository.

Personal Website

This website was my first self designed project and is built entirely from scratch using HTML, CSS, and JavaScript to serve as both a personal portfolio and a central hub for my academic, research, and personal projects. Every section was custom-designed to reflect a clean, minimal layout with responsive styling for both desktop and mobile devices.

It features collapsible menus, dynamic project toggles, and a simple category-based structure that allows visitors to browse educational, research, and personal projects smoothly. The focus throughout was on performance, clarity, and cohesive design, ensuring that the website grows seamlessly alongside my academic and technical work.

The full source code and layout are available in my GitHub Repository.

Hockey Hours – Coaching Management App

Currently in development, this cross-platform mobile app is being built to simplify how hockey clubs schedule, track, and manage their coaching hours. Designed initially for my own club, it aims to replace outdated spreadsheets with a streamlined digital platform that integrates scheduling, hour logging, and invoicing in one place.

The app allows clubs to assign coaches to specific sessions, view real-time availability, and automatically calculate hours worked for invoicing — reducing administrative work and minimizing scheduling errors. Coaches can log in to see their weekly schedule, track accumulated hours, and manage payments directly through the interface.

Future development plans include data synchronization, user authentication, and mobile push notifications to alert coaches of session updates or changes. This project combines my background in software design with my experience as a hockey coach, creating a tool that serves both the technical and sporting communities.

You can view the ongoing development and source code in my GitHub Repository.

Quantum Gate Simulator – Building Quantum Circuits in C++

The Quantum Gate Simulator is a compact C++ program built to model the fundamentals of quantum computation from the ground up. It lets users assemble and execute simple quantum circuits directly from the command line using gates such as Pauli-X, Y, Z, Hadamard, Phase, and CNOT.

Each qubit is represented as a complex-valued vector, and gates are treated as unitary matrices. State evolution is handled through matrix–vector multiplication with normalization and probability tracking after every operation. Commands like:

./quantum_sim.exe --circuit "H CNOT" --two-qubits

prepare a maximally entangled Bell state — a clean demonstration of quantum superposition and entanglement handled entirely in C++. The codebase follows an industry-style layout with src/ and include/ directories, a Makefile for compilation, and a modular object-oriented design.

The simulator serves as both a learning tool and a coding exercise in low-level quantum logic simulation. Planned updates include Bloch sphere visualization, measurement statistics, and unit testing with Catch2.

Explore the source code and implementation details on my GitHub Repository.