Differences

This shows you the differences between two versions of the page.

--- aa:lab:sol:3 [2023/10/27 12:10]
ioana.dabelea
+++ aa:lab:sol:3 [2025/10/19 21:59] (current)
andreidarlau04 [Algebraic Data Types]
@@ Line 1: / Line 1: @@
-===== Exercițiul 1 =====
+===== Exercitiul 1 =====
-  * $ f_{111}(M) = TRUE \iff  M[111] \rightarrow TRUE$
+==== Metoda Agregatelor ====
-O să încercăm să arătăm că $ f_{h} \le_m f_{111}$.
+=== ArrayList - inserare ===
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{111}$:
+Raspuns: ĉ<sub>i</sub> = 3
-$ M, w \to t \to M^*$
-După ce am găsit asta,  mai ramane de demonstrat doar: $ f_{h}(M, w) = TRUE \iff f_{111}(M^*) = TRUE$
+Explicatie: Incepem cu un array cu capacitate 1 si 0 elemente (vom nota cost insert = c<sub>i</sub>, copiere n elemente = cpy<sub>n</sub>.
+  * insert1: c = c<sub>i</sub> = 1
+  * insert2: c = cpy<sub>1</sub> + c<sub>i</sub> = 2
+  * insert3: c = cpy<sub>2</sub> + c<sub>i</sub> = 3
+  * insert4: c = c<sub>i</sub> = 1
+  * insert5: c = cpy<sub>4</sub> + c<sub>i</sub> = 5
+  * insert6: c = c<sub>i</sub> = 1
+  * insert7: c = c<sub>i</sub> = 1
+  * insert8: c = c<sub>i</sub> = 1
+  * insert9: c = cpy<sub>8</sub> + c<sub>i</sub> = 9
-$ M^*(x):$
-<code>
-   run M[w]
-   return x == 111
-</code>
-Demonstraţii:
+Observam ca numarul de copieri este cpy<sub>1</sub> + cpy<sub>2</sub> + cpy<sub>4</sub> + cpy<sub>8</sub> + ... + cpy<sub>n</sub> = 2 * n (suma geometrica). (1)
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] $ se termină  $\Rightarrow $ vom returna x == 111 $\Rightarrow $ când x este 111, $ M^* $ va tranziţiona în Y $\Rightarrow M^*[111] \rightarrow TRUE \Rightarrow f_{111}(M^*) = TRUE$
-  - $ f_{111}(M^*) = TRUE \Rightarrow M^*[111] \rightarrow TRUE \Rightarrow $ am ajuns la return $\Rightarrow $ run M[w] nu a ciclat $ \Rightarrow $ M[w] s-a oprit $\Rightarrow f_{h}(M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{111}$.
+De asemenea, au avut loc n insert-uri, care au c = n. (2)
-------
+Din (1) si (2) => ĉ<sub>i</sub> = T(n) / n = (2 * n + n) / n = 3.
-  * $ f_{p}(M) = TRUE \iff \forall w, M \text{ decide dacă w e palindrom} $
-O să încercăm să arătăm că $ f_{h} \le_m f_{p}$.
+=== ArrayList - stergere ===
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{p}$:
+Raspuns = ĉ<sub>i</sub> = 2.
-$ M, w \to t \to M^*$
-$ M^*(x):$
+Presupunem cel mai rau caz: capacitate = 4 * n, nr. elemente = n + 1 (delete va cauza o copiere, deoarece la primul delete ajungem la 1/4 din capacitate)
-<code>
-   run M[w]
-   check if x is palindrome
-</code>
-Demonstraţii:
+  * delete1: cpy<sub>n/2</sub> + c<sub>delete</sub> = n/2 + 1 -> capacitatea devine 2 * n
-  - $ f_{h}(M, w) = TRUE \Rightarrow M[w] $ se termină $\Rightarrow $ o sa verificăm dacă x este palindrom $\Rightarrow $ când x este palindrom, $ M^* $ va tranziţiona în Y $  \Rightarrow f_{p}(M^*) = TRUE$
+  * delete2: c<sub>delete</sub> = 1
-  - $ f_{p} (M^*) = TRUE \Rightarrow M^*[x] $ decide daca x este palindrom  $  \forall x \Rightarrow $ am ajuns la return $  \Rightarrow $ run M[w] din  $ M^* $ nu a ciclat $  \Rightarrow $ M[w] s-a oprit $  \Rightarrow f_{h} (M, w) = TRUE$
+  * delete3: c<sub>delete</sub> = 1
+  * ...
+  * delete(n/2): cpy<sub>n/4</sub> + c<sub>delete</sub> = n/4 + 1 -> capacitatea devine n
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{p}$.
+Observam ca numarul de copieri este cpy<sub>n/2</sub> + cpy<sub>n/4</sub> + cpy<sub>n/8</sub> + ... = n. (1)
-------
-  * $ f_{rev}(M) = TRUE \iff \forall w, M \text{ computează inversul lui w}$
-O să încercăm să arătăm că $ f_{h} \le_m f_{rev}$.
+Numarul de stergeri efective este n. (2)
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{rev}$:
+Din (1) si (2) => ĉ<sub>i</sub> = T(n) / n = (n + n) / n = 2.
-$ M, w \to t \to M^*$
-$ M^*(x):$
-<code>
-   run M[w]
-   return rev(x)
-</code>
-Demonstraţii:
+=== ArrayList - cazul generic ===
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $ se termină $  \Rightarrow  $ o sa calculeze rev(x) deoarece ajunge la return $  \Rightarrow f_{rev} (M^*) = TRUE$
-  - $ f_{rev} (M^*) = TRUE \Rightarrow M^*[x]  $ calculeaza rev(x)  $  \forall x \forall x \Rightarrow  $ am ajuns la return $  \Rightarrow  $ run M[w] din  $ M^*  $ nu a ciclat $  \Rightarrow  $ M[w] s-a oprit $  \Rightarrow f_{h} (M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{rev}$.
+Fie capacitatea initiala = 1, c<sub>i</sub> = costul inserarii, c<sub>d</sub> = costul stergerii.
-------
-  * $ f_{own}(M) = TRUE \iff M[enc(M)] \rightarrow TRUE$
-O să încercăm să arătăm că $ f_{h} \le_m f_{own}$.
+Stim ca:
+  * c<sub>i</sub> = 1 pentru cazul fara copiere
+  * c<sub>i</sub> + m cazul pentru copiere si inserare
+  * c<sub>d</sub> = 1 pentru cazul fara copiere
+  * c<sub>d</sub> + m pentru cazul stergerii si copierii
+  * n<sub>final</sub> = k - p numarul final de elemente (elemente inserare - elemente sterse)
+  * nr<sub>operatii</sub> = k + p
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{own}$:
+=> ĉ<sub>i</sub> = C<sub>total</sub> / (k + p) = (C<sub>ins</sub> + C<sub>del</sub>) / (k + p)
-$ M, w \to t \to M^*$
-$ M^*(x):$
+Am stabilit precedent ca:
-<code>
+  * costul tuturor copierilor la inserare este de 2k
-   if x == enc(M*):
+  * costul tuturor inserarilor efective este k
-     run M[w]
+  * => C<sub>ins</sub> = 3k
-   else:
-     nu se termină
-</code>
-Demonstraţii:
+De asemenea:
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $ se termină $  \Rightarrow M^*[enc(M^*)]  $ se termina $  \Rightarrow f_{own} (M^*) = TRUE$
+  * costul tuturor copierilor la stergere este de p
-  - $ f_{own} (M^*) = TRUE \Rightarrow M^*[enc(M^*)]  $ se termina $  \Rightarrow  $ run M[w] din  $ M^*  $ nu a ciclat $  \Rightarrow  $ M[w] s-a oprit $  \Rightarrow f_{h} (M, w) = TRUE$
+  * costul tuturor stergerilor efective este tot p
+  * => C<sub>del</sub> = 2p
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{own}$.
+=> ĉ<sub>i</sub> = (3k + 2p) / (k + p)
-------
+Interpretare:
-  * $ f_{finite}(M) = TRUE \iff M \text{ se oprește pentru un număr finit de cuvinte}$
+  * pentru p = 0, avem ĉ<sub>i</sub> = 3 (adevarat, asta este costul doar inserarilor)
+  * pentru k = 0 (presupunem ca avem deja un array), ĉ<sub>i</sub> = 2 (adevarat, costul stergerii)
+  * pentru k = p, avem ĉ<sub>i</sub> = 2.5
+  * => costul amortizat este mai apropiat de 3 pentru mai multe inserari, dar mai apropiat de 2 pentru mai multe stergeri.
-O să încercăm să arătăm că $ f_{h} \le_m f_{finite}$.
+==== Metoda bancherului ====
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{finite}$:
-$ M, w \to t \to M^*$
-$ M^*(x):$
+(pentru insertion: 3 bani -> 1 inserare, 1 banut atribuit inseratiei curente, 1 banut atribuit altei inseratii din bucata copiata precedent)
-<code>
-   run M[w] pentru maxim |x| paşi
-    dacă M[w] s-a oprit:
-     nu se termina
-    else:
-     se termina
-</code>
-Demonstraţii:
+Idee de rezolvare: impartim array-ul in 2 bucati:
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $  se termină in n paşi $  \Rightarrow M^*[w]  $ se opreşte  $  \forall x  $ , |x| < n $ ,  $ ciclează  $  \forall x  $ , |x| >= n $  \Rightarrow f_{finite} (M^*) = TRUE$
+  * bucata care se va copia = elementele care raman dupa stergeri
-  - $ f_{finite} (M^*) = TRUE \Rightarrow M^*[x]  $  se opreşte după un număr finit de cuvinte  $ \Rightarrow  $ M[w] s-a oprit după un număr finit de paşi $  \Rightarrow f_{h} (M, w) = TRUE$
+  * bucata elementelor care se sterg.
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{finite}$.
+Pentru fiecare operatie de stergere (cost 1), "plasam" un banut catre prima bucata a array-ului (cea care se va copia). In acest fel, la momentul copierii, fiecare element are deja banutul pregatit care ii acopera costul. Astfel, nu mai trebuit platit un cost suplimentar pentru copiere.
-------
+==== Metoda potentialelor ====
-  * $ f_{set}(A, M) = TRUE \iff \forall w \in A, M[w] \text{ halts}$
-O să încercăm să arătăm că $ f_{h} \le_m f_{set}$.
+ĉ<sub>i</sub> = c<sub>i</sub> + Φ(D<sub>i</sub>) - Φ(D<sub>i-1</sub>).
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{set}$:
+Definim n = elemente curente, m = capacitate:
-$ M, w \to t \to A, M^*$
-A = {101}
+Fie
-$ M^*(x):$
+    Φ(n,m) = 2n - m,  daca n >= m/2
-<code>
+           = m/2 - n, altfel
-   if x is in A:
-    run M[w]
-   else:
-    nu se termină
-</code>
-Demonstraţii:
+. Cazul stergerii in cazul in care capacitatea nu se schimba:
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $ se termină $  \Rightarrow  $ cum  $  M^*  $ se poate opri doar pentru x = 101 $  \Rightarrow \forall w f_{set} (A, M^*) = TRUE$
+  * c<sub>i</sub> = 1
-  - $ f_{set} (M^*) = TRUE \Rightarrow M^*[x]  $ o să se oprească pentru orice x din A $  \Rightarrow  $ M[w] s-a oprit $  \Rightarrow f_{h} (M, w) = TRUE$
+  * ΔΦ = Φ(n - 1, m) - Φ(n, m):
+    * caz 1: n > m/2 => ΔΦ = (2(n - 1) - m) - (2n - m) = -2
+    * caz 2: n = m/2 => ΔΦ = (m/2 - (n - 1)) - (2n - m) = 1 + 3m/2 - 3n, dar n = 3m/2 => ΔΦ = 1 + 3m/2 - 3m/2 = 1
+    * caz 3: n < m/2 => ΔΦ = (m/2 - (n - 1)) - (m/2 - n) = 1
+Aflam ca pentru un load factor de peste 1/2 (suntem aproape de capacitatea maxima) avem cost amortizat -1, iar 2 daca ne apropiem de injumatatire.
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{set}$.
+<note important>In operatiile de analiza amortizata, noi luam drept cost amortizat costul operatiilor mai "scumpe", neluand in calcul operatiile "ieftine", deci ĉ<sub>i</sub> = 2 in acest caz, nu -1. </note>
-------
-  * $ f_{x}(M) = TRUE \iff \exists w, M[w] \text{ scrie un x pe bandă la un moment dat}$
-O să încercăm să arătăm că $ f_{h} \le_m f_{x}$.
+. Cazul stergerii in care capacitatea se schimba:
+  * Perechea (n, m) este de fapt (n + 1, 4 * n) -> (n, 2 * n)
+  * ΔΦ = Φ(n, 2 * n) - Φ(n + 1, 4 * n) = (2 * n - 2 * n) - (4 * n / 2 - n - 1) = 1 - n
+  * c<sub>i</sub> = 1 + n (deletion + copiere)
+  * ĉ<sub>i</sub> = 1 + n + (1 - n) = 2
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{x}$:
+===== Algebraic Data Types =====
-$ M, w \to t \to M^*$
-$ M^*(x):$
+. <code>
-<code>
+typedef struct list {
-   run M[w]
+    int e;
-   print x
+    struct list *next;
-</code>
+} *List;
-Demonstraţii:
+List Void() {
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $ se termină $  \Rightarrow  $ cum  $  M^*  $ printează x la final $  \Rightarrow f_{x} (M^*) = TRUE$
+    return NULL;
-  - $ f_{x} (M^*) = TRUE \Rightarrow M^*[x]  $ ajunge să printeze x pe bandă $  \Rightarrow  $ M[w] s-a oprit $  \Rightarrow f_{h} (M, w) = TRUE$
+}
+List Cons(int e, List list) {
+    List newElem = (List)malloc(sizeof(struct list));
+    newElem->e = e;
+    newElem->next = list;
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{x}$.
+    return newElem;
-------
+}
-  * $ f_{eq}(M_1, M_2) = TRUE \iff  \forall w, M_1[w] \equiv M_2[w]$; i.e. mașinile au același comportament (fie acceptă, fie resping, fie computează aceeași valoare, fie nu se termină) pentru orice cuvânt.
-O să încercăm să arătăm că $ f_{h} \le_m f_{eq}$.
-Trebuie să găsim o transformare t care primeşte inputul lui Halting Problem şi întoarce un input pentru $ f_{eq}$:
-$ M, w \to t \to M_{1}, M_{2}$
-$ M_{1}[x]: $
-<code>
- acceptă
 </code>
+.
-$ M_{2}[x]: $
 <code>
-   run M[w]
+Size(Void) = 0
-   acceptă
+Size(Cons(e, L)) = 1 + Size(L)
 </code>
-Demonstraţii:
-  - $ f_{h} (M, w) = TRUE \Rightarrow M[w]  $ se termină $  \Rightarrow M_{2}   $ acceptă orice x, iar  $  M_{1} [x]  $ deja acceptă orice x din construcţie $  \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq} (M_{1} , M_{2} ) = TRUE$
-  - $ f_{eq} (M_{1} , M_{2} ) = TRUE \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow  $ stim din construcţie că $  M_{1}   $ acceptă orice x $  \Rightarrow M_{2}   $ acceptă orice x $  \Rightarrow M[w]  $ se opreşte $  \Rightarrow f_{h} (M, w) = TRUE$
-Din cele 2 direcţii ale demonstraţiei $\Rightarrow f_{h} \le_m f_{eq}$.
-===== Exercițiul 2 =====
-  * $ f_{all} \le_m f_{eq}$
-$ M \to t \to M_{1}, M_{2}$
-Trebuie să construim o transformare t, astfel încât să obţinem 2 maşini cu acelaşi comportament doar dacă M[w] se opreşte **pentru orice** w
-$ M_{1}[x]: $
 <code>
- acceptă
+Add(Void, x) = Cons(x, Void)
+Add(Cons(y, L), x) = Cons(y, Add(L, x)
 </code>
-$ M_{2}[x]: $
 <code>
-   run M[x]
+Append(Void, L) = L
-   acceptă
+Append(Cons(x, L1), L2) = Cons(x, Append(L1, L2))
 </code>
-**Atenţie** acest exercitiu are transformarea diferită faţă de exerciţiul 1, subpunctul 8.
-Demonstraţii:
-  - $ f_{all} (M) = M \Rightarrow \forall x, M[x]  $ se termină $  \Rightarrow M_{2}   $  acceptă orice x, iar $  M_{1}   $ deja acceptă orice x din construcţie $  \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq} (M_{1} , M_{2} ) = TRUE$
-  - $ f_{eq} (M_{1} , M_{2} ) = TRUE \Rightarrow M_1[w] \equiv M_2[w]  $ , ştim din construcţie că  $  M_{1}  $  acceptă orice x $  \Rightarrow M_{2}   $  acceptă orice x $  \Rightarrow M[x]  $ se opreşte pentru orice x $  \Rightarrow f_{all} (M, w) = TRUE$
-------
-  * $ f_{any} \le_m f_{eq}$
-$ M \to t \to M_{1}, M_{2}$
-$ M_{1}[x]: $
 <code>
- acceptă
+Reverse(Void) = Void
+Reverse(Cons(x, L)) = Append(Reverse(L), Cons(x, Void))
 </code>
+Helper:
-$ M_{2}[x]: $
 <code>
-   k = 1
+isNull(Void) = True
-   inputs = [0]
+isNull(Cons(x, L)) = False
-   while true {
-    for w in inputs:
-     step(M[w]) // rulam o singura tranzitie
-     if(M[w] s-a oprit)
-      accepta
-    k++
-    inputs.append(k)
-   }
 </code>
-Demonstraţii:
+.
-  - $ f_{any}(M) = M \Rightarrow \exists w, M[w]  $ se termină $ \Rightarrow M_{2}  $  acceptă orice x, iar $ M_{1}  $ deja acceptă orice x din construcţie $ \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq}(M_{1}, M_{2}) = TRUE$
-  - $ f_{eq}(M_{1}, M_{2}) = TRUE \Rightarrow M_1[w] \equiv M_2[w]  $ , ştim din construcţie că $ M_{1}  $  acceptă orice x $ \Rightarrow M_{2}  $  acceptă orice x $ \Rightarrow \exists w  $  astfel încât $ M[w]  $  se opreşte $ \Rightarrow f_{any}(M, w) = TRUE$
-------
-  * $ f_{p} \le_m f_{eq}$
-$ M \to t \to M_{1}, M_{2}$
-$ M_{1}[x]: $
 <code>
- acceptă
+bool isNull(List l) {
-</code>
+    return l == NULL;
+}
-$ M_{2}[x]: $
+int size(List l) {
-<code>
+    if (isNull(l))
-   run M[x]
+        return 0;
-   if M decide corect daca x este palindrom:
+    return 1 + size(l->next);
-    accepta
+}
-   else:
-    nu accepta
-</code>
-Demonstraţii:
+List add(List l, int x) {
-  - $ f_{p} = TRUE \Rightarrow \forall x M  $ decide daca e palindrom $ \Rightarrow M_{2}  $  acceptă orice x, iar $ M_{1}  $ deja acceptă orice x din construcţie $ \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq}(M_{1}, M_{2}) = TRUE$
+    if isNull(l))
-  - $ f_{eq}(M_{1}, M_{2}) = TRUE \Rightarrow M_1[w] \equiv M_2[w]  $ , ştim din construcţie că $ M_{1}  $  acceptă orice x $ \Rightarrow M_{2}  $  acceptă orice x $ \Rightarrow M  $  decide corect dacă x este palindrom $ \Rightarrow f_{p} = TRUE$
+        return Cons(x, Void());
---------
+    return Cons(l->e, add(l->next, x));
-  * $ f_{own} \le_m  f_{eq}$
+}
-$ M \to t \to M_{1}, M_{2}$
+List append(List l1, List l2) {
+    if (isNull(l1))
+        return l2;
+    return Cons(l1->e, append(l1->next, l2));
+}
-$ M_{1}[x]: $
+List reverse(List l) {
-<code>
+    if (isNull(l))
- acceptă
+        return Void();
+    return append(reverse(l->next), Cons(l->e, Void()));
+}
 </code>
-$ M_{2}[x]: $
-<code>
-   if x == enc(M):
-    run M[x]
-   accepta
-</code>
-Demonstraţii:
-  - $ f_{own} = TRUE \Rightarrow M[enc(M)]  $  se termină $ \Rightarrow M_{2}  $  acceptă orice x, iar $ M_{1}  $ deja acceptă orice x din construcţie $ \Rightarrow M_1[w] \equiv M_2[w] \Rightarrow f_{eq}(M_{1}, M_{2}) = TRUE$
-  - $ f_{eq}(M_{1}, M_{2}) = TRUE \Rightarrow M_1[w] \equiv M_2[w]  $ , ştim din construcţie că $ M_{1}  $  acceptă orice x $ \Rightarrow M_{2}  $  acceptă orice x $ \Rightarrow M[enc(M)]  $  se termină $ \Rightarrow f_{own} = TRUE$
-===== Exercițiul 3 =====
-Demonstrăm că $ \le_m$ e reflexivă
-Fie o problemă $ f$ şi o transformare $ t: \Sigma^* \rightarrow \Sigma^*, t(w) = w$
-$ f(w) = True \iff f(t(w)) = TRUE$ deci $ f \le_m f$
-Demonstrăm că $ \le_m$ e tranzitivă
-Fie probleme de decizie f, g, h astfel încât:
-$ f \le_m g$ (deci există o transformare $ t_{1}$ a.î. $ f(w) = TRUE \iff g(t_{1}(w)) = TRUE$)
-$ g \le_m h$ (deci există o transformare $ t_{2}$ a.î. $ g(w) = TRUE \iff h(t_{2}(w)) = TRUE$)
-Luăm transformarea $ t = t_{1} \circ t_{2}$:
-$ f(w) = TRUE \iff h(t_{2}(t_{1}(w))) = TRUE$
-$ f(w) = TRUE \iff h(t(w))) = TRUE \Rightarrow f \le_m h$