O documento discute terminação em assistentes de provas. Ele introduz o problema da terminação e propõe o uso de um sistema de tipos com medidas para garantir a terminação de definições recursivas, permitindo tipos de dados indutivos úteis. O sistema de tipos associaria medidas a tipos e permitiria chamadas recursivas apenas sobre termos com medida menor que o parâmetro.

1. Type based termination of recursive definitions
Rodrigo Ribeiro
21 de fevereiro de 2013

2. Motivação — (I)
I Terminação é indecidı́vel para linguagens Turing complete.
I Sendo assim, quem se importa com terminação?
I Problema interessante!
I Aplicações em verificação formal:
I Prova de corretude total de programas.
I Uso em assistentes de provas.

3. Motivação — (II)
I Foco da apresentação: Terminação em assistentes de provas.
I O que é um assistente de provas?
I De maneira simplista: uma linguagem funcional pura onde é
possı́vel desenvolver programas e provas.
I Em tal linguagem, programas podem representar “provas”, e
tipos “fórmulas” lógicas.
I E porquê a terminação importante para assistentes de provas?
I Funções que não terminam tornam a lógica associada ao
assistente de provas inconsistente.

4. Motivação — (III)
I Considere o seguinte trecho (hipotético) de código em Coq,
onde ? representa um tipo qualquer:
I Fixpoint loop(x : ?) : ? := loop x.

5. Motivação — (IV)
I Podemos substitutir a primeira ocorrência de ? por nat e a
segunda por False, contruindo assim uma função de tipo nat
→ False.
I Fixpoint loop(x : nat) : False := loop x.
I Sendo assim, o termo loop 1, possui o tipo False.
I Tal termo pode ser interpretado como uma prova da
proposição False, o que torna a lógica inconsistente.

6. Motivação — (V)
I Assistentes de provas impõe restrições sobre o formato de
definições de funções recursivas, para garantir a terminação.
I Para isso, chamadas recursivas devem ser sempre realizadas
sobre componentes do parâmetro para a função em questão.
I Com isso, funções como loop são rejeitadas:
I Fixpoint loop(x : nat) : False := loop x.

7. Motivação — (VI)
I Porém, essas restrições evitam a definição de funções úteis e
que terminam para qualquer entrada:
Fixpoint div (n m: nat) :=
match n with
| 0 => 0
| S n’ => S (div (n’ - m) m)
end.
I Outros exemplos: algoritmos sobre listas como mergesort e
quicksort.

8. Motivação — (VII)
I Visando contornar essas limitações diversos autores propõe a
utilização de sistemas de tipos que para garantir a terminação
de definições recursivas.
I De maneira simplista, o sistema de tipos associa um limite
sobre a altura de valores de um determinado tipo.
I Chamadas recusivas são somente permitidas sobre valores cuja
altura é menor que o parâmetro de entrada da função.

9. Terminação baseada em tipos — (I)
I Cada tipo de dados d possui uma medida associada.
I Sintaxe de medidas é dada por:
s ::= ι | b
s | ∞
onde ι representa uma variável de medida, o operador b
− é
uma função que associa uma medida a seu sucessor e ∞
corresponde ao limite superior de medidas.
I Relação de subtipagem de medidas: fecho reflexivo e
transitivo das regras
s ≤ b
s s ≤ ∞

10. Terminação baseada em tipos — (II)
I A sintaxe de tipos é dada por:
τ ::= α | τ → τ | ds τ
onde a representa uma sequência de elementos do conjunto
A = {a1, a2..., an}.
I Relação de subtipagem para tipos: fecho reflexivo e transitivo
das regras
s ≤ r τi v τ0
i 1≤i≤ar(d)
ds τ v dr τ0
τ0
1 v τ1 τ2 v τ0
2
τ1 → τ2 v τ0
1 → τ0
2

11. Terminação baseada em tipos — (III)
I Exemplos: Considere o tipo Nat que representa números
naturais na representação de Peano:
data Nat = 0 : Natb
s | S : Nats → Natb
s
I O valor S (S 0) possui tipo Nat
b
b
s.
I Mas por subtipagem, possui também os tipos:
I Nat
b
b
b
s
.
I Nat
b
b
b
b
s
.
I . . .
I Nat∞
.
I O tipo Nat∞ é equivalente ao tipo Nat definido em uma
linguagem sem terminação baseada em tipos.

12. Terminação baseada em tipos — (IV)
I Definições de novos tipos de dados são restritas.
I O tipo de dados:
data D τ =
c1 : A1
...
cn : An
I deve ser tal que cada Ai é da forma:
I B1 → ... → D
I onde cada argumento Bi é tal que
I não menciona o tipo de dados D
I ou possui a forma C1 → ... → D, onde D não ocorre em
nenhum Ci .

13. Terminação baseada em tipos — (V)
I Condições anteriores evitam que possamos construir loops a
partir de tipos recursivos.
I Exemplo (em Haskell):
data Evil = VeryEvil (Evil -> Evil)
bad :: Evil -> (Evil -> Evil)
bad (VeryEvil f) = f
hell :: Evil -> Evil
hell f = (bad f) f
loop :: Evil
loop = hell (VeryEvil hell)

14. Terminação baseada em tipos — (VI)
I Evidentemente loop não termina. . .
loop =
hell (VeryEvil hell) =
bad (VeryEvil hell) (VeryEvil hell) =
hell (VeryEvil hell) =
loop = ...

15. Terminação baseada em tipos — (VII)
I Primeiramente devemos considerar apenas tipos de dados que
respeitam as condições anteriores.
I Tais tipos de dados são ditos possuir ocorrências estritamente
positivas e são normalmente denominados tipos de dados
indutivos.
I Coq e Agda permitem apenas definições de tipos de dados
indutivos.

16. Terminação baseada em tipos — (VIII)
I Com isso vimos a intuição do sistema de tipos para
terminação:
I Associar medidas a definições de tipos.
I Somente permitir tipos de dados indutivos.
I Basicamente o sistema de tipos consiste do λ−cálculo tipado
simples com subtipagem, recursão e tipos de dados algébricos.
I Única modificação necessária: Permitir a chamadas recursivas
somente a termos de medida menor.

17. Terminação baseada em tipos — (IX)
I Sistema de tipos.
I Regras idênticas ao do λ-cálculo.
x : τ ∈ Γ
Γ ` x : τ
(var)
Γ ` e : τ τ v τ0
Γ ` e : τ0
(sub)
Γ , x : τ ` e : τ0
Γ ` λx.e : τ → τ0
(abs)
Γ ` e1 : τ → τ0 Γ ` e2 : τ
Γ ` e1 e2 : τ0
(app)

18. Terminação baseada em tipos — (X)
I Regras para lidar com recursão e tipos de dados.
C(ck) = τ1 → ... → Db
s α
Γ ` ck : τ1 → ... → Db
s α
(con)
Γ ` e : D
b
i τ
C(ck) = τ1 → ... → Db
s α
Γ ` ek : τ1 → ...[α 7→ τ, i 7→ s] → τ0
Γ ` case e of {c1 ⇒ e1 | ... | cn ⇒ en} : τ0
(case)
Γ, f : Di τ → ... → τ0 ` D
b
i τ → ... → τ0[i 7→ b
i]
Γ ` let f = e : Ds τ → ... → τ0[i 7→ s]
(rec)

19. Terminação baseada em tipos — (XI)
I Propriedades do sistema de tipos
I Subject Reduction: Se Γ ` e : τ e e →βιµ e0
então Γ ` e0
: τ.
I Normalização forte: Todo termo bem tipado pode ser reduzido
a sua forma normal em um número finito de passos.
I Demonstrações detalhadas de todas as propriedades do sistema
de tipos.
I Formalização das restrições sintáticas utilizadas atualmente
em assistentes de provas

20. Terminação baseada em tipos — (XII)
I Idéias para trabalhos
I Iniciar a implementação de uma linguagem com dependent
types utilizando terminação baseada em tipos.
I Perguntas?