diff --git a/prace/bakalarka/formatitko_commands.py b/prace/bakalarka/formatitko_commands.py
index 95213f5541c724a9424802d6c9e1e49859ca22ee..54742264f55c008879873fa8ad204ff689847c30 100644
--- a/prace/bakalarka/formatitko_commands.py
+++ b/prace/bakalarka/formatitko_commands.py
@@ -126,7 +126,7 @@ def refs(element, content, processor):
texb(
"""{
\\leftskip=1.3cm
- \\rightskip=0pt plus 3em
+ \\rightskip=0pt plus 5em
\\relax"""
),
copy(div1, *x),
diff --git a/prace/bakalarka/index.md b/prace/bakalarka/index.md
index ebb7c6f17d3850bb766ac26caf6ad734d664c2be..3b1aae778bee7ea2f73ad0e74946acf8c7134d2a 100755
--- a/prace/bakalarka/index.md
+++ b/prace/bakalarka/index.md
@@ -11,10 +11,11 @@ ft:
abstract: |
Binární paint shop je následující optimalizační úloha:
Na barvicí linku vjíždí řada aut.
- Od každého typu auta jsou tu právě dvě auta a
+ Od každého typu auta jsou někde v řadě právě dvě auta a
jedno z nich bychom rádi nabarvili červeně a druhé modře.
Měnit barvu, kterou aktuálně barvíme, je složitá operace,
proto bychom rádi pro danou posloupnost aut provedli co nejméně změn.
+ Vstupem úlohy jsou typy aut v posloupnost a výstupem je jejich obarvení.
Je známé, že úloha je NP-těžká a za určitých předpokladů dokonce neaproximovatelná,
proto je na místě zkoumat řešení, co se chovají dobře na náhodném vstupu.
V této práci je představen nový algoritmus založený na semidefinitním programování,
@@ -31,10 +32,11 @@ ft:
abstract: |
The Binary Paint Shop represents an optimization problem:
A line of cars enters a paint shop.
- There are exactly two cars of each type.
+ There are exactly two cars of each type somewhere in the line.
The aim is to color one of these two cars red and the other blue.
- It is hard to change the current color in paint shop
- so for a given sequence of cars we would like to minimize number of color changes.
+ It is hard to change the current color in the paint shop
+ so for a given sequence of cars we would like to minimize the number of color changes.
+ Input of the task are types of cars in the line and output is the coloring of theses cars.
This task is known to be NP-hard, and under specific conditions, it defies polynomial time approximations.
Therefore, it is a good idea to find some algorithms which behave well on randomly generated input.
In this thesis is introduced new algorithm based on semidefinite programming
@@ -42,34 +44,36 @@ ft:
We proved that for each input this algorithm returns a solution with expected deviation from optimum of at most 0.212 times the number of car types.
---
``` {c=cmt}
-Abstract: Co je vstup/výstup + typy nejsou u sebe
Obrázek koule
+
Klikaci věci + generování obsahu formátítkem
-Více řezů
-složitost je n^c pro jaké c?
-Absolutní číslování ve struktuře
+Algoritmy velké písmena
Popisky obrázků
Popisky os
Obsah bez změn velikostí
barevné schéma grafu
font grafů
+Velikost poznámky pod čárou
+
+složitost je n^c pro jaké c?
+Absolutní číslování ve struktuře
```
::: {only=html}
$\def\progline#1#2#3{\hbox{#1}\hskip 1cm\relax #2 \hskip 1cm\relax #3}
-\def\P{{\rm P}}
-\def\NP{{\rm NP}}
-\def\APX{{\rm APX}}
-\def\opt{{\rm opt}}
-\def\algo#1{{\bf #1}}
-\def\alg{\algo{alg}}$
+\protected\def\P{{\rm P}}
+\protected\def\NP{{\rm NP}}
+\protected\def\APX{{\rm APX}}
+\protected\def\opt{{\rm opt}}
+\protected\def\algo#1{{\bf #1}}
+\protected\def\alg{\algo{alg}}$
:::
``` {=tex}
\def\progline#1#2#3{\hbox to 3cm{#1\hfil}\hbox to 5cm{\hfil$\displaystyle #2$\hfil}\hbox to 4cm{$\displaystyle #3$\hfil}}
-\def\P{{\rm P}}
-\def\NP{{\rm NP}}
-\def\APX{{\rm APX}}
-\def\vec#1{\overrightarrow{#1\,}}
+\protected\def\P{{\rm P}}
+\protected\def\NP{{\rm NP}}
+\protected\def\APX{{\rm APX}}
+\protected\def\vec#1{\overrightarrow{#1\,}}
\let\rightarrowfillreal\rightarrowfill
\catcode`@=11
\def\overrightarrow#1{\vbox{\m@th\ialign{##\crcr
@@ -78,9 +82,9 @@ $\def\progline#1#2#3{\hbox{#1}\hskip 1cm\relax #2 \hskip 1cm\relax #3}
\def\rightarrowfill{$\settextsize{5}\m@th\smash-\mkern-7mu%
\cleaders\hbox{$\mkern-2mu\smash-\mkern-2mu$}\hfill
\settextsize{5}\mkern-7mu\mathord\rightarrow$}
-\def\opt{{\rm opt}}
-\def\algo#1{{\bf #1}}
-\def\alg{\algo{alg}}
+\protected\def\opt{{\rm opt}}
+\protected\def\algo#1{{\bf #1}}
+\protected\def\alg{\algo{alg}}
```
::: {c=head}
@@ -447,7 +451,7 @@ V této práci se budeme věnovat pouze binárnímu paint shop problému.
Semidefinitní programování
==========================
-V této kapitole si představíme princip semidefinitního programování, jak jej popisují Gärtner a Matoušek [@semidef], a jeho použití na problém maximálního řezu,
+V této kapitole si představíme princip semidefinitního programování (dále též SDP), jak jej popisují Gärtner a Matoušek [@semidef], a jeho použití na problém maximálního řezu,
z něhož vychází algoritmus na binary paint shop.
Nejprve zavedeme a připomeneme notaci důležitou v této kapitole.
@@ -526,7 +530,7 @@ Každá hrana bude v řezu s pravděpodobností $1/2$ -- při umisťování druh
máme pravděpodobnost $1/2$, že ho umístíme do stejné množiny a tedy hrna nebude součásti řezu
a pravděpodobnost $1/2$ že do opačné a tedy bude součástí řezu.
Součet hran v řezu je součtem indikátorů jevů přítomnosti jednotlivých hran v řezu vynásobený jejich hodnotou.
-Z linearity součtu středních hodnot tedy střední hodnota součtu vah hran v řezu je $1/2$ celkového součtu vah hran, což je alespoň $1/2$ optima.
+Z linearity střední hodnoty tedy střední hodnota součtu vah hran v řezu je $1/2$ celkového součtu vah hran, což je alespoň $1/2$ optima.
:::
Povšimněme si, že triviální algoritmus dosáhl poměrně zajímavého aproximačního poměru
@@ -537,7 +541,7 @@ Výsledný algoritmus pak vždy najde řešení obsahující alespoň $1/2$ hran
Lepšího aproximačního poměru můžeme dosáhnout
-Goemans-Williamsonovým algoritmem, založeným na semidefinitním
+Goemansův-Williamsonovým algoritmem, založeným na semidefinitním
programování a proto popsaného mimo jiné v již dříve zmíněném úvodu do semidefinitního programování [@semidef].
Naivní implementace je, že si pro každý vrchol $u$
@@ -546,8 +550,8 @@ Do optimalizační funkce pak zakódujeme graf.
Účelová funkce bude
$$ \sum_{uv \in E} h(u,v)\cdot\left(- \frac{x_u x_v}{2} + \frac{1}{2}\right) = \frac{F}{2} + \frac{1}{2} \sum_{uv \in E} -h(u,v)x_u x_v ,$$
kde $F=\sum_{uv\in E} h(u,v)$ značí součet hodnot všech hran.
-Pro každou hranu tedy přičte $h(u,v)$ pokud $x_u$ a $x_v$ mají
-různá znaménka a $0$ pokud stejná.
+Pro každou hranu tedy přičte $h(u,v)$, pokud $x_u$ a $x_v$ mají
+různá znaménka, a $0$, pokud stejná.
Takovýto optimalizační problém bohužel ani pomocí semidefinitního programování neumíme řešit.
Na to, abychom uměli vyjádřit nějaký součin, musíme použít semidefinitního programování v dekomponovaném tvaru.
@@ -559,11 +563,11 @@ Tím jsme vyrobili relaxaci výše uvedeného programu, protože za těchto podm
i jiných poloh než $(\pm 1,0,\dots,0)$.
Celý algoritmus pak vypadá následovně:
-::: {c=box t=algo name="Goemans-Williamsonův"}
+::: {c=box t=algo name="Goemansův-Williamsonův"}
Vyřešíme následující semidefinitní program v dekomponovaném tvaru:
$$\progline{maximalizuj}{\sum_{uv \in E} -h(u,v)\vec{y_u}^{\rm T} \vec{y_v}}{}$$
$$\progline{za podmínek}{|y_i| = 1}{0 \le i < |V|}$$
-Dále uniformě náhodně zvolíme jednotkový vektor vektor $z\in \R^n$
+Dále uniformně náhodně zvolíme jednotkový vektor vektor $z\in \R^n$
a do jedné množiny vybereme právě ty vrcholy $v$, pro které $y_v^{\rm T} z \ge 0$.
:::
@@ -588,7 +592,7 @@ podle toho se zvyšuje pravděpodobnost toho, že vrcholy budou v jiných množi
Výběr nadroviny a rozdělování bodů jde implementovat pomocí výběru vektoru $\vec{z}$ kolmého na nadrovinu. Pro každý bod pak stačí
spočítat skalární součin se $\vec{z}$ a podle znaménka víme,
do kterého poloprostoru patří.
-Pokud vybereme uniformě náhodný jednotkový vektor, tak jsme uniformě náhodně vybrali nadrovinu.
+Pokud vybereme uniformně náhodný jednotkový vektor, tak jsme uniformně náhodně vybrali nadrovinu.
Jednotkový vektor můžeme generovat tak, že vygenerujeme náhodný vektor nezávisle po složkách z normálního rozdělení, a pak ho znormujeme.
Povšimne si, že normalizace ani není potřeba,
protože to na znaménku součinů nic nemění.
@@ -614,7 +618,7 @@ label("$\vec{v}$", v, E);
draw(scale(0.2)*rotate(-15)*subpath(unitcircle, 0, 85/90));
label("$\alpha$", (0.2, 0), 0.7*ENE);
```
-Znázornění řezu rovinou obsahující $vec{u}$ i $vec{v}$. TODO
+Znázornění řezu rovinou obsahující $\vec{u}$ i $\vec{v}$.
:::
@@ -623,7 +627,7 @@ mezi $\vec{u}$ a $\vec{v}$.
Velikost tohoto úhlu označme $\alpha$.
Víme, že $\vec{u}^{\rm\, T}\vec{v} = 1 \cdot 1 \cdot \cos a$.
Náhodnou přímku můžeme vygenerovat jako náhodný úhel $\beta$ mezi $0$ a $2\pi$ s tím, že
-přímka pak povede směrem $\beta$ a $\beta + \pi \mod 2\pi$. Nikdy však uvnitř konvexního úhlu nebudou obě
+přímka pak povede směrem $\beta$ a $(\beta + \pi) \mod 2\pi$. Nikdy však uvnitř konvexního úhlu nebudou obě
ramena přímky, tedy pravděpodobnost, že alespoň jedno bude uvnitř a tedy body budou oddělené je:
$$ \frac{2 \cdot \alpha}{2\pi} = \frac{\alpha}{\pi} = \frac{\arccos \vec{u}^{\rm\,T}\vec{v}}{\pi}$$
@@ -679,24 +683,24 @@ Bohužel na rozdíl od lineárního programování, u semidefinitního programov
Naštěstí však platí, že v polynomiálním čase za určitých podmínek jsme schopní se mu libovolně přiblížit.
Přesněji řečeno, pro každé $\varepsilon > 0$ jsme schopní najít řešení s účelovou funkcí nejdále $\varepsilon$ od optima.
Ovšem musí platit, že všechna přípustná řešení jsou dostatečně malá.
-Přesněji řečeno, musí platit, že Fobeniova norma všech přípustných matic je omezena konstantou s polynomiální délkou zápisu.
+Přesněji řečeno, musí platit, že Frobeniova norma všech přípustných matic je omezena konstantou s polynomiální délkou zápisu.
Tohoto výsledku jde dosáhnout pomocí elipsoidové metody, která má nejlepší teoretické výsledky. V praxi se však často používají jiné algoritmy.
Všechny naše programy budou splňovat podmínky na řešení, protože každá z hodnot hledané matice nutně bude ležet v intervalu $[-1, -1]$.
::: {c=box t=theorem}
-Goemans-Williamsonův algoritmus je pravděpodobnostní $0.878$-aproxi\-mační algoritmus.
+Goemansův-Williamsonův algoritmus je pravděpodobnostní $0.878$-aproxi\-mační algoritmus.
:::
::: {c=proof}
-Využitím předešlých pozorování a elipsoidové metody získáme:
+Využitím předešlých pozorování a elipsoidové metody získáme (MC značí max cut, tedy maximální řez):
$$ \E[\hbox{Řešení MC}] \ge c\cdot\,\hbox{Řešení SDP} \ge c(1-\varepsilon)\cdot\,\hbox{Optim. SDP} \ge c(1-\varepsilon)\cdot\,\hbox{Optim. MC}.$$
Pro dostatečně malé $\varepsilon$ se tedy jedná o $0.878$ pravděpodobnostní aproximační algoritmus.
:::
-Řešení pomocí semidefinitního programování
-==========================================
+Řešení semidefinitním programováním
+====================================
-Řešení vychází z Goemans-Williamsonova algoritmu na maximální řez.
+Řešení vychází z Goemansův-Williamsonova algoritmu na maximální řez.
Pro každé auto nám bude semidefinitní program umísťovat bod (někdy také chápán jako vektor) na jednotkovou sféru.
Poté náhodně rozřízneme nadrovinou sféru na dvě poloviny
a podle toho, do které poloviny auto patří, zvolíme jeho barvu.
@@ -711,7 +715,7 @@ vynutíme $\vec{y_i} = -\vec{y_j}$. Na to nám stačí jediná podmínka -- ří
$$\progline{maximalizuj}{\sum_{0\le i<2n-1} \vec{y_i}^{\rm T} \vec{y_{i+1}}}{}$$
$$\progline{za podmínek}{\vec{y_{a_{i,0}}} = -\vec{y_{a_{i,1}}}}{0\le i < n}$$
$$\progline{}{|y_i| = 1}{0\le i < 2n}$$
-Dále uniformě náhodně zvolíme jednotkový vektor $z\in \R^{2n}$
+Dále uniformně náhodně zvolíme jednotkový vektor $z\in \R^{2n}$
a červeně obarvíme právě ty auta $i$, pro které $y_i^{\rm T} z \ge 0$.
Náhodných výběrů vektoru je možné provést vícero a pak vybrat nejlepší nalezené řešení.
:::
@@ -771,7 +775,7 @@ $$f'(x) = - \frac{1}{\pi \sqrt{-x^2 +1}} + \frac12 ,$$
x = var('x')
r = plot(derivative(arccos(x)/pi - (1/2 - x/2)), xmin=-1, xmax=1, ymin=-1, ymax=0.3)
```
-Derivace $f$
+Derivace funkce $f$.
:::
což má dva kořeny $x = \pm \sqrt{\pi^2 - 4}/\pi$,
@@ -820,15 +824,22 @@ $$\progline{za podmínek}{|y_i| = 1}{0 \le i < n}$$
Výhodou je, že je potřeba poloviční počet proměnných, matice je čtvrtinová a odebrali jsme $n$ podmínek,
proto v implementační části práce využijeme této formy programu.
-Měření SDP řešení
+Měření řešení BPS
=================
Součástí práce je implementace algoritmů řešících Binární paint shop problém.
-Každý z nich byl následně spuštěn pro různé velikosti, pokaždé na 100 nezávisle náhodně vybraných vstupech.
-Celý test běžel jedno vláknově zhruba dva dny a využíval nejvýše 16 GB operační paměti.
+Každý z nich byl následně spuštěn pro různé velikosti, pokaždé na 100 nezávisle náhodně vybraných vstupech s počtem typů aut
+10, 20, 50, 100, 200, 400, 566, 800, 1131, 1600, 2263 a 3200 (jedna z implementací $\algo{sdp}$ vyžaduje moc paměti a proto byla spuštěna jen na vstupech do velikosti $566$).
+Celý test běžel jednovláknově zhruba dva dny a využíval nejvýše 16 GB operační paměti.
U $\algo{sdp}$ řešení bylo použito 10 náhodných řezů a vždy byl vybraný nejlepší z nich.
+Gitový repozitář s implementací i naměřenými daty je dostupný na <https://gitlab.kam.mff.cuni.cz/jirikalvoda/binary-paint-shop-problem>.
Na následujících stranách jsou zpracovaná různá naměřená data.
+Pro reprodukovatelnost vygenerovaných řešení byly vstupy generovány ze seedů.
+Se stejným seedem se tedy vždy vygeneruje stejný vstup a ideálně i stejné řešení.
+Pro různé algoritmy a velikosti vstupů byly použité různé seedy.
+
+
Praktické řešení semidef. programů
-----------------------------------------
U triviálních algoritmů byla implementace poměrně přímočará.
@@ -861,7 +872,7 @@ ve funkci `Newton::compute_bMatgVec_dense_threads_SDP`.
Při následujícím ladění programu bylo zjištěno, že se program zacyklí v dané funkci ve smyčce, při které inkrementuje hodnotu proměnné
`Column_Number` až do doby, kdy přeteče, což už přímo vede k pádu programu.
Pohledem na kód to vypadá, že toto by se nemělo dít.
-Program už mnohokrát měl ukončit smyčku a doběhnout na konec funkce, ovšem po přidání dostatečného počtu debugovacích výpisů je
+Program už mnohokrát měl ukončit smyčku a doběhnout na konec funkce, ovšem po přidání dostatečného počtu debugovacích výpisů
je vidět, že program cyklus opustí, provede příkazy mezi cyklem a koncem funkce a pak se zase objeví uprostřed cyklu.
Problém byl v tom, že funkce vracející `void*`
@@ -879,7 +890,7 @@ A v tomto případě optimalizace překladače přeložili program tak,
To je důsledkem toho, jakým způsobem se snaží překladač optimalizovat kód.
Překladače nemusí dodržovat naprogramovanou strukturu programu.
Tedy není problém přesunout část za smyčkou do ní na místo, kde se smyčka opouští.
-No a když překladač ví, že v korektním programu by se tudy nemělo opouštět funkci, nemusí se překladač obtěžovat umísťováním explicitního návratu z funkce na dané místo.
+Když překladač ví, že v korektním programu by se tudy nemělo opouštět funkci, nemusí se překladač obtěžovat umísťováním explicitního návratu z funkce na dané místo.
Naštěstí oprava tohoto problému je přímočará -- stačí do takovýchto funkcí explicitně dopsat `return NULL;`.
@@ -887,7 +898,10 @@ Naštěstí oprava tohoto problému je přímočará -- stačí do takovýchto f
Toto bohužel není jediný problém s SDPA-C.
Na některých vstupech knihovna dojde do stavu, kdy nemá semidefinitní matici a výpočet spadne s následující chybou:
+``` {c=cmt}
TODO SAZBA blockquote
+```
+
```
CHOLMOD warning: matrix not positive definite.
file: ../Supernodal/t_cholmod_super_numeric.c line: 911
@@ -903,7 +917,7 @@ Problém se projevuje například na vstupu s $n=5$ a seedem $19$.
Další problém (nebo ten stejný) se projevuje zejména u větších vstupů.
Uprostřed algoritmu se také objeví chybová hláška o nesemidefinitnosti matice.
-Následně program udělá mnoho iterací s nekonečnou účelovou funkcí, dokud se nepřekročí maximální počet iterací a pak je vrácena matice
+Následně program udělá mnoho iterací s nekonečnou účelovou funkcí, dokud se nepřekročí maximální počet iterací, a pak je vrácena matice
ze samých $\pm \infty$, což dokonce porušuje zadané podmínky.
Toto se stává například na seedu $18$ pro $n = 150$.
@@ -925,6 +939,8 @@ Drobným problémem je, že dle dokumentace [@sage-semidef-doc] rozhraní sage v
ovšem náš algoritmus je založený na řešení duálního semidefinitního programu.
Mezi nimi však lze snadno přecházet pomocí triviální úpravy, ovšem výsledný kód pak vypadá velice neintuitivně.
+\vfil\eject
+
Hodnoty skalárních součinů
--------------------------
@@ -977,7 +993,7 @@ Ve 100 vstupech by tedy sousedních aut stejného typu mělo být ve střední h
Není však vyloučeno, že hodnoty skalárního součinu $-1$ nebo blízké program dosáhne i jinak.
-Dimenze řešení
+Dimenze SDP
--------------
Semidefinitní program rozmísťuje vektory do $n-1$ dimenzionální sféry.
@@ -1071,13 +1087,17 @@ Vizualizace jednoho z řešení pro $n=50$, které se vejde do 3D.
\vfil\supereject
-## Časová složitost
+## Časová složitost algoritmu $\algo{sdp}$
Víme, že existuje implementace algoritmu $\algo{sdp}$ s polynomiální časové složitosti (za použití elipsoidové metody).
-Použité řešiče však využívají jiných metod řešení semidefinitních programů.
-Bohužel ani jeden z nich moc neslibuje, jakou přesně složitost má.
+Použité řešiče však využívají jiných metod řešení semidefinitních programů a ani jeden z nich moc neslibuje, jakou přesně složitost má.
Proto je na místě změřit, jak rychlé řešení jsou.
+Testování probíhalo na stroji s procesorem AMD Ryzen 5 7600.
+Programům bylo poskytnuto $16\,{\rm GB}$ operační paměti
+a běh byl omezen na jedno jádro procesoru.
+Během výpočtu na stoji neběželo nic kromě výpočtu a základních funkcí operačního systému.
+
::: {#tmp2 c=figure}
```python {c=plotly}
from bakalarka import g, data_lib
@@ -1102,15 +1122,26 @@ fig.update_layout(
Závislost času řešení na velikosti vstupu.
:::
+TODO proložit přímkou a udělat závěr.
+
+\vfil\supereject
+
Skóre
-----
-::: {#tmp c=figure}
+Nejzajímavější je pro nás naměřené (relativní) skóre algoritmů.
+
+Mezi uvažovanými řešeními jsou dvě implementace $\algo{sdp}$.
+Implementace pomocí sage bohužel vyžaduje velké množství paměti a proto nebyla testovaná na tak velkých vstupech.
+O implementaci pomocí SDPA-C víme, že občas chybuje. Naštěstí chyby nenastávají tak často, aby to moc ovlivňovalo výsledné skóre.
+Pokud algoritmus chyboval a vrátil nějaké řešení, je uvažováno skóre daného řešení.
+Pokud algoritmus žádné řešení nevrátil, uvažuje se místo toho hodnota $n$, což je jistě horní odhad na snadno dosažitelné řešení.
+
+::: {#score c=figure}
```python {c=plotly}
from bakalarka import g, data_lib
data = g.load_main_test()
-hd = data_lib.group_by_n(data.pipelines["semidef_prog_sage.sage(10, CVXOPT)"])
fig = go.Figure(data=[go.Box(
x=[i.n for i in d],
@@ -1135,13 +1166,66 @@ fig.update_layout(
Naměřená závislost relativního skóre řešení na velikosti vstupu.
:::
+Na výše uvedeném grafu si můžeme všimnout, že s rostoucím $n$
+se u všech měřených algoritmů zmenšuje rozptyl relativního skóre
+navíc i naměřená střední hodnota má spíše klesající či stagnující
+tendenci. Tedy pokud tento trend pokračuje i dále, algoritmy
+se na větších než měřených vstupech chovají alespoň tak dobře jako na měřených.
+
+Z grafu vidíme, že pro dostatečně velká $n$ je naměřené relativní skóre algoritmu $\algo{sdp}$ menší než $0.34$.
+Z toho můžeme tedy usuzovat, že $\delta_{\algo{sdp}}(n) \le 0.34$ pro $n\in\{100, 200, 400, 566, 800, 1131, 1600, 2263\}$.
+Z toho pak můžeme vyslovit hypotézu, že $\delta_{\algo{sdp}}(n) \le 0.34$ pro $n \ge 100$ a tedy i $\delta_{\algo{sdp}}^+ \le 0.34$.
+
+Z naměřených dat také můžeme usuzovat, že $\algo{sdp}$ je lepší než libovolný z jiných představených algoritmů.
+
+\vfil\eject
+
Dolní odhad
-----------
Výstup z každého algoritmu nám dává hodní odhad na optimum daného vstupu.
Ovšem semidefinitní programování nám navíc dává i dolní odhad na optimum, protože víme,
-že optimum jednho z ekvivalentních vyjádření účelové funkce je vždy menši rovno optimu BPS.
-Použité řešiče semidefinitních programů nám navíc dají i horní odhad na optimum SDP (řešení duálního programu).
+že optimum jednoho z ekvivalentních vyjádření účelové funkce je vždy menši rovno optimu BPS.
+Použité řešiče semidefinitních programů nám navíc dají i horní odhad na optimum SDP (který se od nalezeného řešení může nepatrně lišit).
+
+::: {#lower_bound c=figure}
+```python {c=plotly}
+from bakalarka import g, data_lib
+
+
+data = g.load_main_test()
+d = data.pipelines["semidef_prog_sage.sage(10, CVXOPT)"]
+
+fig = go.Figure(data=[
+ go.Box(
+ x=[i.n for i in d],
+ y=[i.score/i.n for i in d],
+ name="Horní odhad"
+ ),
+ go.Box(
+ x=[i.n for i in d],
+ y=[i.data["lower_bound"]/i.n for i in d],
+ name="Dolní odhad"
+ ),
+ ])
+
+fig.add_hline(y=0.214,
+ annotation_text="0.214", annotation_position="top left",
+ fillcolor="green")
+fig.update_layout(
+ xaxis=dict(showgrid=False, type="log"),
+ yaxis=dict(range=[0, 1]),
+)
+```
+
+Horní a dolní odhad na 100 náhodných instancí vygenerovaný sage $\algo{spd}$.
+:::
+
+Takto vygenerovaný dolní odhad nám bohužel nepřináší žádnou zajímavou informaci o chování na náhodném vstupu.
+Připomeňme, že Hančl a kol. [@docw] dokázali, že $\delta^- \ge 0.214$. Průměrný dolní odhad na testovaných vstupech je pro
+dostatečně velký vstup dle obrázku [](#lower_bound) menší než $0.214$, tedy nedostáváme ani žádnou novou hypotézu na dolní odhad.
+
+Nicméně stále je zajímavé, že pro konkrétní instanci umíme určit nějaký netriviální dolní odhad.
Závěr {-}
=========
@@ -1161,23 +1245,6 @@ A druhak jsme si všimli, že dimenze řešení semidefinitního programování
Stále však zůstává otevřená otázka, kolik přesně je $\delta^+$ a $\delta^-$ (a případně zda se rovnají)
a jaké nejlepší $\delta^+_{\alg}$ je možno dosáhnout polynomiálním algoritmem $\alg$.
-Seznam zkratek {-}
-==================
-
-------- -----------------------------------
-Zkratka Vysvětlení
-------- -----------------------------------
-Řeš. Řešení
-
-Opt. Optimum
-
-SDP Semidefinitní programování
-
-MC Max cut - Maximální řez
-
-BPS Binární paint shop problém
-------- -----------------------------------
-
Seznam použité literatury {-}
=============================
diff --git a/prace/bakalarka/sample.bib b/prace/bakalarka/sample.bib
index a755e98c1d55493ef711e2eddf1fcfbc9e78d39a..7c54056c38ad5f3a9e2caef0130a5f79709ecea0 100644
--- a/prace/bakalarka/sample.bib
+++ b/prace/bakalarka/sample.bib
@@ -69,7 +69,7 @@ abstract = {In the binary paint shop problem we are given a word on n characters
author = {{SDPA Project}},
title = {SDPA Official Page},
url = {https://sdpa.sourceforge.net/},
- year = {1995-2024},
+ year = {1995–2024},
urldate = {2024-03-30}
}