| accept_list | 
 Def DA(l)  == FinalState(DA)(Result(DA)l)
Thm*  Alph,St:Type, A:Automata(Alph;St), l:Alph*. A(l)      
 | 
| DA_fin | 
 Def FinalState(a) == 2of(2of(a))
 
 Thm*  Alph,States:Type, a:Automata(Alph;States). FinalState(a)   States    
 | 
| assert | 
 Def  b == if b  True else False fi
Thm*  b: . b   Prop 
 | 
| automata | 
 Def Automata(Alph;States) == (States  Alph  States) States (States   )
Thm*  Alph,States:Type{i}. Automata(Alph;States)   Type{i'} 
 | 
| connected | 
 Def Con(A) ==  s:St.  l:Alph*. (Result(A)l) = s
Thm*  Alph,St:Type, A:Automata(Alph;St). Con(A)   Prop 
 | 
| refine | 
 Def A1   A2 
==  x,y:Alph*. (Result(A1)x) = (Result(A1)y)   S1    (Result(A2)x) = (Result(A2)y)   S2
Thm*  Alph,S1,S2:Type, A1:Automata(Alph;S1), A2:Automata(Alph;S2). A1   A2    Prop 
 | 
| compute_list | 
 Def Result(DA)l
 == if null(l)  InitialState(DA) else  DA((Result(DA)tl(l)),hd(l)) fi
 (recursive)
 Thm*  Alph,St:Type, A:Automata(Alph;St), l:Alph*. (Result(A)l)   St 
 | 
| iff | 
 Def P    Q == (P    Q)  &  (P    Q)
Thm*  A,B:Prop. (A    B)   Prop 
 | 
| DA_init | 
 Def InitialState(a) == 1of(2of(a))
 
 Thm*  Alph,States:Type, a:Automata(Alph;States). InitialState(a)   States 
 | 
| pi2 | 
 Def 2of(t) == t.2
 
 Thm*  A:Type, B:(A  Type), p:a:A B(a). 2of(p)   B(1of(p)) 
 | 
| hd | 
 Def hd(l) == Case of l; nil   "?" ; h.t   h
 Thm*  A:Type, l:A*. ||l|| 1    hd(l)   A 
 | 
| tl | 
 Def tl(l) == Case of l; nil   nil ; h.t   t
 Thm*  A:Type, l:A*. tl(l)   A* 
 | 
| DA_act | 
 Def  a == 1of(a)
 Thm*  Alph,States:Type, a:Automata(Alph;States).  a   States  Alph  States 
 | 
| null | 
 Def null(as) == Case of as; nil   true  ; a.as'   false 
 Thm*  T:Type, as:T*. null(as)    
 
 Thm* null(nil)     
 | 
| rev_implies | 
 Def P    Q == Q    P
Thm*  A,B:Prop. (A    B)   Prop 
 | 
| pi1 | 
 Def 1of(t) == t.1
 Thm*  A:Type, B:(A  Type), p:a:A B(a). 1of(p)   A 
 |