Add code :rocket:

.isort.cfg

@@ -0,0 +1,5 @@
+[settings]
+length_sort=true
+multi_line_output=3
+include_trailing_comma=true
+force_sort_within_sections=true

.pre-commit-config.yaml

@@ -0,0 +1,30 @@
+default_language_version:
+  python: python3.12
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-merge-conflict
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: debug-statements
+      - id: check-yaml
+      - id: check-docstring-first
+      - id: requirements-txt-fixer
+  - repo: https://github.com/pycqa/flake8
+    rev: 6.0.0
+    hooks:
+    - id: flake8
+      args: ["--max-line-length=120","--extend-ignore=E203","--per-file-ignores=.github/scripts/bump_version.py:E402"]
+  - repo: https://github.com/ambv/black
+    rev: 23.7.0
+    hooks:
+    - id: black
+      args: [--line-length=100]
+      additional_dependencies: ['click==8.0.4']
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+    - id: isort
+      name: isort
+      args: [--line-length=100]

README.md

@@ -1,14 +1,32 @@
 ---
 title: Bell Violation
-emoji: 👁
-colorFrom: gray
+emoji: 🚀
+colorFrom: purple
 colorTo: indigo
 sdk: streamlit
 sdk_version: 1.39.0
-app_file: app.py
+app_file: main.py
 pinned: false
 license: mit
 short_description: Data Science Internship Challenge 2024
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### Code Style
+
+This repository uses pre-commit hooks with forced python formatting ([black](https://github.com/psf/black),
+[flake8](https://flake8.pycqa.org/en/latest/), and [isort](https://pycqa.github.io/isort/)):
+
+```sh
+pip install pre-commit
+pre-commit install
+```
+
+Whenever you execute `git commit` the files altered / added within the commit will be checked and corrected.
+`black` and `isort` can modify files locally - if that happens you have to `git add` them again.
+You might also be prompted to introduce some fixes manually.
+
+To run the hooks against all files without running `git commit`:
+
+```sh
+pre-commit run --all-files
+```

main.py

@@ -0,0 +1,216 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+from matplotlib import pyplot as plt
+
+from physics.particles import OneBitEntangledPhoton, LocalDeterministicPhoton
+
+
+def main():
+    st.write("# Object Oriented Bell Violation")
+    st.write(
+        """
+    This is a part of the coding challenge for [EPR Labs](https://epr-labs.com) data-science internship for physicists.
+
+    The challenge is to implement a non-local model of a pair of entangled particles that recreates
+    the results of Bell-violating EPR experiments through a Monte Carlo simulation.
+    """
+    )
+
+    st.write(
+        """
+    Particle class should inherid `PolarizedParticleBase` – for simplicity you can assume
+    it's a photon, and we're interested in measuring polarization given a detector at an angle.
+    """
+    )
+
+    code = """
+    class PolarizedParticleBase(ABC):
+        @abstractmethod
+        def measure_polarization(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+            pass
+    """
+    st.code(code, language="python")
+
+    st.write(
+        """
+    The Monte Carlo simulation should perform at least 10k measurements of an entangled
+    pair with random detector angles. We're interested in tracking the information about
+    detector angles and measurement outputs. Here's an overview of what the simulation loop can look like:
+    """
+    )
+
+    code = """
+    results = []
+    for it in range(100_000):
+        a_photon = YourPhoton(...)
+        b_photon = YourPhoton(...)
+
+        # Your entanglement mechanism
+        a_photon.entangle(b_photon)
+
+        # We are interested only in the angle difference in range [0, pi/2]
+        a_detector_angle = 0
+        b_detector_angle = np.random.random() * np.pi / 2
+
+        a_polarization_status = a_photon.measure_polarization(a_detector_angle)
+        b_polarization_status = b_photon.measure_polarization(b_detector_angle)
+        result = {
+            "a_outcome": a_polarization_status.value,
+            "b_outcome": b_polarization_status.value,
+            "a_detector": a_detector_angle,
+            "b_detector": b_detector_angle,
+        }
+        results.append(result)
+    """
+    st.code(code, language="python")
+
+    st.write(
+        """
+    Below you can see results for two different simulations.
+    One for a local hidden variables model, which fails to violate Bell inequalities,
+    and one for a model with 1-bit non-local communication, that violates Bell inequalities, but
+    fails to reproduce empirical results.
+    """
+    )
+
+    st.write("## Local Photon Model")
+    st.write("What Einstein hoped for 🥲")
+    df = run_local_experiment()
+    df["angle_bin"] = df.angle_diff.round(2)
+    # TODO: Write an experiment results wrapper class & nice chart
+    angle_agreement = df.groupby("angle_bin").agreement.mean().reset_index()
+
+    fig = draw_polarization_agreement_chart(agreement_df=angle_agreement)
+    st.pyplot(fig)
+
+    st.write("## 1-bit superluminal communication")
+    st.write(
+        "This simulation recreates a model proposed by T.Maudlin in 1992 [[1](https://www.jstor.org/stable/192771)]."
+    )
+    df = run_entangled_experiment()
+    df["angle_bin"] = df.angle_diff.round(2)
+    # TODO: Write an experiment results wrapper class & nice chart
+    angle_agreement = df.groupby("angle_bin").agreement.mean().reset_index()
+
+    fig = draw_polarization_agreement_chart(agreement_df=angle_agreement)
+    st.pyplot(fig)
+
+    show_refs()
+
+
+def show_refs():
+    title = "The Communication Cost of Simulating Bell Correlations"
+    link = "https://arxiv.org/abs/quant-ph/0304076"
+    st.write(f"[{title}]({link})")
+
+
+def draw_polarization_agreement_chart(agreement_df: pd.DataFrame):
+    fig, ax = plt.subplots(figsize=[9, 4])
+    x = agreement_df.angle_bin.values * 180 / np.pi
+    ax.plot(
+        x,
+        agreement_df.agreement,
+        ".",
+        ms=7,
+        label="this simulation",
+        color="indigo",
+    )
+
+    ax.plot(
+        x,
+        np.cos(agreement_df.angle_bin) ** 2,
+        label="EPR experiments",
+        color="teal",
+    )
+    ax.set_xlabel("Detectors angle difference [degrees]", fontsize=14)
+    ax.set_ylabel(
+        "Proportion of agreement in\nspace time separated\npolarization angle measurements",
+        fontsize=14,
+    )
+
+    ax.set_ylim(0, 1)
+    ax.set_xlim(0, x.max())
+
+    ax.legend()
+
+    y_down = np.zeros_like(x)
+    # y_up = np.ones_like(x)
+    y_diagonal = np.linspace(1, 0, len(x))
+    ax.fill_between(x, y_down, y_diagonal, color="gray", alpha=0.2)
+    ax.text(10.3, 0.3, "Possible with\nBell-local theory", fontsize=20, rotation=0)
+
+    # ax.fill_between(x, y_diagonal, y_up, color="gray", alpha=0.4)
+    ax.text(54.3, 0.50, "Not possible with\nBell-local theory", fontsize=20, rotation=0)
+
+    return fig
+
+
+def run_entangled_experiment(n_steps: int = 100_000) -> pd.DataFrame:
+    results = []
+    for it in range(n_steps):
+        reference_angle = np.random.random() * np.pi
+        a_photon = OneBitEntangledPhoton(reference_angle)
+        b_photon = OneBitEntangledPhoton(reference_angle)
+
+        a_photon.entangle(b_photon)
+        b_photon.entangle(a_photon)
+
+        # We are interested in the angle difference between detectors
+        # and we only want to measure within range of [0 - pi/2] ...
+        a_detector_angle = 0
+        # ... so we only allow the movement of the second detector within that range
+        b_detector_angle = np.random.random() * np.pi / 2
+
+        a_polarization_status = a_photon.measure_polarization(a_detector_angle)
+        b_polarization_status = b_photon.measure_polarization(b_detector_angle)
+        result = {
+            "a_outcome": a_polarization_status.value,
+            "b_outcome": b_polarization_status.value,
+            "a_detector": a_detector_angle,
+            "b_detector": b_detector_angle,
+        }
+        results.append(result)
+
+    df = pd.DataFrame(results)
+    df["agreement"] = df.a_outcome == df.b_outcome
+    df["angle_diff"] = df.b_detector - df.a_detector
+
+    return df
+
+
+def run_local_experiment(n_steps: int = 100_000) -> pd.DataFrame:
+    results = []
+    for it in range(n_steps):
+        # In the experimental setup we have photons with same polarization
+        polarization_angle = np.random.random() * np.pi
+        a_photon = LocalDeterministicPhoton(polarization_angle)
+        b_photon = LocalDeterministicPhoton(polarization_angle)
+
+        # We are interested in the angle difference between detectors
+        # and we only want to measure within range of [0 - pi/2] ...
+        a_detector_angle = 0
+        # ... so we only allow the movement of the second detector within that range
+        b_detector_angle = np.random.random() * np.pi / 2
+
+        # Without entanglement order of measurement doesn't matter
+        # (does it matter with entangled particles? :thinking:)
+        a_polarization_status = a_photon.measure_polarization(a_detector_angle)
+        b_polarization_status = b_photon.measure_polarization(b_detector_angle)
+        result = {
+            "a_outcome": a_polarization_status.value,
+            "b_outcome": b_polarization_status.value,
+            "a_detector": a_detector_angle,
+            "b_detector": b_detector_angle,
+        }
+        results.append(result)
+
+    df = pd.DataFrame(results)
+    df["agreement"] = df.a_outcome == df.b_outcome
+    df["angle_diff"] = df.b_detector - df.a_detector
+
+    return df
+
+
+if __name__ == "__main__":
+    main()

physics/particles.py

@@ -0,0 +1,87 @@
+from enum import Enum
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+
+class PolarizationMeasurementOutcome(Enum):
+    PASSED = True
+    ABSORBED = False
+
+
+class PolarizedParticleBase(ABC):
+    @abstractmethod
+    def measure_polarization(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+        pass
+
+
+class EntangledPolarizedParticleBase(PolarizedParticleBase):
+    @abstractmethod
+    def superluminal_communication(self):
+        pass
+
+
+class LocalDeterministicPhoton(PolarizedParticleBase):
+    def __init__(self, polarization_angle: float):
+        self.polarization_angle = polarization_angle
+
+    def measure_polarization(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+        angle_difference = self.polarization_angle - detector_angle_rad
+        # This means the difference is within [-pi/4, pi/4]
+        if np.cos(angle_difference) ** 2 > 0.5:
+            return PolarizationMeasurementOutcome.PASSED
+        else:
+            # And this means it's more than pi/4 and less than 3pi/4
+            return PolarizationMeasurementOutcome.ABSORBED
+
+
+class OneBitEntangledPhoton(EntangledPolarizedParticleBase):
+    def __init__(
+        self,
+        reference_angle_rad: float,
+    ):
+        self.decided = False
+        self.use_strategy_b = False
+
+        # Entangled photons do not have polarization decided when created
+        # but they share a reference frame
+        self.reference_angle_rad = reference_angle_rad
+
+    def strategy_a(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+        angle_difference = self.reference_angle_rad - detector_angle_rad
+
+        # This means the difference is within [-pi/4, pi/4]
+        if np.cos(angle_difference) ** 2 > 0.5:
+            return PolarizationMeasurementOutcome.PASSED
+        else:
+            # And this means it's more than pi/4 and less than 3pi/4
+            return PolarizationMeasurementOutcome.ABSORBED
+
+    def strategy_b(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+        angle_difference = self.reference_angle_rad - detector_angle_rad
+
+        # This means the difference is within [-pi/4, pi/4]
+        if np.cos(angle_difference - np.pi / 4) ** 2 > 0.5:
+            return PolarizationMeasurementOutcome.PASSED
+        else:
+            # And this means it's more than pi/4 and less than 3pi/4
+            return PolarizationMeasurementOutcome.ABSORBED
+
+    def entangle(self, other_photon: "OneBitEntangledPhoton"):
+        self.other_photon = other_photon
+
+    def superluminal_communication(self, use_strategy_b: bool):
+        self.use_strategy_b = use_strategy_b
+        self.decided = True
+
+    def measure_polarization(self, detector_angle_rad: float) -> PolarizationMeasurementOutcome:
+        # Quantum magic
+        if not self.decided:
+            angle_difference = self.reference_angle_rad - detector_angle_rad
+            self.use_strategy_b = (angle_difference - np.pi / 8) % (np.pi / 2) < np.pi / 4
+            self.other_photon.superluminal_communication(use_strategy_b=self.use_strategy_b)
+
+        if self.use_strategy_b:
+            return self.strategy_b(detector_angle_rad)
+        else:
+            return self.strategy_a(detector_angle_rad)