Skip to content
View tavelarocque's full-sized avatar

Block or report tavelarocque

Block user

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users.

You must be logged in to block users.

Content in all repositories owned by your account will be closed.
Maximum 250 characters. Please don’t include any personal information such as legal names or email addresses. This note will only be visible to you.
Report abuse

Contact GitHub support about this user’s behavior. Learn more about reporting abuse.

Report abuse
tavelarocque/README.md

Hey, I'm Tave 👋

I'm an Engineering student at UBC (Integrated Engineering, computer + finance) working on quantitative research and AI evaluation.

🌐 tavelarocque.com: research, builds and resume

What ties my work together is that the results can be checked. Hypotheses are written down and registered before the data that decides them is touched. Every important number is computed twice, by implementations written independently. Planted bugs prove the tests can fail. Final runs reproduce bit for bit, and on the chip, the hardware is formally proven equal to a separate spec.

Right now that means a pre-registered test of order-driven volatility on NASDAQ order-book data, a protocol emulator chip for Jane Street's ASIC competition, and exact computations on an open problem in online calibration.


🔬 Research and Projects

A C++20 engine that rebuilds NASDAQ's full order-by-order (L3) book from raw TotalView-ITCH 5.0 data, 423 million messages a day, at 92 ns per message. That's 3.3× faster than CppTrader's L3 book on the same machine, and the output is byte-identical to an independent Python reference. The rebuilt book is the ground truth for three studies:

  • Queue position. Across 7.5M orders, 85% of cancelled volume comes from behind an order, so the L2 queue models backtests use overfill. Behind 10–24 orders, 1 in 6 of the uniform model's simulated fills never happened.
  • Forecasting. On 7 out-of-time days, DeepLOB beats a multi-level order-flow-imbalance baseline (macro-F1 0.53 vs 0.45). But no model survives the spread and fees: 0.1–0.4 ticks of edge against at least 1.6 ticks of cost.
  • Order-driven volatility (pre-registered). An out-of-sample test of Maitrier and Bouchaud (2026) on 8 NASDAQ days, registered on OSF with the code frozen at a git tag before the held-out stocks were used.
    • In one Holm family of 8 tests, P-F is rejected in both tick-size bins, which is evidence against the informed-flow regime and nothing more. The other three predictions are not rejected.
    • Power studies run before the freeze showed why a single venue's data can't settle them.
    • The confirmatory run reproduces bit for bit.

C++20 CMake GoogleTest RapidCheck libFuzzer Python NumPy PyTorch Pre-registration

GitHub · Walkthroughs (PDF) · Pre-registration


ImpossibleBench measures how often LLMs cheat by defeating tests that cannot honestly be passed. PR #6 changes which code block in a model's reply gets executed, and that choice can hide a cheat behind an honest attempt.

Method:

  • The plan was pre-registered before the first model call.
  • 714 episodes across two models (Qwen and Gemini) were generated and re-scored under 4 extraction rules × 2 exit settings.
  • Every run used an isolated, locked-down sandbox.
  • Nothing was reported until three gates passed:
    • a fixture suite published before any model call;
    • 22 planted known-answer cases;
    • replay matching the benchmark's own logged scores on 711 of 714 episodes.

Results:

  • The headline is a null: the extraction rule barely moves the final cheating rate.
  • But the benchmark's rule shows the model a SyntaxError instead of its test results on 20.7% of Qwen attempts and 19.7% of Gemini attempts. The reverse case occurred 0 times in either model.
  • Requiring the test function to finish, rather than accepting a zero exit code, cuts Gemini's measured cheating rate from 59.2% to 19.4%: 71 of 123 passes called sys.exit before the tests ran.
  • Stated limit: Gemini covers 199 of 206 planned episodes, and the 7 missing ones are not a random sample.

Python Inspect Docker LLM Evaluation Pre-registration McNemar

GitHub · Report


An ASIC for Jane Street's protocol emulator competition, written in Hardcaml and designed for tapeout through Tiny Tapeout on IHP 130nm. It's a tiny two-thread CPU modelled on the RP2040's PIO: its instructions read pins, write pins and count cycles, so UART, SPI and I2C live in firmware loaded after fabrication.

  • It runs all three protocols, two at a time, including an I2C-to-SPI bridge with no host in the data path.
  • It can also act as the I2C target or SPI device for outside controllers.
  • JTAG, an Arm SWD probe and a low-speed USB host were added as firmware after the hardware was frozen, with no hardware change.
  • Its firmware runs on the post-layout gate-level netlist.
  • The whole chip, pins to pins, is formally proven equivalent to an independently written spec, with a SAT proof in Hardcaml_verify and Z3. Bugs planted in the spec break the proof, so the proof isn't vacuous.
  • 58 planted bugs, kept as code across every layer, are all caught.

OCaml Hardcaml Z3 cocotb Tiny Tapeout IHP 130nm

GitHub


A live research system comparing Kalshi's S&P 500, Nasdaq-100 and Bitcoin contracts with the probabilities implied by option prices: Breeden–Litzenberger on arbitrage-checked SVI smiles, with Deribit for Bitcoin.

  • A cloud pipeline on GitHub Actions collects Cboe, Kalshi, Polymarket and Deribit data around the clock.
  • It paper-trades the gap under fixed rules, re-reading the order book after every trade to check the trade would really have filled.
  • Every test is pre-registered before its data exists, judged on a locked holdout, and adjusted in a multiple-testing ledger (Holm / BHY).

Results so far: Kalshi's S&P contracts are well calibrated, and a Kalshi + realized-volatility blend beat Kalshi's own price on the sealed holdout.

Python NumPy pandas SciPy Options Pricing Multiple Testing GitHub Actions

GitHub


A financial contract language in OCaml, after Peyton Jones, Eber and Seward's Composing contracts, that prices Kalshi's Bitcoin contracts from the distributions implied by Deribit options.

  • Every contract is a tree of nine combinators.
  • Contracts are valued by three independent pricers that check each other: density integration, Carr–Madan replication and a Rubinstein implied tree. They match Implied Odds' Python probabilities to 2.7 × 10⁻¹² across 13,804 contracts.
  • On top: bump-and-reprice Greeks, a delta-hedging simulation, an Avellaneda–Stoikov market maker adapted to $0/$1 payouts, and a markout system for measuring order-flow toxicity.

OCaml Core dune Options Pricing Market Making Property Testing

GitHub


A counterfactual regret minimization solver for heads-up no-limit hold'em, built from scratch in Rust. It has the same pieces as Libratus and Pluribus, at laptop scale:

  • a CFR engine verified against exact best responses (4.9 × 10⁻⁶ exploitability on Leduc hold'em);
  • a 7-card hand evaluator checked on all 133.8M hands;
  • a multithreaded postflop solver that solves a 293,000-node flop tree to 0.33% of pot in 31 s;
  • an abstracted strategy trained for 1.5 billion Monte Carlo CFR iterations.

The trained bot runs in the browser.

Rust rayon proptest Game Theory Monte Carlo CFR

Project page · Play the bot · GitHub


Independent research on the optimal rate of sequential calibration error, an open problem in online prediction. The best known bounds pass through the sign-preservation-with-reuse game of Dagan et al. (STOC 2025), and this code computes that game exactly.

  • Exact game values. A memoised minimax solver in Rust computes exact values of the full game up to 18 cells, the forced-erasure game up to 20, and the no-reuse game up to 22. It is cross-checked against brute force and an independent Python reference.
  • Certified bounds for oblivious strategies. Each lower bound is the exact rational value of a stored strategy, checked by two independent verifiers. Each upper bound is an exact Farkas certificate.

Rust Python Linear Programming (HiGHS) Exact Arithmetic Online Learning

GitHub


🏗️ Outside Research

💪 MODUX: training app for hybrid athletes. A native iOS app for athletes who both lift and run, built end to end and submitted to the App Store.

  • Its Interference Score models how strength and endurance training conflict, using an 11-dimensional fatigue vector with 72-hour decay, shown as a 0–100 readiness score.
  • It syncs with Strava and Apple HealthKit, and fuzzy-matches workouts across the two so none is counted twice.

React Native Expo TypeScript Supabase Postgres HealthKit

🌐 Current at UBC: student-to-industry event. I co-founded it, and it's launching April 2027: 300+ students, 3 keynote speakers and 50 Vancouver industry leaders in one room, with all net proceeds going to BC Children's Hospital Foundation. I built the whole production stack: the site, automations, CRM, DNS and email.

Earlier projects:


🛠️ Toolkit

C++ OCaml Rust Python TypeScript SQL

  • Also: Java · C · Hardcaml (RTL) · PyTorch · NumPy / pandas / SciPy · React / React Native · Node.js · Supabase · GitHub Actions
  • Verification:
    • pre-registration and locked holdouts;
    • Holm / BHY multiple-testing corrections, bootstrap and jackknife inference;
    • property tests (RapidCheck, proptest, Quickcheck) and planted-bug (mutation) tests;
    • fuzzing under ASan / UBSan / TSan;
    • formal equivalence proofs;
    • bit-identical reproduction.
  • Quantitative methods: SVI smiles · Breeden–Litzenberger densities · Carr–Madan replication · implied binomial trees · Black-76 · Greeks · Avellaneda–Stoikov market making · markouts and order-flow toxicity
  • Market microstructure: L3 book reconstruction from TotalView-ITCH · queue-position models · multi-level OFI · DeepLOB · propagator models · cost-aware evaluation
  • Game theory: CFR, CFR+, Linear / Discounted CFR, Monte Carlo CFR · exact and local best response · abstraction
  • AI evaluation: Inspect · sandboxed execution of model-written code · re-scoring and replay gates
  • Math: Calculus I–III · Linear Algebra · probability and statistics
  • Spoken languages: English (native) · Japanese · French (basic) · Spanish (basic)

🎓 About Me

  • 📐 Engineering student @ University of British Columbia (BASc, expected 2028)
  • 💼 Co-Founder & CEO @ Current at UBC
  • 📱 Co-Founder & Lead Engineer @ MODUX
  • 🏦 Indigenous Project Assistant Intern @ Vancity: AI automations for Corporate Real Estate (May–Aug 2026)
  • 📋 Director of Philanthropy @ KS Society. I was promoted from Recruiter in 4 months after leading External Recruitment, and I now own philanthropic strategy, partner outreach and event programming.
  • 🛠️ Built microcontroller systems, CAD-designed 3D-printed devices, and a full rainwater harvesting system
  • 🏔️ Former ski patrol volunteer · 💪 Certified Weight Lifting Trainer and varsity athlete

📫 Let's Connect

LinkedIn Website Email

🟢 Open to quantitative research, AI evaluation and software roles: Summer 2027 internships and full-time opportunities, in Vancouver, BC or remote.

Pinned Loading

  1. itchbook itchbook Public

    Private development history for itchbook (public: tavelarocque/itchbook)

    Python

  2. impossiblebench-extraction-study impossiblebench-extraction-study Public

    Does ImpossibleBench's code extraction change its measured cheating rate? Pre-registered re-scoring study with sandboxed replay.

    Python

  3. protocol-emulator protocol-emulator Public

    OCaml

  4. implied-odds-research implied-odds-research Public

    Prediction markets vs. option-implied probabilities: live paper trading with pre-registered tests (Kalshi, Deribit, SPX/NDX options)

    Jupyter Notebook

  5. ocaml-contracts ocaml-contracts Public

    A financial contract language in OCaml that prices Kalshi’s Bitcoin prediction markets from Deribit option-implied densities. Three independent pricers (grid, static replication, implied binomial t…

    OCaml

  6. holdem-cfr holdem-cfr Public

    CFR solver for heads-up no-limit hold'em in Rust: MCCFR blueprint, exact postflop solver, local best response

    Rust