I tried to understand the interference patterns observed when coherent or Fock states of light are passed through a beamsplitter.

My expertise lies in astrophysics, and quantum optics is not my specialty. I am unable to explain this difference obtained from the following simulartion. I would appreciate it if someone knowledgeable in this area could provide an explanation. Thank you in advance.

The simulations are designed as follows:

- A pair of modes (representing two paths in a double-slit experiment) are prepared in either coherent or Fock states.
- [Coherent state] the amplitude is 1 (= Poisson distribution with a mean value of 1)
- [Fock state] a single photon state + a vacuum state

- A phase shift is applied to one of the modes to simulate the path difference effect in an interference setup.
- A beamsplitter combines these modes, resulting in interference.
- Photon number measurements are performed to observe the resulting interference pattern.

All the codes and outputs are available from my google colab page.

The outcomes of these simulations are the probability of detecting photons in each mode against the applied phase shift. In the case of coherent states, we expect to see a continuous, wave-like interference pattern. In contrast, Fock state interference should exhibit distinct quantum interference characteristics due to the particle nature of single photons.

The results and the codes are as follows.

```
import strawberryfields as sf
from strawberryfields import ops
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import poisson
def run_state_simulation(num_phases, state_preparation, filename):
# Initialization
phases = np.linspace(-2 * np.pi, 2 * np.pi, num_phases)
probabilities_00 = np.zeros(num_phases)
probabilities_01 = np.zeros(num_phases)
probabilities_10 = np.zeros(num_phases)
eng = sf.Engine(backend="fock", backend_options={"cutoff_dim": 10})
# Simulate for each phase
for i, phase in enumerate(phases):
prog = sf.Program(2)
with prog.context as q:
state_preparation(q) # State preparation
# Apply phase shift and beamsplitter
ops.Rgate(phase) | q[1]
ops.BSgate() | (q[0], q[1])
# Run the program and get probabilities of different photon numbers
state = eng.run(prog).state
probabilities_00[i] = state.fock_prob([0, 0])
probabilities_01[i] = state.fock_prob([0, 1])
probabilities_10[i] = state.fock_prob([1, 0])
# Plotting interference patterns
plt.plot(phases, probabilities_00, ".", label="Photons = [0,0]")
plt.plot(phases, probabilities_01, ".", label="Photons = [0,1]")
plt.plot(phases, probabilities_10, ".", label="Photons = [1,0]")
plt.plot(phases, 1/np.e**2 * np.ones(len(phases)), "--", label=r"1/$e^2$")
plt.xlabel("Phase (radians)")
plt.ylabel("Probability in Modes")
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.grid(alpha=0.4)
plt.savefig(filename)
plt.show()
# Case 1: Coherent State (using state)
def prepare_coherent_state(q):
amplitude = 1.0
ops.Coherent(amplitude) | q[0]
ops.Coherent(amplitude) | q[1]
def apply_phase_shift(q, phase):
ops.Rgate(phase) | q[0]
num_phases = 200 # Number of phase values to simulate
# Run the simulation and plot the results
run_state_simulation(num_phases, prepare_coherent_state, "stw_young_coherent_state.png")
```

The outputs from the coherent state are trigonometric functions.

```
# Case 2: Fock State (using state)
def prepare_fock_state(q):
ops.Fock(1) | q[0]
ops.Fock(0) | q[1]
num_phases = 200 # Number of phase values to simulate
# Run the simulation and plot the results
run_state_simulation(num_phases, prepare_fock_state, "stw_young_fock_state.png")
```

The outputs from the fock state are constant against phase.

The coherent state simulation aligns with our classical understanding of light as a wave, so-called the Young’s double-slit experiment. However, the Fock state simulation did not show any modulation against phase. Would it be a natural consequence from the quantum optics? I would appreciate it if someone could provide an explanation.

This question is on 2023.11.23, using sf.version() = 0.23.0