# Fourier analysis of exoplanet transit to determine the number of planets in the system

Although I think that this can be done by simply looking at the transit graph, I was wondering if a Fourier transform of a transit (basically transforming transit depth/amplitude vs time graph to transit depth/amplitude vs frequency graph) can be used to determine the number of planets in a system. I suppose the different “peaks” could indicate different exoplanets. Does this make sense and is it possible?

Also, I don’t know much about Fourier transforms (although I am willing to learn about it). I thought of doing my IB Maths AA HL internal assessment on this topic. Would this be possible?

• Yes, it's a standard technique to get a first estimate at the data. Ruling out false positives and estimating errors with this technique is difficult thought. Commented Aug 18, 2022 at 11:56
• To complement the existing answers - there are more effective algorithms for search of periodic transits. You can read about Box-Least Squares and its variants. They are used in practice, not Fourier. Commented Aug 19, 2022 at 11:09

As AtmosphericPrisonEscape mentioned in a comment, this could in principle be done, but there are some difficulties involved.

Let's consider a very idealistic case in which we are able to measure the light curve of a star for a long period of time, at regular intervals, and we see many transits.

In this toy model each transiting planet is described by four parameters:

• The orbital period $$P$$
• the contrast ratio $$k = {R_p^2 \over R_s^2}$$, where $$R_p$$ and $$R_s$$ are the effective radius of the planet and the star, respectively.
• the transit duration $$\tau$$.
• the time of first transit $$t_0$$, which is chosen arbitrary of as the middle time of one of the transits.

The ligth curve $$lc(t)$$ can be then modelled as follows:

• when there is no planet transiting, $$lc(t) = 1$$
• when there are one or more planets transiting, $$lc(t) = 1- \sum k_i$$, where $$k_i$$ is the contrast ratio of the i-th planet that is transiting at time $$t$$.

This model can be easily implemented in python:

import numpy as np

class Planet_Transit:
def __init__(self, period, contrast_ratio, transit_duration, first_transit_time):
"""
This class contains the bare minimum parameters necessary to describe a planet
transiting in front of a star
"""
self.P = period         # the orbital period
self.k = contrast_ratio # the square of the ratio of the effective
# radii of the planet and of the star
self.tau = transit_duration      # the time it takes to transit
self.t0 = first_transit_time    # the time at which the planet is at
# the middle point of a transit.
# It is needed to fix a reference time

def is_in_transit(self, t):
"""
return whether the planet is transiting the star at time t
"""
return np.mod(t - (self.t0-self.tau/2), self.P) < self.tau

def light_curve(t_start, t_end, dt, planet_transits):
Dt = t_end-t_start
t = np.linspace(t_start, t_end, int(Dt/dt))

lc = np.ones(t.shape) # the light curve

for p in planet_transits:
lc = lc - p.k * p.is_in_transit(t)
return t, lc


So, for example, we could have two planets with the following characteristics $$P_1 = 8, P_2 = 13$$ $$k_1 = 0.01, k_2 = 0.005$$ $$k_1 = 0.01, k_2 = 0.005$$ $$\tau_1 = 0.1, \tau_2 = 0.06$$ $$t_{0,1} = 0.3, t_{0,2} = 0.5$$

Plotting the light curve gives

import matplotlib.pyplot as plt

P1 = 8
P2 = 13
planet_transits =[
Planet_Transit(P1, 0.01, 0.1, 0.3),
Planet_Transit(P2, 0.005, 0.06, 0.5)
]

t_start = 0
t_end = 1
dt = 0.001
t, lc = light_curve(t_start, t_end, dt, planet_transits)

plt.plot(t, lc)
plt.xlabel("time")
plt.ylabel("light curve")
plt.show()


the two transits are neat and clearly visible. If we look at the star for a longer time, we see a clear pattern.

In this simple example it is easy to see that there are two planets, just by looking at the light curve. Will taking the Fourier transform make things even simpler?

Let's plot the Fourier transform of the latest plot:

from scipy.fft import fft

# The array of frequencies
freq = np.linspace(0, 1/dt, len(t))
# The fourier transform. Notice that I subtract 1 from lc, in order to
# suppress the zero frequency mode.
transform =  np.abs(fft(lc-1))
plt.plot(freq, transform)


... a forest of peaks... probably not what you expected. But if you zoom on the region where we know there are the planet's orbital frequencies (marked with a red line) we see that at least there are two peaks corresponding to the planet's frequencies.

# The array of frequencies
freq = np.linspace(0, 1/dt, len(t))
# The fourier transform. Notice that I subtract 1 from lc, in order to
# suppress the zero frequency mode.
transform =  np.abs(fft(lc-1))
plt.plot(freq, transform)
plt.xlim(0,1)
plt.axvline(1/P1, color="red")
plt.axvline(1/P2, color="red")
plt.show()


All the other peaks appear because the function we are transforming is not just the sum of two $$\sin$$ functions. It contains many other frequencies that are shown in the Fourier transforms as peaks. Furthermore, we are not guaranteed that the peak with the lowest frequency will be a planet, because it could be an alias of a higher frequency.

Analyzing the Fourier transform looking for planets is thus not straightforward. Moreover, this is a very idealized case. In reality things can only become much worse. A real light curve will be much more complicated: there will be a phase modulation, limb darkening effects, starspots and flares, and noise, lots of it, at all the frequencies. If there are many planets in the system, there could also be transit time variations, so that the time between one transit and the next one is not fixed.

If this wasn't enough, we must also consider that it is not common to be able to observe a star for a very long time, taking data points at regular intervals without any interruption. But if the points are not regularly spaced in time, one cannot use a Fourier transform. And this is why other methods such as the Lomb-Scargle peridogram are sometimes preferred.

A series of transits could to first-order be represented as a set of repeating delta functions - otherwise known as a Dirac comb with a repeating period equal to the orbital period of the planet. If you take the Fourier transform of this you would get another Dirac comb in frequency space, with a repeating interval equal to the orbital frequency of the planet ($$2\pi/$$orbital period).

More realistically, the transit time series looks like a Dirac comb convolved with a top hat function with a width equal to the width of the transit. The FT of this will be a Dirac comb multiplied by the FT of a top hat function, which is a sinc function. This won't have much effect if the gap between transits is long compared with the width of the transit. You would also have to take into account the finite window of the observations. This would have the effect of convolving the FT with a narrow sinc function, which would mean rather than a spike, your principle frequency would be somewhat blurred.

If you have a set of planets, each one with a different orbital period, then this will give you a set of different frequencies in the FT. Providing the duration of the observation is much greater than the orbital periods, and the orbital periods are not multiples of each other, then these frequencies will be distinct in the FT.

So yes, it could work.