Theory-of-Algorithms-Cheatsheet/main.typ

#import "@preview/finite:0.5.0": automaton
#import "@preview/fletcher:0.5.7" as fletcher: diagram, edge, node
#import "@preview/gentle-clues:1.2.0": *
#import "@preview/tablex:0.0.9": tablex
#import "layout.typ": indent-par, project

#show: project.with(title: [Theory of Algorithms Cheatsheet], authors: (
  "Kristofers Solo",
))

#let teo(title: "Teorēma", ..args) = memo(title: title, ..args)

#let TM = `TM`
#let qrej = $q_"rej"$
#let qacc = $q_"acc"$
#let halt = `HALTING`
#let halt2 = `HALTING_2`
#let NP = `NP`

= Tjūringa Mašīnas
== Variācijas 
Var būt 3 veida uzdevumi: stāvokļu, tekstuāls, vairāklenšu.

#info(title: "Čērča-Tjūringa tēze")[
  Viss, ko var intuitīvi saukt par "algoritmu" vai "efektīvu procedūru", var
  tikt izpildīts ar Tjūringa mašīnu.
  Tā nav pierādāma teorēma, bet gan skaitļošanas modeļa definīcija, kurai līdz
  šim nav atrasts pretpiemērs.
]

=== Viena lente<one_tape>
$(q, a) -> (q', a', d)$ -- stāvoklī $q$ redzot $a$, ieraksta $a'$
un iet virzienā $d space (<- "vai" ->)$.

=== Divas (vai vairākas fiksētas) lentes
$(q, a_1, a_2) -> (q', b_1, b_2, d_1, d_2)$ -- $a_1$, $b_1$, $d_1$ pirmai
lentei un $a_2$, $b_2$, $d_2$ otrai lentei. Svarīga atšķirība ir ka
vairlāklenšu TM  papildus $<-$ un $->$ virzieniem ir $arrow.b$ (stāvēšana uz
vietas).

\* Derīgs ar uzdevumiem, kur palīdz kopēšana/salīdzināšana.

=== Stāvēšana uz vietas
Nosimulēt stāvēšanu uz vietas jeb $d=0$ var šādi:
- $(q, a) -> (q_"new", a', ->)$
- $(q_"new", a slash b slash c slash * ) -> (q_"new", a slash b slash c slash *, <-)$

=== Modelis, ko pamatā izmanto šajā kursā!

Šajā kursā fokusējas uz TM, kas ir:
  + Vienas lentes (skat. @one_tape); 
  + Bezgalīga vienā virzienā -- pa labi; 
  + Pirmais simbols ir tukšais simbols (`_`); 
  + Pēc pirmā simbola ir ievade;
  + Pēc ievades ir bezgalīgs tukšu simbolu skaits;
  + Sāk uz pirmā ievades simbola (viens pēc pirmā tukšuma).

== Risinājuma shēma 
+ Izdomāt, kā aizstājot simbolus ar $*$ var pārbaudīt virknes derību.
+ Atcerēties par secību -- aiz $a$ var sekot tikai $b slash c$, aiz $b$ var sekot tikai $c$, utt.
+ Doties katrā no virzieniem var doties arī līdz galam jeb tukšumam $\_$.
+ Vairāklenšu #TM pārraksta pirmo daļu līdz $\#$ uz otras lentes un salīdzina.

Tas ir bieži sastopamais formāts, bet var gadīties arī cits.

== Piemērs $(a^n b^n c^n", kur" n > 0)$
Vai ieejas virknē $a^n b^n c^n$, kur $n>0$

#context [
  $(q_1, a) -> (q_2, *, ->)$ \
  $(q_1, b slash c) -> qrej$ \
  $(q_1, *) -> (q_1, *, ->)$ \
  $(q_1, \_) -> qacc$ \

  $(q_2, a) -> (q_2, a, ->)$ \
  $(q_2, b) -> (q_3, *, ->)$ \
  $(q_2, c) -> qrej$ \
  $(q_2, *) -> (q_2, *, ->)$ \

  $(q_3, a) -> qrej$ \
  $(q_3, b) -> (q_3, b, ->)$ \
  $(q_3, c) -> (q_4, *, ->)$ \
  $(q_3, *) -> (q_3, *, ->)$ \

  $(q_4, a slash b) -> qrej$ \
  $(q_4, c) -> (q_4, c, ->)$ \
  $(q_4, \_) -> (q_5, \_, <-)$ \

  $(q_5, a slash b slash c slash *) -> (q_5, a slash b slash c slash *, <-)$ \
  $(q_5, \_) -> (q_1, \_, ->)$ \
]

- Aizstāj $a$ ar $*$, $b$ ar $*$, $c$ ar $*$.
- Kontrolē secību (pēc $a$ jāseko $a$ vai $b$, pēc $b$ jāseko $b$ vai $c$, pēc
  $c$ var sekot tikai $c$).
- Ja kādu simbolu nevar atrast, noraida.

== Piemērs (vai virkne atkārt. pēc `#`)
Vai ieejas virkne $x \# x$, kur $x in {0,1}^*$

#context [
  $(q_1, 0, \_) -> (q_1, 0, 0, ->, ->)$ \
  $(q_1, 1, \_) -> (q_1, 1, 1, ->, ->)$ \
  $(q_1, \#, \_) -> (q_2, \#, \_, 0, <-)$ \

  $(q_2, 0, 0) -> (q_2, 0, 0, <-)$ \
  $(q_2, 1, 1) -> (q_2, 1, 0, <-)$ \
  $(q_2, \#, \_) -> (q_3, \#, \_, ->, ->)$ \

  $(q_3, 0, 0) -> (q_3, 0, 0, ->, ->)$ \
  $(q_3, 0, 1) -> qrej$ \
  $(q_3, 1, 0) -> qrej$ \
  $(q_3, 1, 1) -> (q_3, 1, 1 ->, ->)$ \
  $(q_3, 0 slash 1, \_) -> qrej$ \
  $(q_3, \_, 0 slash 1) -> qrej$ \
  $(q_3, \_, \_) -> qacc$ \
]

- Nokopē simbolus līdz $\#$ uz otras lentes.
- Sasniedzot $\#$, uz otras lentes iet atpakaļ līdz pirmajam simbolam.
- Salīdzina pirmās lentes simbolus pēc $\#$ ar otro lenti.

= Sanumurējamība
== Definīcija 
- Bezgalīgas kopas $A$, $B$ ir vienāda izmēra, ja ir bijekcija ($1:1$ attiecība)
  $F: A->B$.
- $A$ ir sanumurējama ar atkārtojumiem, ja ir attēlojums $F:N->A$, kas par katru
  $a$ $E$ $A$ attēlo vismaz vienu $x$ $E$ $N$.
#teo[$A$ ir sanumurējama ar atkārtojumiem tad un tikai tad, ja $A$ ir sanumurējama.]

== Sanumerātības pierādījums 
- Kopa ir sanumurējama, ja tajā eksistē bijekcija starp kopas elementiem un
  naturāliem skaitļiem. Citos vārdos sakot, katram kopas elementam var piešķirt
  unikālu naturālu skaitli.
- Ja kopa ir galīga, tā ir triviāli sanumurējama, jo katram elementam var
  piešķirt unikālu naturālu skaitli.
- Ja kopa ir bezgalīga (ar ko bieži vien darbojamies), jāņem vērā divi varianti:
  - Ja var izveidot bijekciju starp kopu un naturāliem skaitļiem, tad
    jāpierāda, ka bijekcija pastāv -- Var skaidri definēt funkciju, kas katram
    kopas elementam piešķir unikālu naturālu skaitli un parādīt, ka tā apvieno
    visus elementus bez dublēšanās.
  - Ja nevar atrast bijekciju starp kopu un naturāliem skaitļiem, tad jāpierāda,
    ka bijekcija nepastāv.
    Parasti tas tiek darīts, izmantojot pierādīšanas tehnikas, piemēram,
    diagonālināciju vai pretrunu (sk. @diagonalization, @contradiction).
- Ja izdodas pierādīt, ka start kopu un naturāliem skaitļiem nav bijekcijas, tad
  kopa ir nesaskaitāma.

=== Algoritmiska sanumurētība (par sanumerātību)

- Kopa $A$ ir sanumurējama, ja $A={x_1, x_2, ...}$
- Kopa $A$ ir algoritmiski sanumurējama, ja ir Tjūringa mašīna, kas izdod virkni
  $x_1, x_2, ...$, kurai $A={x_1, x_2, ...}$
#let DL = `DL`
#let IL = `IL`
Divu lenšu #TM, kur viena ir klasiska darba lente (#DL) un otra ir izvada
lente (#IL) (tikai rakstīšanai).

==== Piemērs $(a^k b^k mid(|) k>=0) "ir sanum.?"$
Pamatot, ka kopa ${a^k b^k mid(|) k>=0}$ ir algoritmiski sanumurējama.

+ Uzraksta uz izejas lentes tukšu vārdu.
+ Uzraksta vienu $a$ uz darba lentes.
+ Atkārto:
  + Uz ieejas lentes uzrakstām tikpat $a$, cik bija uz #DL;
  + Uz izejas lentes uzrakstām tikpat $b$, cik $a$ bija uz #DL;
  + Uz izejas lentes uzrakstām $\_$;
  + Uz darba lentes pierakstām klāt vienu $a$.
+ Izejas lente $=epsilon, a b, a a b b, a a a b b b,...$

==== Piemērs (atkārt. pēc \# ir sanum\.?)
Pamatot, ka kopa ${x \# x mid(|) x in {a, b}^* }$ ir algoritmiski sanumurējama.

+ Uz darba lentes iet cauri visiem $x$.
+ Katram $x$ uz izejas lentes uzraksta $x \# x$.
+ Uz izejas lentes uzraksta $\#\_$.
+ Uz darba lentes uzraksta $a$.
+ Atkārto:
  + Pārraksta darba lentes saturu $x$ uz izejas lenti;
  + Uzraksta $\#$ uz #IL, vēlreiz pārraksta $x$ uz #IL, uzrakstām $\_$ uz #IL.
  + Uz #DL nomaina $x$ pret nākošo vārdu.

=== Diagonālinācija (pret sanumurējāmību) <diagonalization>
Paņēmienu -- ir saraksts (pieņem, ka ir iegūts saraksts) vai uzskaitījums ar
visiem kopas elementiem un tiek konstruēts jauns elements, kas neatrodas šajā
sarakstā. Tas demonstrē, ka kopa ir nesanumurējama, jo vienmēr var izveidot
jaunu elementu, kas nav iekļauts uzskaitē (piemēram, reālos skaitļos).

=== Pretruna (pret sanumurējāmību) <contradiction>
Pieņem, ka kopa ir saskaitāma un tad rodas pretruna. To var izdarīt, parādot,
ka kaut kādas kopas īpašības vai kardinalitāte ir pretrunā ar sanumurējamības
pieņēmumu.

== Piemērs $(ZZ "sanumurētība")$
Vai visu veselo skaitļu kopa $ZZ={..., -1, 0, 1, ...}$ ir sanumurējama? \
Vai ir $F:{F(1), F(2), ..., F(n), ...}=ZZ$? \


$ F(1)=0, F(2)=-1, F(3)=1, F(4)=-2, ... $

Viens no veidiem, kā izveidot bijekciju pāra kopai, ir izmantot metodi, ko sauc
par Kantoro pārošanas funkciju.
Kantora pārošanas funkcija ir definēta sekojoši:
$f(k_1, k_2) := 1/2(k_1 + k_2)(k_1 + k_2 + 1) + k_2$, kur $k_1,k_2 in NN = {0, 1, 2, ...}$

#figure(
  image("assets/img/cantors-pairing-function.png", width: 50%),
  caption: "Cantor's pairing function",
)

Šī funkcija kā ievadi pieņem naturālo skaitļu pāri $(k_1, k_2)$ un to attēlo
kā unikālu naturālo skaitli.
Tā nodrošina, ka katram pārim tiek piešķirts unikāls skaitlis un tiek aptverti
visi iespējamie pāri bez atkārtojumiem.

Lai pierādītu, ka naturālo skaitļu pāru $(k_1, k_2)$ kopa ir saskaitāma, mēs
varam parādīt, ka funkcija $f(k_1, k_2)$ nodrošina bijekciju starp naturālo
skaitļu pāru kopu un naturālo skaitļu kopu. 

$"Injektivitāte" + "Surjektivitāte" = "Bijektivitāte"$

=== Injektivitāte
Pieņemsim, ka $f(k_1, k_2) = f(k_3, k_4)$, kur $(k_1, k_2)$ un $(k_3, k_4)$
ir atšķirīgi pāri no naturālo skaitļu kopas.
Vienkāršojot un nolīdzinot izteiksmes, varam parādīt, ka
$k_1 = k_3$ un $k_2 = k_4$.
Tātad funkcija $f$ ir injektīva.

=== Surjektivitāte
Jebkuram naturālam skaitlim $n$ varam atrast pāri $(k_1, k_2)$, kas tiek
attēlots uz $n$, izmantojot Kantora pārošanas funkcijas apgriezto funkciju.
Pielietojot apgriezto funkciju uz $n$, varam atgūt sākotnējo pāri $(k_1, k_2)$.
Tādējādi funkcija $f$ ir surjektīva.

= Redukcijas

== Definīcija

- $A <= B$, ja ir ar Tjūringa mašīnu izrēķināms pārveidojums 
  - $R$: (ieejas dati $A$) -> (ieejas dati $B$),
  - $B(R(x)) = A(x)$.

Ja $A <= B$ -- ja var atrisināt $B$, tad var atrisināt $A$. $A$ ir reducējuma
par $B$.

Ja $A <= B and A >= B$, tad $A$ un $B$ ir ekvivalentas.

== Piemērs (var vai nevar reducēt)

// Jorens: Originally šeit bija sajaukta secība, bet uzdevums ir kinda valīds
// abās pusēs, kopumā risinājums ir nedaudz problemātisks.

#quote[
  Dota problēma $halt2(M, x, y) = 1$, kur Tjūringa mašīna $M$ apstājas vismaz uz
  vienas no ievadēm $x$ vai $y$. Pierādīt, ka to var vai nevar reducēt uz
  $halt$, tas ir parādīt $(halt 2 <= halt)$.
]

Lai pierādītu, ka problēmu $halt2(M, x, y)$ var noreducēt uz #halt, mums
jāparāda, ka varam konstruēt Tjūringa mašīnu, kas atrisina #halt2, izmantojot
#halt kā atrisinātu problēmu (jeb kā apakšprogrammu).

Pieņemsim, ka mums ir Tjūringa mašīna $H$, kas atrisina #halt problēmu.
Konstruēsim jaunu Tjūringa mašīnu $H 2$, kas atrisina #halt2 problēmu:

Tjūringa mašīna $H 2$ darbojas sekojoši:
- Doti ievades dati $M$, $x$ un $y$.
- Palaiž $H$ ar ievaddatiem $(M, x)$.
- Ja $H$ akceptē $(M, x)$, apstājas un akceptē.
- Ja $H$ noraida $(M, x)$, palaiž $H$ ar ievaddatiem $(M, y)$.
- Ja $H$ akceptē $(M, y)$, apstājas un akceptē.
- Ja $H$ noraida $(M, y)$, apstājas un noraida.

// Jorens:Nav "vai nu", bet "vai". Citādi paliek abi pozitīvi, kas nav
// apskatīti.
Konstruējot $H 2$ šādā veidā, mēs simulējam $H$ darbību uz abām ievadēm $x$ un
$y$:
- Ja $H$ akceptē $(M, x)$ vai $(M, y)$, $H 2$ akceptēs un apstāsies.
- Ja $H$ noraida gan $(M, x)$, gan $(M, y)$, $H 2$ noraidīs un apstāsies.

// Jorens: Tas jau ir nedaudz liekvārdīgi, izņēmu dažas lietas.

_Tālākais teksts nav obligāts risinājumā._

Redukcijas analīze:
- Ja $halt2(M, x, y) = 1$, tas nozīmē, ka Tjūringa mašīna $M$ apstājas vismaz
  uz vienas no ievadēm $x$ vai $y$. Šajā gadījumā $H 2$ arī apstāsies un
  akceptēs, jo tā veiksmīgi simulē $H$ uz abām ievadēm un akceptē, ja $H$
  akceptē kādu no tām. Tādējādi #halt2 tiek reducēta uz #halt.
- Ja $halt2(M, x, y) = 0$, tas nozīmē, ka Tjūringa mašīna $M$ neapstājas ne uz
  $x$, ne uz $y$. Šajā gadījumā #halt2 arī neapstāsies un noraidīs, jo tā
  simulē $H$ uz abām ievadēm un noraida, ja $H$ norada abas.

Tādējādi #halt2 tiek reducēta uz #halt.

= Neatrisināmas (non-decidable) problēmas 

#let acc = `ACCEPTING`
#let eqans = `EQUAL_ANSWERS`
#let one = `ONE`
#let infinite = `INFINITE`
#let equiv = `EQUIV`
#let hamcycle = `HAMCYCLE`
#let linineq = `LIN-INEQ`
#let M1 = $M 1$
#let M2 = $M 2$
#let SAT = `SAT`

== Definīcija

Neatrisināma problēma ir problēma ir problēma, kurai neeksistē TM, kas
atrisinātu šo problēmu.

== Funkcionālas un nefunkcionālas īpašības

TODO.

== Raisa teorēma

#teo(
  title: "Raisa teorēma",
)[Ja $F$ nav triviāla (ir $M:F(M)=0$ un $M':F(M')=1$), tad $F$ -- neatrisināma.]

Teorēma pasaka mums priekšā, ka jebkuru netriviālu *funkcionālu* īpašību var
parādīt kā redukciju no HALTING.

== Uzskaitījums 
- $halt(M\# x)=1$, ja $M$ apstājas, ja ieejas virkne $=x$.
- $acc(M\# x)=1$, ja $M$ uz ieejas virknes izdod atbildi $1$.
- $eqans(M\# x \# y)=1$, ja $M$ uz ieejas virknēm $x$ un $y$ izdod vienādas atbildes.
- $one(M)=1$, ja eksistē ieejas virkne $x$, uz kuras $M$ izdod atbildi $1$.
- $infinite(M)=1$, ja eksistē bezgalīgi daudzas ieejas virknes $x$, uz kurām $M$ izdod atbildi $1$.
- $equiv(M 1, M 2)=1$, ja $M1(x)=M2(x)$
- $linineq(S)=1$, ja sistēmai ir atrisinājums $x_1, x_2, ..., x_n in {0,1}$
- $"pcp"(S)=1$ (Post-correspondance problem), ja divām galībām kopām $A = [a_1,
  a_2, ..., a_n]$ un $B = [b_1, b_2, dots, b_n]$ var izvēlēties indeksu secības
  $a_("i1") a_("i2") ... a_("ik")$ = $b_("i1") b_("i2") ... b_("ik")$ (tā lai
  konkatenācijas būtu vienādas); domino kauliņi ar augšu un apakšu, ko saliekot
  kopā, globālai augšai un apakšai jāsakrīt. 
- $"mortal-matrix"(S)=1$, vai no matricām $M_1, M_2, ..., M_n$ var izveidot
  secību (ar atkārtojumiem), ka matricu reizinājums būtu 0.
// LININEQ, HAMCYCLE are DECIDABLE!
// - $"hilbert's-10th"(S)=1$, ...?

#info[Ja var atrisināt #acc, tad var atrisināt arī #halt.]
#info[Ja var atrisināt #eqans / #one / #infinite / #equiv, tad var atrisināt arī #acc.]

== Pierādījums no redukcijas (Soļi)
+ Skaidri definē problēmu, kuru vēlas pierādīt kā #NP -- norādot, kas ir derīga
  ievade un kādus rezultātus programmai paredzēts izvadīt.
+ Pieņem, ka eksistē algoritms vai #TM, kas spēj atrisināt problēmu visiem
  iespējamiem ievaddatiem.
  Šī pieņēmuma mērķis ir rādīt pretrunu.
+ Definē citu problēmu, kas var tikt noreducēta līdz sākotnējai problēmai.
  Tas nozīmē, ka, ja var atrisināt sākotnējo problēmu, var atrisināt arī
  saistīto problēmu.
+ Izveido transformācijas vai redukcijas algoritmu, kas ņem saistītās problēmas
  instanci un pārveido to par sākotnējās problēmas instanci. Šai redukcijai
  vajadzētu saglabāt atbildi uz saistīto problēmu.
+ Pierāda, ka, ja sākotnējai problēmai ir risinājums, tad arī saistītajai
  problēmai ir risinājums.
  Šajā solī parasti ir jāpierāda, ka redukcijas algoritms ir pareizs un pareizi
  pārveido instances.
+ Pierāda, ka, ja saistītajai problēmai ir risinājums, tad arī sākotnējai
  problēmai ir risinājums.
  Šis solis parasti ietver pierādījumu, ka redukcijas algoritmu var atgriezt
  atpakaļ, lai iegūtu risinājumu sākotnējai problēmai.
+ Apvieno iepriekšējos soļus, lai parādītu, ka, ja sākotnējai problēmai ir
  risinājums, tad arī saistītajai problēmai ir risinājums.
  Šeit jārodas pretrunai.
#context [
  #set par(justify: false)
  == Piemēri (prob. ir neatr)
  === #halt / #acc
  - #underline("Teorēma"): Ja var atrisināt #acc, tad var atrisināt arī #halt
  - #underline("Pierādījums"): Attēlojums $R:M->M'$ ar īpašību $halt(M\#x) = acc(M'\#x)$.
  - Tad $halt(M\#x)$ var atrisināt sekojoši:
  - izrēķina $M'=R(M)$, izrēķinām, vai $acc(M'\#x)$.
  - $M'$ -- programma, ko iegūst no $M$, visur aizstājot #qrej ar #qacc.
  - Ja $M$ akceptē/noraida, tad $M'$ akceptē (izdos $1$).
  - Ja $M$ neapstājas, $M'$ arī neapstājas.

  === #eqans/ #acc
  - #underline("Zinām"): #acc nav atrisināma
  - #underline("Pierādām"): Ja var atrisināt #eqans, tad var atrisināt arī #acc.
  - #underline("Secinām"): #eqans nevar atrisināt.
  - Dots: $M, x$
  - Jādefinē: $M', y: eqans(M' \# x \# y) = acc(M\# x)$.
  - $y$ -- virkne no viena simbola $s$, kas nav vārdā $x$.
  - Ja $M'$ redz simbolu $s$, $M'$ akceptē, citādi darbina $M$.
  - $M'(quote.angle.l.double s quote.angle.r.double)=1$, $M'(x)=M(x)$, ja $x$ nesatur $s$.
  - $eqans(M'\# x \# quote.angle.l.double s quote.angle.r.double)=acc(M\#x)$.

  === #one/ #acc
  - #underline("Pierādām"): Ja var atrisināt #one, tad var atrisināt arī #acc.
  - Dots: $M, x$
  - Jādefinē: $M': one(M') = acc(M\# x)$.
  - $M'$: nodzēš no lentes ieejas virkni $y$, uzraksta $x$, palaiž $M$ programmu.
  - Jebkurai $y, M'(y)=M(x)$.

  === #infinite/ #acc
  - #underline("Pierādām"): Ja var atrisināt #infinite, tad var atrisināt arī #acc.
  - Dots: $M, x$
  - Jādefinē: $M': infinite(M') = acc(M\# x)$.
  - Jebkurai $y, M'(y)=M(x)$.
  - Ja $M(x)=1$, tad $M'(y)=1$ jebkurai $y$.

  === #equiv / #acc
  - #underline("Pierādām"): Ja var atrisināt #equiv, tad var atrisināt arī #acc.
  - Dots: $M, x$
  - Jādefinē: $M_1, M_2: equiv(M_1, M_2) = acc(M\# x)$.
  - Ja $M$ akceptē $x, M_1, M_2$ jābūt ekvivalentām.
  - Ja $M$ neakceptē $x, M_1, M_2$ nav jābūt ekvivalentām.
  - $M_1$: nodzēš ieejas virkni $y$, uzraksta $x$, darbina $M$.
  - $M_2$: uzreiz pāriet uz akceptējoši stāvokli.
  - Ja $acc(M\#x)=1$, tad $M_1(y)=1$ visiem $y$.
  Tā kā $M_2(y)=1$, tad $equiv(M_1, M_2)=1$.

  === #halt -- pierādījums no pretējā
  - Pieņemsism, ka ir #TM $M_H$, kas risina #halt.
  - Definē $M'$ šādā veidā:
    - Ieejas dati: $x$.
    - Atrod $x$ atbilstošo Tjūringa mašīnas programmu $M$.
    - Ja $M_H(M\#x)=1$, tad caur universālo #TM darbina $M$ uz $x$, izdod pretējo atbildi.
    - Ja $M_H(M\#x)=0$, tad izdod $1$.

  Jebkuram $x:M'(x) != M(x)$, kur $M$ -- #TM, kas atbilst $x$.

  === #acc -- pierādījums no pretējā
  - Pieņem, ka #acc ir atrisināma.
  - $M(x)$:
    - Atrod ieejas virknei $x$ atbilstošo $M_i$.
    - Ja $acc(M_i \# x)=1$, $M$ izdod $0$.
    - Ja $acc(M_i \# x)=0$, $M$ izdod $1$.

  Jebkurai $M_i$, būs $x$, kuram $M(x) != M_i(x)$.

  === $A(M)=1$, ja $M$ -- #TM programma un, darbinot $M$ uz tukšas ieejas virknes, tā apstājas un izdod $1$
  Pieņemsim, ka eksistē algoritms $D$ problēmai $A(M)$.
  $D$ ir algoritms, kas spēj noteikt, vai Tjūringa mašīna $M$, apstājas un
  atgriež $1$ ar tukšu ievades virkni.

  Tagad konstruēsim jaunu #TM, $N$:
  + Palaiž $M$ ar tukšu ievades virkni.
  + Ja $M$ apstājas un atgriež $1$, $N$ apstājas un atgriež $1$.
  + Ja $M$ apstājas, bet neatgriež $1$, $N$ ieiet bezgalīgā ciklā.
  + Ja $M$ neapstājas, $N$ apstājas un atgriež $0$.

  Dodot algoritmam $D$ ievadi $N$ notiks sekojošais:
  - Ja $D$ atgriež $1$, tas nozīmē, ka $M$ apstājas un atgriež $1$ ar tukšu
    ievades virkni (atbilstoši $A(M)$ definīcijai).
    Šajā gadījumā $N$ apstāsies un atgriezīs $1$, un $D$ būs devis pareizu
    atbildi.
  - Ja $D$ atgriež $0$, tas nozīmē, ka vai nu $M$ neapstājas, vai $M$ apstājas,
    bet neatgriež $1$ ar tukšu ievades virkni.
    Pirmajā gadījumā $N$ apstāsies un atgriezīs $0$, kas atbilst $D$ dotajai
    atbildei.
    Tomēr otrajā gadījumā $N$ ieies bezgalīgā ciklā, un $D$ būs devis nepareizu
    atbildi.

  Tā kā $D$ uz $N$ sniedz nepareizu atbildi vienā no gadījumiem, mēs varam
  secināt, ka problēma $A(M)$ ir #NP.
  Tāpēc neeksistē algoritms, kas spētu noteikt, vai dotā Tjūringa mašīna
  apstājas un atgriež $1$ ar tukšu ievades virkni visām iespējamām Tjūringa
  mašīnām.
]

#teo(
  title: "Kuka-Levina teorēma",
)[#SAT problēma (Boolean satisfiability problem) ir NP-pilna.]

#info[
  #SAT problēma: dots Būla algebras izteikums, vai ir iespējams piešķirt
  mainīgajiem vērtības (patiess/aplams) tā, lai viss izteikums būtu
  patiess?
]
Šī teorēma bija pirmā, kas pierādīja kādas problēmas NP-pilnību.
Pēc tās, lai pierādītu, ka cita problēma $L$ ir NP-pilna, pietiek parādīt,
ka $L in NP$ un ka $SAT <_p L$ (vai jebkura cita zināma NP-pilna problēma).


== Daļēja atrisināmība

// Jorens: Tas teksta blāķis, kas šeit bija var apjucināt cilvēkus, viss kas
// vajadzīgs ir sarakstāms īsāk.

- $A$ –- daļēji atrisināma, ja ir Tjūringa mašīna $T$:
  - Ja $A(x) = 1$, tad $T(x) = 1$.
  - Ja $A(x) = 0$, tad $T(x) = 0$ vai $T(x)$ neapstājas.

Tas, ka problēma ir daļēji atrisināma, nozīmē, ka nav konkrēta un *vispārīga*
algoritma, kas vienmēr varētu sniegt pareizu "nē" atbildi gadījumiem ārpus
problēmas. 

Var būt iespējams konstruēt Tjūringa mašīnu, kas apstājas un sniedz
"nē" atbildi noteiktiem gadījumiem ārpus problēmas, bet tas nav garantēts
visiem gadījumiem (_un īsti nav apskatīts šajā kursā_).

#teo[$A$ -- daļēji atrisināma tad un tikai tad, ja $A$ -- algoritmiski sanumurējama.]

Cits nosaukums daļējai atrisināmībai ir atpazīstamība (angl. recognizability/recognizable).

= Nekustīgo punktu teorija 

== Nekustīgā punkta teorēma

Lai $phi_x$ ir daļēji definēta funkcija, ko aprēķina Tjūringa mašīna ar
programmu $x$.  Lai $F: Sigma^* -> Sigma^*$ ir jebkurš visur definēts
aprēķināms pārveidojums uz programmām.

Tad: $"eksistē"(x): phi_{F(x)} = phi_x$

- $phi_x$: funkcija, ko aprēķina programma $x$.
- $F$: jebkura visur definēta aprēķināma funkcija virknēm (programmām).
- $Sigma^*$: visu galīgo virkņu kopa pār alfabētu $Sigma$.

== NPT pielietošanas piemērs

TODO.

= Sarežģītības teorija

== Lielais $O$ un mazais $o$

Notācija, kas tiek izmantota, lai raksturotu *funkciju* sarežģītību
asimptotiski.

=== Lielais-O (formālā definīcija)

$f(n) in O(g(n))$, ja:

$exists C > 0, exists n_0 > 0:$ $(forall n >= n_0: f(n) <= c * g(n))$

Tas nozīmē, ka funkcija $f(n)$ asimptotiski nepārsniedz konstanti $c$ reizinātu
$g(n)$.

/*
=== Piemērs

$f(n) = 17n^2 + 23n + 4$  
$g(n) = n^2$

Tad $f(n) in O(n^2)$, jo:

$17n^2 + 23n + 4 \leq 17n^2 + 23n^2 + 4n^2 = 44n^2$  
tātad $C = 44$.
*/

=== Mazais-o (formālā definīcija)

$f(n) in o(g(n))$, ja:

$
lim_(i -> infinity) f(n) / g(n) = 0
$

Tas nozīmē, ka funkcija $f(n)$ kļūst nenozīmīga attiecībā pret $g(n)$, $n$
tiecoties uz bezgalību.

/*
=== Piemērs

$log(n) \in o(n)$  
jo jebkuram $epsilon > 0$ pietiekami lieliem $n$:  
$log(n) <= epsilon * n$.
*/

=== $f(n) in O(g(n))$ pamatojuma triks 

Ja ir pierādījums, ka $f(n) in o(g(n))$, tad automātiski var secināt, ka $f(n)
in O(g(n))$. *Tikai pozitīvajā gadījumā!* Jo mazais $o$ ir stingrāka prasība
par lielo $O$.

=== Pamatojuma soļi 

- Ja funkcija pielīdzināta lielajam $O$:
  + Salīdzina funkcijas augstāko pakāpi ar doto $O$ pakāpi.
  + Ja funkcijas pakāpe ir lielāka, tad vienādojums būs patiess, jo funkcija aug
    straujāk.
  + Korektam risinājumam jāpamato kāpēc definīcijas nevienādība ir patiesa
    visiem $n >= n_0$ un iespējams jāparāda piemēra $c$.
- Ja funkcija pielīdzināta mazajam $o$:
  + Jāievieto dotais robežā $lim_(x->oo)f(x)/g(x)$;
  + Rezultāts ir 0, patiess, citādi -- nepatiess.

=== Piemērs (lielais-O)

$ 2n^4 + 6n^2 + 17 =^? O(n^4) $

Izteiksme ir patiesa, tā kā kreisās puses izteiksmes augstākā pakāpe jeb kārta
ir $4$ un iekš $O$ tā arī ir $4$.

=== Piemērs (lielais-O)
$ 2n^4 + 6n^2 + 17 =^? O(n^3) $

Izteiksme ir aplama, jo kreisajā pusē augstākā pakāpe ir $4$, kamēr labajā ir
norādīta $3$, un $4$ pakāpes izteiksmi nevar izpildīt $O(n^3)$.

=== Piemērs (lielais-O)
$ n^3 + 17n + 4 in^? O(n^3) $

Jā, $n^3 + 17n + 4 <= n^3 + 17n^3 + 4n^3 = 22n^3$.

=== Piemērs (lielais-O)
$ n^4 + 17n + 4 in^? O(n^3) $

Nē $n^4 + 17n + 4 > n^4 = n dot n^3$

=== Piemērs (mazais-O) <small-o-example-3>
$ n log^4 n =^? o(n^1.5) $

Ir zināms, ka mazajā $O$ notācijai, ja $lim_(x->oo)f(x)/g(x)$, kur $f(x)$ ir
funkcija un $g(x)$ ir $o$, tad vienādība izpildās.
Ievietojot vērtības $ lim_(n->oo) (n log^4 n)/n^1.5=0 $
Tātad vienādojums ir
patiess.

=== Piemērs (mazais-O)
$ 2^n n^2 =^? o(n^3) $

Pēc tās pašas aprakstītās īpašības, kā @small-o-example-3, sanāktu
$ lim_(n->oo) (2^n n^2)/3^n $
un tā kā $3^n$ aug ātrāk kā $2^n$, šī robeža būs $0$ un sākotnējais
vienādojums būs patiess.


== Sarežģītības klases

#let time = `TIME`

=== Laiks (TIME)

$time(f(n))$ -- problēmas $L$, kurām eksistē Tjūringa mašīna $M$, kas pareizi
risina $L$ un izmanto $O(f(n))$ soļus.

/* random piemērs -> relocate? */

/*
$ lim n/2^n=lim (n)'/(2^n)'=lim 1/(2^n ln 2) $

Augot $n$, $2^n->oo$, tātad $1/n^2->0$.

$ n^2/2^n=(n/2^(n slash 2))^2 $
Mēs zinām, ka $n/2^(n slash 2)->0$.

$ lim (log n)/n = lim (log n)'/(n)' = lim (1 slash n)/1 = lim 1/n $

$ lim (log^17 n)/n = lim (m^17)/c^m = lim (m/c^(m slash 17))^17 -> 0 $

- $time(n)$ -- `2x` lielākā laikā var atrisināt problēmu `2x` lielākam $n$.
- $time(n^2)$ -- `4x` lielākā laikā var atrisināt problēmu `2x` lielākam $n$.
- $time(n^3)$ -- `8x` lielākā laikā var atrisināt problēmu `2x` lielākam $n$.
*/

==== #TM darbības laiks

/*
- Laiks ir soļu skaits un ir atkarīgs no ieejas virknes $x_1, x_2, ..., x_n$.
- Ja ir algoritms ar sarežģītību $n^2$, tad bieži ir arī algoritms ar
  sarežģītību $n^2/2, n^2/3,...$
*/

+ Identificēt galvenās operācijas vai soļus, ko Tjūringa mašīna veic katrai
  ievadei.
  + Tas varētu ietvert simbolu lasīšanu no lentes, simbolu rakstīšanu lentē,
    lentes galviņas pārvietošanu, aprēķinu veikšanu vai lēmumu pieņemšanu,
    pamatojoties uz pašreizējo stāvokli un ievades simbolu.
+ Noteikt sliktākā gadījuma scenāriju.
  + Analizēt ievadi vai ievades secību, kas prasītu maksimālo soļu skaitu,
    lai Tjūringa mašīna pabeigtu savu aprēķinu.
  + Apsvērt ievades, kas maksimizē iterāciju skaitu vai liek mašīnai izpētīt
    visas iespējamās aprēķinu zaru versijas.
+ Izteikt darbības laiku atkarībā no ievades izmēra.
  + Definēt funkciju, kas attēlo Tjūringa mašīnas veikto soļu vai pāreju
    skaitu kā funkciju no ievad izmēra.
  + Piemēram, ja ievades izmērs ir $n$, darbības laika funkciju varētu apzīmēt
    kā $f(n)$.
+ Vienkāršot darbības laika funkciju un izsakot to, izmantojot lielā $O$
  notāciju.
  + Lielā $O$ notācija nodrošina augšējo robežu darbības laika funkcijas
    pieauguma ātrumam, palielinoties ievaddatu izmēram.
  + Noņemt konstantes faktorus un zemākas kārtas locekļus no darbības laika
    funkcijas, lai koncentrētos uz dominējošo locekli, kas atspoguļo pieauguma
    ātrumu.
+ Izteikt vienkāršoto darbības laika funkciju, izmantojot atbilstošo lielā $O$
  notāciju, piemēram, $O(n)$, $O(n log n)$, $O(n^2)$, $O(2^n)$ utt.

===== Piemērs ($|a| = |b|"?"$)
Vai ieejas virknē ir vienāds skaits $a$ un $b$?

+ Virzās no kreisās puses uz labo, aizstājot vienu $a$ un vienu $b$ ar $x$;
+ Ja neatrod nedz $a$, nedz $b$, akceptē;
+ Ja neatrod vienu no $a$ vai $b$, noraida;
+ Ja atrod gan $a$, gan $b$, virzās atpakaļ uz pirmo simbolu un atkārto.

Kopējais soļu skaits:
- Ne vairāk kā $(n/2+1) 2n = n^2 + 2n$ soļi.
- Ja $n$ nav ļoti mazs, $n^2$ būs vairāk nekā $2n$ un soļu skaits $O(n^2)$.

=== Vieta (SPACE)

TODO.

=== Laika-Vietas sakarības

TODO.

=== Asimptotiskas augšanas hierarhija

Sekojošas funkcijas pieaugums pie $x -> infinity$:

$log(x) << x << x \cdot log(x) << x^k << a^x << x! << x^x$

- $x$: mainīgais (parasti $n$).
- $k$: jebkurš vesles pozitīvs skaitlis ($k in NN$).
- $a$: reāla konstante lielāka par $1$ ($a > 1$).

Šo hierarhiju var izmantot intuīcijai par to vai funkcija pieder klasei
sarežģītības klasei, bet kā pamatojums tas nederētu.

_$x^epsilon$ ir izņemts laukā, lai nejauktu galvu_

_Source; Mathematics for Computer Science, 2018, Eric Lehman, Google Inc._

= Klase P (TODO)

.

= Klase NP

== NP problēmas

NP (nederminēti-polinomiālas) problēmas 
ir problēmas (2 ekvivalentas definīcijas):

+ $L in NP$, ja eksistē pārbaudes algoritms - $O(n^c)$ laika Tjūringa mašīna $M$:
  + Ja $L(x) = 1$, tad eksistē y: $M(x, y) = 1$.
  + Ja $L(x) = 0$, tad visiem y: $M(x, y) = 0$.  
+ NP = problēmas $L$, ko var atrisināt ar nedeterminētu mašīnu $O(n^c)$ laikā.

Ekvivalence ir pierādīta ar abpusēju pārveidojumu no pārbaudītāja uz nedet. TM
un atpakaļ.

== NP-pilnas probēmas un to redukcijas

=== Polinomiāla redukcija $(<=_("poly"))$

- $A <= B$ – A var atrisināt, noreducējot to uz B.
- $A <=_("poly") B$, ja ir $O(n^c)$ laika algoritms (Tjūringa mašīna) $P$:
  - $M$ pārveido $A$ ieejas datus par $B$ ieejas datiem;
  - $A(x) = B(M(x))$.

=== NP-pilnīgums

- A – NP-pilna, ja:
  - $A in "NP"$;
  - Ja $B in NP$, tad $B <=_("poly") A$.

=== 3-SAT problēma 

Vai formulai 3-CNF formā var piemeklēt katra mainīgā vērtības tā, lai formula
būtu 1 (patiess).

=== CIRCUIT-SAT problēma 

Dota funkcija $F(x_1, ..., x_n)$, kas sastāv no vārtiem (AND, OR, NOT).

#figure(
  image("assets/img/circuit_sat.png", width: 50%),
  caption: "CIRCUIT-SAT visual",
)

Vai var atrast mainīgo vērtības tā lai gala izvade būtu 1 (patiess).

=== CLIQUE problēma

$exists C subset.eq V: (|C| = k) and (forall (u, v in C): (u, v) in E)$

Vārdiski. Vai eksistē virsotņu kopa $S$ lielumā $k$, kurā katra virsotne ir
savienota ar katru otro no kopas $S$.

=== IND-SET problēma

$exists S subset.eq V: (|S| = k) and (forall (u, v in S): (u, v) in.not E)$

Vārdiski. Vai grafā $G=(V, E)$ eksistē virsotņu kopa $S$ lielumā $k$, kurā
katra no virsotnēm nav savienota ar nevienu citu virsotni no šīs
kopas.

=== LIN-INEQ problēma

Vai dotā lineāru nevienādību sistēma ar bināriem mainīgajiem ir atrisināma.

=== CIRCUIT-SAT ≤ₚ 3-SAT

- Katram starprezultātam (kas nav pirmajā ievadē, i.e., $x_1$, $x_2$, $dots$,
  $x_n$) ievieš jaunus mainīgos $y_i$.
- Katriem vārtiem formulē atbilstošas izteiksmes.

Piemērs AND vārtiem. Nosaucam ievades kā x, y un izvadi kā z: $z = x and y$

#table(
  columns: 4,
  [*$x$*],[*$y$*],[*$z$*],[*$z = x and z$?*],
  [$0$],[$0$],[$0$],[jā],
  [$0$],[$0$],[$1$],[nē],
  [$0$],[$1$],[$0$],[jā],
  [$0$],[$1$],[$1$],[nē],
  [$1$],[$0$],[$0$],[jā],
  [$1$],[$0$],[$1$],[nē],
  [$1$],[$1$],[$0$],[nē],
  [$1$],[$1$],[$1$],[jā],
)

Izveidojam pretrunas katrai rindai. Tas ir, konjunkciju katrai rindai ar "nē".

Piemēram, 2\. rindai (0, 0, 1): $x or y or not z$.

Tad uzbūvējam konjunkciju vārtiem:

$
(x or y or not z) and (x or not y or not z) and \
 and (not x or y or not z) and (not x or not y or z)
$

Veido konjunkciju no visiem vārtiem shēmā. Tā kā 3-SAT sagaida 3 mainīgos katrā
iekavā. Tiem, kas satur 1 vai 2 (identitātes vārti un not vārti attiecīgi),
pārveido tos par 3-CNF konjunkciju pievienojot jaunu mainīgo, kas vienā
formulā ir pozitīvs un otrā -- negācija.

$
(x or not b) = (x or not b or a) and (x or not b or not a)
$

Analoģiski iekavām ar vienu elementu. Rezultātā ir 3-CNF formula, ko var
izmantot ar 3-SAT algoritmu.

=== 3-SAT ≤ₚ IND-SET

Katrai iekavai no formulas veido $3$ virsotnes (grafa komponenti), kas apzīmē
mainīgo (ar NOT, ja ir negācija). Katra virsotne (literālis) no komponentes ir
savā starpā savienota ar pārējām. Starp pretrunīgiem literāliem starp
komponentēm pievieno šķautni.

Piemērs formulai $(x or y or not z) and (not x or y or z)$:

#figure(
  image("assets/img/3_sat_indset.png", width: 50%),
  caption: "3-SAT -> INDSET visual",
)

Tagad varam pielietot $"IND-SET"\(G, m\)$ ar izveidoto grafu un $m$ kā iekavu
skaitu originālajā formulā.

=== IND-SET ≤ₚ CLIQUE

- Veido grafa papildinājumu (komplementu) $G' = (V, E')$:

$E' := {(u, v) in V times V | (u, v) in.not E}$

Vārdiski. Jauns grafs $G$, kurā ir visas virsotnes no $V$, bet 
visas šķautnes, kas ir $G$ nav $G'$ un pretēji -- visas šķautnes 
kā nav $G$ ir $G'$.

#figure(
  image("assets/img/graph_complement.png", width: 50%),
  caption: "Papildgrafa piemērs",
)

Ir spēkā sakarība $"INDSET"(G, k) = "CLIQUE"(G, k)$.

= Extras

== Logaritmu īpašības

#context [
  #set text(size: 10pt)
  #show math.equation: set text(weight: 400, size: 8pt)

  #figure(table(
    columns: 3,
    [*Property*], [*Definition*], [*Example*],
    [Product],
    $ log_b m n = log_b m + log_b n $,
    $ log_3 9 = log_3 9 + log_3 x $,

    [Quotient],
    $ log_b m/n = log_b m - log_b n $,
    $
      log_(1/4) 4/5 = log_(1/4) 4
      - log_(1/4) 5
    $,

    [Power], $ log_b m^p=p dot log_b m $, $ log_2 8^x = x dot log_2 8 $,
    [Equality],
    $ "If" log_b m = log_b n, \ "then" m=n $,
    $
      log_8(3x-4)=log_8(5x+2) \
      "so," 3x-4=5x+2
    $,
  ))
]

== Atvasinājumu tabula

#context [
  #set text(size: 11pt)
  #show math.equation: set text(weight: 400, size: 11pt)

  #table(
    columns: 3,
    inset: (top: .8em, bottom: .9em), // vert. padding
    [*Funkcija*], [*Atvasinājums*], [*Piezīmes*],

    [$x^n$], [$n x^(n-1)$], [],
    [$e^x$], [$e^x$], [],
    [$a^x$], [$a^x ln(a)$], [$a > 0$],
    [$ln(x)$], [$1 / x$], [],
    [$1 / x$], [$-1 / x^2$], [],
    [$1 / x^n$], [$-n / x^(n+1)$], [],
    [$sqrt(x)$], [$1 / (2 sqrt(x))$], [],
    [$1 / sqrt(x)$], [$-1 / (2 x^(3/2))$], [],
  )

  \* Ja $x = g(x)$ (kompleksa funkcija), tad pie atvasinājuma 
  piereizina $g(x)'$.
]