✎ aa:lab:sol:4 [books]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Soluții inducție structurală ======

1.

** Cazul de bază **

<code>
reverse(reverse(Void)) =(REV1) reverse(Void) =(REV1) Void
</code>

**Pas de inducție**

Presupunem:

<code>
reverse(reverse(l)) = l
</code>

Arătăm:

<code>
reverse(reverse(Cons(x, l)) =( Cons(x, l)
</code>

<code>
reverse(reverse(Cons(x, l)) =(REV2) reverse(append(reverse(l), Cons(x, Void)) =(L1) append(reverse(Cons(x, Void)), reverse(reverse(l))) =(II) append(reverse(Cons(x, Void)), l) =(REV2) append(Cons(x, reverse(Void)), l) =(REV1) append(Cons(x, Void), l) =(APP2) Cons(x, append(Void, l)) =(APP1) Cons(x, l)
</code>

Unde ''L1'' este lemma: $ \forall l1, l2 \in List, reverse(append(l1, l2)) = append(reverse(l2), reverse(l1))$, care necesită o demonstrație separată, tot prin inducție structurală după ''l1''.

**Caz de bază**:

<code>
reverse(append(Void, l2)) =(APP1) = reverse(l2) =(L3) reverse(append(l2, Void))
</code>

(''L3'' este propoziția $ \forall l \in List, append(l, Void) = l$, cu o demonstrație ușoară, omisă aici; vă recomandăm să explicitați voi demonstrația, prin inducție structurală după $ l$).

**Pas de inducție**:

Presupunem:

<code>
reverse(append(l, l2)) = append(reverse(l2), reverse(l))
</code>

Arătăm:

<code>
reverse(append(Cons(x, l), l2)) = append(reverse(l2), reverse(Cons(x, l)))
</code>

<code>
reverse(append(Cons(x, l), l2)) =(APP2) reverse(Cons(x, append(l, l2)) =(REV2) append(reverse(append(l, l2)), Cons(x, Void))) =(II) append(append(reverse(l2), reverse(l)), Cons(x, Void)) =(Asocativitate append) append(reverse(l2), append(reverse(l), Cons(x, Void)) =(REV2) append(reverse(l2), reverse(Cons(x, l)))
</code>

<note>
Asociativitatea operației ''append'' (i.e. $ \forall l1, l2, l3, append(append(l1, l2), l3) = append(l1, append(l2, l3))$) este tot o teoremă care trebuie demonstrată prin inducție structurală; deși laborioasă, este în esență simplă. Vă recomandăm să o redactați explicit.
</note>



<note>
**Notă*: Într-un sens computațional, axiomele noastre reprezintă *reguli de derivare* care ne spun că putem înlocui expresia din stânga cu cea din dreapta. Astfel, un simbol simetric ca ''='' nu pare foarte potrivit, iar expresii de forma ''1 + size(l) =(SZ2) size(Cons(e, l))'' sunt abuzuri de notație, deoarece folosim derivarea "în sens invers".

Totuși, chiar și cu această interpretare, în afară de abuzul notațional, demonstrațiile noastre sunt corecte și riguroase: putem să le rescriem pentru a arăta separat că, din egalitatea ce trebuie demonstrată, și partea stângă și partea dreapta, pot fi derivate separat în aceași expresie.
</note>


2. 

**Cazuri de bază**:

<code>
size(move(Empty)) =(MOV1) size(Empty)

∀x, size(move(Push(x, Empty)) = size(Push(x, Empty))

Rezultă direct din axioma MOV2.
</code>

<notes>
Considerând și ''Push(x, Empty)'' un caz de bază ne permite ca în demonstrația următoare să folosim doar ''Push(e, r)'' ca inel.
</code>

**Pas de inducție**:

Presupunem:

<code>
∀e, size(move(Push(e, r))) = size(Push(e, r))
</code>
Arătăm:

<code>
∀x, ∀e, size(move(Push(x, Push(e, r))))) = size(Push(x, Push(e, r)))
</code>


<code>
size(move(Push(x, Push(e, r)))) =(MOV3) size(Push(e, move(Push(x, r)))) =(SZ2) 1 + size(move(Push(x, r))) =(II) 1 + size(Push(x, r)) =(SZ2) 2 + size(r) =(SZ2) 1 + size(Push(e, r)) = size(Push(x, Push(e, r))
</code>

3. 

∀r.∀i. size(r) >= 2 => element(i,move(r)) = element(i+1,r)

Vom face o demonstrație prin inducție matematică după ''i'':

Pentru **cazul de bază**, luăm ''i = 0'' și vrem să arătăm că:

<code>
element(0, move(r)) = element(1, r)
</code>

Acesta trebuie să fie adevărat pentru orice inel ''r'' cu ''size(r) >= 2''; pentru a demonstra propoziția, vom face inducție structurală după ''r'':

**Caz de bază**:

<code>
element(0, move(Push(e, Push(f, Empty)))) =(MOV2) element(0, Push(f, move(Push(e, Empty))) =(MOV1) = element(0, Push(f, Push(e, Empty))) =(ELEM) elm(0 `mod` 2, Push(f, Push(e, Empty))) = elm(0, Push(f, Push(e, Empty))) =(ELM1) f

element(1, Push(e, Push(f, Empty))) =(ELEM) elm(1 `mod` 2, Push(e, Push(f, Empty))) = elm(1, Push(e, Push(f, Empty))) =(ELM2) elm(0, Push(f, Empty)) =(ELM1) f
</code>

**Pas de inducție**:

Presupunem:

<code>
element(0, move(Push(e, Push(f, r)))) = element(1, Push(e, Push(f, Empty)))
</code>

Arătăm:

<code>
element(0, move(Push(x, Push(e, Push(f, r))))) = element(1, Push(x, Push(e, Push(f, Empty))))
</code>


<code>
element(0, move(Push(x, Push(e, Push(f, r))))) =(MOV3) element(0, Push(e, move(Push(x, Push(f, r))))) =(ELEM + propr. de bază ale `mod`) elm(0, Push(e, move(Push(x, Push(f, r))))) =(ELM1) top(Push(e, move(Push(x, Push(f, r)))) =(TOP) e

element(1, Push(x, Push(e, Push(f, Empty)))) =(ELEM + popr. `mod`) elm(1, Push(x, Push(e, Push(f, Empty))))) =(ELM2) elm(0, Push(e, Push(f, Empty)))) =(ELM1) e
</code>

Asta completează demonstrația prin inducție structurală, deci cazul de bază al demonstrației principale (''i = 0'').

**Pas de inducție**:

Presupunem:

<code>
element(i, move(r)) = element(i + 1, r)

echivalent cu:

elm(i `mod` size(move(r)), move(r)) = elm((i + 1) `mod` size(r), r)
</code>

Arătăm:

<code>
element(i + 1, move(r)) = element(i + 2, r)

echivalent cu:

elm((i + 1) `mod` size(move(r)), move(r)) = elm((i + 2) `mod` size(r), r)
</code>

Din nou, vom face o demonstrație prin inducție structurală după ''r''.

**Caz de bază**:

<code>
element(i + 1, move(Push(e, Push(f, Empty)))) =(ELEM) elm((i + 1) `mod` size(move(Push(e, Push(f, Empty)))), move(Push(e, Push(f, Empty)))) =(2 aplicări de SIZE2, una de SIZE1 și aritmetică) elm((i + 1) `mod` 2, move(Push(e, Push(f, Empty)))) =(MOV3) elm((i + 1) `mod` 2, Push(f, move(Push(e, Empty))))

Dacă i e impar: 
elm(0,  Push(f, move(Push(e, Empty)))) =(ELM1) f

iar în partea dreaptă avem:
element(i + 2, Push(e, Push(f, r))) =(ELEM) elm((i + 2) `mod` 2, Push(e, Push(f, r))) =(i impar, deci i+2 impar) elm(1, Push(e, Push(f, r))) =(ELM2) elm(0, Push(f, r)) =(ELM1) f

-----------------

Dacă i e par: elm(1,  Push(f, move(Push(e, Empty)))) =(ELM2) elm(0, move(Push(e, Empty))) =(MOV2) elm(0, Push(e, Empty)) =(ELM1) e

iar în partea dreaptă avem:
element(i + 2, Push(e, Push(f, r))) =(ELEM) elm((i + 2) `mod` 2, Push(e, Push(f, r))) =(i par, deci i+2 par) elm(0, Push(e, Push(f, r))) =(ELM1) e
</code>