I study how states of the world map to states of the mind and build systems to explore how.

Research context

How does the brain make flexible decisions when the world shifts beneath it? My dissertation studied this through spatial navigation — a domain where you can precisely control what information an animal has access to and measure how it adapts when conditions change. The Corner Maze platform is the tool I built to run those experiments. No commercial system could do what I needed, so I designed one from scratch.

What it is

An automated behavioral neuroscience platform for studying spatial navigation and decision-making. The system runs experiments without human intervention — doors open and close, visual cues appear on monitors, rewards are delivered, and every event is logged with millisecond precision.

The hardware

I modeled the physical maze in Fusion 360 and produced technical drawings with GD&T tolerances for vendor fabrication. I designed all the custom circuitry controlling 12 linear actuators (doors) and 4 stepper-driven syringe pumps (reward delivery). The maze has 4 wall-mounted monitors for visual cue presentation and an overhead IR camera for real-time markerless position tracking.

The software architecture

The system is a multi-node distributed application spanning 5+ devices:

• Master control node (Ubuntu workstation): ~8,200 lines of Python running a multi-threaded PyQt application. Handles session control, device orchestration, real-time video display, SQLite metadata storage, and synchronized event logging.
• Camera node (Raspberry Pi): Multi-process Python application capturing 480x480 frames, running OpenCV-based markerless tracking (background subtraction, morphological filtering, contour detection, zone classification), and streaming frames over ZeroMQ.
• Stimulus display nodes (2x Raspberry Pi): Pygame fullscreen applications receiving cue commands over ZeroMQ. Each Pi drives two monitors for four total stimulus displays.
• Actuator controllers (16x Arduino): MODBUS RTU slaves controlling linear actuators with acceleration/deceleration ramping and EEPROM-based cycle counting for maintenance tracking.
• Syringe pump controllers (4x Arduino): MODBUS RTU slaves driving stepper motors with step-forward-then-retreat motion to prevent liquid seepage between deliveries.
• Light controller (1x Arduino): MODBUS RTU slave for PWM-controlled room and IR illumination.

Network topology: MODBUS RTU over RS-485 for all Arduino communication; ZeroMQ TCP for Raspberry Pi nodes (REQ/REP for control, PUB/SUB for video streaming).

Key design decisions

Protocol selection — MODBUS vs CAN bus: I evaluated both for the Arduino communication bus. MODBUS won because mature libraries existed for both Arduino and Python, and TTL-to-RS485 converters were significantly cheaper than CAN bus equivalents. Practical engineering trade-offs, not theoretical preference.

ZeroMQ for video and display control: Started with raw TCP for video streaming, hit reliability issues, discovered ZeroMQ and switched. Would have used ZeroMQ for the Arduinos too, but no good Arduino library existed and I didn't have time to write one.

GUI designed for multi-user operation: The PyQt interface wasn't built for me — it was built so other researchers could run experiments independently. The Action Vector Table is essentially a domain-specific session programming API: users parameterize entire experimental protocols (trial phases, zone triggers, cue configurations, reward delivery, performance criteria) through the interface without modifying code. Research assistants were trained to run sessions independently using step-by-step documentation I created.

Outcomes

The platform has been in continuous use for years. Other graduate students designed and ran their own experiments on it. One built her own experimental protocols using the session API and general system architecture. I ran 100+ animals through various experimental protocols, refining trial logic and quality control criteria across iterative pilots.

Research context

If the flexible decision-making I observed in real animals depends on specific types of sensory information, could the same strategies emerge in a reinforcement learning agent given similar constraints? That's the question this project was built to answer. I created a virtual replica of the physical Corner Maze as a Gymnasium environment and trained PPO agents to navigate it — not as an exercise in RL engineering, but as a computational model of the biological behavior I was studying.

The simulation

Built on Gymnasium/MiniGrid with a configurable session framework that dynamically mirrors real experimental protocols. The environment generates analysis-ready trajectory and event data in the same format as the real behavioral data, enabling direct model-animal comparison.

Synthetic visual input pipeline

I modeled the maze environment in Fusion 360 and rendered dual left/right perspective views to approximate rodent visual input. Dataset engineering in PyTorch included preprocessing, deduplication of near-identical images across adjacent positions, and structured data storage for classification training.

CNN encoder design

I prototyped multiple single-stream CNN architectures, evaluating each with UMAP projections and cosine-similarity correlograms to assess how cleanly the learned embeddings separated spatial positions and orientations. The final dual-stream design emerged from this systematic evaluation — two input streams (left eye, right eye) feeding into a shared embedding space. The approach was principled model selection, not architectural innovation.

RL agents

Trained PPO agents using Stable-Baselines3 with state-dependent action masking to enforce physical constraints (can't walk through closed doors) and task constraints (must follow trial phase rules). Benchmarked trained agent policies against real animal trajectory data using standardized performance metrics.

The question

A neuron's firing rate can encode where an animal is — but the brain also needs to know how fast it's moving and in what direction. How does a single population of neurons encode both position and velocity at the same time? And is there a cost to carrying both signals?

What we found

Neural populations carry two conjugate codes simultaneously. Individual firing rates (what we call the sigma channel) encode position — head direction, location on a track, spatial phase. But the timing relationships between neurons (the sigma-chi channel — co-firing rates across cell pairs) encode velocity. Increasing the precision of one channel degrades the other, analogous to the position-momentum uncertainty principle in physics.

This isn't a loose metaphor. The math formalizes the trade-off: the same spiking activity that gives you a clean position readout necessarily limits how much velocity information you can extract from the population's temporal structure, and vice versa.

My contributions

This project started as my capstone thesis in UCLA's Computational & Systems Biology major — a genuinely underappreciated program that used to be the cybernetics department. I built the computational groundwork:

• Sigma-chi decoder: I implemented the core decoder framework under my advisor's guidance — the linear readout that separates position information (in firing rates) from velocity information (in co-firing rates) using exponential integration kernels and pseudoinverse regression.
• Head direction to velocity decoding: I built the simulations showing that a ring of head direction cells encodes angular position in their firing rates and angular velocity in their co-firing patterns. Populations of 12-32 simulated neurons with von Mises tuning, Poisson spike generation, and temporal optimization across ±250 ms latency windows.
• Grid cells to speed cells: I showed that the same principle applies to a different circuit — grid cells encode spatial position in their firing rates, and sigma-chi units computed from their co-firing rates behave as speed cells. This wasn't assumed from the head direction result; it had to be demonstrated with different tuning geometry and real behavioral speed data.

My advisor Tad Blair extended the framework to theta-modulated phase coding, where the conjugate relationship inverts — position moves into the co-firing channel and velocity into firing rates. That work completed the paper's argument that the uncertainty principle is a general property of neural population codes, not specific to one cell type.

Methods

All simulations in MATLAB. The pipeline runs from behavioral data (real head direction and position recordings from rats) through spike generation (von Mises-tuned Poisson and regular-interval generators), exponential decay kernels that convert spike trains to firing rates and co-firing rates, and linear decoders trained via pseudoinverse regression. Evaluation used circular distance metrics, latency-accuracy trade-off curves, and hold-out validation.

Why it matters

This work formalized something that had been intuited but never proven: that neural populations face a fundamental information-theoretic constraint when encoding multiple variables simultaneously. It connects to active questions in computational neuroscience about efficient coding, population geometry, and how the brain represents continuous variables — and to questions in AI about how artificial networks can encode multiple factors in shared representations without interference.

Publication

Grgurich, R. & Blair, H.T. (2020). An uncertainty principle for neural coding: Conjugate representations of position and velocity are mapped onto firing rates and co-firing rates of neural spike trains. Hippocampus, 30(4), 396-421. DOI: 10.1002/hipo.23197

What it is

An iOS and watchOS app that bridges Apple HealthKit with Intervals.icu, a training analysis platform popular with endurance athletes. It syncs 32 wellness metrics daily and includes a custom overnight heart rate variability (HRV) capture system that runs on Apple Watch during sleep.

Why I built it

I'm an avid road cyclist and I use Intervals.icu to track training load and recovery. The platform has a wellness feature, but there was no good way to automatically populate it with Apple Health data. I saw a gap, and I built the tool.

How I built it — AI-assisted development

This project is the clearest demonstration of how I use AI coding tools in practice. I don't write Swift — I directed the entire project using AI-assisted development, making all architectural and design decisions while the AI handled implementation in a language I hadn't written in before.

This isn't "I prompted an agent and shipped whatever it produced." I designed the service-oriented architecture, specified the OAuth 2.0 flow, defined the HRV pipeline stages based on sports science literature, identified the data model patterns, and debugged platform-level issues that required understanding what the code was actually doing. The AI wrote the Swift; I engineered the product.

Architecture

• Service-oriented design with clear separation between SwiftUI views, singleton services, and value-type models
• OAuth 2.0 authorization with a Cloudflare Worker handling server-side token exchange (client secret stays off-device, credentials stored in iOS Keychain)
• SwiftData with App Group shared containers for cross-platform persistence between iOS and watchOS
• Background sync via BGProcessingTask with smart sleep detection — the system checks HealthKit for recent sleep samples and reschedules if the user is still asleep

The HRV pipeline

The overnight HRV system uses HKWorkoutSession and HKHeartbeatSeriesBuilder to record raw beat-to-beat RR intervals during sleep. A duty-cycle manager alternates between 5-minute capture windows and rest periods tuned by sleep stage, balancing data quality against battery life.

Raw RR intervals go through a three-stage artifact correction pipeline: physiological range filtering (300-2000 ms), successive-difference ectopic beat removal using the Plews method, and IQR-based outlier rejection. Epoch-level quality gating uses established thresholds from sports science literature. The final nightly metric is median Ln(rMSSD) across valid epochs — a standard metric in athletic recovery monitoring.

Platform debugging war stories

• Discovered an undocumented HealthKit constraint: writing heartbeat series data requires read permission for .heartRateVariabilitySDNN, and missing it causes an uncatchable Objective-C exception with no documentation trail.
• Found that Cloudflare Worker's Response.redirect() silently rejects custom URL schemes — had to build manual response construction to complete the OAuth callback.
• Replaced an unconstrained SwiftData query that was loading all records into memory with targeted fetch descriptors, eliminating memory issues during historical backfill.