Require Import List.
Import ListNotations.

Ltac simpeq := repeat match goal with
  | _ => congruence || (progress subst)
  | H : ?x = ?x |- _ => clear H
  | H : _ = _ |- _ => progress injection H as H
  end.

Ltac simp tac :=
  repeat match goal with
  | |- _ => progress simpl in *
  | |- _ => progress subst
  | |- _ => congruence
  | |- ?x = ?x => reflexivity
  | H : ?x = ?x |- _ => clear H
  | |- forall _, _ => intro
  | |- _ => intro
  | H : False |- _ => destruct H
  | H : True |- _ => destruct H
  | H : exists _, _ |- _ => destruct H
  | H : _ /\ _ |- _ => destruct H
  | H : _ <-> _ |- _ => destruct H
  | x : _ * _ |- _ => destruct x
  | H1 : ?P -> ?Q, H2 : ?P |- _ => specialize (H1 H2)
  | H1 : (?x = ?x) -> ?Q |- _ => specialize (H1 eq_refl)
  | H : True -> ?Q |- _ => specialize (H I)
  | |- _ => progress unfold orb, andb in *
  | |- _ => progress (simpeq; auto)
  (* Do tactics that create multiple subgoals last *)
  | |- _ /\ _ => split
  | |- _ <-> _ => split
  | H : _ \/ _ |- _ => destruct H
  | [ H: ?x ++ ?y = [] |- _ ] => destruct x, y
  | [ H: [] = ?x ++ ?y |- _ ] => destruct x, y
  | [ H: context[match ?X with _ => _ end] |- _ ] => destruct X eqn:?
  | [ |- context[match ?X with _ => _ end] ] => destruct X eqn:?
  | [ H: context[if ?b then _ else _] |- _ ] => destruct b eqn:?
  | [ |- context[if ?b then _ else _] ] => destruct b eqn:?
  | |- _ \/ _ => solve [left; simp tac | right; simp tac]
  | |- _ => progress tac
  end.

Parameter T : Type.
Parameter eq_dec : forall x y : T, {x = y} + {x <> y}.
Parameter A B C : T.

(* Regular expressions *)

Inductive re : Type :=
  | Empty : re
  | Epsilon : re
  | Atom : T -> re
  | Union : re -> re -> re
  | Concat : re -> re -> re
  | Star : re -> re.

(* Matching relation *)
Inductive matches : re -> list T -> Prop :=
  | matches_epsilon : matches Epsilon []
  | matches_atom a : matches (Atom a) [a]
  | matches_union_l r1 r2 s : matches r1 s -> matches (Union r1 r2) s
  | matches_union_r r1 r2 s : matches r2 s -> matches (Union r1 r2) s
  | matches_concat r1 r2 s1 s2 s3 : matches r1 s1 -> matches r2 s2 -> s3 = s1 ++ s2 -> matches (Concat r1 r2) s3
  | matches_star_empty r : matches (Star r) []
  | matches_star_step r s1 s2 s3 : matches r s1 -> matches (Star r) s2 -> s3 = s1 ++ s2 -> matches (Star r) s3.

Lemma cons_eq_app {A} (a : A) x y z : a :: x = y ++ z -> (y = [] /\ z = a :: x) \/ (exists y', y = a :: y' /\ x = y' ++ z).
A: Type
a: A
x, y, z: list A
a :: x = y ++ z ->
y = [] /\ z = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ z)
Proof.
A: Type
a: A
x, y, z: list A
a :: x = y ++ z ->
y = [] /\ z = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ z)
  intros H.
A: Type
a: A
x, y, z: list A
H: a :: x = y ++ z
y = [] /\ z = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ z) replace (a :: x) with ([a] ++ x) in H; eauto.
A: Type
a: A
x, y, z: list A
H: [a] ++ x = y ++ z
y = [] /\ z = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ z)
  apply app_eq_app in H.
A: Type
a: A
x, y, z: list A
H: exists l : list A,
  [a] = y ++ l /\ z = l ++ x \/
  y = [a] ++ l /\ x = l ++ z
y = [] /\ z = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ z) simp eauto.
A: Type
a: A
x, y, x0: list A
H: [a] = y ++ x0
y = [] /\ x0 ++ x = a :: x \/
(exists y' : list A, y = a :: y' /\ x = y' ++ x0 ++ x)
  destruct y; simp eauto.
Qed.

Lemma star_inv r s : 
  s <> [] -> 
  matches (Star r) s -> 
  exists s1 s2, 
    s1 <> [] /\ 
    s = s1 ++ s2 /\ 
    matches r s1 /\ 
    matches (Star r) s2.
r: re
s: list T
s <> [] ->
matches (Star r) s ->
exists s1 s2 : list T,
  s1 <> [] /\
  s = s1 ++ s2 /\ matches r s1 /\ matches (Star r) s2
Proof.
r: re
s: list T
s <> [] ->
matches (Star r) s ->
exists s1 s2 : list T,
  s1 <> [] /\
  s = s1 ++ s2 /\ matches r s1 /\ matches (Star r) s2
  intros Hs Hr.
r: re
s: list T
Hs: s <> []
Hr: matches (Star r) s
exists s1 s2 : list T,
  s1 <> [] /\
  s = s1 ++ s2 /\ matches r s1 /\ matches (Star r) s2 remember (Star r).
r: re
s: list T
Hs: s <> []
r0: re
Heqr0: r0 = Star r
Hr: matches r0 s
exists s1 s2 : list T,
  s1 <> [] /\
  s = s1 ++ s2 /\ matches r s1 /\ matches r0 s2 revert r Heqr0.
s: list T
Hs: s <> []
r0: re
Hr: matches r0 s
forall r : re,
r0 = Star r ->
exists s1 s2 : list T,
  s1 <> [] /\
  s = s1 ++ s2 /\ matches r s1 /\ matches r0 s2 induction Hr; simp eauto.
s1, s2: list T
Hs: s1 ++ s2 <> []
r0: re
IHHr2: s2 <> [] ->
forall r : re,
Star r0 = Star r ->
exists s1 s3 : list T,
  s1 <> [] /\
  s2 = s1 ++ s3 /\
  matches r s1 /\ matches (Star r0) s3
IHHr1: s1 <> [] ->
forall r : re,
r0 = Star r ->
exists s2 s3 : list T,
  s2 <> [] /\
  s1 = s2 ++ s3 /\
  matches r s2 /\ matches r0 s3
Hr2: matches (Star r0) s2
Hr1: matches r0 s1
exists s3 s4 : list T,
  s3 <> [] /\
  s1 ++ s2 = s3 ++ s4 /\
  matches r0 s3 /\ matches (Star r0) s4
  destruct s1; simp eauto.
t: T
s1, s2: list T
Hs: t :: s1 ++ s2 <> []
r0: re
IHHr2: s2 <> [] ->
forall r : re,
Star r0 = Star r ->
exists s1 s3 : list T,
  s1 <> [] /\
  s2 = s1 ++ s3 /\
  matches r s1 /\ matches (Star r0) s3
IHHr1: t :: s1 <> [] ->
forall r : re,
r0 = Star r ->
exists s2 s3 : list T,
  s2 <> [] /\
  t :: s1 = s2 ++ s3 /\
  matches r s2 /\ matches r0 s3
Hr2: matches (Star r0) s2
Hr1: matches r0 (t :: s1)
exists s3 s4 : list T,
  s3 <> [] /\
  t :: s1 ++ s2 = s3 ++ s4 /\
  matches r0 s3 /\ matches (Star r0) s4 exists (t :: s1).
t: T
s1, s2: list T
Hs: t :: s1 ++ s2 <> []
r0: re
IHHr2: s2 <> [] ->
forall r : re,
Star r0 = Star r ->
exists s1 s3 : list T,
  s1 <> [] /\
  s2 = s1 ++ s3 /\
  matches r s1 /\ matches (Star r0) s3
IHHr1: t :: s1 <> [] ->
forall r : re,
r0 = Star r ->
exists s2 s3 : list T,
  s2 <> [] /\
  t :: s1 = s2 ++ s3 /\
  matches r s2 /\ matches r0 s3
Hr2: matches (Star r0) s2
Hr1: matches r0 (t :: s1)
exists s3 : list T,
  t :: s1 <> [] /\
  t :: s1 ++ s2 = (t :: s1) ++ s3 /\
  matches r0 (t :: s1) /\ matches (Star r0) s3 simp eauto.
t: T
s1, s2: list T
Hs: t :: s1 ++ s2 <> []
r0: re
IHHr2: s2 <> [] ->
forall r : re,
Star r0 = Star r ->
exists s1 s3 : list T,
  s1 <> [] /\
  s2 = s1 ++ s3 /\
  matches r s1 /\ matches (Star r0) s3
IHHr1: t :: s1 <> [] ->
forall r : re,
r0 = Star r ->
exists s2 s3 : list T,
  s2 <> [] /\
  t :: s1 = s2 ++ s3 /\
  matches r s2 /\ matches r0 s3
Hr2: matches (Star r0) s2
Hr1: matches r0 (t :: s1)
exists s3 : list T,
  t :: s1 <> [] /\
  t :: s1 ++ s2 = t :: s1 ++ s3 /\
  matches r0 (t :: s1) /\ matches (Star r0) s3
  eexists.
t: T
s1, s2: list T
Hs: t :: s1 ++ s2 <> []
r0: re
IHHr2: s2 <> [] ->
forall r : re,
Star r0 = Star r ->
exists s1 s3 : list T,
  s1 <> [] /\
  s2 = s1 ++ s3 /\
  matches r s1 /\ matches (Star r0) s3
IHHr1: t :: s1 <> [] ->
forall r : re,
r0 = Star r ->
exists s2 s3 : list T,
  s2 <> [] /\
  t :: s1 = s2 ++ s3 /\
  matches r s2 /\ matches r0 s3
Hr2: matches (Star r0) s2
Hr1: matches r0 (t :: s1)
t :: s1 <> [] /\
t :: s1 ++ s2 = t :: s1 ++ ?s2 /\
matches r0 (t :: s1) /\ matches (Star r0) ?s2 simp eauto.
Qed.

Ltac inv H := inversion H; clear H; simpeq.
Ltac auto_inv :=
  try match goal with
  | [ H : matches Empty _ |- _ ] => inv H
  | [ H : matches (Epsilon) _ |- _ ] => inv H
  | [ H : matches (Atom _) _ |- _ ] => inv H
  | [ H : matches (Union _ _) _ |- _ ] => inv H
  | [ H : matches (Concat _ _) _ |- _ ] => inv H
  | [ H : matches (Star _) (_ :: _) |- _ ] => apply star_inv in H
  | [ H : _ :: _ = ?x ++ ?y |- _ ] => apply cons_eq_app in H
  end; eauto.

Ltac X := simp auto_inv.

(* Add constructors of matches to the core auto database *)
Hint Constructors matches : core.

(* Regular expression matching with derivatives *)

(* True if the regular expression matches the empty string *)
Fixpoint eps (r : re) : bool :=
  match r with
  | Empty => false
  | Epsilon => true
  | Atom _ => false
  | Union r1 r2 => eps r1 || eps r2
  | Concat r1 r2 => eps r1 && eps r2
  | Star _ => true
  end.

Lemma eps_matches_1 r : eps r = true -> matches r [].
r: re
eps r = true -> matches r []
Proof.
r: re
eps r = true -> matches r [] induction r; X. Qed.

Lemma eps_matches_2 r : matches r [] -> eps r = true.
r: re
matches r [] -> eps r = true
Proof.
r: re
matches r [] -> eps r = true remember [].
r: re
l: list T
Heql: l = []
matches r l -> eps r = true induction 1; X. Qed.

Hint Resolve eps_matches_1 eps_matches_2 : core.

(* Derivative of a regular expression with respect to a character *)
Fixpoint der (r : re) (a : T) : re :=
  match r with
  | Empty => Empty
  | Epsilon => Empty
  | Atom b => if eq_dec a b then Epsilon else Empty
  | Union r1 r2 => Union (der r1 a) (der r2 a)
  | Concat r1 r2 => if eps r1 then Union (Concat (der r1 a) r2) (der r2 a) else Concat (der r1 a) r2
  | Star r => Concat (der r a) (Star r)
  end.

Lemma der_matches_1 a r s : matches (der r a) s -> matches r (a :: s).
a: T
r: re
s: list T
matches (der r a) s -> matches r (a :: s)
Proof.
a: T
r: re
s: list T
matches (der r a) s -> matches r (a :: s) revert s.
a: T
r: re
forall s : list T,
matches (der r a) s -> matches r (a :: s) induction r; X. Qed.

Lemma der_matches_2 a r s : matches r (a :: s) -> matches (der r a) s.
a: T
r: re
s: list T
matches r (a :: s) -> matches (der r a) s
Proof.
a: T
r: re
s: list T
matches r (a :: s) -> matches (der r a) s revert s.
a: T
r: re
forall s : list T,
matches r (a :: s) -> matches (der r a) s induction r; X.
a: T
r1, r2: re
IHr1: forall s : list T,
matches r1 (a :: s) -> matches (der r1 a) s
IHr2: forall s : list T,
matches r2 (a :: s) -> matches (der r2 a) s
s: list T
Heqb: eps r1 = false
H2: matches r1 []
H3: matches r2 (a :: s)
matches (Concat (der r1 a) r2) s apply eps_matches_2 in H2.
a: T
r1, r2: re
IHr1: forall s : list T,
matches r1 (a :: s) -> matches (der r1 a) s
IHr2: forall s : list T,
matches r2 (a :: s) -> matches (der r2 a) s
s: list T
Heqb: eps r1 = false
H2: eps r1 = true
H3: matches r2 (a :: s)
matches (Concat (der r1 a) r2) s X. Qed.

Hint Resolve der_matches_1 der_matches_2 : core.

Definition matches' (r : re) (s : list T) : bool :=
  eps (fold_left der s r).

Lemma matches'_matches r s : matches' r s = true <-> matches r s.
r: re
s: list T
matches' r s = true <-> matches r s
Proof.
r: re
s: list T
matches' r s = true <-> matches r s unfold matches'.
r: re
s: list T
eps (fold_left der s r) = true <-> matches r s split; revert r; induction s; X. Qed.

(* Bisimulation *)

Definition set (A : Type) := A -> Prop.
Definition cap {A} (X : set (set A)) : set A := fun x => forall Y, X Y -> Y x.
Definition le {A} (X Y : set A) := forall x, X x -> Y x.

Definition f_equiv (bisim : set (re * re)) : set (re * re) :=
  fun '(r1, r2) => eps r1 = eps r2 /\ forall a, bisim (der r1 a, der r2 a).

Lemma f_equiv_mono x y : le x y -> le (f_equiv x) (f_equiv y).
x, y: set (re * re)
le x y -> le (f_equiv x) (f_equiv y)
Proof.
x, y: set (re * re)
le x y -> le (f_equiv x) (f_equiv y)
  unfold le, f_equiv.
x, y: set (re * re)
(forall x0 : re * re, x x0 -> y x0) ->
forall x0 : re * re,
(let
 '(r1, r2) := x0 in
  eps r1 = eps r2 /\
  (forall a : T, x (der r1 a, der r2 a))) ->
let
'(r1, r2) := x0 in
 eps r1 = eps r2 /\
 (forall a : T, y (der r1 a, der r2 a)) simp eauto.
Qed.

Inductive Omega : set (set (re * re)) :=
  | Omega_lim (X : set (set (re * re))) : (forall x, X x -> Omega x) -> Omega (cap X)
  | Omega_suc x : Omega x -> Omega (f_equiv x).

Definition equiv (r1 r2 : re) : Prop := cap Omega (r1, r2).

Lemma Omega_decr x : Omega x -> le (f_equiv x) x.
x: set (re * re)
Omega x -> le (f_equiv x) x
Proof.
x: set (re * re)
Omega x -> le (f_equiv x) x
  induction 1; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re), X x -> le (f_equiv x) x
le (f_equiv (cap X)) (cap X)
x: set (re * re)
H: Omega x
IHOmega: le (f_equiv x) x
le (f_equiv (f_equiv x)) (f_equiv x)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re), X x -> le (f_equiv x) x
le (f_equiv (cap X)) (cap X) unfold le, cap in *.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall x0 : re * re, f_equiv x x0 -> x x0
forall x : re * re,
f_equiv
  (fun x0 : re * re =>
   forall Y : set (re * re), X Y -> Y x0) x ->
forall Y : set (re * re), X Y -> Y x intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall x0 : re * re, f_equiv x x0 -> x x0
x: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) x
Y: set (re * re)
H2: X Y
Y x
    eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall x0 : re * re, f_equiv x x0 -> x x0
x: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) x
Y: set (re * re)
H2: X Y
f_equiv Y x eapply f_equiv_mono; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall x0 : re * re, f_equiv x x0 -> x x0
x: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) x
Y: set (re * re)
H2: X Y
le
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) Y intros ??.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall x0 : re * re, f_equiv x x0 -> x x0
x: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) x
Y: set (re * re)
H2: X Y
x0: (re * re)%type
H3: forall Y : set (re * re), X Y -> Y x0
Y x0
    eapply H3; eauto.
  -
x: set (re * re)
H: Omega x
IHOmega: le (f_equiv x) x
le (f_equiv (f_equiv x)) (f_equiv x) eapply f_equiv_mono; eauto.
Qed.

Lemma cap_le X (y : set (re * re)) : X y -> le (cap X) y.
X: set (re * re) -> Prop
y: set (re * re)
X y -> le (cap X) y
Proof.
X: set (re * re) -> Prop
y: set (re * re)
X y -> le (cap X) y
  intros.
X: set (re * re) -> Prop
y: set (re * re)
H: X y
le (cap X) y unfold le,cap.
X: set (re * re) -> Prop
y: set (re * re)
H: X y
forall x : re * re,
(forall Y : set (re * re), X Y -> Y x) -> y x intros.
X: set (re * re) -> Prop
y: set (re * re)
H: X y
x: (re * re)%type
H0: forall Y : set (re * re), X Y -> Y x
y x eapply H0.
X: set (re * re) -> Prop
y: set (re * re)
H: X y
x: (re * re)%type
H0: forall Y : set (re * re), X Y -> Y x
X (fun x : re * re => y x) eauto.
Qed.

Lemma cap_Omega_decr : le (f_equiv (cap Omega)) (cap Omega).
le (f_equiv (cap Omega)) (cap Omega)
Proof.
le (f_equiv (cap Omega)) (cap Omega)
  eapply Omega_decr.
Omega (cap Omega) constructor.
forall x : set (re * re), Omega x -> Omega x eauto.
Qed.

Lemma cap_Omega_incr : le (cap Omega) (f_equiv (cap Omega)).
le (cap Omega) (f_equiv (cap Omega))
Proof.
le (cap Omega) (f_equiv (cap Omega))
  eapply cap_le.
Omega (f_equiv (cap Omega)) constructor.
Omega (cap Omega) constructor.
forall x : set (re * re), Omega x -> Omega x eauto.
Qed.

Lemma equiv_eps r1 r2 : equiv r1 r2 -> eps r1 = eps r2.
r1, r2: re
equiv r1 r2 -> eps r1 = eps r2
Proof.
r1, r2: re
equiv r1 r2 -> eps r1 = eps r2
  intros H.
r1, r2: re
H: equiv r1 r2
eps r1 = eps r2
  assert (f_equiv (cap Omega) (r1, r2)) as H'.
r1, r2: re
H: equiv r1 r2
f_equiv (cap Omega) (r1, r2)
r1, r2: re
H: equiv r1 r2
H': f_equiv (cap Omega) (r1, r2)
eps r1 = eps r2
  {
r1, r2: re
H: equiv r1 r2
f_equiv (cap Omega) (r1, r2) eapply cap_Omega_incr.
r1, r2: re
H: equiv r1 r2
cap Omega (r1, r2) eauto. }
r1, r2: re
H: equiv r1 r2
H': f_equiv (cap Omega) (r1, r2)
eps r1 = eps r2 clear H.
r1, r2: re
H': f_equiv (cap Omega) (r1, r2)
eps r1 = eps r2
  unfold f_equiv in *.
r1, r2: re
H': eps r1 = eps r2 /\
(forall a : T, cap Omega (der r1 a, der r2 a))
eps r1 = eps r2 simp eauto.
Qed.

Lemma equiv_der a r1 r2 : equiv r1 r2 -> equiv (der r1 a) (der r2 a).
a: T
r1, r2: re
equiv r1 r2 -> equiv (der r1 a) (der r2 a)
Proof.
a: T
r1, r2: re
equiv r1 r2 -> equiv (der r1 a) (der r2 a)
  intros H.
a: T
r1, r2: re
H: equiv r1 r2
equiv (der r1 a) (der r2 a)
  assert (f_equiv (cap Omega) (r1, r2)) as H'.
a: T
r1, r2: re
H: equiv r1 r2
f_equiv (cap Omega) (r1, r2)
a: T
r1, r2: re
H: equiv r1 r2
H': f_equiv (cap Omega) (r1, r2)
equiv (der r1 a) (der r2 a)
  {
a: T
r1, r2: re
H: equiv r1 r2
f_equiv (cap Omega) (r1, r2) eapply cap_Omega_incr.
a: T
r1, r2: re
H: equiv r1 r2
cap Omega (r1, r2) eauto. }
a: T
r1, r2: re
H: equiv r1 r2
H': f_equiv (cap Omega) (r1, r2)
equiv (der r1 a) (der r2 a) clear H.
a: T
r1, r2: re
H': f_equiv (cap Omega) (r1, r2)
equiv (der r1 a) (der r2 a)
  unfold f_equiv in *.
a: T
r1, r2: re
H': eps r1 = eps r2 /\
(forall a : T, cap Omega (der r1 a, der r2 a))
equiv (der r1 a) (der r2 a) simp eauto.
a: T
r1, r2: re
H0: eps r1 = eps r2
H1: forall a : T, cap Omega (der r1 a, der r2 a)
Y: set (re * re)
H: Omega Y
Y (der r1 a, der r2 a)
  eapply H1.
a: T
r1, r2: re
H0: eps r1 = eps r2
H1: forall a : T, cap Omega (der r1 a, der r2 a)
Y: set (re * re)
H: Omega Y
Omega (fun p : re * re => Y p) eauto.
Qed.

Lemma equiv_matches r1 r2 s : equiv r1 r2 -> matches' r1 s = matches' r2 s.
r1, r2: re
s: list T
equiv r1 r2 -> matches' r1 s = matches' r2 s
Proof.
r1, r2: re
s: list T
equiv r1 r2 -> matches' r1 s = matches' r2 s
  intros H.
r1, r2: re
s: list T
H: equiv r1 r2
matches' r1 s = matches' r2 s
  revert r1 r2 H.
s: list T
forall r1 r2 : re,
equiv r1 r2 -> matches' r1 s = matches' r2 s
  induction s; intros; unfold matches'; simpl.
r1, r2: re
H: equiv r1 r2
eps r1 = eps r2
a: T
s: list T
IHs: forall r1 r2 : re, equiv r1 r2 -> matches' r1 s = matches' r2 s
r1, r2: re
H: equiv r1 r2
eps (fold_left der s (der r1 a)) =
eps (fold_left der s (der r2 a))
  -
r1, r2: re
H: equiv r1 r2
eps r1 = eps r2 eapply equiv_eps.
r1, r2: re
H: equiv r1 r2
equiv r1 r2 eauto.
  -
a: T
s: list T
IHs: forall r1 r2 : re, equiv r1 r2 -> matches' r1 s = matches' r2 s
r1, r2: re
H: equiv r1 r2
eps (fold_left der s (der r1 a)) =
eps (fold_left der s (der r2 a)) eapply IHs.
a: T
s: list T
IHs: forall r1 r2 : re, equiv r1 r2 -> matches' r1 s = matches' r2 s
r1, r2: re
H: equiv r1 r2
equiv (der r1 a) (der r2 a) eapply equiv_der.
a: T
s: list T
IHs: forall r1 r2 : re, equiv r1 r2 -> matches' r1 s = matches' r2 s
r1, r2: re
H: equiv r1 r2
equiv r1 r2 eauto.
Qed.

Lemma matches'_equiv r1 r2 : (forall s, matches' r1 s = matches' r2 s) -> equiv r1 r2.
r1, r2: re
(forall s : list T, matches' r1 s = matches' r2 s) ->
equiv r1 r2
Proof.
r1, r2: re
(forall s : list T, matches' r1 s = matches' r2 s) ->
equiv r1 r2
  unfold equiv, cap.
r1, r2: re
(forall s : list T, matches' r1 s = matches' r2 s) ->
forall Y : set (re * re), Omega Y -> Y (r1, r2) intros H Y HY.
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
Y: set (re * re)
HY: Omega Y
Y (r1, r2)
  revert r1 r2 H.
Y: set (re * re)
HY: Omega Y
forall r1 r2 : re,
(forall s : list T, matches' r1 s = matches' r2 s) ->
Y (r1, r2) induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
(forall s : list T, matches' r1 s = matches' r2 s) ->
x (r1, r2)
r1, r2: re
H1: forall s : list T, matches' r1 s = matches' r2 s
cap X (r1, r2)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
f_equiv x (r1, r2)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
(forall s : list T, matches' r1 s = matches' r2 s) ->
x (r1, r2)
r1, r2: re
H1: forall s : list T, matches' r1 s = matches' r2 s
cap X (r1, r2) intros ??.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
(forall s : list T, matches' r1 s = matches' r2 s) ->
x (r1, r2)
r1, r2: re
H1: forall s : list T, matches' r1 s = matches' r2 s
Y: set (re * re)
H2: X Y
Y (r1, r2) eapply H0; eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
f_equiv x (r1, r2) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a)) split.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
eps r1 = eps r2
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
forall a : T, x (der r1 a, der r2 a)
    +
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
eps r1 = eps r2 specialize (H []).
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: matches' r1 [] = matches' r2 []
eps r1 = eps r2 unfold matches' in H.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: eps (fold_left der [] r1) =
eps (fold_left der [] r2)
eps r1 = eps r2 simpl in *.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: eps r1 = eps r2
eps r1 = eps r2 eauto.
    +
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
forall a : T, x (der r1 a, der r2 a) intros a.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
a: T
x (der r1 a, der r2 a) eapply IHHY.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
a: T
forall s : list T,
matches' (der r1 a) s = matches' (der r2 a) s intros s.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
H: forall s : list T, matches' r1 s = matches' r2 s
a: T
s: list T
matches' (der r1 a) s = matches' (der r2 a) s specialize (H (a :: s)).
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 matches' r1 s = matches' r2 s) -> 
x (r1, r2)
r1, r2: re
a: T
s: list T
H: matches' r1 (a :: s) = matches' r2 (a :: s)
matches' (der r1 a) s = matches' (der r2 a) s
      unfold matches' in *.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 eps (fold_left der s r1) =
 eps (fold_left der s r2)) -> 
x (r1, r2)
r1, r2: re
a: T
s: list T
H: eps (fold_left der (a :: s) r1) =
eps (fold_left der (a :: s) r2)
eps (fold_left der s (der r1 a)) =
eps (fold_left der s (der r2 a)) simpl in *.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
(forall s : list T,
 eps (fold_left der s r1) =
 eps (fold_left der s r2)) -> 
x (r1, r2)
r1, r2: re
a: T
s: list T
H: eps (fold_left der s (der r1 a)) =
eps (fold_left der s (der r2 a))
eps (fold_left der s (der r1 a)) =
eps (fold_left der s (der r2 a)) eauto.
Qed.

Lemma equiv_refl r : equiv r r.
r: re
equiv r r
Proof.
r: re
equiv r r 
  unfold equiv.
r: re
cap Omega (r, r) intros Y HY.
r: re
Y: set (re * re)
HY: Omega Y
Y (r, r) revert r.
Y: set (re * re)
HY: Omega Y
forall r : re, Y (r, r)
  induction HY.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (r, r)
forall r : re, cap X (r, r)
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (r, r)
forall r : re, f_equiv x (r, r)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (r, r)
forall r : re, cap X (r, r) unfold cap.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (r, r)
forall (r : re) (Y : set (re * re)), X Y -> Y (r, r) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (r, r)
r: re
Y: set (re * re)
H1: X Y
Y (r, r) eapply H0.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (r, r)
r: re
Y: set (re * re)
H1: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (r, r)
forall r : re, f_equiv x (r, r) intros r.
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (r, r)
r: re
f_equiv x (r, r) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (r, r)
r: re
eps r = eps r /\ (forall a : T, x (der r a, der r a)) eauto.
Qed.

Lemma equiv_sym r1 r2 : equiv r1 r2 -> equiv r2 r1.
r1, r2: re
equiv r1 r2 -> equiv r2 r1
Proof.
r1, r2: re
equiv r1 r2 -> equiv r2 r1
  unfold equiv.
r1, r2: re
cap Omega (r1, r2) -> cap Omega (r2, r1) intros H Y HY.
r1, r2: re
H: cap Omega (r1, r2)
Y: set (re * re)
HY: Omega Y
Y (r2, r1) specialize (H Y HY).
r1, r2: re
Y: set (re * re)
H: Y (r1, r2)
HY: Omega Y
Y (r2, r1)
  revert r1 r2 H.
Y: set (re * re)
HY: Omega Y
forall r1 r2 : re, Y (r1, r2) -> Y (r2, r1) induction HY.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re, cap X (r1, r2) -> cap X (r2, r1)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re,
f_equiv x (r1, r2) -> f_equiv x (r2, r1)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re, cap X (r1, r2) -> cap X (r2, r1) unfold cap in *.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re,
(forall Y : set (re * re), X Y -> Y (r1, r2)) ->
forall Y : set (re * re), X Y -> Y (r2, r1) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
Y: set (re * re)
H2: X Y
Y (r2, r1) eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
Y: set (re * re)
H2: X Y
Y (r1, r2) eapply H1.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
Y: set (re * re)
H2: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re,
f_equiv x (r1, r2) -> f_equiv x (r2, r1) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (r1, r2) -> x (r2, r1)
forall r1 r2 : re,
eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a)) ->
eps r2 = eps r1 /\
(forall a : T, x (der r2 a, der r1 a)) simp eauto.
Qed.

Lemma equiv_trans r1 r2 r3 : equiv r1 r2 -> equiv r2 r3 -> equiv r1 r3.
r1, r2, r3: re
equiv r1 r2 -> equiv r2 r3 -> equiv r1 r3
Proof.
r1, r2, r3: re
equiv r1 r2 -> equiv r2 r3 -> equiv r1 r3
  unfold equiv.
r1, r2, r3: re
cap Omega (r1, r2) ->
cap Omega (r2, r3) -> cap Omega (r1, r3) intros H12 H23 Y HY.
r1, r2, r3: re
H12: cap Omega (r1, r2)
H23: cap Omega (r2, r3)
Y: set (re * re)
HY: Omega Y
Y (r1, r3) specialize (H12 Y HY).
r1, r2, r3: re
Y: set (re * re)
H12: Y (r1, r2)
H23: cap Omega (r2, r3)
HY: Omega Y
Y (r1, r3) specialize (H23 Y HY).
r1, r2, r3: re
Y: set (re * re)
H12: Y (r1, r2)
H23: Y (r2, r3)
HY: Omega Y
Y (r1, r3)
  revert r1 r2 r3 H12 H23.
Y: set (re * re)
HY: Omega Y
forall r1 r2 r3 : re,
Y (r1, r2) -> Y (r2, r3) -> Y (r1, r3) induction HY.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
cap X (r1, r2) -> cap X (r2, r3) -> cap X (r1, r3)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
f_equiv x (r1, r2) ->
f_equiv x (r2, r3) -> f_equiv x (r1, r3)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
cap X (r1, r2) -> cap X (r2, r3) -> cap X (r1, r3) unfold cap in *.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
(forall Y : set (re * re), X Y -> Y (r1, r2)) ->
(forall Y : set (re * re), X Y -> Y (r2, r3)) ->
forall Y : set (re * re), X Y -> Y (r1, r3) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
r1, r2, r3: re
H12: forall Y : set (re * re), X Y -> Y (r1, r2)
H23: forall Y : set (re * re), X Y -> Y (r2, r3)
Y: set (re * re)
H1: X Y
Y (r1, r3) eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
r1, r2, r3: re
H12: forall Y : set (re * re), X Y -> Y (r1, r2)
H23: forall Y : set (re * re), X Y -> Y (r2, r3)
Y: set (re * re)
H1: X Y
Y (r1, ?r2)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
r1, r2, r3: re
H12: forall Y : set (re * re), X Y -> Y (r1, r2)
H23: forall Y : set (re * re), X Y -> Y (r2, r3)
Y: set (re * re)
H1: X Y
Y (?r2, r3)
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
r1, r2, r3: re
H12: forall Y : set (re * re), X Y -> Y (r1, r2)
H23: forall Y : set (re * re), X Y -> Y (r2, r3)
Y: set (re * re)
H1: X Y
Y (r1, ?r2) eapply H12; eauto.
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
r1, r2, r3: re
H12: forall Y : set (re * re), X Y -> Y (r1, r2)
H23: forall Y : set (re * re), X Y -> Y (r2, r3)
Y: set (re * re)
H1: X Y
Y (r2, r3) eapply H23; eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
f_equiv x (r1, r2) ->
f_equiv x (r2, r3) -> f_equiv x (r1, r3) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x (r1, r2) -> x (r2, r3) -> x (r1, r3)
forall r1 r2 r3 : re,
eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a)) ->
eps r2 = eps r3 /\
(forall a : T, x (der r2 a, der r3 a)) ->
eps r1 = eps r3 /\
(forall a : T, x (der r1 a, der r3 a)) simp eauto.
Qed.

Lemma Union_comm r1 r2 : equiv (Union r1 r2) (Union r2 r1).
r1, r2: re
equiv (Union r1 r2) (Union r2 r1)
Proof.
r1, r2: re
equiv (Union r1 r2) (Union r2 r1)
  unfold equiv.
r1, r2: re
cap Omega (Union r1 r2, Union r2 r1) intros Y HY.
r1, r2: re
Y: set (re * re)
HY: Omega Y
Y (Union r1 r2, Union r2 r1)
  revert r1 r2.
Y: set (re * re)
HY: Omega Y
forall r1 r2 : re, Y (Union r1 r2, Union r2 r1) induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
cap X (Union r1 r2, Union r2 r1)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
f_equiv x (Union r1 r2, Union r2 r1)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
cap X (Union r1 r2, Union r2 r1) unfold cap.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
forall Y : set (re * re),
X Y -> Y (Union r1 r2, Union r2 r1) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
Y: set (re * re)
H1: X Y
Y (Union r1 r2, Union r2 r1) eapply H0.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
Y: set (re * re)
H1: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
f_equiv x (Union r1 r2, Union r2 r1) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re, x (Union r1 r2, Union r2 r1)
r1, r2: re
eps (Union r1 r2) = eps (Union r2 r1) /\
(forall a : T,
 x (der (Union r1 r2) a, der (Union r2 r1) a)) simp eauto.
Qed.

Lemma Union_assoc r1 r2 r3 : equiv (Union r1 (Union r2 r3)) (Union (Union r1 r2) r3).
r1, r2, r3: re
equiv (Union r1 (Union r2 r3))
  (Union (Union r1 r2) r3)
Proof.
r1, r2, r3: re
equiv (Union r1 (Union r2 r3))
  (Union (Union r1 r2) r3)
  unfold equiv.
r1, r2, r3: re
cap Omega
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3) intros Y HY.
r1, r2, r3: re
Y: set (re * re)
HY: Omega Y
Y (Union r1 (Union r2 r3), Union (Union r1 r2) r3) 
  revert r1 r2 r3.
Y: set (re * re)
HY: Omega Y
forall r1 r2 r3 : re,
Y (Union r1 (Union r2 r3), Union (Union r1 r2) r3) induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
r1, r2, r3: re
cap X (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3),
   Union (Union r1 r2) r3)
r1, r2, r3: re
f_equiv x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
r1, r2, r3: re
cap X (Union r1 (Union r2 r3), Union (Union r1 r2) r3) unfold cap.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
r1, r2, r3: re
forall Y : set (re * re),
X Y ->
Y (Union r1 (Union r2 r3), Union (Union r1 r2) r3) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
r1, r2, r3: re
Y: set (re * re)
H1: X Y
Y (Union r1 (Union r2 r3), Union (Union r1 r2) r3) eapply H0.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3)
r1, r2, r3: re
Y: set (re * re)
H1: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3),
   Union (Union r1 r2) r3)
r1, r2, r3: re
f_equiv x
  (Union r1 (Union r2 r3), Union (Union r1 r2) r3) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r3 : re,
x
  (Union r1 (Union r2 r3),
   Union (Union r1 r2) r3)
r1, r2, r3: re
eps (Union r1 (Union r2 r3)) =
eps (Union (Union r1 r2) r3) /\
(forall a : T,
 x
   (der (Union r1 (Union r2 r3)) a,
    der (Union (Union r1 r2) r3) a)) simp eauto.
Qed.

Lemma Union_idemp r : equiv (Union r r) r.
r: re
equiv (Union r r) r
Proof.
r: re
equiv (Union r r) r
  unfold equiv.
r: re
cap Omega (Union r r, r) intros Y HY.
r: re
Y: set (re * re)
HY: Omega Y
Y (Union r r, r)
  revert r.
Y: set (re * re)
HY: Omega Y
forall r : re, Y (Union r r, r) induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (Union r r, r)
r: re
cap X (Union r r, r)
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (Union r r, r)
r: re
f_equiv x (Union r r, r)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (Union r r, r)
r: re
cap X (Union r r, r) unfold cap.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (Union r r, r)
r: re
forall Y : set (re * re), X Y -> Y (Union r r, r) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (Union r r, r)
r: re
Y: set (re * re)
H1: X Y
Y (Union r r, r) eapply H0.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall r : re, x (Union r r, r)
r: re
Y: set (re * re)
H1: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (Union r r, r)
r: re
f_equiv x (Union r r, r) unfold f_equiv.
x: set (re * re)
HY: Omega x
IHHY: forall r : re, x (Union r r, r)
r: re
eps (Union r r) = eps r /\
(forall a : T, x (der (Union r r) a, der r a)) simp eauto.
Qed.

Lemma Union_cong r1 r2 r1' r2' : equiv r1 r1' -> equiv r2 r2' -> equiv (Union r1 r2) (Union r1' r2').
r1, r2, r1', r2': re
equiv r1 r1' ->
equiv r2 r2' -> equiv (Union r1 r2) (Union r1' r2')
Proof.
r1, r2, r1', r2': re
equiv r1 r1' ->
equiv r2 r2' -> equiv (Union r1 r2) (Union r1' r2')
  unfold equiv.
r1, r2, r1', r2': re
cap Omega (r1, r1') ->
cap Omega (r2, r2') ->
cap Omega (Union r1 r2, Union r1' r2') intros H1 H2 Y HY.
r1, r2, r1', r2': re
H1: cap Omega (r1, r1')
H2: cap Omega (r2, r2')
Y: set (re * re)
HY: Omega Y
Y (Union r1 r2, Union r1' r2')
  specialize (H1 _ HY).
r1, r2, r1', r2': re
Y: set (re * re)
H1: Y (r1, r1')
H2: cap Omega (r2, r2')
HY: Omega Y
Y (Union r1 r2, Union r1' r2') specialize (H2 _ HY).
r1, r2, r1', r2': re
Y: set (re * re)
H1: Y (r1, r1')
H2: Y (r2, r2')
HY: Omega Y
Y (Union r1 r2, Union r1' r2')
  revert r1 r2 r1' r2' H1 H2.
Y: set (re * re)
HY: Omega Y
forall r1 r2 r1' r2' : re,
Y (r1, r1') ->
Y (r2, r2') -> Y (Union r1 r2, Union r1' r2') induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
cap X (Union r1 r2, Union r1' r2')
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: f_equiv x (r1, r1')
H2: f_equiv x (r2, r2')
f_equiv x (Union r1 r2, Union r1' r2')
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
cap X (Union r1 r2, Union r1' r2') unfold cap.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
forall Y : set (re * re),
X Y -> Y (Union r1 r2, Union r1' r2') intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
Y (Union r1 r2, Union r1' r2') eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
Y (r1, r1')
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
Y (r2, r2')
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
Y (r1, r1') eapply H1.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
X (fun p : re * re => Y p) eauto.
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
Y (r2, r2') eapply H2.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
Y: set (re * re)
H3: X Y
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: f_equiv x (r1, r1')
H2: f_equiv x (r2, r2')
f_equiv x (Union r1 r2, Union r1' r2') unfold f_equiv in *.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 r1' r2' : re,
x (r1, r1') ->
x (r2, r2') -> x (Union r1 r2, Union r1' r2')
r1, r2, r1', r2': re
H1: eps r1 = eps r1' /\
(forall a : T, x (der r1 a, der r1' a))
H2: eps r2 = eps r2' /\
(forall a : T, x (der r2 a, der r2' a))
eps (Union r1 r2) = eps (Union r1' r2') /\
(forall a : T,
 x (der (Union r1 r2) a, der (Union r1' r2') a)) simp eauto.
Qed.

Definition thm (hyps : list (re * re)) (goal : (re * re)) : Prop :=
  forall y, Omega y -> (forall h, In h hyps -> y h) -> y goal.

Lemma f_equiv_weaken x : Omega x -> forall h, f_equiv x h -> x h.
x: set (re * re)
Omega x -> forall h : re * re, f_equiv x h -> x h
Proof.
x: set (re * re)
Omega x -> forall h : re * re, f_equiv x h -> x h
  induction 1; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv (cap X) h
cap X h
x: set (re * re)
H: Omega x
IHOmega: forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H0: f_equiv (f_equiv x) h
f_equiv x h
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv (cap X) h
cap X h unfold cap in *.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) h
forall Y : set (re * re), X Y -> Y h intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) h
Y: set (re * re)
H2: X Y
Y h eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) h
Y: set (re * re)
H2: X Y
f_equiv Y h 
    unfold f_equiv.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H1: f_equiv
  (fun x : re * re =>
   forall Y : set (re * re), X Y -> Y x) h
Y: set (re * re)
H2: X Y
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, Y (der r1 a, der r2 a)) simp eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
r, r0: re
H1: eps r = eps r0
H3: forall (a : T) (Y : set (re * re)),
X Y -> Y (der r a, der r0 a)
Y: set (re * re)
H2: X Y
a: T
Y (der r a, der r0 a) eapply H3.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x -> forall h : re * re, f_equiv x h -> x h
r, r0: re
H1: eps r = eps r0
H3: forall (a : T) (Y : set (re * re)),
X Y -> Y (der r a, der r0 a)
Y: set (re * re)
H2: X Y
a: T
X (fun p : re * re => Y p) eauto.
  -
x: set (re * re)
H: Omega x
IHOmega: forall h : re * re, f_equiv x h -> x h
h: (re * re)%type
H0: f_equiv (f_equiv x) h
f_equiv x h unfold f_equiv in *.
x: set (re * re)
H: Omega x
IHOmega: forall h : re * re,
(let
 '(r1, r2) := h in
  eps r1 = eps r2 /\
  (forall a : T, x (der r1 a, der r2 a))) ->
x h
h: (re * re)%type
H0: let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T,
  eps (der r1 a) = eps (der r2 a) /\
  (forall a0 : T,
   x (der (der r1 a) a0, der (der r2 a) a0)))
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a)) simp eauto.
Qed.

Lemma thm_sym hyps r1 r2 : thm hyps (r1, r2) -> thm hyps (r2, r1).
hyps: list (re * re)
r1, r2: re
thm hyps (r1, r2) -> thm hyps (r2, r1)
Proof.
hyps: list (re * re)
r1, r2: re
thm hyps (r1, r2) -> thm hyps (r2, r1)
  intros H.
hyps: list (re * re)
r1, r2: re
H: thm hyps (r1, r2)
thm hyps (r2, r1) unfold thm in *.
hyps: list (re * re)
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) -> y (r2, r1) intros y HY.
hyps: list (re * re)
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
y: set (re * re)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r2, r1)
  specialize (H y HY).
hyps: list (re * re)
r1, r2: re
y: set (re * re)
H: (forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r2, r1) simp eauto.
hyps: list (re * re)
r1, r2: re
y: set (re * re)
H: y (r1, r2)
HY: Omega y
H0: forall h : re * re, In h hyps -> y h
y (r2, r1)
  revert r1 r2 H hyps H0.
y: set (re * re)
HY: Omega y
forall r1 r2 : re,
y (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> y h) -> y (r2, r1) induction HY; intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: cap X (r1, r2)
hyps: list (re * re)
H2: forall h : re * re, In h hyps -> cap X h
cap X (r2, r1)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: f_equiv x (r1, r2)
hyps: list (re * re)
H0: forall h : re * re, In h hyps -> f_equiv x h
f_equiv x (r2, r1)
  -
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: cap X (r1, r2)
hyps: list (re * re)
H2: forall h : re * re, In h hyps -> cap X h
cap X (r2, r1) unfold cap in *.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
forall Y : set (re * re), X Y -> Y (r2, r1) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
Y (r2, r1) eapply H0; eauto.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
Y (r1, r2)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
forall h : re * re, In h ?hyps -> Y h
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
Y (r1, r2) intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
Y (r1, r2) eapply H1; eauto.
    +
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
forall h : re * re, In h ?hyps -> Y h intros.
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H1: forall Y : set (re * re), X Y -> Y (r1, r2)
hyps: list (re * re)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
h: (re * re)%type
H4: In h ?hyps
Y h eapply H2; eauto.
  -
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: f_equiv x (r1, r2)
hyps: list (re * re)
H0: forall h : re * re, In h hyps -> f_equiv x h
f_equiv x (r2, r1) unfold f_equiv in *.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a))
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
eps r2 = eps r1 /\
(forall a : T, x (der r2 a, der r1 a)) simp eauto.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2
H1: forall a : T, x (der r1 a, der r2 a)
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
x (der r2 a, der r1 a) eapply IHHY; eauto.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2
H1: forall a : T, x (der r1 a, der r2 a)
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
forall h : re * re, In h ?hyps -> x h
    intros.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2
H1: forall a : T, x (der r1 a, der r2 a)
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H2: In h ?hyps
x h eapply f_equiv_weaken; eauto.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2
H1: forall a : T, x (der r1 a, der r2 a)
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H2: In h ?hyps
f_equiv x h eapply H0.
x: set (re * re)
HY: Omega x
IHHY: forall r1 r2 : re,
x (r1, r2) ->
forall hyps : list (re * re),
(forall h : re * re, In h hyps -> x h) ->
x (r2, r1)
r1, r2: re
H: eps r1 = eps r2
H1: forall a : T, x (der r1 a, der r2 a)
hyps: list (re * re)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H2: In h ?hyps
In h hyps eauto.
Qed.

Lemma thm_ind hyps r1 r2 : 
  eps r1 = eps r2 -> 
  (forall a, thm ((r1, r2)::hyps) (der r1 a, der r2 a)) ->
  thm hyps (r1, r2).
hyps: list (re * re)
r1, r2: re
eps r1 = eps r2 ->
(forall a : T,
 thm ((r1, r2) :: hyps) (der r1 a, der r2 a)) ->
thm hyps (r1, r2)
Proof.
hyps: list (re * re)
r1, r2: re
eps r1 = eps r2 ->
(forall a : T,
 thm ((r1, r2) :: hyps) (der r1 a, der r2 a)) ->
thm hyps (r1, r2)
  intros Heq H.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
thm hyps (r1, r2) unfold thm.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) -> y (r1, r2) intros y HY.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
y: set (re * re)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r1, r2)
  induction HY.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
(forall h : re * re, In h hyps -> cap X h) ->
cap X (r1, r2)
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
(forall h : re * re, In h hyps -> f_equiv x h) ->
f_equiv x (r1, r2)
  -
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
(forall h : re * re, In h hyps -> cap X h) ->
cap X (r1, r2) unfold cap in *.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
(forall h : re * re,
 In h hyps -> forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2) intros.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
Y (r1, r2) eapply H1; eauto.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
forall h : re * re, In h hyps -> Y h intros.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
X: set (set (re * re))
H0: forall x : set (re * re), X x -> Omega x
H1: forall x : set (re * re),
X x ->
(forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H2: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H3: X Y
h: (re * re)%type
H4: In h hyps
Y h eapply H2; eauto.
  -
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
(forall h : re * re, In h hyps -> f_equiv x h) ->
f_equiv x (r1, r2) intros.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
f_equiv x (r1, r2) unfold f_equiv.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a)) simp eauto.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
x (der r1 a, der r2 a) eapply H; eauto.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
forall h : re * re, In h ((r1, r2) :: hyps) -> x h
    intros.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
h: (re * re)%type
H1: In h ((r1, r2) :: hyps)
x h simpl in H1.
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
h: (re * re)%type
H1: (r1, r2) = h \/ In h hyps
x h simp eauto.
hyps: list (re * re)
r, r0: re
Heq: eps r = eps r0
H: forall a : T,
thm ((r, r0) :: hyps) (der r a, der r0 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r, r0)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
x (r, r0)
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
r, r0: re
H1: In (r, r0) hyps
x (r, r0)
    +
hyps: list (re * re)
r, r0: re
Heq: eps r = eps r0
H: forall a : T,
thm ((r, r0) :: hyps) (der r a, der r0 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r, r0)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
x (r, r0) eapply IHHY.
hyps: list (re * re)
r, r0: re
Heq: eps r = eps r0
H: forall a : T,
thm ((r, r0) :: hyps) (der r a, der r0 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r, r0)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
forall h : re * re, In h hyps -> x h intros.
hyps: list (re * re)
r, r0: re
Heq: eps r = eps r0
H: forall a : T,
thm ((r, r0) :: hyps) (der r a, der r0 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r, r0)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
h: (re * re)%type
H1: In h hyps
x h eapply f_equiv_weaken; eauto.
    +
hyps: list (re * re)
r1, r2: re
Heq: eps r1 = eps r2
H: forall a : T,
thm ((r1, r2) :: hyps) (der r1 a, der r2 a)
x: set (re * re)
HY: Omega x
IHHY: (forall h : re * re, In h hyps -> x h) ->
x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
a: T
r, r0: re
H1: In (r, r0) hyps
x (r, r0) eapply f_equiv_weaken; eauto.
Qed.

Lemma thm_assumption hyps h : In h hyps -> thm hyps h.
hyps: list (re * re)
h: (re * re)%type
In h hyps -> thm hyps h
Proof.
hyps: list (re * re)
h: (re * re)%type
In h hyps -> thm hyps h
  intros ????.
hyps: list (re * re)
h: (re * re)%type
H: In h hyps
y: set (re * re)
H0: Omega y
H1: forall h : re * re, In h hyps -> y h
y h eauto.
Qed.

Lemma thm_equiv hyps r1 r1' r2 r2' : 
  equiv r1 r1' -> 
  equiv r2 r2' -> 
  thm hyps (r1, r2) -> 
  thm hyps (r1', r2').
hyps: list (re * re)
r1, r1', r2, r2': re
equiv r1 r1' ->
equiv r2 r2' ->
thm hyps (r1, r2) -> thm hyps (r1', r2')
Proof.
hyps: list (re * re)
r1, r1', r2, r2': re
equiv r1 r1' ->
equiv r2 r2' ->
thm hyps (r1, r2) -> thm hyps (r1', r2')
  intros H1 H2 H.
hyps: list (re * re)
r1, r1', r2, r2': re
H1: equiv r1 r1'
H2: equiv r2 r2'
H: thm hyps (r1, r2)
thm hyps (r1', r2') unfold thm in *.
hyps: list (re * re)
r1, r1', r2, r2': re
H1: equiv r1 r1'
H2: equiv r2 r2'
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) -> y (r1', r2') intros y HY.
hyps: list (re * re)
r1, r1', r2, r2': re
H1: equiv r1 r1'
H2: equiv r2 r2'
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
y: set (re * re)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r1', r2')
  specialize (H1 _ HY).
hyps: list (re * re)
r1, r1', r2, r2': re
y: set (re * re)
H1: y (r1, r1')
H2: equiv r2 r2'
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r1', r2') specialize (H2 _ HY).
hyps: list (re * re)
r1, r1', r2, r2': re
y: set (re * re)
H1: y (r1, r1')
H2: y (r2, r2')
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r1', r2') specialize (H _ HY).
hyps: list (re * re)
r1, r1', r2, r2': re
y: set (re * re)
H1: y (r1, r1')
H2: y (r2, r2')
H: (forall h : re * re, In h hyps -> y h) ->
y (r1, r2)
HY: Omega y
(forall h : re * re, In h hyps -> y h) -> y (r1', r2')
  revert r1 r1' r2 r2' H1 H2 H.
hyps: list (re * re)
y: set (re * re)
HY: Omega y
forall r1 r1' r2 r2' : re,
y (r1, r1') ->
y (r2, r2') ->
((forall h : re * re, In h hyps -> y h) -> y (r1, r2)) ->
(forall h : re * re, In h hyps -> y h) -> y (r1', r2') induction HY; intros.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
H3: (forall h : re * re, In h hyps -> cap X h) ->
cap X (r1, r2)
H4: forall h : re * re, In h hyps -> cap X h
cap X (r1', r2')
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: f_equiv x (r1, r1')
H2: f_equiv x (r2, r2')
H: (forall h : re * re, In h hyps -> f_equiv x h) ->
f_equiv x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
f_equiv x (r1', r2')
  -
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: cap X (r1, r1')
H2: cap X (r2, r2')
H3: (forall h : re * re, In h hyps -> cap X h) ->
cap X (r1, r2)
H4: forall h : re * re, In h hyps -> cap X h
cap X (r1', r2') unfold cap in *.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
forall Y : set (re * re), X Y -> Y (r1', r2') intros.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
Y (r1', r2') eapply H0; eauto.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
Y (?r1, r1')
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
Y (?r2, r2')
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
(forall h : re * re, In h hyps -> Y h) -> Y (?r1, ?r2)
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
forall h : re * re, In h hyps -> Y h
    +
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
Y (?r1, r1') eapply H1; eauto.
    +
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
Y (?r2, r2') eapply H2.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
X (fun p : re * re => Y p) eauto.
    +
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
(forall h : re * re, In h hyps -> Y h) -> Y (r1, r2) intros.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
H6: forall h : re * re, In h hyps -> Y h
Y (r1, r2) eapply H3; eauto.
    +
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
forall h : re * re, In h hyps -> Y h intros.
hyps: list (re * re)
X: set (set (re * re))
H: forall x : set (re * re), X x -> Omega x
H0: forall x : set (re * re),
X x ->
forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: forall Y : set (re * re), X Y -> Y (r1, r1')
H2: forall Y : set (re * re), X Y -> Y (r2, r2')
H3: (forall h : re * re,
 In h hyps ->
 forall Y : set (re * re), X Y -> Y h) ->
forall Y : set (re * re), X Y -> Y (r1, r2)
H4: forall h : re * re,
In h hyps -> forall Y : set (re * re), X Y -> Y h
Y: set (re * re)
H5: X Y
h: (re * re)%type
H6: In h hyps
Y h eapply H4; eauto.
  -
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: f_equiv x (r1, r1')
H2: f_equiv x (r2, r2')
H: (forall h : re * re, In h hyps -> f_equiv x h) ->
f_equiv x (r1, r2)
H0: forall h : re * re, In h hyps -> f_equiv x h
f_equiv x (r1', r2') unfold f_equiv in *.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1' /\
(forall a : T, x (der r1 a, der r1' a))
H2: eps r2 = eps r2' /\
(forall a : T, x (der r2 a, der r2' a))
H: (forall h : re * re,
 In h hyps ->
 let
 '(r1, r2) := h in
  eps r1 = eps r2 /\
  (forall a : T, x (der r1 a, der r2 a))) ->
eps r1 = eps r2 /\
(forall a : T, x (der r1 a, der r2 a))
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
eps r1' = eps r2' /\
(forall a : T, x (der r1' a, der r2' a)) simp eauto.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1'
H4: forall a : T, x (der r1 a, der r1' a)
H2: eps r2 = eps r2'
H3: forall a : T, x (der r2 a, der r2' a)
H: eps r1 = eps r2
H5: forall a : T, x (der r1 a, der r2 a)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
x (der r1' a, der r2' a)
    eapply IHHY; eauto.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1'
H4: forall a : T, x (der r1 a, der r1' a)
H2: eps r2 = eps r2'
H3: forall a : T, x (der r2 a, der r2' a)
H: eps r1 = eps r2
H5: forall a : T, x (der r1 a, der r2 a)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
forall h : re * re, In h hyps -> x h intros.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1'
H4: forall a : T, x (der r1 a, der r1' a)
H2: eps r2 = eps r2'
H3: forall a : T, x (der r2 a, der r2' a)
H: eps r1 = eps r2
H5: forall a : T, x (der r1 a, der r2 a)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H6: In h hyps
x h 
    eapply f_equiv_weaken; eauto.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1'
H4: forall a : T, x (der r1 a, der r1' a)
H2: eps r2 = eps r2'
H3: forall a : T, x (der r2 a, der r2' a)
H: eps r1 = eps r2
H5: forall a : T, x (der r1 a, der r2 a)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H6: In h hyps
f_equiv x h 
    eapply H0.
hyps: list (re * re)
x: set (re * re)
HY: Omega x
IHHY: forall r1 r1' r2 r2' : re,
x (r1, r1') ->
x (r2, r2') ->
((forall h : re * re, In h hyps -> x h) ->
 x (r1, r2)) ->
(forall h : re * re, In h hyps -> x h) ->
x (r1', r2')
r1, r1', r2, r2': re
H1: eps r1 = eps r1'
H4: forall a : T, x (der r1 a, der r1' a)
H2: eps r2 = eps r2'
H3: forall a : T, x (der r2 a, der r2' a)
H: eps r1 = eps r2
H5: forall a : T, x (der r1 a, der r2 a)
H0: forall h : re * re,
In h hyps ->
let
'(r1, r2) := h in
 eps r1 = eps r2 /\
 (forall a : T, x (der r1 a, der r2 a))
a: T
h: (re * re)%type
H6: In h hyps
In h hyps eauto.
Qed.

Lemma thm_adequate r1 r2 : thm [] (r1, r2) <-> equiv r1 r2.
r1, r2: re
thm [] (r1, r2) <-> equiv r1 r2
Proof.
r1, r2: re
thm [] (r1, r2) <-> equiv r1 r2
  unfold thm.
r1, r2: re
(forall y : set (re * re),
 Omega y ->
 (forall h : re * re, In h [] -> y h) -> y (r1, r2)) <->
equiv r1 r2
  split.
r1, r2: re
(forall y : set (re * re),
 Omega y ->
 (forall h : re * re, In h [] -> y h) -> y (r1, r2)) ->
equiv r1 r2
r1, r2: re
equiv r1 r2 ->
forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2)
  -
r1, r2: re
(forall y : set (re * re),
 Omega y ->
 (forall h : re * re, In h [] -> y h) -> y (r1, r2)) ->
equiv r1 r2 intros.
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2)
equiv r1 r2 unfold equiv.
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2)
cap Omega (r1, r2) intros Y HY.
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2)
Y: set (re * re)
HY: Omega Y
Y (r1, r2)
    eapply H; eauto.
r1, r2: re
H: forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2)
Y: set (re * re)
HY: Omega Y
forall h : re * re, In h [] -> Y h simp eauto.
  -
r1, r2: re
equiv r1 r2 ->
forall y : set (re * re),
Omega y ->
(forall h : re * re, In h [] -> y h) -> y (r1, r2) intros.
r1, r2: re
H: equiv r1 r2
y: set (re * re)
H0: Omega y
H1: forall h : re * re, In h [] -> y h
y (r1, r2) eapply H.
r1, r2: re
H: equiv r1 r2
y: set (re * re)
H0: Omega y
H1: forall h : re * re, In h [] -> y h
Omega (fun p : re * re => y p) eauto.
Qed.