Built with Alectryon, running Coq+SerAPI v8.10.0+0.7.0. Coq sources are in this panel; goals and messages will appear in the other. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus.
(************************************************************************)
(*         *   The Coq Proof Assistant / The Coq Development Team       *)
(*  v      *   INRIA, CNRS and contributors - Copyright 1999-2018       *)
(* <O___,, *       (see CREDITS file for the list of authors)           *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)
Author: Cristina Cornes From : Constructing Recursion Operators in Type Theory L. Paulson JSC (1986) 2, 325-355
Require Import Relation_Operators.

Section Wf_Disjoint_Union.
  Variables A B : Type.
  Variable leA : A -> A -> Prop.
  Variable leB : B -> B -> Prop.

  Notation Le_AsB := (le_AsB A B leA leB).

  
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

forall x : A, Acc leA x -> Acc Le_AsB (inl x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

forall x : A, Acc leA x -> Acc Le_AsB (inl x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
x:A
H:forall y : A, leA y x -> Acc leA y
H0:forall y : A, leA y x -> Acc Le_AsB (inl y)

Acc Le_AsB (inl x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
x:A
H:forall y0 : A, leA y0 x -> Acc leA y0
H0:forall y0 : A, leA y0 x -> Acc Le_AsB (inl y0)
y:(A + B)%type
H2:Le_AsB y (inl x)

Acc Le_AsB y
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
x:A
H:forall y0 : A, leA y0 x -> Acc leA y0
H0:forall y0 : A, leA y0 x -> Acc Le_AsB (inl y0)
y:(A + B)%type
x0:A
H1:leA x0 x

Acc Le_AsB (inl x0)
auto with sets. Qed.
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

well_founded leA -> forall x : B, Acc leB x -> Acc Le_AsB (inr x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

well_founded leA -> forall x : B, Acc leB x -> Acc Le_AsB (inr x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
x:B
H0:forall y : B, leB y x -> Acc leB y
H1:forall y : B, leB y x -> Acc Le_AsB (inr y)

Acc Le_AsB (inr x)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
x:B
H0:forall y0 : B, leB y0 x -> Acc leB y0
H1:forall y0 : B, leB y0 x -> Acc Le_AsB (inr y0)
y:(A + B)%type
H3:Le_AsB y (inr x)

Acc Le_AsB y
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
x:B
H0:forall y0 : B, leB y0 x -> Acc leB y0
H1:forall y0 : B, leB y0 x -> Acc Le_AsB (inr y0)
y:(A + B)%type
x0:A

Acc Le_AsB (inl x0)
apply acc_A_sum; auto with sets. Qed.
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

well_founded leA -> well_founded leB -> well_founded Le_AsB
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop

well_founded leA -> well_founded leB -> well_founded Le_AsB
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB

well_founded Le_AsB
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB

forall a : A + B, Acc Le_AsB a
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
a:A

Acc Le_AsB (inl a)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
b:B
Acc Le_AsB (inr b)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
a:A

Acc Le_AsB (inl a)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
a:A

Acc leA a
apply (H a).
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
b:B

Acc Le_AsB (inr b)
A, B:Type
leA:A -> A -> Prop
leB:B -> B -> Prop
H:well_founded leA
H0:well_founded leB
b:B

Acc leB b
apply (H0 b). Qed. End Wf_Disjoint_Union.