Algorytmy i kombinatoryka — sortowanie, kolorowanie grafów i spełnianie ograniczeń

Po co wizualizować algorytmy?

Tradycyjna edukacja informatyczna przedstawia algorytmy jako pseudokod i tabele złożoności — tu O(n²), tam O(n log n). To sprawdza się przy analizie teoretycznej, ale nie buduje intuicji co do tego, kiedy algorytmy sobie nie radzą. Wizualizator sortowania pokazuje nie tylko to, że sortowanie przez scalanie jest szybsze od sortowania przez wstawianie, ale dlaczego: sortowanie przez wstawianie marnuje pracę, przesuwając elementy o jedną pozycję przez duże nieuporządkowane obszary, podczas gdy sortowanie przez scalanie zawsze dzieli problem na pół.

Podobnie, obserwując, jak algorytm nawracający dla problemu N hetmanów wycofuje się z pozycji ślepych zaułków, żywo rozumiemy, co oznacza „wykładniczy przypadek najgorszy" — i to sprawia, że kontrast z heurystyką kolorowania grafów DSatur, działającą w czasie wielomianowym, jest jeszcze bardziej uderzający. Ten numer obejmuje siedem symulacji rozciągających się od klasycznego sortowania po otwarte hipotezy matematyczne.

Warstwa 1: sztuka porządkowania — algorytmy sortowania

Wizualizator algorytmów sortowania

Sortowanie to kanoniczny wprowadzający problem algorytmiczny, a jednak jego głębia zaskakuje. Istnieją dziesiątki algorytmów sortowania ogólnego przeznaczenia, każdy o innej złożoności w najlepszym, najgorszym i średnim przypadku, wymaganiach pamięciowych, właściwościach stabilności i praktycznych profilach wydajności. Wizualizator, który odtwarza je obok siebie, czyni te abstrakcyjne własności namacalnymi w ciągu kilku sekund.

Sortowanie bąbelkowe ma złożoność O(n²) i jest boleśnie oczywiste do obserwowania: wielokrotnie przeszukuje tablicę, zamieniając sąsiednie elementy niezgodne z porządkiem, zostawiając po każdym przejściu największy nieuporządkowany element „wypchnięty" na finalną pozycję. Szybkie sortowanie wybiera element osiowy, dzieli tablicę wokół niego i rekurencyjnie sortuje każdą połowę — średnio O(n log n), ale O(n²) dla danych już posortowanych lub niemal posortowanych (rozwiązywane przez losowy wybór elementu osiowego). Sortowanie przez scalanie ma zawsze złożoność O(n log n), ale potrzebuje O(n) dodatkowej pamięci. Sortowanie pozycyjne przełamuje barierę O(n log n), ale tylko dla kluczy całkowitoliczbowych.

Algorithm       Best      Average   Worst     Space  Stable?
─────────────────────────────────────────────────────────────
Bubble Sort     O(n)      O(n²)     O(n²)     O(1)   ✓
Insertion Sort  O(n)      O(n²)     O(n²)     O(1)   ✓
Selection Sort  O(n²)     O(n²)     O(n²)     O(1)   ✗
Shell Sort      O(n log n) varies  O(n^1.5)   O(1)   ✗
Merge Sort      O(n lgn)  O(n lgn)  O(n lgn)  O(n)   ✓
Heap Sort       O(n lgn)  O(n lgn)  O(n lgn)  O(1)   ✗
QuickSort       O(n lgn)  O(n lgn)  O(n²)     O(lgn) ✗
Tim Sort        O(n)      O(n lgn)  O(n lgn)  O(n)   ✓
Radix Sort      O(nk)     O(nk)     O(nk)     O(n+k) ✓
Counting Sort   O(n+k)    O(n+k)    O(n+k)    O(k)   ✓

Dolna granica teoretyczno-informacyjna dla sortowań porównawczych:
  Każde sortowanie oparte na porównaniach wymaga Ω(n log n) porównań
  Dowód: n! możliwych porządków → potrzeba ≥ log₂(n!) porównań
         Stirling: log₂(n!) ≈ n·log₂(n) − n·log₂(e)

Tim Sort (Python sorted(), Java Arrays.sort):
  Hybryda sortowania przez scalanie i przez wstawianie
  Wykrywa naturalne "przebiegi" (już posortowane podciągi)
  O(n) na danych niemal posortowanych — optymalny w praktyce

Symulacja algorytmów sortowania uruchamia jednocześnie ponad 15 algorytmów na tej samej potasowanej tablicy, prezentując kolorowany wykres słupkowy, gdzie wysokość koduje wartość, a kolor — status porównania/zamiany. Licznik zamian i czasomierz aktualizują się na żywo, natychmiast uwidaczniając podział na O(n²) i O(n log n). Tryb dźwiękowy przekłada wysokość słupka na wysokość tonu — można dosłownie usłyszeć, jak szybkie sortowanie kończy pracę wcześniej niż sortowanie przez scalanie.

Warstwa 2: ustawianie hetmanów, które się nie atakują — N hetmanów

Symulacja nawracania dla N hetmanów

Problem N hetmanów polega na ustawieniu N hetmanów na szachownicy N×N tak, aby żadne dwa hetmany się nie atakowały — żadne dwa nie mogą dzielić wiersza, kolumny ani przekątnej. Dla N=8 istnieje 92 rozwiązania; dla N=12 — 14 200; dla N=20 — ponad 39 miliardów. Policzenie wszystkich wymaga wyczerpującego przeszukania, ale znalezienie jednego rozwiązania szybko jest osiągalne dzięki heurystykom.

Nawracanie — systematyczne przeszukiwanie drzewa poszukiwań z wczesnym zakończeniem, gdy częściowe rozwiązanie okazuje się niewykonalne — to kanoniczny algorytm. Ustaw hetmana w wierszu 1, wypróbuj każdą kolumnę, ustaw kolejnego w wierszu 2, wypróbuj każdą dopuszczalną kolumnę i tak dalej. Gdy w bieżącym wierszu nie ma dopuszczalnego ustawienia, wróć do poprzedniego wiersza i wypróbuj następną kolumnę. Drzewo poszukiwań ma w najgorszym przypadku N! liści, ale przycinanie czyni je zarządzalnym.

Pseudokod nawracania:
  solve(row):
    if row == N: solution found; record()
    for col in 0..N-1:
      if safe(row, col):
        place(row, col)
        solve(row + 1)
        remove(row, col)      ← backtrack

Sprawdzanie bezpieczeństwa O(1) przy pomocy masek bitowych:
  cols    = zbiór zajętych kolumn
  diag1   = zbiór zajętych przekątnych (row − col)
  diag2   = zbiór zajętych antyprzekątnych (row + col)
  bezpiecznie, jeśli col ∉ cols ∧ (row−col) ∉ diag1 ∧ (row+col) ∉ diag2

Liczby rozwiązań (łącznie, z uwzględnieniem obrotów/odbić):
  N   Rozwiązań    N   Rozwiązań
  4      2         12   14 200
  5      10        14   365 596
  6      4         16   14 772 512
  7      40        20   39 029 188 884
  8      92
  10     724

Dla dużych N: Q(N) ≈ (0.143 N)^N  (wzrost wykładniczy)

Wariant NP-zupełny:
  Ustalenie, czy częściowe rozmieszczenie da się dokończyć, jest problemem
  NP-zupełnym (wariant decyzyjny badany w spełnianiu ograniczeń w AI)

Symulacja N hetmanów wizualizuje każdy krok algorytmu nawracającego: aktywny hetman, który jest ustawiany, świeci na żółto, pomyślnie ustawione hetmany świecą na zielono, a hetmany w konflikcie — na czerwono. Licznik rozwiązań i licznik nawrotów aktualizują się z każdym krokiem. Ustaw N od 4 do 12 i wybierz prędkość animacji, aby śledzić logikę algorytmu we własnym tempie, lub naciśnij „Auto", aby przelecieć przez wszystkie rozwiązania naraz.

Warstwa 3: kolorowanie grafów

Symulacja kolorowania grafów

Kolorowanie grafu przypisuje kolory wierzchołkom grafu tak, aby żadne dwa sąsiednie wierzchołki nie miały tego samego koloru. Minimalna liczba wymaganych kolorów to liczba chromatyczna χ(G), jeden z najintensywniej badanych parametrów kombinatoryki. Ma bezpośrednie zastosowanie w planowaniu (przydzielanie przedziałów czasowych zadaniom w konflikcie), alokacji rejestrów (przydzielanie rejestrów procesora zmiennym), kolorowaniu map (słynne twierdzenie o czterech barwach) oraz przydzielaniu częstotliwości w sieciach bezprzewodowych.

Dokładne wyznaczenie χ(G) jest problemem NP-trudnym — ale kilka heurystyk wielomianowych szybko daje niemal optymalne kolorowania. Algorytm zachłanny przypisuje każdemu wierzchołkowi najmniejszy dostępny kolor w pewnej kolejności. Algorytm Welsha-Powella poprawia to, porządkując wierzchołki według stopnia (od największego). DSatur (stopień nasycenia) to zachłanny algorytm o dynamicznym priorytecie — na każdym kroku koloruje wierzchołek o największej liczbie różnie pokolorowanych sąsiadów, co często daje kolorowanie optymalne.

Granice liczby chromatycznej:
  χ(G) ≥ ω(G)          (liczba klikowa — największy podgraf pełny)
  χ(G) ≤ Δ(G) + 1      (granica Brooksa; równość tylko dla grafów pełnych lub cykli nieparzystych)
  χ(G) ≤ Δ(G)          (twierdzenie Brooksa dla grafów spójnych, niepełnych i bez cykli nieparzystych)

Twierdzenie o czterech barwach (Appel i Haken, 1976):
  Każdy graf planarny spełnia χ(G) ≤ 4
  (Pierwsze poważne twierdzenie dowiedzione przy pomocy komputera — ponad 1200 konfiguracji)

Algorytm DSatur:
  saturation(v) = |{kolory sąsiadów v}|  (liczba różnych kolorów sąsiadów)
  1. Wybierz niepokolorowany wierzchołek v o maksymalnym nasyceniu (remisy rozstrzygane stopniem)
  2. Przypisz najmniejszy kolor niewykorzystany przez żadnego sąsiada v
  3. Powtarzaj, aż wszystkie wierzchołki będą pokolorowane
  Złożoność: O(n²) naiwnie, O((n+m) log n) z kolejką priorytetową

Górna granica zachłanna:
  Algorytm zachłanny porządkuje wierzchołki dowolnie → χ ≤ Δ + 1
  Welsh-Powell porządkuje malejąco wg stopnia → ciaśniejsza granica w praktyce
  Najgorszy przypadek algorytmu zachłannego: χ = Δ + 1 (np. graf dwudzielny z naprzemiennymi wierzchołkami wysokiego stopnia)

Graf Petersena:
  10 wierzchołków, 15 krawędzi, Δ = 3, χ = 3
  3-regularny, bez mostów — kontrprzykład dla wielu hipotez teorii grafów

Symulacja kolorowania grafów pokazuje działanie algorytmów Greedy, Welsh-Powell i DSatur na gotowych i własnych grafach. Tryb krokowy podświetla, który wierzchołek jest kolorowany i dlaczego — można zobaczyć, jak DSatur dynamicznie przebudowuje kolejkę priorytetów w miarę przypisywania kolorów. Przeciągaj wierzchołki, aby dostosować układ; kliknij puste miejsce, aby dodać nowy wierzchołek; konflikty są podświetlane na czerwono, gdy tworzą je ręczne przypisania.

Warstwa 4: pola pod krzywymi — całkowanie Riemanna

Symulacja całki Riemanna

Całkowanie numeryczne — przybliżanie pola pod krzywą, gdy funkcja pierwotna w postaci analitycznej jest niedostępna — to jedno z najstarszych i praktycznie najważniejszych zadań obliczeniowych. Sumy Riemanna dzielą przedział całkowania na prostokąty, których wysokości próbkuje się w lewym końcu, prawym końcu lub środku każdego podprzedziału. Reguły trapezów i Simpsona wykorzystują odpowiednio interpolację liniową i kwadratową, aby osiągnąć wyższą dokładność przy mniejszej liczbie obliczeń funkcji.

Dokładność każdej metody zależy od gładkości funkcji podcałkowej. Dla funkcji gładkich reguła Simpsona osiąga błąd O(h⁴) — ten sam wynik, który wymaga milionów prostokątów Riemanna, można uzyskać zaledwie 8 przedziałami Simpsona. Dlatego biblioteki numeryczne używają kwadratury adaptacyjnej (dzielenie przedziałów tam, gdzie funkcja podcałkowa szybko się zmienia), a nie równomiernych sum Riemanna, do obliczeń produkcyjnych.

∫ₐᵇ f(x) dx  z n równymi podprzedziałami o szerokości h = (b−a)/n

Lewa suma Riemanna:
  L_n = h · Σᵢ₌₀^{n−1} f(xᵢ)
  Błąd: O(h) = O(1/n)  — metoda pierwszego rzędu

Prawa suma Riemanna:
  R_n = h · Σᵢ₌₁^n f(xᵢ)
  Błąd: O(h) = O(1/n)  — metoda pierwszego rzędu

Reguła punktu środkowego:
  M_n = h · Σᵢ f(xᵢ + h/2)
  Błąd: O(h²) — drugi rząd; dwukrotnie lepsza od L/R dla gładkich f

Reguła trapezów:
  T_n = h · [f(x₀)/2 + f(x₁) + f(x₂) + ... + f(xₙ₋₁) + f(xₙ)/2]
  Błąd: O(h²) — ten sam rząd co punkt środkowy, ale większa stała

Złożona reguła Simpsona 1/3:
  S_n = (h/3) · [f(x₀) + 4f(x₁) + 2f(x₂) + 4f(x₃) + ... + 4f(xₙ₋₁) + f(xₙ)]
  (wymaga parzystego n)
  Błąd: O(h⁴) — czwarty rząd; 100× mniej obliczeń niż w metodzie Riemanna dla tej samej dokładności

Porównanie zbieżności dla ∫₀¹ sin(x) dx = 1 − cos(1) ≈ 0.459698:
  n=10:  błąd L 0.0450,  punkt środkowy 0.00046,  Simpson 4.5×10⁻⁷
  n=100: błąd L 0.0045,  punkt środkowy 4.6×10⁻⁶, Simpson 4.5×10⁻¹¹

Symulacja całkowania Riemanna rysuje prostokąty lub trapezy każdej metody numerycznej w innym kolorze, pokazując wypełnione pole i niepokryte luki obok siebie. Wskaźnik błędu na żywo pokazuje, jak każda reguła zbiega w miarę zwiększania liczby podprzedziałów za pomocą suwaka — czyniąc przewagę O(h⁴) reguły Simpsona dramatyczną: zwiększ n z 10 do 20, a błąd Simpsona spada 16-krotnie, podczas gdy błędy Riemanna spadają tylko dwukrotnie.

Warstwa 5: niedowiedziona hipoteza — problem Collatza

Symulacja hipotezy Collatza

Weź dowolną dodatnią liczbę całkowitą. Jeśli jest parzysta, podziel ją przez 2. Jeśli nieparzysta, pomnóż przez 3 i dodaj 1. Powtarzaj. Hipoteza Collatza mówi, że każda dodatnia liczba całkowita ostatecznie osiąga 1. Sprawdzono ją dla wszystkich liczb do około 2,95 × 10²⁰, a mimo to nie istnieje ogólny dowód. Paul Erdős powiedział: „matematyka nie jest jeszcze gotowa na takie problemy".

Ciągi wykazują pozornie chaotyczne zachowanie. Zaczynając od 27, potrzeba 111 kroków, aby osiągnąć 1, ze wzrostem aż do 9232. Zaczynając od 871, ciąg sięga 190 996 przed opadnięciem. Czas zatrzymania (liczba kroków do osiągnięcia 1) waha się dziko i nieprzewidywalnie — a mimo to hipoteza twierdzi, że jest zawsze skończony. Problem Collatza znajduje się na przecięciu teorii liczb, układów dynamicznych i złożoności obliczeniowej.

Funkcja 3n+1:
  T(n) = n/2       jeśli n ≡ 0 (mod 2)
  T(n) = (3n+1)/2  jeśli n ≡ 1 (mod 2)  [postać przyspieszona]

Czas zatrzymania σ(n): najmniejsze k takie, że T^k(n) = 1
Całkowity czas zatrzymania τ(n): liczba iteracji do pierwszego osiągnięcia 1

Przykłady ekstremalne:
  n=27:  σ=111, maksymalna wartość 9232
  n=871: σ=178, maksymalna wartość 190 996
  n=6171: σ=261, maksymalna wartość 975 400
  n=77031: σ=350, maksymalna wartość 21 933 016

Analiza heurystyczna (Terras, 1976):
  Średnie T(n) ≈ n · (3/4)  [przy założeniu losowej parzystości]
  Oczekiwany czas zatrzymania: O(log n)
  Ale najgorszy czas zatrzymania nie jest ograniczony żadną dowiedzioną funkcją log n

Zweryfikowany zakres (stan na 2024):
  Hipoteza Collatza zachodzi dla wszystkich n ≤ 2,95 × 10²⁰
  (Barina, 2020, obliczenia rozproszone na klastrze GPU)

Związek z otwartymi problemami:
  Terry Tao (2019) dowiódł, że "prawie wszystkie" orbity osiągają wartość poniżej
  dowolnej danej f(n) dla f wolno dążącego do nieskończoności —
  najbliżej dowodu na dziś

Symulacja hipotezy Collatza oferuje trzy wizualizacje: wykres ciągu w skali logarytmicznej pokazujący trajektorię pojedynczej liczby startowej, mapę cieplną czasu zatrzymania pokazującą σ(n) dla n od 1 do N z kolorem proporcjonalnym do czasu zatrzymania, oraz odwrócone drzewo Collatza pokazujące, które liczby prowadzą do danej wartości. Dramatyczne skoki na mapie cieplnej czasu zatrzymania — wyspy wolnych ciągów otoczone szybkimi sąsiadami — czynią nieprzewidywalność hipotezy namacalną.

Warstwa 6: nieskończone sumy jako funkcje — szeregi Taylora

Symulacja szeregów Taylora

Twierdzenie Taylora mówi, że dowolną nieskończenie różniczkowalną funkcję można przybliżyć dowolnie dokładnie w pobliżu punktu wielomianem — a w wielu przypadkach przybliżenie zbiega do dokładnej funkcji wszędzie. Współczynniki wielomianu są całkowicie determinowane pochodnymi funkcji w jednym punkcie: f(a), f'(a), f''(a) i tak dalej. To głębokie spostrzeżenie: całe zachowanie sin(x) na całej osi liczbowej jest zakodowane w jednej liczbie sin(0) = 0 i jej pochodnych 1, 0, −1, 0, 1, 0, …

Szeregi Taylora są silnikiem obliczeń naukowych. Zamieniają funkcje przestępne na wielomiany, umożliwiając szybkie obliczenia na sprzęcie, który natywnie wykonuje jedynie dodawanie i mnożenie. Wyjaśniają, dlaczego sin(x) ≈ x dla małych x (przybliżenie fizyczne stosowane wszędzie — od optyki po mechanikę orbitalną) i dlaczego e^x ≈ 1+x dla małych zaburzeń. Dostarczają teoretycznej podstawy dla różniczkowania numerycznego, różniczkowania automatycznego i funkcji aktywacji sieci neuronowych.

Szereg Taylora funkcji f(x) wokół x = a:
  f(x) = Σₙ₌₀^∞ f⁽ⁿ⁾(a) / n! · (x−a)ⁿ
       = f(a) + f'(a)(x−a) + f''(a)(x−a)²/2! + f'''(a)(x−a)³/3! + ...

Szereg Maclaurina (a = 0):
  sin(x)   = x − x³/3! + x⁵/5! − x⁷/7! + ...        R = ∞
  cos(x)   = 1 − x²/2! + x⁴/4! − x⁶/6! + ...        R = ∞
  eˣ       = 1 + x + x²/2! + x³/3! + x⁴/4! + ...     R = ∞
  ln(1+x)  = x − x²/2 + x³/3 − x⁴/4 + ...            R = 1
  (1+x)^α  = 1 + αx + α(α−1)x²/2! + ...               R = 1  (dwumianowy)
  arctan(x) = x − x³/3 + x⁵/5 − x⁷/7 + ...           R = 1
              (→ wzór Leibniza: π/4 = 1 − 1/3 + 1/5 − ...)

Promień zbieżności R:
  Wyznaczony przez najbliższą osobliwość na płaszczyźnie zespolonej
  ln(1+x): osobliwość przy x = −1 → R = 1
  1/(1−x) = Σ xⁿ: osobliwość przy x = 1 → R = 1
  sin(x): brak skończonych osobliwości → R = ∞

Oszacowanie reszty (Lagrange):
  |f(x) − Tₙ(x)| ≤ M · |x−a|^{n+1} / (n+1)!
  gdzie M = max |f^{(n+1)}(t)| dla t między a i x

Symulacja szeregów Taylora nakłada sumy częściowe T₁(x), T₂(x), ..., Tₙ(x) na oryginalną funkcję f(x). Suwak dodaje po jednym wyrazie naraz, z animacją każdego nowego wyrazu w ciągu 600 ms. Osobny wykres błędu pokazuje |f(x) − Tₙ(x)| w skali logarytmicznej, uwidaczniając wykładniczą zbieżność. Obserwuj, jak przybliżenie rozszerza się na zewnątrz od punktu rozwinięcia niczym fala, zbiegając do różnych funkcji z różną prędkością w zależności od ich promienia zbieżności.

Warstwa 7: liczby w trójkącie — trójkąt Pascala

Symulacja trójkąta Pascala

Trójkąt Pascala buduje się zgodnie z regułą, że każdy element jest sumą dwóch elementów znajdujących się nad nim, z krawędziami wypełnionymi jedynkami. Powstały trójkąt zawiera współczynniki dwumianowe C(n,k) = n!/(k!(n−k)!) — liczące liczbę sposobów wyboru k elementów z n — które pojawiają się jako współczynniki w rozwinięciu (a+b)ⁿ. Ale trójkąt ukrywa znacznie więcej niż współczynniki dwumianowe.

Suma przekątnych wiersza n i wiersza n−1 daje liczby Fibonacciego. Kolorowanie komórek według parzystości (parzyste/nieparzyste) tworzy fraktal trójkąta Sierpińskiego. Kolorowanie według reszty modulo p dla liczby pierwszej p tworzy fraktal p-adyczny o samopodobnej strukturze na wszystkich skalach. Sumy wierszy to potęgi 2; tożsamość „kija hokejowego" daje sumy skumulowane kolumn; środkowa kolumna zawiera środkowe współczynniki dwumianowe, które pojawiają się w prawdopodobieństwach powrotu błądzenia losowego.

Podstawowa definicja:
  C(n, k) = C(n−1, k−1) + C(n−1, k)    (reguła Pascala)
  C(n, 0) = C(n, n) = 1

Twierdzenie dwumianowe:
  (a + b)ⁿ = Σₖ₌₀^n C(n,k) · aⁿ⁻ᵏ · bᵏ

Sumy wierszy (przyjmij a=b=1):
  Σₖ C(n,k) = 2ⁿ   (każdy wiersz sumuje się do potęgi 2)

Sumy przekątnych Fibonacciego:
  Σₖ C(n−k, k) = F(n+1)  (sumy płytkich przekątnych = liczby Fibonacciego)

Tożsamość "kija hokejowego":
  Σⱼ₌ᵣ^n C(j, r) = C(n+1, r+1)

Wzorzec parzystości (twierdzenie Kummera):
  C(n, k) jest nieparzyste ⟺ k AND n = k  w zapisie binarnym (bitowe AND)
  Równoważnie: nie zachodzi przeniesienie przy dodawaniu k i (n−k) w systemie binarnym
  → Nieparzyste elementy tworzą fraktal trójkąta Sierpińskiego

Środkowe współczynniki dwumianowe:
  C(2n, n) = (2n)! / (n!)²  ≈ 4ⁿ / √(πn)  (przybliżenie Stirlinga)
  Występuje w: oczekiwanym czasie powrotu symetrycznego błądzenia losowego,
              liczbach Catalana C_n = C(2n,n)/(n+1), zliczaniu ścieżek na kracie

Symulacja trójkąta Pascala renderuje do 20 wierszy z trzema trybami kolorowania: skalą logarytmiczną (wielkości względne), trybem parzystości (który ujawnia trójkąt Sierpińskiego) i kolorowaniem modularnym (gdzie wybiera się modulo pierwsze i koloruje według reszty — tworząc różne fraktale p-adyczne dla każdej liczby pierwszej). Przekątne Fibonacciego i liczb trójkątnych można podświetlić osobno. Najedź kursorem na dowolną komórkę, aby zobaczyć dokładną wartość i wzór C(n,k).

Wszystkie siedem symulacji na pierwszy rzut oka

Jedność matematyki dyskretnej

Te siedem symulacji może wyglądać na oddzielne tematy, ale są głęboko powiązane przez pryzmat matematyki dyskretnej. Algorytmy sortowania są specjalizacjami sieci porównawczych, których optymalna głębokość wiąże się z teoretyczno-informacyjnymi dolnymi granicami. Kolorowanie grafów i N hetmanów to oba problemy spełniania ograniczeń, należące do tej samej klasy złożoności (NP-zupełnej dla wersji decyzyjnych). Szeregi Taylora są ciągłym odpowiednikiem elementów wierszy trójkąta Pascala: współczynniki e^x w szeregu Taylora to 1/n! = 1/C(n,n) · n!/n! — odwrotności elementów diagonalnych trójkąta Pascala.

Problem Collatza opiera się połączeniu z ugruntowaną matematyką — stoi samotnie jako przypomnienie, że proste reguły mogą generować głęboką złożoność, która pokonuje najlepsze narzędzia, jakie mamy. Całkowanie numeryczne z kolei może wydawać się przyziemne, ale jest praktycznym obliczem szeregów nieskończonych: reguła Simpsona to po prostu ocena wielomianu Taylora trzeciego stopnia w trzech punktach i jego dokładne całkowanie.

Algorytmy to język, w którym wyrażamy obliczenia. Te symulacje nie tylko pokazują działanie algorytmów — ujawniają struktury matematyczne wyjaśniające dlaczego działają, gdzie sobie nie radzą i jakich granic żaden algorytm nie może obejść.