What you need before you start

Draft, for review. Every resource below was opened and its span checked on 2026-10-09; where a pointer could not be verified it says so rather than guessing.

The short answer

You can read the whole curriculum, and score every exercise, with no Python installed and no mathematics beyond school algebra. Every notebook is published here already run, with its figures and printed numbers, and not one of the 188 exercises asks you to write code. That is not a consolation prize — it is a legitimate way through, and it is how most readers should start.

What the mathematics buys you is the difference between reading a result and checking one. You will hit that difference at a specific place, and it is worth naming it now: lesson L1.2, the second lesson of Level 1, roughly five hours in. Fourteen lessons pass with almost no notation, and then the discrete Fourier transform arrives as X[k] = Σ x[n] · exp(−2πi k n / N). If you are going to stall anywhere, it is there.

This page exists because the usual advice at that moment — “go learn Fourier” — is bad advice. A full course is a semester you do not need, and a twenty-minute explainer leaves you unable to continue. What you need is a bound: how much of each idea this curriculum actually uses, and permission to stop there.

Two tracks, running on separate clocks

Reading trackRunning track
Needsnothing installedPython, or a browser and Colab
Gets youevery lesson, every widget, every exercise, every notebook’s outputthe ability to change a number and see what happens
Startnowwhenever you like, in parallel

Treat them as independent. Readers who wait until they “know enough Python” to begin the EEG material usually acquire neither, because nothing motivates the Python. Start reading, and let the code catch up.

The maths gates

Six ideas carry nearly all the load through Level 4, which is as far as filtering and time-frequency require. Each gate below says what the curriculum does with the idea, what counts as enough, what you may skip, and how to know you are done.

Gate 1 — Logarithms, decibels and octaves

Where it bites. L0.3 quotes amplifier rejection in dB; L1.3 puts every spectrum on a log axis; L1.4 states window quality entirely in dB and dB-per-octave, and its exercise is graded on one; L1.7 makes a straight line on log-log axes the whole subject.

Enough. That a log turns ratios into distances, so equal spacing on the axis means equal factors. That dB is a log ratio: 10·log10 for power, 20·log10 for amplitude, so +10 dB is ten times the power and +6 dB is about twice the amplitude. That an octave is a doubling of frequency, so “6 dB per octave” means amplitude halves each time frequency doubles. That a power law P = k·f^(−x) plots as a straight line on log-log with slope −x — this single fact is what L1.7’s widget is doing.

Skip. Natural logs and e (not needed until L4.2, and then only inside a formula you read rather than manipulate), change-of-base, log identities beyond log(ab) = log a + log b, and anything about logarithmic scales in acoustics.

Done when you can say, without computing: a spectrum falling 20 dB from 10 Hz to 20 Hz has lost what factor of power, and what is the exponent of that power law? (Answers: one hundredth; about 6.6.)

Where. Any school-level treatment of logarithms, plus the glossary entries here: logarithm, decibel, octave. This gate does not need a course. Budget: 1–2 hours.

Gate 2 — Complex numbers and the complex exponential

This is the wall. It is also far smaller than it looks.

Where it bites. L1.2, in the definition of the DFT, and then wherever a phase appears: L4.2’s wavelet, L4.3’s analytic signal, L4.5’s inter-trial coherence.

Enough. That a complex number is an arrow: it has a length and an angle, and nothing else about it is used here. That exp(iθ) is an arrow of length 1 at angle θ, so multiplying by it rotates without stretching. That the Fourier coefficient X[k] is one such arrow per frequency — its length is how much of that frequency is present, its angle is where in its cycle it starts. That |X[k]| means the length. That averaging arrows gives a short result when their angles disagree and a long one when they agree, which is the whole content of inter-trial coherence.

Skip. What i “really is”, proofs of Euler’s formula, complex arithmetic (multiplying, dividing, conjugates), the complex plane as a field, analytic functions, contour integration — all of it. You will not be asked to manipulate a complex number anywhere in this curriculum. If a resource starts proving things about i, you are in the wrong resource; this is exactly where the MIT-OpenCourseWare path goes wrong for this purpose.

Done when you can look at X[5] = 3·e^(iπ/2) and say: there is an amount 3 of the fifth frequency, and it starts a quarter of a cycle in.

Where. Think DSP (free, CC-licensed), chapter 7, “Discrete Fourier Transform”. Its first two sections are Complex Exponentials and Complex Signals, and they are exactly this gate — stop at the end of “Complex Signals” and you have what the lesson needs. The book reaches it through Python code rather than through phasors, which is the opposite of the approach that defeats most readers here. If you want the transform itself as well, read on to the end of the chapter; sections 3 onward build it.

Mike X Cohen’s channel teaches the same ground for neural data specifically, which some readers find lands better. I have not verified a particular video or timing there, so treat it as a place to look rather than a prescription.

See also complex number and radian. Budget: 3–4 hours.

Gate 3 — Convolution

Where it bites. L1.5, where every filter is one, and again in L4.2 where a wavelet transform is one.

Enough. That a filter slides a short set of weights along the signal, multiplying and summing — so every output sample is a weighted blend of nearby input samples. That convolving in time equals multiplying in frequency, which is why a filter can be described either by its kernel or by its gain per frequency. That the trade-off follows from this: a sharp cut in frequency needs a long kernel, and a long kernel rings in time.

Skip. Computing a convolution by hand, the convolution integral, proofs of the convolution theorem, circular versus linear convolution (the lessons flag where it matters).

Done when you can answer: why does a steeper filter ring more? (convolution)

Where. The Scientist and Engineer’s Guide to DSP, free in full and written for practitioners rather than mathematicians — chapter 6, “Convolution”, which opens by calling it “the single most important technique in Digital Signal Processing” and builds it from impulse decomposition rather than from an integral. The digital-filter chapters that follow are the natural continuation when you reach L1.5; the book’s chapter index lists them. Budget: 2–3 hours.

Gate 4 — Variance, standard deviation, z-scores and correlation

Where it bites. L0.5 uses variance to spot a dead channel; L2.2 builds a whole bad-channel detector on robust z-scores and inter-channel correlation, and grades an exercise on it.

Enough. That variance measures spread and zero variance means no signal. That standard deviation is its square root, in microvolts, and that one artifact inflates it — which is why a robust version built on the median is used instead. That a z-score counts standard deviations from typical, making different channels comparable. That correlation runs −1 to +1, and that in EEG a channel correlating poorly with its neighbours is the broken one, not the interesting one.

Skip. Deriving any of them, the distinction between sample and population denominators, significance testing of a correlation.

Done when you can say why a channel with near-zero variance and a channel with enormous variance are both suspect, and why low correlation with neighbours is bad news rather than good.

Where. The four glossary entries linked above are written to be sufficient. Budget: under an hour.

Gate 5 — Radians

Where it bites. Everywhere a phase appears, starting at L1.2, and in every notebook, because NumPy, SciPy and MNE all work in radians.

Enough. 2π is a full cycle, π is half, π/2 is a quarter. Read phases as fractions of a cycle and never convert to degrees.

Skip. Everything else. (radian)

Done when you can read np.pi / 2 in a notebook as “a quarter cycle” without pausing. Budget: ten minutes.

Gate 6 — Why spectra are noisy

Where it bites. L1.3, which argues that a raw periodogram is unusable and that averaging is not optional.

Enough. That a single spectral estimate is as noisy as it is large, no matter how long the recording, and that averaging across segments or tapers is what fixes it. That is the lesson’s conclusion, and you can hold it without the distribution theory.

Skip. Chi-square distributions, degrees of freedom, estimator bias and consistency as formal ideas. The lesson states them; nothing downstream requires you to use them.

Done when you can say why a longer recording alone does not give a cleaner spectrum. Budget: it is the lesson, not a prerequisite.

The Python gates

Gate 7 — Reading a notebook

Nothing required. Every notebook is published already run. Read the code as a recipe and the output as the result.

Gate 8 — Running a notebook

Press Download on any notebook card and open the file in Jupyter, VS Code, or Colab via File → Upload notebook. The first cell installs what it needs and fetches the shared helpers from this site, so a single downloaded file runs on its own. Locally you will also need a notebook environment: pip install jupyterlab, then the pinned requirements.txt.

Enough Python to begin: run a cell, read an error message, change a number and re-run. That is genuinely it for Level 0.

Gate 9 — Reading and changing notebook code

Where it bites. From nb-0-5 onward the code indexes 2-D arrays by axis, masks by boolean condition, and reshapes.

Enough. Variables, function calls, imports, lists and dicts; then NumPy arrays specifically — that an EEG array is channels × samples, that x[2, 100:200] means one channel and a time range, and that an axis argument says which direction an operation runs.

Skip. Classes, decorators, generators, packaging, type hints, and every part of pandas except reading a column.

Where. Neuromatch Academy’s pre-reqs refreshers, free under CC BY 4.0 and — importantly — available to work through right now. The summer cohort is a community, not a gate on the material. The days you want are W0D1 and W0D2, Python Workshop 1 and 2; W0D3 is linear algebra and W0D5 statistics, neither of which this curriculum needs before Level 5.

One calibration note, since this page exists to give you those. Neuromatch says you “will learn how to code in Python from scratch using a simple neural model” — and it means it, but it does so by building a leaky integrate-and-fire neuron from the first tutorial. That is motivating if you have programmed anything before and brisk if you have not. If W0D1 moves too fast, that is the material’s pace and not your failure; any gentle introduction to Python will get you to the same place, and you can come back to W0D2 for the NumPy part.

Budget: 10–20 hours, spread over weeks, in parallel with reading.

If you want a cohort

The material above is self-paced by necessity. If the structure of a cohort is what you need, Neuromatch runs one annually and its curriculum is the same one linked above, so you can work through it now and join later without repeating anything.

What this page does not do

It does not teach the mathematics. Where a lesson leans on an idea, this page states how much of it the lesson uses and where to get that much; the lessons themselves are being revised to carry the same bound at the point where the formula appears. If you hit something in a lesson that this page does not cover, that is a gap in this page and worth reporting.