(* This program is free software; you can redistribute it and/or      *)
(* modify it under the terms of the GNU Lesser General Public License *)
(* as published by the Free Software Foundation; either version 2.1   *)
(* of the License, or (at your option) any later version.             *)
(*                                                                    *)
(* This program is distributed in the hope that it will be useful,    *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of     *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      *)
(* GNU General Public License for more details.                       *)
(*                                                                    *)
(* You should have received a copy of the GNU Lesser General Public   *)
(* License along with this program; if not, write to the Free         *)
(* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *)
(* 02110-1301 USA                                                     *)
Unset Standard Proposition Elimination Names.

(* Specifications: *)
Theorem swap_par_or_name :
forall r p q : PP, pname (swap_par r p q) = swap_name (pname r) p q.
Theorem swap_is_subs_on_names :
forall (n : name) (p q : PP),
n <> pname p -> subs_par_name n (pname p) q = swap_name n p q.
Theorem swap_under_inp :
forall (P : proc) (n : name) (p q : PP) (x : VV),
swap_proc (inp n x P) p q = inp (swap_name n p q) x (swap_proc P p q).
Theorem swap_under_out :
forall (P : proc) (n1 n2 : name) (p q : PP),
swap_proc (out n1 n2 P) p q =
out (swap_name n1 p q) (swap_name n2 p q) (swap_proc P p q).
Theorem swap_name_inefficient :
forall (n : name) (p q : PP),
n <> pname p -> n <> pname q -> swap_name n p q = n.
Theorem swap_proc_inefficient :
forall (P : proc) (p q : PP), fresh p P -> fresh q P -> swap_proc P p q = P.
Theorem swap_under_subs_name :
forall (n : name) (p q : PP) (m : name) (x : VV),
swap_name (subs_var_name n m x) p q =
subs_var_name (swap_name n p q) (swap_name m p q) x.
Theorem swap_under_subs :
forall (P : proc) (p q : PP) (n : name) (x : VV),
swap_proc (subs_var_proc P n x) p q =
subs_var_proc (swap_proc P p q) (swap_name n p q) x.
Theorem swap_env_by_addenv :
forall (G : env) (p q : PP),
eqvenv (swap_env G p q) (addenv (addenv G p (G q)) q (G p)).
Theorem swap_on_gettype :
forall (G : env) (r p q : PP), swap_env G p q r = G (swap_par r p q).
Theorem swap_par_twice : forall r p q : PP, swap_par (swap_par r p q) p q = r.
Theorem swap_on_addenv :
forall (G : env) (r p q : PP) (t : type),
eqvenv (swap_env (addenv G r t) p q)
(addenv (swap_env G p q) (swap_par r p q) t).
Theorem fresh_after_swap_name :
forall (n : name) (r p q : PP),
freshname r (swap_name n p q) -> freshname (swap_par r p q) n.
Theorem fresh_after_swap :
forall (P : proc) (r p q : PP),
fresh r (swap_proc P p q) -> fresh (swap_par r p q) P.
Theorem swap_name_twice :
forall (n : name) (p q : PP), swap_name (swap_name n p q) p q = n.
Theorem typing_after_swap :
forall (G : env) (P : proc),
typing G P -> forall p q : PP, typing (swap_env G p q) (swap_proc P p q).
Theorem gettype_not_added_name :
forall (G : env) (p q : PP) (t : type), p <> q -> addenv G p t q = G q.
Theorem gettype_added_name :
forall (G : env) (p : PP) (t : type), addenv G p t p = t.
Theorem eqv_addenv :
forall (G D : env) (p : PP) (t : type),
eqvenv G D -> eqvenv (addenv G p t) (addenv D p t).
Theorem eqv_trans :
forall G G' G'' : env, eqvenv G G' -> eqvenv G' G'' -> eqvenv G G''.
Theorem eqv_typing :
forall G D : env, eqvenv G D -> forall P : proc, typing G P -> typing D P.
Theorem switch_addenv :
forall (G : env) (p q : PP) (t1 t2 : type),
p <> q -> eqvenv (addenv (addenv G p t1) q t2) (addenv (addenv G q t2) p t1).
Theorem trivial_addenv :
forall (G : env) (p : PP), eqvenv G (addenv G p (G p)).
Theorem redundant_addenv :
forall (G : env) (P : proc),
typing G P ->
forall (D : env) (p : PP) (t : type),
fresh p P -> eqvenv G (addenv D p t) -> typing D P.
Theorem addenv_unused_name :
forall (G : env) (P : proc),
typing G P ->
forall (q : PP) (t : type), fresh q P -> typing (addenv G q t) P.
Theorem eqe_refl : forall G : env, eqvenv G G.
Theorem eqe_sym : forall G D : env, eqvenv G D -> eqvenv D G.
Theorem eqe_mask :
forall (G : env) (p : PP) (t1 t2 : type),
eqvenv (addenv (addenv G p t1) p t2) (addenv G p t2).