
\section{Pesquisa em uma \sqn}
O problema aqui consiste em determinar se  um elemento $x$ ocorre em uma \sqn.

Uma \sqn\ de elementos de um tipo $A$ \ee\ definida atrav\ee s do seguinte
conjunto de axiomas:

\begin{align}
	\label{nullsqn} &\text{\sqn\ vazia: } \xnil\in\sqntype{A} \\
	\label{sqncons} &\text{construtor: } \xcons cx \in \sqntype{A} \\
	\label{isconssqn}& \text{diferen\ca\ de vazio:} \xcons cx\neq\xnil\\
	\label{iseqsqn}& \text{Igualdade: }\xcons bx=\xcons cy\ll.=\lr. b=c\land x=y
\end{align}

Al\ee m disso, o seguinte priinc\ii pio da indu\cao\ \'e usado para provar 
propriedades sobre \sqn s.

\begin{equation}
	\label{sqninduction} \bndA{x}{x\in\sqntype{A}}{P.x}\ll.=\lr.P.\xnil
	\land\bndA{c,y}{c\in A\land y\in\sqntype{A}}{P.y\limp P.\xcons cy}
\end{equation}
Uma \sqn\ pode ser representada por uma lista ou por um vetor. Seus elemtos 
s\ao\ todos de um mesmo tipo $A$. Neste texto, em princ\ii pio, todas as 
\sqn s cont\^em inteiros, tipo $Int$. Ser\ao\ abordadas solu\coes\ funcionais 
usando listas em Haskell e solu\coes\ imperativas, usando vetores e matrizes em 
uma linguagem de comandos guardados\cite{dijkstra:discipline,gries:science-prog}.


\subsection{Pesquisa Linear}
Dada uma \sqn\ $S$ de $m$ inteiros e um elementos $x$, tamb\'em inteiro, 
determine se $x\in S$. 

\subsubsection{Uma solu\cao\ funcional}
Uma solu\cao\ em Haskell para o problema, assumindo que
$S$ \'e representada por uma lista \'e bastante trivial.

\emph{Motiva\cao} 
\[x\in S = (x=S.0 \lor x=S.1 \lor \ldots \lor x=S.m-1) \]

\emph{A solu\cao}

\lstinputlisting[language=Haskell]{linsearch.hs}

Note que essa solu\cao\ tem a desvantagem de passar pela \sqn\ duas vezes. 
A solu\cao\ apresentada em sala de aula, que aplica a id\'eia, da associatividade
\`a esquerda  compara $x$ com cada elemento da \sqn\ apenas uma vez.

\begin{ex} Considere ainda o problema de apresentar solu\coes\ funcionais 
	para busca de um elemento em \sqn.

\begin{enumerate}
	\item Mostre que a solu\cao\ acima implementa diretamente o resultado 
		proposto $\exists y: y\in S: x=y$.
	\item Use os combinadores \textbf{foldl} e \textbf{foldr} para produzir 
		solu\coes\ funcionais para o problema. 
	\item Produza um algoritmo recursivo para resolver esse problema.
	\item Prove a corre\cao\ das suas solu\coes.
\end{enumerate}
\end{ex}
\subsubsection{A solu\cao\ imperativa}
Considere agora que a \sqn\ \'e representada por um vetor: 
$\typeof{s.0..m-1}{Int}$ e $\typeof{x}{Int}$. Determine 
\[ R = (\bnd{\exists}{i}{\lelt{0}{i}{m}} x=s.i)\]

\begin{notation}
	A nota\cao\ associada a vetores \'e essencialmente emprestada da linguagem Ada:
	\begin{itemize}
		\item $S.i$ ou $S(i)$, elemento da posi\cao\ $i$ de $S$;
		\item $S.0..m-1$ ou $S(0..m-1)$, vetor com $m$ elementos, 
			indexados de $0$ a $m$;
		\item Dado um operador relacional $\oplus$, 
		$$B(i..j) \oplus S(i..j) \dfn
		   \bnd{\forall}{k}{\lele{i}{k}{j}}{B.k \oplus}S.k $$
	$$x \oplus S(i..j) \dfn
		   \bnd{\forall}{k}{\lele{i}{k}{j}}{x \oplus}S.k $$

	\end{itemize}
\end{notation}


\emph{Motiva\cao:}

Relaxe o objetivo, e assuma que  $x\not\in S$. No \uu ltimo passo da
computa\cao\ seria v\'alido:
  \[x\not\in S.0..i-1 \land i=m\]
 e o passo final consistiria em testar atingir determinar que n\ao\ existe
 o que buscar porque $i=m$.

Generalizando para qualquer passo e voltando \`a especifica\cao\ original onde 
$x$ pode ocorrer em $S$, o \'ultimo passo da computa\cao\ assumiria:
\begin{itemize}
	\item $x$ n\ao\ ocorreu ainda na \sqn: $x\not\in S.0..i-1$, para algum 
		$i$;
	\item $i$ \'e um \ii ndice v\aa lido na \sqn.
\end{itemize}

Isso d\'a a seguinte candidata a invariante:
\[ P\dfn \lele0im\land \bnd{\forall}{j}{\lelt0ij}{x\neq S.j}\]

O progresso na computa\cao\ ocorre pelo esgotamento da \sqn\ a pesquisar:

\textbf{Vari\aa vel derivada (ou \emph{bound function)}:} $T \dfn m-i$

A computa\cao\ termina quando

\begin{itemize}
	\item \sqn\ est\'a esgotada: $m-i =0$
	\item \sqn\ n\ao\ est\'a esgotada, mas $x = S.i$;
\end{itemize}

o que define o ponto-fixo do loop: $(m-i =0 \cor x = S.i)$. Sua 
nega\cao, $B$, d\'a a condi\cao\ para computa\cao\ continuar:
\[ B \dfn (m-i\neq 0 \cand x\neq S.i)\]

Note que 
\[ (P\land\neg B) \limp \bnd{\forall}{k}{\lelt0ki}{x \neq S.k}\]
o que, quando $i=m$,  significa que $x$ n\ao\ ocorre em $S$.

O algoritmo aparece na \rffig{linsearch}. Note que ele aparece decorado com a 
invariante do loop e a vari\aa vel derivada, que define o \emph{bound} do loop.

\begin{figure}
\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel},
	caption={[t]Linear search}}
\lstinputlisting{linsearch.tex}
\caption{Pesquisa linear}\label{linsearch}
\end{figure}	
Note que esta solu\cao, ao contr\'ario da funcional, s\'o percorre a \sqn\ uma 
vez: mas\ldots cada passo da computa\cao\ usa duas compara\coes\ de inteiros, ent\ao\ldots 

\textbf{\large A corre\cao.} 
A prova de corre\cao\ do programa \ee\ composta dos seguintes passos:
\begin{itemize}
	\item A corre\cao\ parcial: a prova de que o programa, se termina, produz
		o resultado desejado. Essa prova ser\'a decomposta nas seguintes
		fases:
		\begin{itemize}
			\item prova de que $P$ vale inicialmente;
			\item prova de que $P$ \'e uma invariante do loop;
			\item prova de que $(P\land\neg B)\limp \bnd{\forall}{k}{\lelt0ki}{x\neq S.k}$
		\end{itemize}
	
        \item A prova de que o programa termina. A prova ser\'a constitu\ii da dos seguintes est\aa gios:
		\begin{itemize}
			\item Prova de que $P\land B \limp T>0$
			\item Prova de que o loop eventualmente termina.
		\end{itemize}
	\item Prova de eventualmente o programa computa o $R$ desejado.
\end{itemize}

\begin{theo}
	$P$ vale inicialmente.
\proofbeg
Primeiro fator de $P$.
\begin{align*}
	& \jst{initially}{} \\
   & i = 0 \land m\ge 0 \\
   = & \jst{aritm\'etica}{}\\
   &(\lele0im) 
\end{align*}

Segundo fator de $P$.
\begin{align*}
	& \jst{initially}{} \\
   & i = 0 \land m\ge 0 \\
   \limp & \jstop{\lrelim\land}{}\\
   & i=0 \\
   \limp & \jst{l\'ogica}{}\\
   & \bnd{\forall}{k}{\lelt0ki}{x\neq S.k}
\end{align*}
\proofend
\end{theo}

\begin{theo}
$P$ \'e uma invariante do loop.
\proofbeg
O objetivo \'e provar que 
\[\hoare{P\land B}{G_0}{P}\]
Se $P$ \'e v\'alido e a guarda $B$ \'e v\aa lida, $G_0$ \ee\ executado e, depois, $P$ ainda ser\aa\ v\aa lido. 
\begin{align*}
    & \jst{P depois \'e }{P'}\\
    & P' = P[i:=i+1] \\
    = & \jstop{\text{substitui\cao\ de }i} \\
    & \lele0{i+1}m\land\bnd{\forall}{k}{\lelt0k{i+1}}{x\neq S.k}\\
    = & \jst{aritm\'etica}{}\\
    & \lelt{-1}im\land\bnd{\forall}{k}{\lelt0k{i+1}}{x\neq S.k}\\
    = &\jst{l\'ogica}{}\\
    & \lele{-1}im\land m\neq i\land\bnd{\forall}{k}{\lelt0ki}{x\neq S.k}\land{x\neq S.i} \\
    \lif&\jst{weakening}{} \\
    &(\lele0im\land\bnd{\forall}{k}{\lelt0ki}{x\neq S.k})\land(m-i\neq0\land x\neq S.i)\\
    = & \jst{premissa do teorema}{}\\
    & P\land B
\end{align*}
\proofend
\end{theo}

A prova acima consite em mostrar que
\[ P\land B\ll.\limp\lr.\wp{i:=i+1}{P}\]

onde \wp{\alpha}{P} \ee\ o transformador de predicados de Dijkstra\cite{dijkstra:discipline}.

\begin{definition}
	A precondi\cao\ mais simples \emph{(weakest precondition)} da atribui\cao\ \ee\ dada por:
\[	\wp{x:=e}{P} = P[x:=e]\]
\end{definition}
\begin{theo}
Enquanto a guarda $B$ for v\'alida, a vari\aa vel derivada $T$ \'e maior do que 
zero:
\[ P\land B .\limp. T>0\]

\proofbeg
\begin{align*}
&\jst{initially }{P}\\
&\lele0im\land\bnd{\forall}{k}{\lelt0ki}{x\neq S.k}\\
&\limp\jst{pela validade de }{B}\\
&\lele0im\land\bnd{\forall}{k}{\lelt0ki}{x\neq S.k}\land m-i\neq0\\
=&\jst{elimina\cao\ da conjun\cao\ e aritm\'etica por }{i\le m\land m-i\neq0}\\
& i<m\\
=& \jst{aritm\ee tica}{}\\
& 0< m-i\\
=& \jst{defini\cao\ de }{T} \\
&0<T\\
=& T>0
\end{align*}
\proofend
\end{theo}

\begin{theo}
	Se $B$ \'e v\aa lida, $T$ decresce.

	\proofbeg
	Trivial: Se $B$ \'e  v\'alida, $i$ cresce e $m-i$ decresce.
	\proofend
\end{theo}

\begin{theo}
	O programa da \rffig{linsearch} termina.

	\proofbeg
	Se inicialmente $m=0$, $B$ \'e falso e o programa termina de imediato. 
	Se $m>0$, existem dois casos:
	\begin{enumerate}
		\item eventualmente $x$ \'e igual a algum $S.i$ e $B$ se torna 
			falso, terminando o loop e o programa, ou
		\item $T$ decresce (provado anteriormente) e atinge zero, tornando
			$B$ falso, o que termina o loop e o programa.
	\end{enumerate}
\end{theo}

\begin{theo}
	Ao final do loop, quando $\neg B$ \'e v\'alido, $x\in S$ 
	se e somente se $i\neq m$.
	\[P\land\neg B.=. (i\neq m)=\bnd{\exists}{k}{\lelt0km}{x=S.k}\]
	\proofbeg
	\begin{align*}
		 P&\land \neg B \\
	       =& \lele0im\land x\not\in S.0..i-1\land\neg(m-i\neq 0\cand x\neq S.i)\\
	       =&\jstop{\lrdemorgan\cand}\\
	       & \lele0im\land x\not\in S.0..i-1\land(m=i \cor x = S.i)\\
	       =&\jstop{\lrdist\land\cor}\\
	       &(\lele0im\land x\not\in S.0..i-1\land m=i)\\
	       &\qquad\cor
	          (\lele0im\land x\not\in S.0..i-1\land m\neq i\land x=S.i)\\
	       =& (i=m \land \neg\bnd{\exists}{k}{\lelt0km}{x=S.k})\\
	       &\qquad\cor
	          (\lelt 0im \land \bnd{\exists}{k}{\lelt0km}{x=S.k})\\
	       =& (i=m)=\neg\bnd{\exists}{k}{\lelt0km}{x=S.k})
	\end{align*}
	\proofend
\end{theo}
\begin{theo}
O programa da \rffig{linsearch} termina.

\proofbeg
Os valores de $m-i$ formam uma cadeia finita decrescente porque
\begin{enumerate}
	\item inicialmente $m\ge0$;
	\item $m$ n\ao\ muda;
	\item inicialmente $i=$;
	\item $i$ \ee\ incrementado a cada passo.
\end{enumerate}

Logo, eventualmente, $m-i$ e loop termina, mesmo que $x\not\in S$.
\proofend
\end{theo}

\begin{theo}
	O programa da \rffig{linsearch} termina e computa 
	\[ R = x\in S\]
	\proofbeg
	Provado nos teoremas acima.
	\proofend
\end{theo}
O que foi feito at\'e aqui? Um programa imperativo para o problema de pesquisa 
linear foi derivado no sentido de que sua constru\cao\ obedeceu a uma \sqn\ que 
passou por:
\begin{itemize}
	\item definir claramente o objetivo do mesmo;
	\item estabelecer claramente suas pr\ee-condi\coes;
	\item definir uma invariante para o loop da computa\cao;
	\item estabelecer a condi\cao\ de progresso e a vari\aa vel derivada;
	\item definir a guarda do loop;
	\item definir o c\'odigo do programa;
	\item inverter este roteiro para encontrar a prova de corre\cao\ do programa.
\end{itemize}

Note que cada passo de cada uma das provas est\'a l\oo gicamente fundamentado.
Ao longo deste curso,  s\oo\ ser\ao\ aceitas provas apresentadas dessa forma.
Construa para todos os outros programas desta nota (e deste curso) provas de 
corre\cao\ que apresentem o mesmo rigor.

\begin{ex}
Volte \`a id\ee ia da relaxa\cao: se for poss\ii vel assumir que $x$ ocorre
na \sqn, pode-se contruir algoritmo para encontrar a posi\cao\ de sua 
ocorr\^encia em at\ee\ $m$ compara\coes. Use essa id\ee ia para derivar 
um algoritmo que faz no m\aa ximo $m+2$ compara\coes\ para determinar 
 \[(\lelt 0im \land x=S.i) \cor (i=m \land x\not\in S)\]
\end{ex}

\subsection{Pesquisa bidimensional}
Considere agora que uma \sqn\ bidimensional \'e dada: $S(0..m-1,0..n-1)$. O 
objetivo consiste em determinar outra vez 
$$ R = \bnd{\exists}{i,j}{\lelt{0}{i}{m}\land\lelt{0}{j}{n}}{S.i.j = x}$$


\subsection{Pesquisa em \sqn\ ordenada}
Dados $\typeof{x}{Int}$ e $\typeof{S.0..m-1}{Int}$ e $\bnd{\forall}{i,j}{0\le i< j< m}{S.i\le S.j}$, 
determine
\[ present = \bnd{\exists}{i}{\lelt{0}{i}{m}}{x = S.i} \]


O algoritmo exposto a seguir \ee\ apresentado por Dijkstra em
\cite{dijkstra:fillers}.\footnote{
Ao ler estas notas voc\^e estar\aa\ lendo minha interpreta\cao, o que certamente
n\ao\ deveria ser substituto para a leitura do original.}

Para efeito de desenvolvimento, parece razo\aa vel relaxar o 
objetivo e assuma que
a \sqn\ se estende at\ee\ a posi\cao\ e que $x<S.m$. 

Por outro lado, dado que o objetivo consiste em computar  um quantificador 
existencial, parece intuitivo usar uma leitura construtiva desse
quantificador e propor construir um $i$ tal que:

\begin{itemize}
	\item $S.i = x$ determina a presen\ca\ de $x$ em $S$;
	\item $S.i\neq x$ garante que $x\not\in S$.
\end{itemize}

O objetivo de determinar o valor de $present$ passa a ser constru\ii do em duas 
etapas:
\begin{itemize}
	\item construir um $i$ tal que $\lelt{S.i}x{S.i+1}$, proposi\cao\
%		que ser\aa\ identificada como $R$:
%		\[ R \dfn $\lelt{S.i}x{S.i+1}\]
	\item estabelecer o valor de $present$
		\[ present := S.i=x\]
\end{itemize}

Um primeiro refinamento para o algoritmo aparece na \rffig{binsearchfst}.

\begin{figure}
\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel,Bool}}
	\lstinputlisting{binsearch.fst.tex}
\caption{Pesquisa bin\aa ria: primeiro refinamento}\label{binsearchfst}
\end{figure}

No estado inicial \ee\ v\aa lido que
\[ \lelt{S.0}x{S.m} \]

Generalizando esta proposi\cao\, produzimos a  invariante
\[ P\dfn \lelt{S.i}x{S.j} \land 0\le\ltle ijm\]

O objetivo do algoritmo consiste em reduzir a se\cao\ entre $i$ e $j$ at\ee\ que
$j$ seja $i+1$, quando a condi\cao\ $R$ estar\aa\ estabelecida. A \varderiv\ ser\aa
\[ T\dfn j-i \]

e a guarda do loop
\[ B\dfn j\neq i+1\]

O novo algoritmo aparece na \rffig{binsearchsnd}.
\begin{figure} 
\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel,Bool}}
	\lstinputlisting{binsearch.snd.tex}
\caption{Pesquisa bin\aa ria: segundo refinamento}\label{binsearchsnd}
\end{figure}

A se\cao\ entre $i$ e $j$ pode ser reduzida por:
\begin{itemize}
	\item redu\cao\ de $j$ para algum $h$ tal que
		\[ x< S.h\land \lelt ihj \]
		que mant\ee m a validade da invariante;
	\item incremento de $i$ para algum $h$ tal que
		\[ S.h \le x \land \ltle ihj\]
		que tamb\ee m mant\ee m a validade da invariante.
\end{itemize}

Se existem duas ou mais alternativas para a mesma a\cao, considere um comando
alternativo: \textbf{if}. Veja o algoritmo de \emph{shrink} na 
\rffig{binsearchshrink}.

\begin{figure}
\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel,Bool}}
	\lstinputlisting{binsearch.shrink.tex}
\caption{Pesquisa bin\aa ria: shrink}\label{binsearchshrink}
\end{figure}

Duas constru\coes\ importantes se destacam na especifica\cao\ de \emph{shrink}:
o uso do comando alternativo e o uso da atribui\cao\ n\ao\ determin\ii stica.

O comando alternativo da linguagem de comandos guardados de Dijkstra \ee\
n\ao-determin\ii stico. O trecho da \rffig{ifcomm} define que:
\begin{itemize}
	\item ao menos um dos $B_i$ $(\lele 0in)$ deve ser verdadeiro;
	\item se mais de um $B_i$ for v\aa lido, um deles ser\aa\ selecionado
		sendo a a\cao\ $S_i$ respectiva executada.
\end{itemize}

Provar a corre\cao\ desse comando demanda provar que:
\[ (\bndE{i}{\lele 0in} B_i)\land (\bndA{i}{\lele 0in}{Q\land B_i \limp P}\]

\begin{figure}
\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel}}
\begin{lstlisting}{}
	@$\{Q\}$@
	if 
	  @$B_0$@ -> @$S_0$@
	  @$\assync B_1$@ -> @$S_1$@
	  @$\ldots$@
	  @$\assync B_{n}$@ -> @$S_n$@
	fi @$\{P\}$@
\end{lstlisting}
\caption{Comando if}\label{ifcomm}
\end{figure}

A id\ee ia de usar atribui\coes\ n\ao\ determin\ii sticas em especifica\coes\
de programas parece ter sido proposta originialmente por Morris, ver por exemplo
\cite{morris:data-refinment}. A sem\^antica dessa atribui\cao\ \ee\ dada
pelo seguinte c\aa lculo de pr\ee-condi\cao:
\[ \wp{\xassgn zQ}{P}=(\forall x: Q.x\limp P)\]




Nessa especifica\cao, o valor de $h$ \ee\ escolhido arbitrariamente de um
range v\aa lido. No entanto, se o valor de $h$ for a m\ee dia aritm\ee tica
de $i$ e $j$, cada ciclo do loop reduzir\aa\ a se\cao\ do array a considerar
pela metade: o que significa esgotar o array em $O(\lg m)$ passos. O
algoritmo completo segue na \rffig{binsearch}.

\begin{figure}
	\lstset{language=VHDL,keywordstyle=\bfseries,escapechar=\@,
	singlecomment={\{}{\}},
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,Bool,let,tel}}
	\lstinputlisting{binsearch.tex}
\caption{Pesquisa bin\aa ria}\label{binsearch}
\end{figure}

Considere tamb\ee m nas provas a seguir que:
\begin{gather*}
	B_0 \dfn  x < S.h\\
	B_1 \dfn  S.h\le x
\end{gather*}

e que:
\begin{gather*}
	S_0 \dfn j:=h\\
	S_1 \dfn i:=h
\end{gather*}

Assuma que
\[ \lelt{S.0}{x}{S.m} \land S(m-1)<S.m\]
e prove os teoremas a seguir. Os teoremas \ref{binlttheo} e \ref{bingttheo}
consideram os casos em que $x<S.0$ e $x>S.m-1$.
\begin{theo}
	Prove que 
	\[ P\land B \limp \wp{{h}:={(i+j)/2}}{\ltlt ihj}\]
	\proofbeg
	Trivial: aritm\ee tica.
	\proofend
\end{theo}

O teorema a seguir estabelece que, em qualquer ciclo em que $P$ e $B$ 
s\ao\ v\aa lidos, o comando alternativo n\ao\ bloqueia.

\begin{theo}
	Prove que 
	\[P\land B\limp (B_0\lor B_1)\]
	\proofbeg
	Trivial. $B_0$ \ee\ a nega\cao\ de $B_1$: a implica\cao\ \ee\ sempre
	verdadeira.
	\proofend
\end{theo}

\begin{theo}
	\label{Pinit}
	Prove que $P$ vale inicialmente.
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

Os teoremas a seguir provam que o comando alternativo preserva a invariante
do loop.
\begin{theo}
	\label{Pstable}
	Prove que 
	\[P\land B\land \ltlt ihj \follows B_0 \limp \wp{S_0}{P}\]
	\proofbeg
	
\begin{align*}
	&P\land B\land \ltlt ihj \follows B_0 \limp \wp{S_0}{P}
	=& \jstop{\text{Teorema da dedu\cao}} \\
        & \follows P\land B\land \ltlt ihj \land B_0 \limp \wp{S_0}{P}
\end{align*}
	\proofend
	O objetivo, ent\ao, consistir\aa\ em provar que:
        \[ P\land B\land \ltlt ihj \land B_0 \limp \wp{S_0}{P}\]

	\begin{align*}
		& \wp S_0P\\
		=& \\
		& 0\le\ltle ihm \land \lelt{S.i}x{S.h}\\
		=&\jstop{\text{l\oo gica}}\\
		& 0\le i \land i< h \land h\le m \land {S.i}\le x\land x<{S.h}\\
		\lif&\jstop{\lrelim \land}\\
	&0\le i \land i< h\land h< j \land j\le m \land S.i\le x \land x< S.h\\
	&=\jstop{\text{trasitividade de } <}\\
	&0\le\ltle ijm\land h<j\land S.i\le x \land x< S.h\\
	\lif&\jstop{h<j\text{ e }S\text{ ordenado}}\\
	& 0\le\ltlt ijm\land S.i\le x\land x<S.j\land x<S.h\land \ltlt ihj\\
	=&\\
&	P\land B\land\ltlt ihj\land B_0
	\end{align*}
\end{theo}

\begin{theo}
	Prove que 
	\[P\land B\land \ltlt ihj \follows B_1 \limp \wp{S_1}{P}\]
	\proofbeg
	Parecido com anterior. Exerc\ii cio.
	\proofend
\end{theo}

\begin{theo}
	Prove que $P$ \ee\ uma invariante do loop do algoritmo da 
	\rffig{binsearch}.
	\proofbeg
	$P$ vale inicialmente, de acordo com \rftheo{Pinit},
	e validade de $P$ \ee\ mantida pelo loop,
	segundo \rftheo{Pstable}.
	\proofend
\end{theo}

\begin{theo}
	Prove que
	\[ P\land B \limp T>0\]
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

\begin{theo}
	Prove que $T$ decresce, provando que
	\[P\land B\land \ltlt ihj \follows \forall{v}:T = v\limp \wp{S_0}{T>v}\]
	e que 
        \[P\land B\land \ltlt ihj \follows \forall{v}:T = v\limp \wp{S_0}{T>v}\]
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}
\begin{theo}
	Prove que o loop do algoritmo da \rffig{binsearch} termina.
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

\begin{theo}
	\label{bingttheo}
	Assuma que $x>S(m-1)$ e prove que $P$ ainda \ee\ uma invariante
	do algoritmo da \rffig{binsearch}.
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

\begin{theo}
	\label{binlttheo}
	Assuma que $x<S.0$ e prove que 
	\[ i=0 \land x<S.0\]
	\ee\ uma invariante do loop 
	do algoritmo da \rffig{binsearch}.
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

\begin{theo}
	Prove que o algoritmo estabelece
	\[ present = \bndE{k}{\lelt 0km}{S.k = x}\]
	\proofbeg
	Exerc\ii cio.
	\proofend
\end{theo}

Algumas observa\coes\ finais sobre o algoritmo de pesquisa bin\aa ria:
\begin{itemize}
	\item A deriva\cao\ do algoritmo \ee\ feita passo a passo baseada em
		condi\coes\ logicamente consistentes: o resultado inevit\aa vel
		\ee\ um algoritmo correto. Na verdade, a metodologia de
		programa\cao\ de Dijkstra d\aa\ relev\^ancia a esse processo
		de deriva\cao\ do algoritmo ficando a prova em segundo 
		plano: por exemplo, \cite{dijkstra:fillers} n\ao\ cont\ee m
		a prova de corre\cao\ do algoritmo final.
	\item A prova de corre\cao\ levou em conta tr\^es: $x$ ser menor do que
		$S.0$, $x$ estar entre $S.0$ e $S.m-1$ e $x$ ser maior do que
		$S.m-1$. \'E poss\ii vel, no entanto, estabelecer um invariante
		mais forte para o mesmo algoritmo e construir provas para
		$x$ gen\ee rico.
	\item Embora a prova assuma que $S.m> S.m-1$, $S.m$ n\ao\ \ee\
		usado no algoritmo. \emph{No segmentation fault!}
\end{itemize}
