{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5b4f2d2a",
   "metadata": {},
   "source": [
    "# Testy nieparametryczne\n",
    "\n",
    "W tym notatniku poznasz kilka klasycznych procedur, które **nie wymagają** założenia normalności i często opierają się na **rangach**. Przykłady będą bardzo proste i osadzone w typowych sytuacjach badawczych z kognitywistyki (czasy reakcji, oceny, zgodność koderów, trafność odpowiedzi).\n",
    "\n",
    "Omówimy:\n",
    "\n",
    "- test Wilcoxona dla prób zależnych (test rangowanych znaków),\n",
    "- test U Manna–Whitneya dla prób niezależnych (test sumy rang),\n",
    "- zgodność koderów: $\\kappa$ Cohena i $\\kappa$ Fleissa,\n",
    "- porównanie wielu grup: test Kruskala–Wallisa + porównania następcze (test Dunna z korektą Bonferroniego),\n",
    "- dane sparowane 0/1: test McNemara.\n",
    "\n",
    "W kilku miejscach pojawią się też krótkie **widżety** (suwaki). Ich celem jest pokazanie intuicji: skąd bierze się p-wartość w testach permutacyjnych oraz dlaczego praca na rangach zmniejsza wpływ obserwacji odstających."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c9d3f6c",
   "metadata": {},
   "source": [
    "## Cele\n",
    "\n",
    "- Umieć zdecydować, kiedy test nieparametryczny ma sens (skala porządkowa, odstające obserwacje, silna skośność, małe próby).\n",
    "- Umieć przeprowadzić każdy przykład **krok po kroku**: historia → pytanie → $H_0/H_A$ (kierunkowość) → $α$ → statystyka i rozkład pod $H_0$ → region krytyczny → p-wartość \"na piechotę\" → weryfikacja funkcją → interpretacja.\n",
    "- Pamiętać o raportowaniu **efektu i niepewności** (choćby w prostej formie: estymata + przedział ufności), a p-wartość traktować jako *jedną* część informacji.\n",
    "- Interpretować p-wartości poprawnie: $P(\\text{dane tak skrajne lub bardziej} \\mid H_0)$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d5090c9",
   "metadata": {},
   "source": [
    "## Wymagania wstępne\n",
    "\n",
    "- Schemat testowania hipotez: $H_0/H_A$, poziom istotności $α$, p-wartość, region krytyczny.\n",
    "- Podstawy `numpy`, `pandas`.\n",
    "- Podstawy wykresów w `matplotlib`/`seaborn`.\n",
    "- (Opcjonalnie) Widżety interaktywne w notatniku Jupyter (pakiet `ipywidgets`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ae7c56a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scikit_posthocs as sp\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from statsmodels.stats.contingency_tables import mcnemar\n",
    "from statsmodels.stats.inter_rater import cohens_kappa, fleiss_kappa\n",
    "\n",
    "from IPython.display import display\n",
    "\n",
    "SEED = 20250116\n",
    "rng = np.random.default_rng(SEED)\n",
    "\n",
    "sns.set_theme(style=\"whitegrid\")\n",
    "plt.rcParams[\"figure.dpi\"] = 120\n",
    "\n",
    "try:\n",
    "    import ipywidgets as widgets\n",
    "\n",
    "    WIDGETY_DOSTEPNE = True\n",
    "except ImportError:\n",
    "    widgets = None\n",
    "    WIDGETY_DOSTEPNE = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4e84f7d",
   "metadata": {},
   "source": [
    "## Wstęp do testów nieparametrycznych\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a1d5f2",
   "metadata": {},
   "source": [
    "### Parametryczne vs nieparametryczne\n",
    "\n",
    "Większość poznanych przez nas procedur statystycznych obejmuje estymację **parametrów rozkładu populacji**, z której pochodziła próba (albo próby). Tego typu procedury opierają się na **założeniach dotyczących rozkładu**.\n",
    "\n",
    "Przykład: jednym z założeń testu *t* jest to, że populacja ma rozkład normalny (albo przynajmniej, że przy danej liczebności możemy rozsądnie użyć przybliżenia).\n",
    "\n",
    "Takie testy (opierające się na estymacji parametrów i/lub założeniach dotyczących rozkładu) nazywamy testami **parametrycznymi**.\n",
    "\n",
    "W odróżnieniu od nich testy **nieparametryczne** nie opierają się na estymacji parametrów rozkładu i zazwyczaj **nie wymagają** założenia konkretnego kształtu rozkładu w populacji.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c9404b",
   "metadata": {},
   "source": [
    "### Kiedy użyć testu nieparametrycznego?\n",
    "\n",
    "Najpierw powinniśmy się zastanowić, czy nasze dane spełniają założenia testu parametrycznego, którego chcemy użyć.\n",
    "\n",
    "Jeżeli chcemy użyć testu $t$, to musimy zadać sobie pytanie: na ile uprawnieni jesteśmy, żeby zakładać, że rozkład danej zmiennej w populacji jest normalny.\n",
    "\n",
    "#### Kiedy możemy rozsądnie założyć, że rozkład w populacji nie jest normalny?\n",
    "\n",
    "- kiedy nasza zmienna jest na **skali porządkowej**,\n",
    "- kiedy mamy obserwacje **odstające** (których nie możemy się pozbyć),\n",
    "- kiedy widać to na wykresach diagnostycznych (histogram, wykres kwantyl–kwantyl).\n",
    "\n",
    "#### Kiedy jeszcze możemy użyć testów nieparametrycznych?\n",
    "\n",
    "- kiedy bardziej niż średnia interesuje nas **mediana**,\n",
    "- kiedy mamy **bardzo małe grupy**.\n",
    "\n",
    "#### Kiedy nie jest rozsądnie zakładać, że rozkład populacji nie jest normalny?\n",
    "\n",
    "- kiedy mamy dużą próbę i jakiś test na normalność odrzuci nam hipotezę, że dane pochodzą z rozkładu normalnego, ale w praktyce rozbieżność nie jest duża (wiele testów parametrycznych jest dość odpornych np. na lekką skośność)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2a400aa",
   "metadata": {},
   "source": [
    "## Testy na rangach\n",
    "\n",
    "Duża część testów nieparametrycznych opiera się na prostym pomyśle:\n",
    "\n",
    "- zamiast pracować na samych wartościach, pracujemy na **rangach**,\n",
    "- dzięki temu pojedyncze skrajne obserwacje mają mniejszy wpływ,\n",
    "- a część wnioskowania można oprzeć o symetrie i permutacje (co często daje testy \"bez rozkładu\").\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55df96a8",
   "metadata": {},
   "source": [
    "### Widżet: dlaczego rangi bywają przydatne?\n",
    "\n",
    "Poniżej pokazujemy tę samą sytuację na dwa sposoby:\n",
    "\n",
    "- po lewej: **surowe wartości** czasu reakcji,\n",
    "- po prawej: te same obserwacje po zamianie na **rangi**.\n",
    "\n",
    "Suwak zwiększa jedną obserwację odstającą w grupie A.\n",
    "W danych surowych punkt może „uciec” bardzo daleko i mocno przesuwać średnią.\n",
    "Po zamianie na rangi ten sam punkt może dostać najwyższą rangę, ale nie może stać się „dziesięć razy bardziej najwyższy”.\n",
    "\n",
    "W ramce porównujemy trzy proste wielkości: różnicę średnich, różnicę median i różnicę średnich rang.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "0bdbdc17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8c994039e2a4038be946df465124094",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntSlider(value=20, continuous_update=False, description='n', max=80, min=6, step=2), IntSlider…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2344789ac17a4285a80415fcca424379",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not WIDGETY_DOSTEPNE:\n",
    "    print(\"Widżety nie są dostępne. Jeśli pracujesz w Jupyterze, doinstaluj pakiet ipywidgets.\")\n",
    "else:\n",
    "    n_slider = widgets.IntSlider(value=20, min=6, max=80, step=2, description=\"n\", continuous_update=False)\n",
    "    outlier_slider = widgets.IntSlider(\n",
    "        value=0,\n",
    "        min=0,\n",
    "        max=600,\n",
    "        step=10,\n",
    "        description=\"odstająca (+ms)\",\n",
    "        continuous_update=False,\n",
    "    )\n",
    "    seed_input = widgets.IntText(value=SEED, description=\"ziarno\")\n",
    "\n",
    "    def pokaz_wartosci_i_rangi(n, outlier_ms, seed):\n",
    "        n = int(n)\n",
    "        outlier_ms = float(outlier_ms)\n",
    "        rng_local = np.random.default_rng(int(seed))\n",
    "\n",
    "        grupa_a = rng_local.normal(loc=600.0, scale=80.0, size=n)\n",
    "        grupa_b = rng_local.normal(loc=600.0, scale=80.0, size=n)\n",
    "        grupa_a = grupa_a.copy()\n",
    "        grupa_a[0] = grupa_a[0] + outlier_ms\n",
    "\n",
    "        values = np.concatenate([grupa_a, grupa_b])\n",
    "        groups = np.array([\"A\"] * n + [\"B\"] * n)\n",
    "        is_outlier = np.array([True] + [False] * (n - 1) + [False] * n)\n",
    "        ranks = stats.rankdata(values)\n",
    "\n",
    "        df = pd.DataFrame(\n",
    "            {\n",
    "                \"wartosc\": values,\n",
    "                \"ranga\": ranks,\n",
    "                \"grupa\": groups,\n",
    "                \"odstajaca\": is_outlier,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        mean_diff = float(grupa_a.mean() - grupa_b.mean())\n",
    "        median_diff = float(np.median(grupa_a) - np.median(grupa_b))\n",
    "        mean_rank_a = float(df.loc[df[\"grupa\"] == \"A\", \"ranga\"].mean())\n",
    "        mean_rank_b = float(df.loc[df[\"grupa\"] == \"B\", \"ranga\"].mean())\n",
    "        mean_rank_diff = mean_rank_a - mean_rank_b\n",
    "        outlier_rank = float(df.loc[df[\"odstajaca\"], \"ranga\"].iloc[0])\n",
    "\n",
    "        rng_jitter = np.random.default_rng(12345)\n",
    "        x_raw = np.where(df[\"grupa\"] == \"A\", 0.0, 1.0) + rng_jitter.normal(0, 0.04, size=len(df))\n",
    "        x_rank = np.where(df[\"grupa\"] == \"A\", 0.0, 1.0) + rng_jitter.normal(0, 0.04, size=len(df))\n",
    "        colors = np.where(df[\"odstajaca\"], \"tomato\", \"black\")\n",
    "        sizes = np.where(df[\"odstajaca\"], 85, 28)\n",
    "\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(12, 4.8), constrained_layout=True)\n",
    "\n",
    "        axes[0].scatter(x_raw, df[\"wartosc\"], c=colors, s=sizes, alpha=0.85)\n",
    "        for x_pos, group in enumerate([\"A\", \"B\"]):\n",
    "            group_values = df.loc[df[\"grupa\"] == group, \"wartosc\"]\n",
    "            mean_value = float(group_values.mean())\n",
    "            median_value = float(group_values.median())\n",
    "            axes[0].hlines(mean_value, x_pos - 0.23, x_pos + 0.23, color=\"steelblue\", linewidth=3, label=\"średnia\" if x_pos == 0 else None)\n",
    "            axes[0].hlines(median_value, x_pos - 0.23, x_pos + 0.23, color=\"darkorange\", linewidth=3, label=\"mediana\" if x_pos == 0 else None)\n",
    "        axes[0].set_xlim(-0.5, 1.5)\n",
    "        axes[0].set_ylim(250, 1300)\n",
    "        axes[0].set_xticks([0, 1], [\"A\", \"B\"])\n",
    "        axes[0].set_title(\"Surowe wartości\")\n",
    "        axes[0].set_xlabel(\"grupa\")\n",
    "        axes[0].set_ylabel(\"czas reakcji (ms)\")\n",
    "        axes[0].legend(loc=\"upper left\")\n",
    "\n",
    "        axes[1].scatter(x_rank, df[\"ranga\"], c=colors, s=sizes, alpha=0.85)\n",
    "        for x_pos, group in enumerate([\"A\", \"B\"]):\n",
    "            group_ranks = df.loc[df[\"grupa\"] == group, \"ranga\"]\n",
    "            mean_rank = float(group_ranks.mean())\n",
    "            axes[1].hlines(mean_rank, x_pos - 0.23, x_pos + 0.23, color=\"steelblue\", linewidth=3, label=\"średnia ranga\" if x_pos == 0 else None)\n",
    "        axes[1].set_xlim(-0.5, 1.5)\n",
    "        axes[1].set_ylim(0.5, 2 * n + 0.5)\n",
    "        axes[1].set_xticks([0, 1], [\"A\", \"B\"])\n",
    "        axes[1].set_title(\"Te same obserwacje jako rangi\")\n",
    "        axes[1].set_xlabel(\"grupa\")\n",
    "        axes[1].set_ylabel(\"ranga\")\n",
    "        axes[1].legend(loc=\"upper left\")\n",
    "\n",
    "        result_text = \"\\n\".join(\n",
    "            [\n",
    "                f\"różnica średnich A-B = {mean_diff:.1f} ms\",\n",
    "                f\"różnica median A-B = {median_diff:.1f} ms\",\n",
    "                f\"różnica średnich rang A-B = {mean_rank_diff:.2f}\",\n",
    "                f\"ranga obserwacji odstającej = {outlier_rank:.0f}/{2*n}\",\n",
    "            ]\n",
    "        )\n",
    "        axes[1].text(\n",
    "            0.98,\n",
    "            0.04,\n",
    "            result_text,\n",
    "            transform=axes[1].transAxes,\n",
    "            va=\"bottom\",\n",
    "            ha=\"right\",\n",
    "            fontsize=10,\n",
    "            bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.90},\n",
    "        )\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "    out = widgets.interactive_output(\n",
    "        pokaz_wartosci_i_rangi,\n",
    "        {\"n\": n_slider, \"outlier_ms\": outlier_slider, \"seed\": seed_input},\n",
    "    )\n",
    "\n",
    "    display(widgets.HBox([n_slider, outlier_slider, seed_input]), out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e39c6435",
   "metadata": {},
   "source": [
    "### Test sumy rang Wilcoxona (próby zależne)\n",
    "\n",
    "Rozważmy bardzo klasyczny przykład z kognitywistyki: **zadanie Stroopa**.\n",
    "\n",
    "- W warunku **zgodnym** nazwa koloru i kolor atramentu są zgodne (np. słowo „CZERWONY” napisane na czerwono).\n",
    "- W warunku **niezgodnym** są sprzeczne (np. „CZERWONY” napisane na niebiesko).\n",
    "\n",
    "Badani mają **nazywać kolor atramentu**, a nie czytać słowo. Zmienną zależną jest **czas reakcji** (ms).\n",
    "\n",
    "To schemat eksperymentalny **wewnątrzosobniczy**: każda osoba wykonuje oba warunki. W takim układzie naturalnie analizujemy różnice *w parach* (osoba po osobie).\n",
    "\n",
    "Czasy reakcji często są skośne i mają obserwacje odstające, więc zamiast testu *t* możemy użyć testu Wilcoxona na rangach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "e9d2c8d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zgodny (ms): [580 600 620 610 590 605 615 595]\n",
      "niezgodny (ms): [610 645 605 680 675 595 725 735]\n",
      "różnica (niezgodny - zgodny): [ 30  45 -15  70  85 -10 110 140]\n"
     ]
    }
   ],
   "source": [
    "zgodny_ms = np.array([580, 600, 620, 610, 590, 605, 615, 595])\n",
    "niezgodny_ms = np.array([610, 645, 605, 680, 675, 595, 725, 735])\n",
    "\n",
    "roznica = niezgodny_ms - zgodny_ms\n",
    "\n",
    "print(\"zgodny (ms):\", zgodny_ms)\n",
    "print(\"niezgodny (ms):\", niezgodny_ms)\n",
    "print(\"różnica (niezgodny - zgodny):\", roznica)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "aab4b2a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>zgodny_ms</th>\n",
       "      <th>niezgodny_ms</th>\n",
       "      <th>różnica_ms</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>580</td>\n",
       "      <td>610</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>600</td>\n",
       "      <td>645</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>620</td>\n",
       "      <td>605</td>\n",
       "      <td>-15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>610</td>\n",
       "      <td>680</td>\n",
       "      <td>70</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>590</td>\n",
       "      <td>675</td>\n",
       "      <td>85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>605</td>\n",
       "      <td>595</td>\n",
       "      <td>-10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>615</td>\n",
       "      <td>725</td>\n",
       "      <td>110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>595</td>\n",
       "      <td>735</td>\n",
       "      <td>140</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   zgodny_ms  niezgodny_ms  różnica_ms\n",
       "0        580           610          30\n",
       "1        600           645          45\n",
       "2        620           605         -15\n",
       "3        610           680          70\n",
       "4        590           675          85\n",
       "5        605           595         -10\n",
       "6        615           725         110\n",
       "7        595           735         140"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_pomiary = pd.DataFrame(\n",
    "    {\n",
    "        \"zgodny_ms\": zgodny_ms,\n",
    "        \"niezgodny_ms\": niezgodny_ms,\n",
    "        \"różnica_ms\": roznica,\n",
    "    }\n",
    ")\n",
    "df_pomiary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0c9d4d07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 4))\n",
    "plt.hist(roznica, bins=8, color=\"lightgrey\", edgecolor=\"white\")\n",
    "plt.title(\"Histogram różnic czasu reakcji (niezgodny − zgodny)\")\n",
    "plt.xlabel(\"różnica czasu reakcji (ms)\")\n",
    "plt.ylabel(\"liczba osób\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "f8a9b2fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5, 5))\n",
    "stats.probplot(roznica, dist=\"norm\", plot=plt)\n",
    "plt.title(\"Wykres Q–Q dla różnic czasu reakcji\")\n",
    "plt.xlabel(\"kwantyle teoretyczne (normalne)\")\n",
    "plt.ylabel(\"kwantyle empiryczne (różnice)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3c78d63",
   "metadata": {},
   "source": [
    "Przyjmijmy, że nie możemy (albo nie chcemy) zakładać, że różnice czasu reakcji mają rozkład normalny.\n",
    "\n",
    "Jeśli efekt Stroopa nie istnieje, to (upraszczając) oczekujemy, że dodatnie i ujemne różnice będą się równoważyć. Mówiąc precyzyjniej:\n",
    "\n",
    "- $H_0$: różnice są **symetrycznie rozłożone wokół zera**,\n",
    "- $H_A$: różnice **nie są** symetrycznie rozłożone wokół zera.\n",
    "\n",
    "W naszej historii interesuje nas hipoteza kierunkowa: warunek niezgodny **spowalnia**, czyli $\\text{niezgodny} - \\text{zgodny} > 0$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c171e08",
   "metadata": {},
   "source": [
    "#### Ustalamy hipotezy i poziom istotności\n",
    "\n",
    "Historia → pytanie:\n",
    "\n",
    "- Czy w zadaniu Stroopa warunek **niezgodny** wydłuża czas reakcji?\n",
    "\n",
    "Hipotezy (kierunkowość):\n",
    "\n",
    "- $H_0$: rozkład różnic (niezgodny − zgodny) jest symetryczny wokół $0$,\n",
    "- $H_A$: różnice są przesunięte w stronę wartości dodatnich (czyli \"częściej\" niezgodny − zgodny $> 0$).\n",
    "\n",
    "Poziom istotności: przyjmijmy $α = 0.05$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "2c8fdd0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = 0.05\n",
    "alpha"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb35a778",
   "metadata": {},
   "source": [
    "#### Statystyka i rozkład pod $H_0$\n",
    "\n",
    "Test Wilcoxona dla prób zależnych opiera się na **rangach wartości bezwzględnych różnic**.\n",
    "\n",
    "Kroki (intuicyjnie):\n",
    "\n",
    "1) usuwamy różnice równe 0,\n",
    "2) sortujemy różnice po $|d_i|$ i nadajemy rangi $1,2,\\dots,n$,\n",
    "3) bierzemy sumę rang tych obserwacji, które mają dodatni znak.\n",
    "\n",
    "Nazwijmy tę sumę $V$.\n",
    "\n",
    "Jeśli $H_0$ jest prawdziwe (symetria) znaki $+/-$ są w uproszczeniu \"losowe\" (każda konfiguracja znaków jest równie prawdopodobna), więc możemy wyprowadzić rozkład $V$ przez proste zliczanie.\n",
    "\n",
    "Ponieważ interesują nas dodatnie różnice, test jest **prawostronny**: duże $V$ wspierają $H_A$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2d0b6a6",
   "metadata": {},
   "source": [
    "#### Krok 0: usuń różnice równe 0\n",
    "\n",
    "W naszej próbie nie ma zer, ale w teście Wilcoxona trzeba je usuwać.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1f6f20a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30,  45, -15,  70,  85, -10, 110, 140])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roznica_niezerowa = roznica[roznica != 0]\n",
    "roznica_niezerowa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2cb8f67",
   "metadata": {},
   "source": [
    "#### Krok 1: sortujemy po $|d_i|$, nadajemy znaki i rangi\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "e57d1f6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>różnica</th>\n",
       "      <th>|różnica|</th>\n",
       "      <th>sgn</th>\n",
       "      <th>ranga</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-10</td>\n",
       "      <td>10</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-15</td>\n",
       "      <td>15</td>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>30</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>45</td>\n",
       "      <td>45</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>70</td>\n",
       "      <td>70</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>85</td>\n",
       "      <td>85</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>110</td>\n",
       "      <td>110</td>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>140</td>\n",
       "      <td>140</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   różnica  |różnica|  sgn  ranga\n",
       "0      -10         10   -1      1\n",
       "1      -15         15   -1      2\n",
       "2       30         30    1      3\n",
       "3       45         45    1      4\n",
       "4       70         70    1      5\n",
       "5       85         85    1      6\n",
       "6      110        110    1      7\n",
       "7      140        140    1      8"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "order = np.argsort(np.abs(roznica_niezerowa))\n",
    "sorted_roznica = roznica_niezerowa[order]\n",
    "\n",
    "sgn_roznica = np.where(sorted_roznica > 0, 1, -1)\n",
    "ranks = np.arange(1, len(sorted_roznica) + 1)\n",
    "\n",
    "df_rangi = pd.DataFrame(\n",
    "    {\n",
    "        \"różnica\": sorted_roznica,\n",
    "        \"|różnica|\": np.abs(sorted_roznica),\n",
    "        \"sgn\": sgn_roznica,\n",
    "        \"ranga\": ranks,\n",
    "    }\n",
    ")\n",
    "df_rangi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a2b3d1f",
   "metadata": {},
   "source": [
    "#### Krok 2: statystyka testowa $V$\n",
    "\n",
    "Statystyką testową (nazwijmy ją $V$) będzie suma rang tych obserwacji, dla których znak jest dodatni:\n",
    "\n",
    "$$\n",
    "V = \\sum_{i: d_i>0} r_i.\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4d9bde15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V = int((df_rangi.loc[df_rangi[\"sgn\"] > 0, \"ranga\"]).sum())\n",
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c6f2dbd",
   "metadata": {},
   "source": [
    "#### p-wartość \"na piechotę\": rozkład $V$ przez zliczanie\n",
    "\n",
    "Dla małych prób możemy policzyć p-wartość dokładnie:\n",
    "\n",
    "- pod $H_0$ każdy z $n$ znaków jest (w uproszczeniu) losowy,\n",
    "- mamy więc $2^n$ możliwych konfiguracji,\n",
    "- dla każdej liczymy $V$ i zliczamy, jak często $V$ jest co najmniej tak duże jak obserwowane.\n",
    "\n",
    "Definicja p-wartości w tym teście (prawy ogon):\n",
    "\n",
    "$$\n",
    "p = P(V \\ge V_{\\mathrm{obs}} \\mid H_0).\n",
    "$$\n",
    "\n",
    "Poniższe funkcje są dodatkiem dydaktycznym: w zwykłej analizie użyjemy `scipy.stats.wilcoxon`, ale tutaj jawnie budujemy rozkład $V$, żeby zobaczyć, skąd bierze się dokładna p-wartość.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "a32f44e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def wilcoxon_v_distribution(n: int) -> dict[int, float]:\n",
    "    \"\"\"Zwraca rozkład V (prawdopodobieństwa) dla rang 1..n.\n",
    "\n",
    "    Zakładamy brak remisów w |różnicach| i symetrię pod H0.\n",
    "    Dla n=8 mamy tylko 2^8 = 256 konfiguracji, więc liczymy dokładnie.\n",
    "    \"\"\"\n",
    "\n",
    "    ranks = np.arange(1, n + 1)\n",
    "    counts: dict[int, int] = {}\n",
    "\n",
    "    for signs in itertools.product([0, 1], repeat=n):\n",
    "        v = int(ranks[np.array(signs, dtype=bool)].sum())\n",
    "        counts[v] = counts.get(v, 0) + 1\n",
    "\n",
    "    total = 2**n\n",
    "    return {v: c / total for v, c in sorted(counts.items())}\n",
    "\n",
    "\n",
    "def right_tail_p_value(dist: dict[int, float], v_obs: int) -> float:\n",
    "    \"\"\"P(V >= v_obs) dla zadanego rozkładu dyskretnego.\"\"\"\n",
    "\n",
    "    return float(sum(p for v, p in dist.items() if v >= v_obs))\n",
    "\n",
    "\n",
    "def right_tail_critical_value(dist: dict[int, float], alpha: float) -> int:\n",
    "    \"\"\"Najmniejsza wartość c taka, że P(V >= c) <= alpha.\"\"\"\n",
    "\n",
    "    values = sorted(dist)\n",
    "    for c in values:\n",
    "        if right_tail_p_value(dist, c) <= alpha:\n",
    "            return c\n",
    "    return values[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6f0b6d2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 8\n",
      "V_obs = 33\n",
      "V_crit (prawy ogon, alpha=0.05) = 31\n",
      "p-value (dokładnie, zliczanie) = 0.01953125\n"
     ]
    }
   ],
   "source": [
    "n = len(roznica_niezerowa)\n",
    "dist_V = wilcoxon_v_distribution(n)\n",
    "\n",
    "p_manual = right_tail_p_value(dist_V, V)\n",
    "V_crit = right_tail_critical_value(dist_V, alpha=alpha)\n",
    "\n",
    "print(\"n =\", n)\n",
    "print(\"V_obs =\", V)\n",
    "print(\"V_crit (prawy ogon, alpha=0.05) =\", V_crit)\n",
    "print(\"p-value (dokładnie, zliczanie) =\", p_manual)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb5dc09",
   "metadata": {},
   "source": [
    "#### Widżet: intuicja permutacyjna (sign-flip) dla Wilcoxona\n",
    "\n",
    "W teście Wilcoxona dla prób zależnych pod $H_0$ znaki różnic możemy myśleć jako \"losowe\" (dodatni/ujemny z podobnym prawdopodobieństwem). To prowadzi do intuicji permutacyjnej: \"co się dzieje ze statystyką $V$, gdy losowo odwracamy znaki?\"\n",
    "\n",
    "Poniżej symulujemy wiele takich losowych \"odwróceń znaków\" i dostajemy przybliżenie p-wartości."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "665ff260",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cac7e8ea35b649cea7701672ac117603",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntSlider(value=5000, continuous_update=False, description='perm', max=100000, min=200, step=20…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45b5d9b46d6643b99bcf723cbb7f7be8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not WIDGETY_DOSTEPNE:\n",
    "    print(\"Widżety nie są dostępne. Jeśli pracujesz w Jupyterze, doinstaluj pakiet ipywidgets.\")\n",
    "else:\n",
    "    n_perm_slider = widgets.IntSlider(value=5000, min=200, max=100000, step=200, description=\"perm\", continuous_update=False)\n",
    "    test_dropdown = widgets.Dropdown(\n",
    "        options=[(\"Jednostronny (prawy ogon)\", \"greater\"), (\"Dwustronny\", \"two-sided\")],\n",
    "        value=\"greater\",\n",
    "        description=\"Test\",\n",
    "    )\n",
    "    seed_input = widgets.IntText(value=SEED, description=\"ziarno\")\n",
    "\n",
    "    def pokaz_wilcoxon_permutacje(n_perm, test, seed):\n",
    "        n_perm = int(n_perm)\n",
    "        rng_local = np.random.default_rng(int(seed))\n",
    "\n",
    "        roznica = niezgodny_ms - zgodny_ms\n",
    "        roznica_niezerowa = roznica[roznica != 0]\n",
    "        order = np.argsort(np.abs(roznica_niezerowa))\n",
    "        sorted_roznica = roznica_niezerowa[order]\n",
    "\n",
    "        ranks = np.arange(1, len(sorted_roznica) + 1)\n",
    "        sgn = np.where(sorted_roznica > 0, 1, -1)\n",
    "        V_obs = int(ranks[sgn > 0].sum())\n",
    "        v_max = int(ranks.sum())\n",
    "\n",
    "        signs = rng_local.integers(0, 2, size=(n_perm, len(ranks)))\n",
    "        V_sim = (signs * ranks).sum(axis=1)\n",
    "\n",
    "        if test == \"greater\":\n",
    "            p_sim = float(np.mean(V_sim >= V_obs))\n",
    "        else:\n",
    "            left = float(np.mean(V_sim <= V_obs))\n",
    "            right = float(np.mean(V_sim >= V_obs))\n",
    "            p_sim = min(float(2 * min(left, right)), 1.0)\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=(8, 3.8))\n",
    "        ax.hist(V_sim, bins=np.arange(-0.5, v_max + 1.5, 1), color=\"lightgrey\", edgecolor=\"white\", density=True)\n",
    "        ax.axvline(V_obs, color=\"black\", linestyle=\"--\", linewidth=2, label=\"$V_{obs}$\")\n",
    "        ax.set_xlim(-0.5, v_max + 0.5)\n",
    "        ax.set_title(\"Rozkład V przy losowym odwracaniu znaków ($H_0$)\")\n",
    "        ax.set_xlabel(\"V\")\n",
    "        ax.set_ylabel(\"gęstość (przybliżenie)\")\n",
    "        ax.legend()\n",
    "        ax.text(\n",
    "            0.98,\n",
    "            0.95,\n",
    "            f\"V_obs = {V_obs}\\np ≈ {p_sim:.4f}\\nperm = {n_perm}\",\n",
    "            transform=ax.transAxes,\n",
    "            va=\"top\",\n",
    "            ha=\"right\",\n",
    "            fontsize=10,\n",
    "            bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.88},\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    out = widgets.interactive_output(\n",
    "        pokaz_wilcoxon_permutacje,\n",
    "        {\"n_perm\": n_perm_slider, \"test\": test_dropdown, \"seed\": seed_input},\n",
    "    )\n",
    "\n",
    "    display(widgets.HBox([n_perm_slider, test_dropdown, seed_input]), out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cbd6c3b",
   "metadata": {},
   "source": [
    "#### Weryfikacja funkcją\n",
    "\n",
    "W `scipy` możemy policzyć dokładnie to samo (dla małych prób wybieramy metodę `exact`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e09d9c4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "WilcoxonResult(statistic=np.float64(33.0), pvalue=np.float64(0.01953125))"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_wilcoxon = stats.wilcoxon(\n",
    "    niezgodny_ms,\n",
    "    zgodny_ms,\n",
    "    alternative=\"greater\",\n",
    "    method=\"exact\",\n",
    ")\n",
    "res_wilcoxon"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d8a7f23",
   "metadata": {},
   "source": [
    "#### Interpretacja i efekt\n",
    "\n",
    "P-wartość mówi, jak rzadki byłby wynik co najmniej tak skrajny jak obserwowany, **gdyby $H_0$ była prawdziwa**.\n",
    "\n",
    "Dlatego obok p-wartości podajemy prosty opis efektu i niepewności. W tym przykładzie policzymy:\n",
    "\n",
    "- **medianę różnic** (w ms) i bootstrapowy 95% przedział ufności,\n",
    "- **korelację rangowo-dwuseryjną** $r_{rb}$ (ang. *rank-biserial*), która dla tego testu ma postać:\n",
    "\n",
    "$$\n",
    "r_{rb} = \\frac{W_+ - W_-}{W_+ + W_-} = \\frac{2V - \\sum_{i=1}^n i}{\\sum_{i=1}^n i}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a6cbab4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mediana różnic: 57.5\n",
      "Bootstrapowy 95% przedział ufności dla mediany: [-10.0, 110.0]\n",
      "Rank-biserial r_rb: 0.833\n"
     ]
    }
   ],
   "source": [
    "median_diff = float(np.median(roznica_niezerowa))\n",
    "\n",
    "total_rank_sum = n * (n + 1) / 2\n",
    "rank_biserial = float((2 * V - total_rank_sum) / total_rank_sum)\n",
    "\n",
    "n_boot = 10_000\n",
    "boot_sample = rng.choice(roznica_niezerowa, size=(n_boot, n), replace=True)\n",
    "boot_medians = np.median(boot_sample, axis=1)\n",
    "ci_low, ci_high = np.quantile(boot_medians, [0.025, 0.975])\n",
    "\n",
    "print(f\"Mediana różnic: {median_diff:.1f}\")\n",
    "print(f\"Bootstrapowy 95% przedział ufności dla mediany: [{ci_low:.1f}, {ci_high:.1f}]\")\n",
    "print(f\"Rank-biserial r_rb: {rank_biserial:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c25c6d0",
   "metadata": {},
   "source": [
    "**Uwaga.** W literaturze spotkasz się z nieco innym zapisem statystyki testowej (często oznaczanym jako $W$).\n",
    "\n",
    "Są to warianty tej samej idei: pracujemy na rangach $|d_i|$ i sprawdzamy, czy \"dodatnie\" rangi przeważają.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2efc5d19",
   "metadata": {},
   "source": [
    "### Test U Manna–Whitneya (próby niezależne)\n",
    "\n",
    "Teraz przejdźmy do schematu **międzyosobniczego**: dwie niezależne grupy.\n",
    "\n",
    "Przykład kognitywistyczny: interesuje nas, czy **niewyspanie** spowalnia reakcje w prostym zadaniu (np. naciśnij klawisz, gdy pojawi się bodziec).\n",
    "\n",
    "Porównamy czasy reakcji (ms) w dwóch grupach po 6 osób: **wyspani** vs **niewyspani**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "62f152f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>czas_ms</th>\n",
       "      <th>grupa</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>320</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>340</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>360</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>380</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>400</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>420</td>\n",
       "      <td>wyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>350</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>370</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>390</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>410</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>430</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>450</td>\n",
       "      <td>niewyspany</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    czas_ms       grupa\n",
       "0       320     wyspany\n",
       "1       340     wyspany\n",
       "2       360     wyspany\n",
       "3       380     wyspany\n",
       "4       400     wyspany\n",
       "5       420     wyspany\n",
       "6       350  niewyspany\n",
       "7       370  niewyspany\n",
       "8       390  niewyspany\n",
       "9       410  niewyspany\n",
       "10      430  niewyspany\n",
       "11      450  niewyspany"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wyspany_ms = np.array([320, 340, 360, 380, 400, 420])\n",
    "niewyspany_ms = np.array([350, 370, 390, 410, 430, 450])\n",
    "\n",
    "data_ex = pd.DataFrame(\n",
    "    {\n",
    "        \"czas_ms\": np.concatenate([wyspany_ms, niewyspany_ms]),\n",
    "        \"grupa\": [\"wyspany\"] * len(wyspany_ms) + [\"niewyspany\"] * len(niewyspany_ms),\n",
    "    }\n",
    ")\n",
    "data_ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "8c8f6e41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 840x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7, 4))\n",
    "sns.boxplot(data=data_ex, x=\"grupa\", y=\"czas_ms\", color=\"lightgrey\")\n",
    "sns.stripplot(data=data_ex, x=\"grupa\", y=\"czas_ms\", color=\"black\", jitter=0.1)\n",
    "plt.title(\"Czas reakcji (ms): wyspani vs niewyspani\")\n",
    "plt.xlabel(\"grupa\")\n",
    "plt.ylabel(\"czas reakcji (ms)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d5110e",
   "metadata": {},
   "source": [
    "#### Hipotezy i poziom istotności\n",
    "\n",
    "Pytanie:\n",
    "\n",
    "- Czy osoby niewyspane mają (typowo) **dłuższe** czasy reakcji niż osoby wyspane?\n",
    "\n",
    "Hipotezy (kierunkowość):\n",
    "\n",
    "- $H_0$: rozkłady w obu grupach są takie same,\n",
    "- $H_A$: wartości w grupie niewyspanej są większe (przesunięcie w górę).\n",
    "\n",
    "Przyjmijmy znów $α = 0.05$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "eaf9d6c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = 0.05\n",
    "alpha"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "610a4ce8",
   "metadata": {},
   "source": [
    "#### Statystyka testowa $U$\n",
    "\n",
    "Łączymy wszystkie obserwacje, zamieniamy je na rangi i liczymy sumę rang w grupie.\n",
    "\n",
    "Dla dwóch grup o liczebnościach $n_1$ i $n_2$:\n",
    "\n",
    "- $R_1$ = suma rang w grupie 1,\n",
    "- $U_1 = R_1 - \\frac{n_1(n_1+1)}{2}$.\n",
    "\n",
    "Intuicja: jeśli grupa 1 ma większe wartości, to jej obserwacje będą mieć większe rangi, więc $U_1$ będzie duże.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "f8b2da8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_niewyspany = 6\n",
      "n_wyspany    = 6\n",
      "Suma rang (niewyspany) R = 47.0\n",
      "U (niewyspany) = 26.0\n"
     ]
    }
   ],
   "source": [
    "values = data_ex[\"czas_ms\"].to_numpy()\n",
    "ranks_all = stats.rankdata(values)\n",
    "\n",
    "n1 = len(niewyspany_ms)\n",
    "n2 = len(wyspany_ms)\n",
    "\n",
    "mask_niewyspany = data_ex[\"grupa\"].to_numpy() == \"niewyspany\"\n",
    "R_niewyspany = float(ranks_all[mask_niewyspany].sum())\n",
    "U_niewyspany = R_niewyspany - n1 * (n1 + 1) / 2\n",
    "\n",
    "print(\"n_niewyspany =\", n1)\n",
    "print(\"n_wyspany    =\", n2)\n",
    "print(\"Suma rang (niewyspany) R =\", R_niewyspany)\n",
    "print(\"U (niewyspany) =\", float(U_niewyspany))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d52d3aa2",
   "metadata": {},
   "source": [
    "#### Rozkład $U$ pod $H_0$ i p-wartość \"na piechotę\"\n",
    "\n",
    "Pod $H_0$ etykiety grup są wymienne: gdyby nie było różnic, to dowolny podział rang na dwie grupy tej samej wielkości byłby równie prawdopodobny.\n",
    "\n",
    "Dla małych prób możemy policzyć rozkład $U$ przez enumerację wszystkich podziałów rang (tu: $\\binom{12}{6}=924$ możliwości).\n",
    "\n",
    "Dla testu prawostronnego (niewyspani „więksi”):\n",
    "\n",
    "$$\n",
    "p = P(U \\ge U_{\\mathrm{obs}} \\mid H_0).\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5c0f775a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U_obs = 26\n",
      "U_crit (prawy ogon, alpha=0.05) = 29\n",
      "p-value (dokładnie, zliczanie) = 0.12012987012987013\n"
     ]
    }
   ],
   "source": [
    "def mann_whitney_u_distribution(n1: int, n2: int) -> dict[int, float]:\n",
    "    \"\"\"Dokładny rozkład U dla rang 1..(n1+n2), bez remisów.\n",
    "\n",
    "    Liczymy wszystkie kombinacje wyboru rang dla grupy 1.\n",
    "    \"\"\"\n",
    "\n",
    "    n_total = n1 + n2\n",
    "    all_ranks = np.arange(1, n_total + 1)\n",
    "    counts: dict[int, int] = {}\n",
    "\n",
    "    for ranks_group1 in itertools.combinations(all_ranks, n1):\n",
    "        R1 = sum(ranks_group1)\n",
    "        U1 = int(R1 - n1 * (n1 + 1) / 2)\n",
    "        counts[U1] = counts.get(U1, 0) + 1\n",
    "\n",
    "    total = math.comb(n_total, n1)\n",
    "    return {u: c / total for u, c in sorted(counts.items())}\n",
    "\n",
    "\n",
    "dist_U = mann_whitney_u_distribution(n1=n1, n2=n2)\n",
    "U_obs = int(U_niewyspany)\n",
    "p_u_manual = float(sum(p for u, p in dist_U.items() if u >= U_obs))\n",
    "\n",
    "U_crit = None\n",
    "for u in sorted(dist_U):\n",
    "    if sum(p for uu, p in dist_U.items() if uu >= u) <= alpha:\n",
    "        U_crit = u\n",
    "        break\n",
    "\n",
    "print(\"U_obs =\", U_obs)\n",
    "print(\"U_crit (prawy ogon, alpha=0.05) =\", U_crit)\n",
    "print(\"p-value (dokładnie, zliczanie) =\", p_u_manual)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215bb2c8",
   "metadata": {},
   "source": [
    "#### Weryfikacja funkcją\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "f0f16b0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MannwhitneyuResult(statistic=np.float64(26.0), pvalue=np.float64(0.12012987012987013))"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_mwu = stats.mannwhitneyu(\n",
    "    niewyspany_ms,\n",
    "    wyspany_ms,\n",
    "    alternative=\"greater\",\n",
    "    method=\"exact\",\n",
    ")\n",
    "res_mwu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a5f8a42",
   "metadata": {},
   "source": [
    "#### Interpretacja i efekt\n",
    "\n",
    "Jeśli p-wartość jest mała, to przy $H_0$ taki (albo bardziej skrajny) układ rang zdarzałby się rzadko.\n",
    "\n",
    "Jako prostą miarę efektu możemy użyć **prawdopodobieństwa przewagi** (tzw. miary wspólnojęzykowej):\n",
    "\n",
    "$$\n",
    "\\hat{p} = P(X>Y) + \\frac{1}{2}P(X=Y) = \\frac{U}{n_1 n_2},\n",
    "$$\n",
    "\n",
    "gdzie $X$ to losowa obserwacja z grupy **niewyspanej**, a $Y$ z grupy **wyspanej**.\n",
    "\n",
    "Policzmy też bootstrapowy 95% przedział ufności dla tej miary.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "f6cebd0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prawdopodobieństwo przewagi (U/(n1*n2)): 0.722\n",
      "Bootstrapowy 95% przedział ufności: [0.389, 0.972]\n"
     ]
    }
   ],
   "source": [
    "p_przewagi = float(U_obs / (n1 * n2))\n",
    "\n",
    "n_boot = 5_000\n",
    "boot_niewyspany = rng.choice(niewyspany_ms, size=(n_boot, n1), replace=True)\n",
    "boot_wyspany = rng.choice(wyspany_ms, size=(n_boot, n2), replace=True)\n",
    "\n",
    "boot_u = []\n",
    "for i in range(n_boot):\n",
    "    u = stats.mannwhitneyu(\n",
    "        boot_niewyspany[i],\n",
    "        boot_wyspany[i],\n",
    "        alternative=\"greater\",\n",
    "        method=\"exact\",\n",
    "    ).statistic\n",
    "    boot_u.append(float(u))\n",
    "\n",
    "boot_u = np.array(boot_u)\n",
    "boot_p = boot_u / (n1 * n2)\n",
    "ci_low, ci_high = np.quantile(boot_p, [0.025, 0.975])\n",
    "\n",
    "print(f\"Prawdopodobieństwo przewagi (U/(n1*n2)): {p_przewagi:.3f}\")\n",
    "print(f\"Bootstrapowy 95% przedział ufności: [{ci_low:.3f}, {ci_high:.3f}]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96b6bde9",
   "metadata": {},
   "source": [
    "#### Widżet: \"Mann–Whitney to nie test median\"\n",
    "\n",
    "Częsty skrót myślowy brzmi: \"test Manna–Whitneya porównuje mediany\". To **nie jest ogólnie prawda**.\n",
    "\n",
    "W uproszczeniu test odpowiada na pytanie o **porządek stochastyczny** (czy wartości z jednej grupy mają tendencję do bycia większymi niż z drugiej), a nie wyłącznie o medianę.\n",
    "\n",
    "Poniżej możesz generować różne scenariusze i porównać: mediany oraz p-wartość testu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5e9a1ab0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a3d9447188d4ec28f9050ca57c4a9de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(Dropdown(description='scenariusz', options=(('Przesunięcie (inna lokalizacja)', …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d562036a1f674655b13912684c8d30e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not WIDGETY_DOSTEPNE:\n",
    "    print(\"Widżety nie są dostępne. Jeśli pracujesz w Jupyterze, doinstaluj pakiet ipywidgets.\")\n",
    "else:\n",
    "    scenario = widgets.Dropdown(\n",
    "        options=[\n",
    "            (\"Przesunięcie (inna lokalizacja)\", \"shift\"),\n",
    "            (\"Te same mediany, ale skośność\", \"skew\"),\n",
    "            (\"Te same mediany, ale pojedyncza obserwacja odstająca\", \"outlier\"),\n",
    "        ],\n",
    "        value=\"shift\",\n",
    "        description=\"scenariusz\",\n",
    "    )\n",
    "\n",
    "    n_slider = widgets.IntSlider(value=30, min=10, max=200, step=5, description=\"n\", continuous_update=False)\n",
    "    delta_slider = widgets.FloatSlider(value=0.5, min=0.0, max=2.0, step=0.1, description=\"Δ\", readout_format=\".1f\", continuous_update=False)\n",
    "    skew_slider = widgets.FloatSlider(value=1.0, min=0.2, max=2.0, step=0.1, description=\"skośność\", readout_format=\".1f\", continuous_update=False)\n",
    "    outlier_slider = widgets.FloatSlider(value=4.0, min=0.0, max=10.0, step=0.5, description=\"odstająca\", readout_format=\".1f\", continuous_update=False)\n",
    "    seed_input = widgets.IntText(value=SEED, description=\"ziarno\")\n",
    "\n",
    "    def generuj_dane(scenario, n, delta, skew, outlier, seed):\n",
    "        rng_local = np.random.default_rng(int(seed))\n",
    "        n = int(n)\n",
    "        delta = float(delta)\n",
    "        skew = float(skew)\n",
    "        outlier = float(outlier)\n",
    "\n",
    "        if scenario == \"shift\":\n",
    "            a = rng_local.normal(loc=0.0, scale=1.0, size=n)\n",
    "            b = rng_local.normal(loc=delta, scale=1.0, size=n)\n",
    "        elif scenario == \"skew\":\n",
    "            a = rng_local.normal(loc=0.0, scale=1.0, size=n)\n",
    "            b = rng_local.lognormal(mean=0.0, sigma=skew, size=n) - 1.0\n",
    "        else:\n",
    "            a = rng_local.normal(loc=0.0, scale=1.0, size=n)\n",
    "            b = rng_local.normal(loc=0.0, scale=1.0, size=n)\n",
    "            b = b.copy()\n",
    "            b[0] = b[0] + outlier\n",
    "\n",
    "        return a, b\n",
    "\n",
    "    def pokaz_mwu_vs_mediana(scenario, n, delta, skew, outlier, seed):\n",
    "        a, b = generuj_dane(scenario, n, delta, skew, outlier, seed)\n",
    "\n",
    "        med_a = float(np.median(a))\n",
    "        med_b = float(np.median(b))\n",
    "        res = stats.mannwhitneyu(a, b, alternative=\"two-sided\", method=\"asymptotic\")\n",
    "        p = float(res.pvalue)\n",
    "        U = float(res.statistic)\n",
    "        p_przewagi = float(U / (len(a) * len(b)))\n",
    "\n",
    "        df = pd.DataFrame({\"wartość\": np.concatenate([a, b]), \"grupa\": [\"A\"] * len(a) + [\"B\"] * len(b)})\n",
    "        fig, ax = plt.subplots(figsize=(8, 4.8))\n",
    "        sns.boxplot(data=df, x=\"grupa\", y=\"wartość\", color=\"lightgrey\", ax=ax)\n",
    "        sns.stripplot(data=df, x=\"grupa\", y=\"wartość\", color=\"black\", jitter=0.15, size=3, ax=ax)\n",
    "        ax.set_ylim(-4, 14)\n",
    "        ax.set_title(\"Porównanie rozkładów (syntetyczne dane)\")\n",
    "        ax.set_xlabel(\"grupa\")\n",
    "        ax.set_ylabel(\"wartość\")\n",
    "        ax.text(\n",
    "            0.98,\n",
    "            0.98,\n",
    "            \"\\n\".join(\n",
    "                [\n",
    "                    f\"mediana A = {med_a:.2f}\",\n",
    "                    f\"mediana B = {med_b:.2f}\",\n",
    "                    f\"p M-W = {p:.4f}\",\n",
    "                    f\"P(A>B) ≈ {p_przewagi:.2f}\",\n",
    "                ]\n",
    "            ),\n",
    "            transform=ax.transAxes,\n",
    "            va=\"top\",\n",
    "            ha=\"right\",\n",
    "            fontsize=10,\n",
    "            bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.88},\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    out = widgets.interactive_output(\n",
    "        pokaz_mwu_vs_mediana,\n",
    "        {\n",
    "            \"scenario\": scenario,\n",
    "            \"n\": n_slider,\n",
    "            \"delta\": delta_slider,\n",
    "            \"skew\": skew_slider,\n",
    "            \"outlier\": outlier_slider,\n",
    "            \"seed\": seed_input,\n",
    "        },\n",
    "    )\n",
    "\n",
    "    controls = widgets.VBox(\n",
    "        [\n",
    "            widgets.HBox([scenario, n_slider, seed_input]),\n",
    "            delta_slider,\n",
    "            skew_slider,\n",
    "            outlier_slider,\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    display(controls, out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea1f4e2d",
   "metadata": {},
   "source": [
    "## Zgodność koderów\n",
    "\n",
    "W badaniach kognitywistycznych często prosimy koderów o ręczne oznaczanie odpowiedzi (np. typu błędu, kategorii reakcji, strategii). Poniżej zobaczymy, jak mierzyć zgodność **ponad przypadek**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c25ecdd1",
   "metadata": {},
   "source": [
    "### Kappa Cohena\n",
    "\n",
    "Załóżmy, że poprosiliśmy sędziego ze znacznym doświadczeniem klinicznym o przeprowadzenie wywiadów z 30 nastolatkami i zakwalifikowanie każdego z nich jako przejawiających:\n",
    "\n",
    "1) brak problemów behawioralnych,\n",
    "2) internalizację problemów behawioralnych,\n",
    "3) eksternalizację problemów behawioralnych.\n",
    "\n",
    "Gdyby ktoś recenzował naszą pracę, to naturalne pytanie brzmi: skąd wiemy, że sędzia jest w tym co robi lepszy, niż gdyby po prostu zgadywał?\n",
    "\n",
    "Aby to sprawdzić, prosimy drugiego sędziego o niezależną klasyfikację tych samych przypadków i tworzymy tabelę krzyżową.\n",
    "\n",
    "Uwaga: sama \"procentowa zgoda\" bywa myląca, bo część zgodności może wynikać z przypadku (np. gdy jedna kategoria jest bardzo częsta).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "0d6c2604",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>obserwacja</th>\n",
       "      <th>koder_1</th>\n",
       "      <th>koder_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   obserwacja   koder_1   koder_2\n",
       "0           1  poprawna  poprawna\n",
       "1           2  poprawna  poprawna\n",
       "2           3  poprawna  poprawna\n",
       "3           4  poprawna  poprawna\n",
       "4           5  poprawna  poprawna"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koder_1 = (\n",
    "    [\"poprawna\"] * 15\n",
    "    + [\"błąd słowa\"] * 2\n",
    "    + [\"błąd koloru\"] * 3\n",
    "    + [\"poprawna\"] * 1\n",
    "    + [\"błąd słowa\"] * 3\n",
    "    + [\"błąd koloru\"] * 2\n",
    "    + [\"błąd słowa\"] * 1\n",
    "    + [\"błąd koloru\"] * 3\n",
    ")\n",
    "koder_2 = [\"poprawna\"] * 20 + [\"błąd słowa\"] * 6 + [\"błąd koloru\"] * 4\n",
    "\n",
    "kategoryzacja = pd.DataFrame(\n",
    "    {\n",
    "        \"obserwacja\": np.arange(1, 31),\n",
    "        \"koder_1\": koder_1,\n",
    "        \"koder_2\": koder_2,\n",
    "    }\n",
    ")\n",
    "kategoryzacja.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "d4dc6392",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>koder_2</th>\n",
       "      <th>błąd koloru</th>\n",
       "      <th>błąd słowa</th>\n",
       "      <th>poprawna</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>koder_1</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>błąd koloru</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>błąd słowa</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>poprawna</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "koder_2      błąd koloru  błąd słowa  poprawna\n",
       "koder_1                                       \n",
       "błąd koloru            3           2         3\n",
       "błąd słowa             1           3         2\n",
       "poprawna               0           1        15"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tab = pd.crosstab(kategoryzacja[\"koder_1\"], kategoryzacja[\"koder_2\"])\n",
    "tab"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d3a9f79",
   "metadata": {},
   "source": [
    "#### Kappa jako \"zgodność ponad przypadek\"\n",
    "\n",
    "Niech:\n",
    "\n",
    "- $p_o$ = obserwowana zgodność (odsetek przypadków na przekątnej),\n",
    "- $p_e$ = zgodność oczekiwana \"przez przypadek\" (wynikająca z częstości kategorii u obu sędziów).\n",
    "\n",
    "Wtedy:\n",
    "\n",
    "$$\n",
    "\\kappa = \\frac{p_o - p_e}{1 - p_e}.\n",
    "$$\n",
    "\n",
    "To jest miara efektu: im bliżej 1, tym większa zgodność ponad przypadek.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "4aee7e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 30\n",
      "p_o (zgodność obserwowana) = 0.700\n",
      "p_e (zgodność przez przypadek) = 0.431\n",
      "kappa = 0.4727\n"
     ]
    }
   ],
   "source": [
    "n = int(tab.to_numpy().sum())\n",
    "\n",
    "p_o = float(np.trace(tab.to_numpy()) / n)\n",
    "\n",
    "row_marginals = tab.sum(axis=1).to_numpy() / n\n",
    "col_marginals = tab.sum(axis=0).to_numpy() / n\n",
    "p_e = float((row_marginals * col_marginals).sum())\n",
    "\n",
    "kappa_manual = float((p_o - p_e) / (1 - p_e))\n",
    "\n",
    "print(f\"n = {n}\")\n",
    "print(f\"p_o (zgodność obserwowana) = {p_o:.3f}\")\n",
    "print(f\"p_e (zgodność przez przypadek) = {p_e:.3f}\")\n",
    "print(f\"kappa = {kappa_manual:.4f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d74f48bd",
   "metadata": {},
   "source": [
    "#### Test $H_0: \\kappa = 0$ i weryfikacja funkcją\n",
    "\n",
    "Możemy też potraktować $κ jako statystykę testową i sprawdzić, czy jest istotnie większa od 0.\n",
    "\n",
    "Uwaga dydaktyczna: przy większych $n$ nawet mała $κ$ może być \"statystycznie istotna\" — dlatego interpretujemy przede wszystkim wielkość $κ$ (oraz przedział ufności).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "ad330fe6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  Simple Kappa Coefficient\n",
      "              --------------------------------\n",
      "              Kappa                     0.4727\n",
      "              ASE                       0.1304\n",
      "              95% Lower Conf Limit      0.2170\n",
      "              95% Upper Conf Limit      0.7283\n",
      "\n",
      "                 Test of H0: Simple Kappa = 0\n",
      "\n",
      "              ASE under H0              0.1284\n",
      "              Z                         3.6810\n",
      "              One-sided Pr >  Z         0.0001\n",
      "              Two-sided Pr > |Z|        0.0002\n",
      "\n",
      "z (z outputu) = 3.681003969985412\n",
      "p (dwustronnie, z Normalnego) = 0.00023231738731039687\n",
      "p (dwustronnie, statsmodels) = 0.00023231738731039687\n"
     ]
    }
   ],
   "source": [
    "res_kappa = cohens_kappa(tab.to_numpy())\n",
    "print(res_kappa)\n",
    "\n",
    "z_manual = float(res_kappa[\"z_value\"])\n",
    "p_two_sided_manual = float(2 * stats.norm.sf(abs(z_manual)))\n",
    "\n",
    "print(\"z (z outputu) =\", z_manual)\n",
    "print(\"p (dwustronnie, z Normalnego) =\", p_two_sided_manual)\n",
    "print(\"p (dwustronnie, statsmodels) =\", float(res_kappa[\"pvalue_two_sided\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c46a8d47",
   "metadata": {},
   "source": [
    "### Kappa Fleissa\n",
    "\n",
    "A co by się stało, gdybyśmy mieli nie 2, a 3 sędziów?\n",
    "\n",
    "Wtedy zamiast $\\kappa$ Cohena używa się często $\\kappa$ Fleissa — jej interpretacja jest analogiczna: zgoda ponad przypadek.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "d8c5f5e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>koder_1</th>\n",
       "      <th>koder_2</th>\n",
       "      <th>koder_3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "      <td>poprawna</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    koder_1   koder_2   koder_3\n",
       "0  poprawna  poprawna  poprawna\n",
       "1  poprawna  poprawna  poprawna\n",
       "2  poprawna  poprawna  poprawna\n",
       "3  poprawna  poprawna  poprawna\n",
       "4  poprawna  poprawna  poprawna"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koder_3 = [\"poprawna\"] * 17 + [\"błąd słowa\"] * 8 + [\"błąd koloru\"] * 5\n",
    "\n",
    "kategoryzacja2 = pd.DataFrame(\n",
    "    {\n",
    "        \"koder_1\": koder_1,\n",
    "        \"koder_2\": koder_2,\n",
    "        \"koder_3\": koder_3,\n",
    "    }\n",
    ")\n",
    "kategoryzacja2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f59f6f6a",
   "metadata": {},
   "source": [
    "W teście Fleissa potrzebujemy macierzy postaci:\n",
    "\n",
    "- wiersze: przypadki (osoby),\n",
    "- kolumny: kategorie,\n",
    "- wartości: ilu sędziów przypisało dany przypadek do danej kategorii.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "be922c92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>poprawna</th>\n",
       "      <th>błąd słowa</th>\n",
       "      <th>błąd koloru</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   poprawna  błąd słowa  błąd koloru\n",
       "0         3           0            0\n",
       "1         3           0            0\n",
       "2         3           0            0\n",
       "3         3           0            0\n",
       "4         3           0            0"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "categories = [\"poprawna\", \"błąd słowa\", \"błąd koloru\"]\n",
    "\n",
    "counts = []\n",
    "for _, row in kategoryzacja2.iterrows():\n",
    "    row_counts = []\n",
    "    for cat in categories:\n",
    "        row_counts.append(int((row == cat).sum()))\n",
    "    counts.append(row_counts)\n",
    "\n",
    "fleiss_table = np.array(counts)\n",
    "pd.DataFrame(fleiss_table, columns=categories).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33ddc1ac",
   "metadata": {},
   "source": [
    "#### $\\kappa$ Fleissa + bootstrapowy przedział ufności\n",
    "\n",
    "W `statsmodels` możemy policzyć $\\kappa$ Fleissa, a niepewność oszacujemy przez bootstrap (resampling przypadków).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "9cbd16df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fleiss kappa: 0.5893\n",
      "Bootstrapowy 95% przedział ufności: [0.3630, 0.7849]\n"
     ]
    }
   ],
   "source": [
    "kappa_fleiss = float(fleiss_kappa(fleiss_table))\n",
    "\n",
    "n_boot = 5_000\n",
    "boot = rng.choice(np.arange(fleiss_table.shape[0]), size=(n_boot, fleiss_table.shape[0]))\n",
    "\n",
    "boot_kappa = []\n",
    "for idx in boot:\n",
    "    boot_kappa.append(float(fleiss_kappa(fleiss_table[idx])))\n",
    "\n",
    "boot_kappa = np.array(boot_kappa)\n",
    "ci_low, ci_high = np.quantile(boot_kappa, [0.025, 0.975])\n",
    "\n",
    "print(f\"Fleiss kappa: {kappa_fleiss:.4f}\")\n",
    "print(f\"Bootstrapowy 95% przedział ufności: [{ci_low:.4f}, {ci_high:.4f}]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a3dd5a4",
   "metadata": {},
   "source": [
    "#### Widżet: \"paradoks\" kappy (wpływ częstości kategorii)\n",
    "\n",
    "Kappa porównuje zgodność obserwowaną z tą, której oczekiwalibyśmy **przez przypadek** przy danych marginesach. Gdy jedna kategoria jest bardzo częsta (np. prawie same odpowiedzi poprawne), można mieć wysoką zgodność procentową, ale umiarkowaną (a czasem niską) kappę.\n",
    "\n",
    "Poniżej symulujemy prostą sytuację binarną (\"poprawna\" / \"niepoprawna\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "900219cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94bf565c239644cbb0b70248f7e4b133",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntSlider(value=200, continuous_update=False, description='n', max=2000, min=30,…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "99b43ba158b046b9ae5facd7247f7422",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not WIDGETY_DOSTEPNE:\n",
    "    print(\"Widżety nie są dostępne. Jeśli pracujesz w Jupyterze, doinstaluj pakiet ipywidgets.\")\n",
    "else:\n",
    "    n_slider = widgets.IntSlider(value=200, min=30, max=2000, step=10, description=\"n\", continuous_update=False)\n",
    "    prev_slider = widgets.FloatSlider(value=0.90, min=0.05, max=0.99, step=0.01, description=\"częstość poprawnych\", readout_format=\".2f\", continuous_update=False)\n",
    "    err_slider = widgets.FloatSlider(value=0.10, min=0.00, max=0.40, step=0.01, description=\"błąd kodera\", readout_format=\".2f\", continuous_update=False)\n",
    "    seed_input = widgets.IntText(value=SEED, description=\"ziarno\")\n",
    "\n",
    "    def pokaz_kappa_paradoks(n, prev, err, seed):\n",
    "        n = int(n)\n",
    "        prev = float(prev)\n",
    "        err = float(err)\n",
    "        rng_local = np.random.default_rng(int(seed))\n",
    "\n",
    "        prawda = rng_local.random(n) < prev\n",
    "        k1 = prawda.copy()\n",
    "        k2 = prawda.copy()\n",
    "\n",
    "        flip1 = rng_local.random(n) < err\n",
    "        flip2 = rng_local.random(n) < err\n",
    "        k1[flip1] = ~k1[flip1]\n",
    "        k2[flip2] = ~k2[flip2]\n",
    "\n",
    "        tab = pd.crosstab(k1, k2)\n",
    "        tab = tab.reindex(index=[False, True], columns=[False, True], fill_value=0)\n",
    "\n",
    "        counts = tab.to_numpy()\n",
    "        n_total = int(counts.sum())\n",
    "        p_o = float(np.trace(counts) / n_total)\n",
    "\n",
    "        row_marginals = tab.sum(axis=1).to_numpy() / n_total\n",
    "        col_marginals = tab.sum(axis=0).to_numpy() / n_total\n",
    "        p_e = float((row_marginals * col_marginals).sum())\n",
    "\n",
    "        kappa = float((p_o - p_e) / (1 - p_e)) if p_e < 1 else float(\"nan\")\n",
    "        proportions = tab / n_total\n",
    "        labels = np.array([[f\"{counts[i, j]}\\n({proportions.iloc[i, j]:.2f})\" for j in range(2)] for i in range(2)])\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=(6.2, 5))\n",
    "        sns.heatmap(\n",
    "            proportions,\n",
    "            vmin=0,\n",
    "            vmax=1,\n",
    "            cmap=\"cividis\",\n",
    "            annot=labels,\n",
    "            fmt=\"\",\n",
    "            cbar=False,\n",
    "            square=True,\n",
    "            ax=ax,\n",
    "        )\n",
    "        ax.set_xticklabels([\"koder 2: niepoprawna\", \"koder 2: poprawna\"], rotation=20, ha=\"right\")\n",
    "        ax.set_yticklabels([\"koder 1: niepoprawna\", \"koder 1: poprawna\"], rotation=0)\n",
    "        ax.set_title(\"Zgodność koderów: liczebności i proporcje\")\n",
    "        ax.text(\n",
    "            1.04,\n",
    "            0.98,\n",
    "            f\"n = {n_total}\\np_o = {p_o:.3f}\\np_e = {p_e:.3f}\\nκ = {kappa:.3f}\",\n",
    "            transform=ax.transAxes,\n",
    "            va=\"top\",\n",
    "            ha=\"left\",\n",
    "            fontsize=10,\n",
    "            bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.88},\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    out = widgets.interactive_output(\n",
    "        pokaz_kappa_paradoks,\n",
    "        {\"n\": n_slider, \"prev\": prev_slider, \"err\": err_slider, \"seed\": seed_input},\n",
    "    )\n",
    "\n",
    "    controls = widgets.VBox([widgets.HBox([n_slider, seed_input]), prev_slider, err_slider])\n",
    "    display(controls, out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b548b25a",
   "metadata": {},
   "source": [
    "## Nieparametryczna \"analiza wariancji\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b5dfc44",
   "metadata": {},
   "source": [
    "### Test Kruskala–Wallisa\n",
    "\n",
    "Test Kruskala–Wallisa jest nieparametrycznym odpowiednikiem jednoczynnikowej analizy wariancji (ANOVA) dla prób niezależnych.\n",
    "\n",
    "Przykład kognitywistyczny: trzy grupy uczą się listy słów różnymi strategiami, a potem wykonują krótki test pamięci (wynik: liczba poprawnie odtworzonych słów, 0–20).\n",
    "\n",
    "W takich danych często pojawiają się sufity/podłogi i skośność, więc podejście rangowe jest naturalne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "4cb54b9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>wynik</th>\n",
       "      <th>strategia</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>powtarzanie</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>12</td>\n",
       "      <td>powtarzanie</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "      <td>powtarzanie</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>powtarzanie</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8</td>\n",
       "      <td>powtarzanie</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   wynik    strategia\n",
       "0     10  powtarzanie\n",
       "1     12  powtarzanie\n",
       "2      9  powtarzanie\n",
       "3     11  powtarzanie\n",
       "4      8  powtarzanie"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powtarzanie = np.array([10, 12, 9, 11, 8, 13, 12, 10, 9, 11])\n",
    "obrazowanie = np.array([13, 14, 15, 12, 16, 14, 13, 15, 14, 16])\n",
    "odniesienie_do_siebie = np.array([16, 17, 18, 15, 19, 17, 18, 16, 19, 18])\n",
    "\n",
    "df_pamiec = pd.DataFrame(\n",
    "    {\n",
    "        \"wynik\": np.concatenate([powtarzanie, obrazowanie, odniesienie_do_siebie]),\n",
    "        \"strategia\": (\n",
    "            [\"powtarzanie\"] * len(powtarzanie)\n",
    "            + [\"obrazowanie\"] * len(obrazowanie)\n",
    "            + [\"odniesienie do siebie\"] * len(odniesienie_do_siebie)\n",
    "        ),\n",
    "    }\n",
    ")\n",
    "df_pamiec.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "ef0d909e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 4))\n",
    "sns.boxplot(data=df_pamiec, x=\"strategia\", y=\"wynik\", color=\"lightgrey\")\n",
    "sns.stripplot(\n",
    "    data=df_pamiec,\n",
    "    x=\"strategia\",\n",
    "    y=\"wynik\",\n",
    "    color=\"black\",\n",
    "    size=4,\n",
    "    jitter=0.15,\n",
    ")\n",
    "plt.title(\"Wynik testu pamięci po trzech strategiach uczenia\")\n",
    "plt.xlabel(\"strategia\")\n",
    "plt.ylabel(\"liczba poprawnych słów (0–20)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "6da61b3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n</th>\n",
       "      <th>mediana</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>strategia</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>obrazowanie</th>\n",
       "      <td>10</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>odniesienie do siebie</th>\n",
       "      <td>10</td>\n",
       "      <td>17.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>powtarzanie</th>\n",
       "      <td>10</td>\n",
       "      <td>10.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        n  mediana\n",
       "strategia                         \n",
       "obrazowanie            10     14.0\n",
       "odniesienie do siebie  10     17.5\n",
       "powtarzanie            10     10.5"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_pamiec.groupby(\"strategia\").agg(n=(\"wynik\", \"size\"), mediana=(\"wynik\", \"median\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "f3f4f9d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>wynik</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>30.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>14.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.140393</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>8.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>12.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>14.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>16.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>19.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           wynik\n",
       "count  30.000000\n",
       "mean   14.000000\n",
       "std     3.140393\n",
       "min     8.000000\n",
       "25%    12.000000\n",
       "50%    14.000000\n",
       "75%    16.000000\n",
       "max    19.000000"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# (Dodatkowy sanity-check)\n",
    "df_pamiec.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f7c5c63",
   "metadata": {},
   "source": [
    "#### Hipotezy i poziom istotności\n",
    "\n",
    "- $H_0$: wszystkie strategie mają ten sam rozkład wyników (w praktyce: brak różnic typowych wartości),\n",
    "- $H_A$: przynajmniej jedna strategia ma inny rozkład.\n",
    "\n",
    "Przyjmijmy $α = 0.05$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "de6db0c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = 0.05\n",
    "alpha"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c9c047",
   "metadata": {},
   "source": [
    "#### Statystyka $H$ i rozkład pod $H_0$\n",
    "\n",
    "Test Kruskala–Wallisa opiera się na statystyce:\n",
    "\n",
    "$$\n",
    "H = \\frac{12}{N(N+1)} \\sum_{j=1}^k \\frac{R_j^2}{n_j} - 3(N+1),\n",
    "$$\n",
    "\n",
    "gdzie:\n",
    "\n",
    "- $k$ — liczba grup (miesięcy),\n",
    "- $N$ — łączna liczba obserwacji (po usunięciu braków),\n",
    "- $n_j$ — liczebność w grupie $j$,\n",
    "- $R_j$ — suma rang w grupie $j$ (rangi liczone na całej próbie).\n",
    "\n",
    "Dla większych prób (i przybliżeń) pod $H_0$ zachodzi:\n",
    "\n",
    "$$\n",
    "H \\approx \\chi^2_{k-1}.\n",
    "$$\n",
    "\n",
    "To jest test prawostronny (duże $H$ świadczy o różnicach).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "a9a01516",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                        n      R\n",
      "strategia                       \n",
      "obrazowanie            10  157.0\n",
      "odniesienie do siebie  10  250.0\n",
      "powtarzanie            10   58.0\n",
      "\n",
      "N = 30 k = 3 df = 2\n",
      "H (bez korekty) = 23.791\n",
      "korekta na remisy = 0.992214\n",
      "H (po korekcie) = 23.978\n",
      "Region krytyczny: H >= chi2_(1-alpha) = 5.991\n",
      "p-value = P(Chi^2 >= H_obs | H0) = 0.000006\n"
     ]
    }
   ],
   "source": [
    "values = df_pamiec[\"wynik\"].to_numpy()\n",
    "groups = df_pamiec[\"strategia\"].to_numpy()\n",
    "\n",
    "ranks = stats.rankdata(values)\n",
    "\n",
    "df_tmp = pd.DataFrame({\"strategia\": groups, \"rank\": ranks, \"value\": values})\n",
    "group_stats = df_tmp.groupby(\"strategia\").agg(n=(\"rank\", \"size\"), R=(\"rank\", \"sum\"))\n",
    "\n",
    "N = int(group_stats[\"n\"].sum())\n",
    "k = int(group_stats.shape[0])\n",
    "\n",
    "H = (12 / (N * (N + 1))) * float(((group_stats[\"R\"] ** 2) / group_stats[\"n\"]).sum()) - 3 * (\n",
    "    N + 1\n",
    ")\n",
    "\n",
    "# Korekta na remisy (tie correction)\n",
    "tie_counts = pd.Series(values).value_counts()\n",
    "tie_term = float(((tie_counts**3) - tie_counts).sum())\n",
    "tie_correction = 1.0 - tie_term / (N**3 - N)\n",
    "H_corrected = H / tie_correction\n",
    "\n",
    "df = k - 1\n",
    "critical = float(stats.chi2.ppf(1 - alpha, df=df))\n",
    "p_value_manual = float(stats.chi2.sf(H_corrected, df=df))\n",
    "\n",
    "print(group_stats)\n",
    "print(\"\\nN =\", N, \"k =\", k, \"df =\", df)\n",
    "print(f\"H (bez korekty) = {H:.3f}\")\n",
    "print(f\"korekta na remisy = {tie_correction:.6f}\")\n",
    "print(f\"H (po korekcie) = {H_corrected:.3f}\")\n",
    "print(f\"Region krytyczny: H >= chi2_(1-alpha) = {critical:.3f}\")\n",
    "print(f\"p-value = P(Chi^2 >= H_obs | H0) = {p_value_manual:.6f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8cc5d8",
   "metadata": {},
   "source": [
    "#### Weryfikacja funkcją\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f9e0f0f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KruskalResult(statistic=np.float64(23.97766816143497), pvalue=np.float64(6.213202585407337e-06))"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groups_values = []\n",
    "for g in df_pamiec[\"strategia\"].unique():\n",
    "    groups_values.append(df_pamiec.loc[df_pamiec[\"strategia\"] == g, \"wynik\"].to_numpy())\n",
    "\n",
    "res_kw = stats.kruskal(*groups_values)\n",
    "res_kw"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3b8d2a4",
   "metadata": {},
   "source": [
    "#### Wielkość efektu\n",
    "\n",
    "Dla testu Kruskala–Wallisa często raportuje się $ε^2$:\n",
    "\n",
    "$$\n",
    "\\varepsilon^2 = \\frac{H - k + 1}{N - k}.\n",
    "$$\n",
    "\n",
    "To przybliżona miara tego, jaka część \"zmienności rang\" wiąże się z grupą.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "4d6b905a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8139877096827767"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epsilon_sq = float((H_corrected - k + 1) / (N - k))\n",
    "epsilon_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d7f88cd",
   "metadata": {},
   "source": [
    "#### Porównania następcze: które strategie różnią się od których?\n",
    "\n",
    "Sam test Kruskala–Wallisa mówi tylko, że **co najmniej jedna** grupa różni się od innych.\n",
    "\n",
    "Aby sprawdzić, które pary strategii różnią się istotnie, używa się porównań następczych na rangach (np. test Dunna).\n",
    "\n",
    "Skorzystamy z pakietu `scikit-posthocs`, który zawiera gotowy test Dunna z korektą dla wielu porównań."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "fb8a1c78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>obrazowanie</th>\n",
       "      <th>odniesienie do siebie</th>\n",
       "      <th>powtarzanie</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>obrazowanie</th>\n",
       "      <td>1.0000</td>\n",
       "      <td>0.0532</td>\n",
       "      <td>0.0348</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>odniesienie do siebie</th>\n",
       "      <td>0.0532</td>\n",
       "      <td>1.0000</td>\n",
       "      <td>0.0000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>powtarzanie</th>\n",
       "      <td>0.0348</td>\n",
       "      <td>0.0000</td>\n",
       "      <td>1.0000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       obrazowanie  odniesienie do siebie  powtarzanie\n",
       "obrazowanie                 1.0000                 0.0532       0.0348\n",
       "odniesienie do siebie       0.0532                 1.0000       0.0000\n",
       "powtarzanie                 0.0348                 0.0000       1.0000"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dunn_p = sp.posthoc_dunn(\n",
    "    df_pamiec,\n",
    "    val_col=\"wynik\",\n",
    "    group_col=\"strategia\",\n",
    "    p_adjust=\"bonferroni\",\n",
    ")\n",
    "\n",
    "dunn_p.round(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f76f0f75",
   "metadata": {},
   "source": [
    "Interpretujemy tabelę tak:\n",
    "\n",
    "- każda komórka poza przekątną to porównanie dwóch strategii,\n",
    "- wartości w tabeli to p-wartości po korekcie Bonferroniego.\n",
    "\n",
    "Pamiętaj: test Kruskala–Wallisa mówi tylko, że **co najmniej jedna** grupa różni się od innych. Porównania następcze pomagają sprawdzić, które pary odpowiadają za ten wynik."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa71bcb",
   "metadata": {},
   "source": [
    "## Wariacje na temat $\\chi^2$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb839a1a",
   "metadata": {},
   "source": [
    "### Test McNemara\n",
    "\n",
    "Test McNemara dotyczy danych **sparowanych** w tabeli 2x2, np. gdy tę samą osobę mierzymy *przed* i *po* interwencji, a wynik jest binarny (0/1).\n",
    "\n",
    "Przykład kognitywistyczny: uczestnicy wykonują krótki trening uwagi, a my sprawdzamy trafność odpowiedzi w prostym zadaniu **2AFC**.\n",
    "\n",
    "**2AFC** (dwualternatywny wybór wymuszony) oznacza, że w każdej próbie badany musi wybrać jedną z dwóch odpowiedzi (np. „bodziec A” vs „bodziec B”). Wynik pojedynczej próby to **poprawnie/niepoprawnie**.\n",
    "\n",
    "Poniżej użyjemy mocno uproszczonej wersji: zamiast tysięcy prób analizujemy, czy dana osoba była „poprawna” w sensie przekroczenia progu (np. ≥65% trafności) przed i po treningu.\n",
    "\n",
    "Uwaga techniczna: w macierzy 2x2 poniżej **wiersze** oznaczają wynik *przed*, a **kolumny** wynik *po* treningu. Kolejność kategorii to: `poprawnie`, potem `niepoprawnie`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "7c116a53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obserwacje:\n",
      " [[36. 28.]\n",
      " [45. 19.]]\n",
      "Oczekiwane (H0):\n",
      " [[40.5 23.5]\n",
      " [40.5 23.5]]\n",
      "chi2 = 2.7234, df = 1, p = 0.0989\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Chi2ContingencyResult(statistic=np.float64(2.723404255319149), pvalue=np.float64(0.09888690877928379), dof=1, expected_freq=array([[40.5, 23.5],\n",
       "       [40.5, 23.5]]))"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statystyka_indep = np.array([[36, 28], [45, 19]])\n",
    "\n",
    "# \"Na piechotę\": chi^2 dla tabeli 2x2\n",
    "obs = statystyka_indep.astype(float)\n",
    "row_sums = obs.sum(axis=1, keepdims=True)\n",
    "col_sums = obs.sum(axis=0, keepdims=True)\n",
    "N = float(obs.sum())\n",
    "\n",
    "expected = row_sums @ col_sums / N\n",
    "chi2 = float(((obs - expected) ** 2 / expected).sum())\n",
    "df = 1\n",
    "p_chi2 = float(stats.chi2.sf(chi2, df=df))\n",
    "\n",
    "print(\"Obserwacje:\\n\", obs)\n",
    "print(\"Oczekiwane (H0):\\n\", expected)\n",
    "print(f\"chi2 = {chi2:.4f}, df = {df}, p = {p_chi2:.4f}\")\n",
    "\n",
    "# Weryfikacja funkcją\n",
    "chi2_scipy = stats.chi2_contingency(statystyka_indep, correction=False)\n",
    "chi2_scipy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f88c8035",
   "metadata": {},
   "source": [
    "Teraz uwzględnijmy parowanie.\n",
    "\n",
    "Możemy postawić hipotezę, że częściej zmiana była w kierunku „niepoprawnie” → „poprawnie” niż „poprawnie” → „niepoprawnie”.\n",
    "\n",
    "Hipoteza zerowa: w parach niezgodnych prawdopodobieństwa przejść w obie strony są takie same.\n",
    "\n",
    "W tabeli 2x2 McNemara interesują nas przede wszystkim **pary niezgodne**:\n",
    "\n",
    "- $b$ = liczba osób, które zmieniły z „poprawnie” na „niepoprawnie”,\n",
    "- $c$ = liczba osób, które zmieniły z „niepoprawnie” na „poprawnie”.\n",
    "\n",
    "Pod $H_0$ (dwustronnie) $b$ ma rozkład dwumianowy: $b \\sim \text{Bin}(n=b+c, 0.5)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "cfb6c2d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[33, 12],\n",
       "       [ 3, 16]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statystyka_paired = np.array([[33, 12], [3, 16]])\n",
    "statystyka_paired\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "40fa90a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 12, c = 3, n = b+c = 15\n",
      "min(b,c) = 3\n",
      "k_crit (dwustronnie, alpha=0.05) = 3\n",
      "p-value (dokładny, dwumianowy) = 0.03515625\n",
      "pvalue      0.03515625\n",
      "statistic   3.0\n"
     ]
    }
   ],
   "source": [
    "b = int(statystyka_paired[0, 1])\n",
    "c = int(statystyka_paired[1, 0])\n",
    "n = b + c\n",
    "\n",
    "k = min(b, c)\n",
    "p_mcnemar_manual = float(2 * stats.binom.cdf(k, n=n, p=0.5))\n",
    "\n",
    "# Region krytyczny (dwustronny): znajdź największe k takie, że 2*P(X<=k) <= alpha\n",
    "k_crit = None\n",
    "for kk in range(0, n + 1):\n",
    "    if 2 * stats.binom.cdf(kk, n=n, p=0.5) <= alpha:\n",
    "        k_crit = kk\n",
    "\n",
    "print(f\"b = {b}, c = {c}, n = b+c = {n}\")\n",
    "print(\"min(b,c) =\", k)\n",
    "print(\"k_crit (dwustronnie, alpha=0.05) =\", k_crit)\n",
    "print(\"p-value (dokładny, dwumianowy) =\", p_mcnemar_manual)\n",
    "\n",
    "res_mcnemar = mcnemar(statystyka_paired, exact=True, correction=False)\n",
    "print(res_mcnemar)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4d1ef4",
   "metadata": {},
   "source": [
    "#### Interpretacja i efekt\n",
    "\n",
    "McNemar wykorzystuje dodatkową informację o sparowaniu obserwacji, więc często ma większą moc niż test niezależności $\\chi^2$ zastosowany „na skróty”.\n",
    "\n",
    "Jako prostą miarę efektu dla tabeli sparowanej 2x2 można policzyć **iloraz szans dla par niezgodnych**:\n",
    "\n",
    "$$\n",
    "\\widehat{OR} = \\frac{b}{c}.\n",
    "$$\n",
    "\n",
    "W tym zapisie $b$ to „pogorszenia” (poprawnie → niepoprawnie), a $c$ to „poprawy” (niepoprawnie → poprawnie).\n",
    "\n",
    "Poniżej (ostrożnie) wyznaczymy przybliżony 95% przedział ufności dla $OR$ przez logarytm.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "ebc2e8d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OR_hat = 4.000\n",
      "Przybliżony 95% przedział ufności dla OR: [1.129, 14.175]\n"
     ]
    }
   ],
   "source": [
    "or_hat = b / c\n",
    "se_log_or = np.sqrt(1 / b + 1 / c)\n",
    "ci_low = float(np.exp(np.log(or_hat) - 1.96 * se_log_or))\n",
    "ci_high = float(np.exp(np.log(or_hat) + 1.96 * se_log_or))\n",
    "\n",
    "print(f\"OR_hat = {or_hat:.3f}\")\n",
    "print(f\"Przybliżony 95% przedział ufności dla OR: [{ci_low:.3f}, {ci_high:.3f}]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "528a89f4",
   "metadata": {},
   "source": [
    "#### Widżet: McNemar na żywo (tylko pary niezgodne)\n",
    "\n",
    "W teście McNemara znaczenie mają wyłącznie liczby $b$ i $c$ (pary niezgodne). Poniższy widżet pozwala zobaczyć, jak zmienia się p-wartość, gdy zmieniają się te dwie liczby."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "99c4bd64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2b83e40ed76484fb3a6d6eb58778bdd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntSlider(value=12, continuous_update=False, description='b', max=60), IntSlider(value=3, conti…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b0403406abb4e28ad32b1aef97ec0ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not WIDGETY_DOSTEPNE:\n",
    "    print(\"Widżety nie są dostępne. Jeśli pracujesz w Jupyterze, doinstaluj pakiet ipywidgets.\")\n",
    "else:\n",
    "    b_slider = widgets.IntSlider(value=12, min=0, max=60, step=1, description=\"b\", continuous_update=False)\n",
    "    c_slider = widgets.IntSlider(value=3, min=0, max=60, step=1, description=\"c\", continuous_update=False)\n",
    "    alpha_slider = widgets.FloatSlider(value=0.05, min=0.001, max=0.20, step=0.001, description=\"α\", readout_format=\".3f\", continuous_update=False)\n",
    "\n",
    "    def pokaz_mcnemar_widget(b, c, alpha):\n",
    "        b = int(b)\n",
    "        c = int(c)\n",
    "        alpha = float(alpha)\n",
    "\n",
    "        n = b + c\n",
    "        fig, ax = plt.subplots(figsize=(8, 4.5))\n",
    "\n",
    "        if n == 0:\n",
    "            ax.set_xlim(0, 60)\n",
    "            ax.set_ylim(0, 1)\n",
    "            ax.set_title(\"Test McNemara: brak par niezgodnych\")\n",
    "            ax.text(\n",
    "                0.5,\n",
    "                0.5,\n",
    "                \"Jeśli b=c=0, test McNemara nie ma czego testować.\",\n",
    "                transform=ax.transAxes,\n",
    "                ha=\"center\",\n",
    "                va=\"center\",\n",
    "                bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.88},\n",
    "            )\n",
    "            plt.tight_layout()\n",
    "            plt.show()\n",
    "            return\n",
    "\n",
    "        k = min(b, c)\n",
    "        p_two = min(float(2 * stats.binom.cdf(k, n=n, p=0.5)), 1.0)\n",
    "        p_one = float(stats.binom.sf(b - 1, n=n, p=0.5))\n",
    "\n",
    "        x = np.arange(0, n + 1)\n",
    "        pmf = stats.binom.pmf(x, n=n, p=0.5)\n",
    "        colors = np.where((x <= k) | (x >= n - k), \"tomato\", \"lightgrey\")\n",
    "        ax.bar(x, pmf, color=colors, edgecolor=\"white\")\n",
    "        ax.axvline(b, color=\"black\", linestyle=\"--\", linewidth=2, label=\"b\")\n",
    "        ax.axvline(c, color=\"steelblue\", linestyle=\":\", linewidth=2, label=\"c\")\n",
    "        ax.set_xlim(-0.5, 60.5)\n",
    "        ax.set_ylim(0, 0.25)\n",
    "        ax.set_title(\"McNemar: rozkład liczby pogorszeń pod $H_0$\")\n",
    "        ax.set_xlabel(\"liczba pogorszeń przy n=b+c parach niezgodnych\")\n",
    "        ax.set_ylabel(\"prawdopodobieństwo\")\n",
    "        ax.legend(loc=\"upper right\")\n",
    "\n",
    "        if b == 0 or c == 0:\n",
    "            effect_text = \"OR niestabilny\\n(b=0 lub c=0)\"\n",
    "        else:\n",
    "            or_hat = b / c\n",
    "            se_log_or = np.sqrt(1 / b + 1 / c)\n",
    "            ci_low = float(np.exp(np.log(or_hat) - 1.96 * se_log_or))\n",
    "            ci_high = float(np.exp(np.log(or_hat) + 1.96 * se_log_or))\n",
    "            effect_text = f\"OR = {or_hat:.2f}\\n95% CI [{ci_low:.2f}, {ci_high:.2f}]\"\n",
    "\n",
    "        ax.text(\n",
    "            0.02,\n",
    "            0.95,\n",
    "            \"\\n\".join(\n",
    "                [\n",
    "                    f\"b = {b}, c = {c}, n = {n}\",\n",
    "                    f\"p dwustr. = {p_two:.4f}\",\n",
    "                    f\"p jedn. (c>b) = {p_one:.4f}\",\n",
    "                    f\"α = {alpha:.3f}: {'TAK' if p_two <= alpha else 'nie'}\",\n",
    "                    effect_text,\n",
    "                ]\n",
    "            ),\n",
    "            transform=ax.transAxes,\n",
    "            va=\"top\",\n",
    "            ha=\"left\",\n",
    "            fontsize=10,\n",
    "            bbox={\"boxstyle\": \"round,pad=0.45\", \"facecolor\": \"white\", \"edgecolor\": \"black\", \"alpha\": 0.88},\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    out = widgets.interactive_output(\n",
    "        pokaz_mcnemar_widget,\n",
    "        {\"b\": b_slider, \"c\": c_slider, \"alpha\": alpha_slider},\n",
    "    )\n",
    "\n",
    "    display(widgets.HBox([b_slider, c_slider, alpha_slider]), out)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4d4f4f8",
   "metadata": {},
   "source": [
    "## Regresja logistyczna: przykład z trafnością (0/1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c9d7fa",
   "metadata": {},
   "source": [
    "### Statystyczna istotność współczynników w regresji logistycznej\n",
    "\n",
    "Regresja logistyczna opisuje związek między predyktorami a prawdopodobieństwem zdarzenia binarnego (np. poprawna odpowiedź: 1/0).\n",
    "\n",
    "Weźmy mini-przykład 2AFC: sprawdzamy, czy dodanie szumu utrudnia zadanie oraz czy trudność bodźców wpływa na trafność. Dane są celowo małe i sztuczne, aby łatwo było je prześledzić.\n",
    "\n",
    "Uwaga metodyczna: tutaj traktujemy obserwacje jako niezależne. W realnych danych z wielu prób na osobę często lepszy jest model z efektem losowym (modele mieszane), ale to wykracza poza ten kurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "f2e0c8d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>warunek</th>\n",
       "      <th>trudnosc</th>\n",
       "      <th>n</th>\n",
       "      <th>poprawne</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>40</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>trudne</td>\n",
       "      <td>40</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>szum</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>40</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>szum</td>\n",
       "      <td>trudne</td>\n",
       "      <td>40</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     warunek trudnosc   n  poprawne\n",
       "0  bez szumu    łatwe  40        36\n",
       "1  bez szumu   trudne  40        30\n",
       "2       szum    łatwe  40        32\n",
       "3       szum   trudne  40        24"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela = pd.DataFrame(\n",
    "    {\n",
    "        \"warunek\": [\"bez szumu\", \"bez szumu\", \"szum\", \"szum\"],\n",
    "        \"trudnosc\": [\"łatwe\", \"trudne\", \"łatwe\", \"trudne\"],\n",
    "        \"n\": [40, 40, 40, 40],\n",
    "        \"poprawne\": [36, 30, 32, 24],\n",
    "    }\n",
    ")\n",
    "tabela"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "e56b1b20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Liczba obserwacji: 160\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>warunek</th>\n",
       "      <th>trudnosc</th>\n",
       "      <th>poprawna</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>bez szumu</td>\n",
       "      <td>łatwe</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     warunek trudnosc  poprawna\n",
       "0  bez szumu    łatwe         1\n",
       "1  bez szumu    łatwe         1\n",
       "2  bez szumu    łatwe         1\n",
       "3  bez szumu    łatwe         1\n",
       "4  bez szumu    łatwe         1"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rozwijamy dane zagregowane do postaci 0/1 (pedagogicznie prościej).\n",
    "rows = []\n",
    "for _, row in tabela.iterrows():\n",
    "    for _ in range(int(row[\"poprawne\"])):\n",
    "        rows.append({\"warunek\": row[\"warunek\"], \"trudnosc\": row[\"trudnosc\"], \"poprawna\": 1})\n",
    "    for _ in range(int(row[\"n\"] - row[\"poprawne\"])):\n",
    "        rows.append({\"warunek\": row[\"warunek\"], \"trudnosc\": row[\"trudnosc\"], \"poprawna\": 0})\n",
    "\n",
    "df_2afc = pd.DataFrame(rows)\n",
    "\n",
    "# Ustawiamy kategorie tak, aby kategoria bazowa była czytelna w tabeli wyników.\n",
    "df_2afc[\"warunek\"] = pd.Categorical(df_2afc[\"warunek\"], categories=[\"bez szumu\", \"szum\"])\n",
    "df_2afc[\"trudnosc\"] = pd.Categorical(df_2afc[\"trudnosc\"], categories=[\"łatwe\", \"trudne\"])\n",
    "\n",
    "print(\"Liczba obserwacji:\", int(df_2afc.shape[0]))\n",
    "df_2afc.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "c7d2b2a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>Generalized Linear Model Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>       <td>poprawna</td>     <th>  No. Observations:  </th>  <td>   160</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                  <td>GLM</td>       <th>  Df Residuals:      </th>  <td>   157</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model Family:</th>        <td>Binomial</td>     <th>  Df Model:          </th>  <td>     2</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Link Function:</th>         <td>Logit</td>      <th>  Scale:             </th> <td>  1.0000</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>                <td>IRLS</td>       <th>  Log-Likelihood:    </th> <td> -82.444</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>            <td>Sun, 10 May 2026</td> <th>  Deviance:          </th> <td>  164.89</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                <td>22:42:49</td>     <th>  Pearson chi2:      </th>  <td>  160.</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>No. Iterations:</th>          <td>4</td>        <th>  Pseudo R-squ. (CS):</th>  <td>0.06370</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>     <td>nonrobust</td>    <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "            <td></td>               <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Intercept</th>             <td>    2.1492</td> <td>    0.400</td> <td>    5.375</td> <td> 0.000</td> <td>    1.366</td> <td>    2.933</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>C(warunek)[T.szum]</th>    <td>   -0.7351</td> <td>    0.391</td> <td>   -1.879</td> <td> 0.060</td> <td>   -1.502</td> <td>    0.032</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>C(trudnosc)[T.trudne]</th> <td>   -1.0269</td> <td>    0.399</td> <td>   -2.576</td> <td> 0.010</td> <td>   -1.808</td> <td>   -0.246</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/latex": [
       "\\begin{center}\n",
       "\\begin{tabular}{lclc}\n",
       "\\toprule\n",
       "\\textbf{Dep. Variable:}        &     poprawna     & \\textbf{  No. Observations:  } &      160    \\\\\n",
       "\\textbf{Model:}                &       GLM        & \\textbf{  Df Residuals:      } &      157    \\\\\n",
       "\\textbf{Model Family:}         &     Binomial     & \\textbf{  Df Model:          } &        2    \\\\\n",
       "\\textbf{Link Function:}        &      Logit       & \\textbf{  Scale:             } &    1.0000   \\\\\n",
       "\\textbf{Method:}               &       IRLS       & \\textbf{  Log-Likelihood:    } &   -82.444   \\\\\n",
       "\\textbf{Date:}                 & Sun, 10 May 2026 & \\textbf{  Deviance:          } &    164.89   \\\\\n",
       "\\textbf{Time:}                 &     22:42:49     & \\textbf{  Pearson chi2:      } &     160.    \\\\\n",
       "\\textbf{No. Iterations:}       &        4         & \\textbf{  Pseudo R-squ. (CS):} &  0.06370    \\\\\n",
       "\\textbf{Covariance Type:}      &    nonrobust     & \\textbf{                     } &             \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n",
       "\\begin{tabular}{lcccccc}\n",
       "                               & \\textbf{coef} & \\textbf{std err} & \\textbf{z} & \\textbf{P$> |$z$|$} & \\textbf{[0.025} & \\textbf{0.975]}  \\\\\n",
       "\\midrule\n",
       "\\textbf{Intercept}             &       2.1492  &        0.400     &     5.375  &         0.000        &        1.366    &        2.933     \\\\\n",
       "\\textbf{C(warunek)[T.szum]}    &      -0.7351  &        0.391     &    -1.879  &         0.060        &       -1.502    &        0.032     \\\\\n",
       "\\textbf{C(trudnosc)[T.trudne]} &      -1.0269  &        0.399     &    -2.576  &         0.010        &       -1.808    &       -0.246     \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n",
       "%\\caption{Generalized Linear Model Regression Results}\n",
       "\\end{center}"
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                 Generalized Linear Model Regression Results                  \n",
       "==============================================================================\n",
       "Dep. Variable:               poprawna   No. Observations:                  160\n",
       "Model:                            GLM   Df Residuals:                      157\n",
       "Model Family:                Binomial   Df Model:                            2\n",
       "Link Function:                  Logit   Scale:                          1.0000\n",
       "Method:                          IRLS   Log-Likelihood:                -82.444\n",
       "Date:                Sun, 10 May 2026   Deviance:                       164.89\n",
       "Time:                        22:42:49   Pearson chi2:                     160.\n",
       "No. Iterations:                     4   Pseudo R-squ. (CS):            0.06370\n",
       "Covariance Type:            nonrobust                                         \n",
       "=========================================================================================\n",
       "                            coef    std err          z      P>|z|      [0.025      0.975]\n",
       "-----------------------------------------------------------------------------------------\n",
       "Intercept                 2.1492      0.400      5.375      0.000       1.366       2.933\n",
       "C(warunek)[T.szum]       -0.7351      0.391     -1.879      0.060      -1.502       0.032\n",
       "C(trudnosc)[T.trudne]    -1.0269      0.399     -2.576      0.010      -1.808      -0.246\n",
       "=========================================================================================\n",
       "\"\"\""
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = smf.glm(\n",
    "    \"poprawna ~ C(warunek) + C(trudnosc)\",\n",
    "    data=df_2afc,\n",
    "    family=sm.families.Binomial(),\n",
    ").fit()\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d9d7a1",
   "metadata": {},
   "source": [
    "#### Jak rozumieć testy współczynników?\n",
    "\n",
    "Dla pojedynczego współczynnika $β$ typowo testujemy:\n",
    "\n",
    "- $H_0: \\beta = 0$ (brak wpływu predyktora w modelu),\n",
    "- $H_A: \\beta \\ne 0$.\n",
    "\n",
    "Test Waldowski wykorzystuje statystykę:\n",
    "\n",
    "$$\n",
    "z = \\frac{\\hat{\\beta}}{SE(\\hat{\\beta})},\n",
    "$$\n",
    "\n",
    "która (w przybliżeniu) ma rozkład standardowy normalny pod $H_0$.\n",
    "\n",
    "Policzmy to \"na piechotę\" dla jednego współczynnika i porównajmy z wynikiem z tabeli.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "d1b6a9f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Współczynnik: C(warunek)[T.szum]\n",
      "beta_hat = -0.7351\n",
      "SE = 0.3912\n",
      "z = -1.879\n",
      "p (dwustronnie) = 0.060214\n",
      "OR = exp(beta) = 0.479\n",
      "95% przedział ufności dla OR: [0.223, 1.032]\n"
     ]
    }
   ],
   "source": [
    "params = model.params\n",
    "bse = model.bse\n",
    "\n",
    "coef_name = \"C(warunek)[T.szum]\"\n",
    "beta_hat = float(params[coef_name])\n",
    "se_hat = float(bse[coef_name])\n",
    "\n",
    "z = beta_hat / se_hat\n",
    "p_two = float(2 * stats.norm.sf(abs(z)))\n",
    "\n",
    "or_hat = float(np.exp(beta_hat))\n",
    "or_ci_low = float(np.exp(beta_hat - 1.96 * se_hat))\n",
    "or_ci_high = float(np.exp(beta_hat + 1.96 * se_hat))\n",
    "\n",
    "print(\"Współczynnik:\", coef_name)\n",
    "print(f\"beta_hat = {beta_hat:.4f}\")\n",
    "print(f\"SE = {se_hat:.4f}\")\n",
    "print(f\"z = {z:.3f}\")\n",
    "print(f\"p (dwustronnie) = {p_two:.6f}\")\n",
    "print(f\"OR = exp(beta) = {or_hat:.3f}\")\n",
    "print(f\"95% przedział ufności dla OR: [{or_ci_low:.3f}, {or_ci_high:.3f}]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca9d52bb",
   "metadata": {},
   "source": [
    "Warto pamiętać o interpretacji:\n",
    "\n",
    "- p-wartość mówi o (nie)zgodności danych z $H_0$ **warunkowo na model i założenia**,\n",
    "- wielkość efektu w regresji logistycznej wygodnie raportować jako **iloraz szans** (OR) z przedziałem ufności."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d20d403",
   "metadata": {},
   "source": [
    "## Podsumowanie\n",
    "\n",
    "- Testy nieparametryczne są szczególnie przydatne przy skalach porządkowych, obserwacjach odstających i małych próbach.\n",
    "- Wilcoxon (próby zależne) i Mann–Whitney (próby niezależne) można rozumieć jako testy na rangach z intuicją permutacyjną.\n",
    "- Przy wielu grupach używamy Kruskala–Wallisa, a potem (ostrożnie) porównań następczych.\n",
    "- Dla danych binarnych sparowanych (0/1): McNemar.\n",
    "- Zawsze patrz na efekt i niepewność (przedziały ufności), a p-wartość interpretuj jako $P(\\cdot\\mid H_0)$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9690a3",
   "metadata": {},
   "source": [
    "## Ćwiczenia\n",
    "\n",
    "1) Dla danych Stroopa (Wilcoxon):\n",
    "   - policz wersję dwustronną i porównaj z jednostronną,\n",
    "   - podaj estymatę efektu (np. medianę różnic) i bootstrapowy 95% przedział ufności.\n",
    "\n",
    "2) Dla danych \"wyspani vs niewyspani\" (Mann–Whitney):\n",
    "   - policz test dwustronny,\n",
    "   - zinterpretuj \"prawdopodobieństwo przewagi\" jako opis efektu.\n",
    "\n",
    "3) Zmień parametry w widżecie \"MWU to nie test median\" i znajdź przykład, w którym mediany są podobne, a p-wartość jest mała.\n",
    "\n",
    "4) Dla przykładu Kruskala–Wallisa:\n",
    "   - usuń jedną obserwację odstającą (np. największy wynik) i sprawdź, jak zmienia się wniosek,\n",
    "   - wykonaj porównania następcze i opisz, które strategie różnią się najbardziej.\n",
    "\n",
    "5) W teście McNemara:\n",
    "   - policz p-wartość jednostronną dla hipotezy, że \"poprawa\" jest częstsza niż \"pogorszenie\" (czyli $c>b$),\n",
    "   - pobaw się widżetem i zobacz, dla jakich wartości $b$ i $c$ wynik staje się istotny."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}