src/HOL/Transitive_Closure.thy
 author huffman Fri Aug 19 14:17:28 2011 -0700 (2011-08-19) changeset 44311 42c5cbf68052 parent 43596 78211f66cf8d child 44890 22f665a2e91c permissions -rw-r--r--
new isCont theorems;
simplify some proofs.
     1 (*  Title:      HOL/Transitive_Closure.thy

     2     Author:     Lawrence C Paulson, Cambridge University Computer Laboratory

     3     Copyright   1992  University of Cambridge

     4 *)

     5

     6 header {* Reflexive and Transitive closure of a relation *}

     7

     8 theory Transitive_Closure

     9 imports Predicate

    10 uses "~~/src/Provers/trancl.ML"

    11 begin

    12

    13 text {*

    14   @{text rtrancl} is reflexive/transitive closure,

    15   @{text trancl} is transitive closure,

    16   @{text reflcl} is reflexive closure.

    17

    18   These postfix operators have \emph{maximum priority}, forcing their

    19   operands to be atomic.

    20 *}

    21

    22 inductive_set

    23   rtrancl :: "('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set"   ("(_^*)" [1000] 999)

    24   for r :: "('a \<times> 'a) set"

    25 where

    26     rtrancl_refl [intro!, Pure.intro!, simp]: "(a, a) : r^*"

    27   | rtrancl_into_rtrancl [Pure.intro]: "(a, b) : r^* ==> (b, c) : r ==> (a, c) : r^*"

    28

    29 inductive_set

    30   trancl :: "('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set"  ("(_^+)" [1000] 999)

    31   for r :: "('a \<times> 'a) set"

    32 where

    33     r_into_trancl [intro, Pure.intro]: "(a, b) : r ==> (a, b) : r^+"

    34   | trancl_into_trancl [Pure.intro]: "(a, b) : r^+ ==> (b, c) : r ==> (a, c) : r^+"

    35

    36 declare rtrancl_def [nitpick_unfold del]

    37         rtranclp_def [nitpick_unfold del]

    38         trancl_def [nitpick_unfold del]

    39         tranclp_def [nitpick_unfold del]

    40

    41 notation

    42   rtranclp  ("(_^**)" [1000] 1000) and

    43   tranclp  ("(_^++)" [1000] 1000)

    44

    45 abbreviation

    46   reflclp :: "('a => 'a => bool) => 'a => 'a => bool"  ("(_^==)" [1000] 1000) where

    47   "r^== == sup r op ="

    48

    49 abbreviation

    50   reflcl :: "('a \<times> 'a) set => ('a \<times> 'a) set"  ("(_^=)" [1000] 999) where

    51   "r^= == r \<union> Id"

    52

    53 notation (xsymbols)

    54   rtranclp  ("(_\<^sup>*\<^sup>*)" [1000] 1000) and

    55   tranclp  ("(_\<^sup>+\<^sup>+)" [1000] 1000) and

    56   reflclp  ("(_\<^sup>=\<^sup>=)" [1000] 1000) and

    57   rtrancl  ("(_\<^sup>*)" [1000] 999) and

    58   trancl  ("(_\<^sup>+)" [1000] 999) and

    59   reflcl  ("(_\<^sup>=)" [1000] 999)

    60

    61 notation (HTML output)

    62   rtranclp  ("(_\<^sup>*\<^sup>*)" [1000] 1000) and

    63   tranclp  ("(_\<^sup>+\<^sup>+)" [1000] 1000) and

    64   reflclp  ("(_\<^sup>=\<^sup>=)" [1000] 1000) and

    65   rtrancl  ("(_\<^sup>*)" [1000] 999) and

    66   trancl  ("(_\<^sup>+)" [1000] 999) and

    67   reflcl  ("(_\<^sup>=)" [1000] 999)

    68

    69

    70 subsection {* Reflexive closure *}

    71

    72 lemma refl_reflcl[simp]: "refl(r^=)"

    73 by(simp add:refl_on_def)

    74

    75 lemma antisym_reflcl[simp]: "antisym(r^=) = antisym r"

    76 by(simp add:antisym_def)

    77

    78 lemma trans_reflclI[simp]: "trans r \<Longrightarrow> trans(r^=)"

    79 unfolding trans_def by blast

    80

    81

    82 subsection {* Reflexive-transitive closure *}

    83

    84 lemma reflcl_set_eq [pred_set_conv]: "(sup (\<lambda>x y. (x, y) \<in> r) op =) = (\<lambda>x y. (x, y) \<in> r \<union> Id)"

    85   by (auto simp add: fun_eq_iff)

    86

    87 lemma r_into_rtrancl [intro]: "!!p. p \<in> r ==> p \<in> r^*"

    88   -- {* @{text rtrancl} of @{text r} contains @{text r} *}

    89   apply (simp only: split_tupled_all)

    90   apply (erule rtrancl_refl [THEN rtrancl_into_rtrancl])

    91   done

    92

    93 lemma r_into_rtranclp [intro]: "r x y ==> r^** x y"

    94   -- {* @{text rtrancl} of @{text r} contains @{text r} *}

    95   by (erule rtranclp.rtrancl_refl [THEN rtranclp.rtrancl_into_rtrancl])

    96

    97 lemma rtranclp_mono: "r \<le> s ==> r^** \<le> s^**"

    98   -- {* monotonicity of @{text rtrancl} *}

    99   apply (rule predicate2I)

   100   apply (erule rtranclp.induct)

   101    apply (rule_tac [2] rtranclp.rtrancl_into_rtrancl, blast+)

   102   done

   103

   104 lemmas rtrancl_mono = rtranclp_mono [to_set]

   105

   106 theorem rtranclp_induct [consumes 1, case_names base step, induct set: rtranclp]:

   107   assumes a: "r^** a b"

   108     and cases: "P a" "!!y z. [| r^** a y; r y z; P y |] ==> P z"

   109   shows "P b" using a

   110   by (induct x\<equiv>a b) (rule cases)+

   111

   112 lemmas rtrancl_induct [induct set: rtrancl] = rtranclp_induct [to_set]

   113

   114 lemmas rtranclp_induct2 =

   115   rtranclp_induct[of _ "(ax,ay)" "(bx,by)", split_rule,

   116                  consumes 1, case_names refl step]

   117

   118 lemmas rtrancl_induct2 =

   119   rtrancl_induct[of "(ax,ay)" "(bx,by)", split_format (complete),

   120                  consumes 1, case_names refl step]

   121

   122 lemma refl_rtrancl: "refl (r^*)"

   123 by (unfold refl_on_def) fast

   124

   125 text {* Transitivity of transitive closure. *}

   126 lemma trans_rtrancl: "trans (r^*)"

   127 proof (rule transI)

   128   fix x y z

   129   assume "(x, y) \<in> r\<^sup>*"

   130   assume "(y, z) \<in> r\<^sup>*"

   131   then show "(x, z) \<in> r\<^sup>*"

   132   proof induct

   133     case base

   134     show "(x, y) \<in> r\<^sup>*" by fact

   135   next

   136     case (step u v)

   137     from (x, u) \<in> r\<^sup>* and (u, v) \<in> r

   138     show "(x, v) \<in> r\<^sup>*" ..

   139   qed

   140 qed

   141

   142 lemmas rtrancl_trans = trans_rtrancl [THEN transD, standard]

   143

   144 lemma rtranclp_trans:

   145   assumes xy: "r^** x y"

   146   and yz: "r^** y z"

   147   shows "r^** x z" using yz xy

   148   by induct iprover+

   149

   150 lemma rtranclE [cases set: rtrancl]:

   151   assumes major: "(a::'a, b) : r^*"

   152   obtains

   153     (base) "a = b"

   154   | (step) y where "(a, y) : r^*" and "(y, b) : r"

   155   -- {* elimination of @{text rtrancl} -- by induction on a special formula *}

   156   apply (subgoal_tac "(a::'a) = b | (EX y. (a,y) : r^* & (y,b) : r)")

   157    apply (rule_tac [2] major [THEN rtrancl_induct])

   158     prefer 2 apply blast

   159    prefer 2 apply blast

   160   apply (erule asm_rl exE disjE conjE base step)+

   161   done

   162

   163 lemma rtrancl_Int_subset: "[| Id \<subseteq> s; (r^* \<inter> s) O r \<subseteq> s|] ==> r^* \<subseteq> s"

   164   apply (rule subsetI)

   165   apply (rule_tac p="x" in PairE, clarify)

   166   apply (erule rtrancl_induct, auto)

   167   done

   168

   169 lemma converse_rtranclp_into_rtranclp:

   170   "r a b \<Longrightarrow> r\<^sup>*\<^sup>* b c \<Longrightarrow> r\<^sup>*\<^sup>* a c"

   171   by (rule rtranclp_trans) iprover+

   172

   173 lemmas converse_rtrancl_into_rtrancl = converse_rtranclp_into_rtranclp [to_set]

   174

   175 text {*

   176   \medskip More @{term "r^*"} equations and inclusions.

   177 *}

   178

   179 lemma rtranclp_idemp [simp]: "(r^**)^** = r^**"

   180   apply (auto intro!: order_antisym)

   181   apply (erule rtranclp_induct)

   182    apply (rule rtranclp.rtrancl_refl)

   183   apply (blast intro: rtranclp_trans)

   184   done

   185

   186 lemmas rtrancl_idemp [simp] = rtranclp_idemp [to_set]

   187

   188 lemma rtrancl_idemp_self_comp [simp]: "R^* O R^* = R^*"

   189   apply (rule set_eqI)

   190   apply (simp only: split_tupled_all)

   191   apply (blast intro: rtrancl_trans)

   192   done

   193

   194 lemma rtrancl_subset_rtrancl: "r \<subseteq> s^* ==> r^* \<subseteq> s^*"

   195   apply (drule rtrancl_mono)

   196   apply simp

   197   done

   198

   199 lemma rtranclp_subset: "R \<le> S ==> S \<le> R^** ==> S^** = R^**"

   200   apply (drule rtranclp_mono)

   201   apply (drule rtranclp_mono)

   202   apply simp

   203   done

   204

   205 lemmas rtrancl_subset = rtranclp_subset [to_set]

   206

   207 lemma rtranclp_sup_rtranclp: "(sup (R^**) (S^**))^** = (sup R S)^**"

   208   by (blast intro!: rtranclp_subset intro: rtranclp_mono [THEN predicate2D])

   209

   210 lemmas rtrancl_Un_rtrancl = rtranclp_sup_rtranclp [to_set]

   211

   212 lemma rtranclp_reflcl [simp]: "(R^==)^** = R^**"

   213   by (blast intro!: rtranclp_subset)

   214

   215 lemmas rtrancl_reflcl [simp] = rtranclp_reflcl [to_set]

   216

   217 lemma rtrancl_r_diff_Id: "(r - Id)^* = r^*"

   218   apply (rule sym)

   219   apply (rule rtrancl_subset, blast, clarify)

   220   apply (rename_tac a b)

   221   apply (case_tac "a = b")

   222    apply blast

   223   apply (blast intro!: r_into_rtrancl)

   224   done

   225

   226 lemma rtranclp_r_diff_Id: "(inf r op ~=)^** = r^**"

   227   apply (rule sym)

   228   apply (rule rtranclp_subset)

   229    apply blast+

   230   done

   231

   232 theorem rtranclp_converseD:

   233   assumes r: "(r^--1)^** x y"

   234   shows "r^** y x"

   235 proof -

   236   from r show ?thesis

   237     by induct (iprover intro: rtranclp_trans dest!: conversepD)+

   238 qed

   239

   240 lemmas rtrancl_converseD = rtranclp_converseD [to_set]

   241

   242 theorem rtranclp_converseI:

   243   assumes "r^** y x"

   244   shows "(r^--1)^** x y"

   245   using assms

   246   by induct (iprover intro: rtranclp_trans conversepI)+

   247

   248 lemmas rtrancl_converseI = rtranclp_converseI [to_set]

   249

   250 lemma rtrancl_converse: "(r^-1)^* = (r^*)^-1"

   251   by (fast dest!: rtrancl_converseD intro!: rtrancl_converseI)

   252

   253 lemma sym_rtrancl: "sym r ==> sym (r^*)"

   254   by (simp only: sym_conv_converse_eq rtrancl_converse [symmetric])

   255

   256 theorem converse_rtranclp_induct [consumes 1, case_names base step]:

   257   assumes major: "r^** a b"

   258     and cases: "P b" "!!y z. [| r y z; r^** z b; P z |] ==> P y"

   259   shows "P a"

   260   using rtranclp_converseI [OF major]

   261   by induct (iprover intro: cases dest!: conversepD rtranclp_converseD)+

   262

   263 lemmas converse_rtrancl_induct = converse_rtranclp_induct [to_set]

   264

   265 lemmas converse_rtranclp_induct2 =

   266   converse_rtranclp_induct [of _ "(ax,ay)" "(bx,by)", split_rule,

   267                  consumes 1, case_names refl step]

   268

   269 lemmas converse_rtrancl_induct2 =

   270   converse_rtrancl_induct [of "(ax,ay)" "(bx,by)", split_format (complete),

   271                  consumes 1, case_names refl step]

   272

   273 lemma converse_rtranclpE [consumes 1, case_names base step]:

   274   assumes major: "r^** x z"

   275     and cases: "x=z ==> P"

   276       "!!y. [| r x y; r^** y z |] ==> P"

   277   shows P

   278   apply (subgoal_tac "x = z | (EX y. r x y & r^** y z)")

   279    apply (rule_tac [2] major [THEN converse_rtranclp_induct])

   280     prefer 2 apply iprover

   281    prefer 2 apply iprover

   282   apply (erule asm_rl exE disjE conjE cases)+

   283   done

   284

   285 lemmas converse_rtranclE = converse_rtranclpE [to_set]

   286

   287 lemmas converse_rtranclpE2 = converse_rtranclpE [of _ "(xa,xb)" "(za,zb)", split_rule]

   288

   289 lemmas converse_rtranclE2 = converse_rtranclE [of "(xa,xb)" "(za,zb)", split_rule]

   290

   291 lemma r_comp_rtrancl_eq: "r O r^* = r^* O r"

   292   by (blast elim: rtranclE converse_rtranclE

   293     intro: rtrancl_into_rtrancl converse_rtrancl_into_rtrancl)

   294

   295 lemma rtrancl_unfold: "r^* = Id Un r^* O r"

   296   by (auto intro: rtrancl_into_rtrancl elim: rtranclE)

   297

   298 lemma rtrancl_Un_separatorE:

   299   "(a,b) : (P \<union> Q)^* \<Longrightarrow> \<forall>x y. (a,x) : P^* \<longrightarrow> (x,y) : Q \<longrightarrow> x=y \<Longrightarrow> (a,b) : P^*"

   300 apply (induct rule:rtrancl.induct)

   301  apply blast

   302 apply (blast intro:rtrancl_trans)

   303 done

   304

   305 lemma rtrancl_Un_separator_converseE:

   306   "(a,b) : (P \<union> Q)^* \<Longrightarrow> \<forall>x y. (x,b) : P^* \<longrightarrow> (y,x) : Q \<longrightarrow> y=x \<Longrightarrow> (a,b) : P^*"

   307 apply (induct rule:converse_rtrancl_induct)

   308  apply blast

   309 apply (blast intro:rtrancl_trans)

   310 done

   311

   312 lemma Image_closed_trancl:

   313   assumes "r  X \<subseteq> X" shows "r\<^sup>*  X = X"

   314 proof -

   315   from assms have **: "{y. \<exists>x\<in>X. (x, y) \<in> r} \<subseteq> X" by auto

   316   have "\<And>x y. (y, x) \<in> r\<^sup>* \<Longrightarrow> y \<in> X \<Longrightarrow> x \<in> X"

   317   proof -

   318     fix x y

   319     assume *: "y \<in> X"

   320     assume "(y, x) \<in> r\<^sup>*"

   321     then show "x \<in> X"

   322     proof induct

   323       case base show ?case by (fact *)

   324     next

   325       case step with ** show ?case by auto

   326     qed

   327   qed

   328   then show ?thesis by auto

   329 qed

   330

   331

   332 subsection {* Transitive closure *}

   333

   334 lemma trancl_mono: "!!p. p \<in> r^+ ==> r \<subseteq> s ==> p \<in> s^+"

   335   apply (simp add: split_tupled_all)

   336   apply (erule trancl.induct)

   337    apply (iprover dest: subsetD)+

   338   done

   339

   340 lemma r_into_trancl': "!!p. p : r ==> p : r^+"

   341   by (simp only: split_tupled_all) (erule r_into_trancl)

   342

   343 text {*

   344   \medskip Conversions between @{text trancl} and @{text rtrancl}.

   345 *}

   346

   347 lemma tranclp_into_rtranclp: "r^++ a b ==> r^** a b"

   348   by (erule tranclp.induct) iprover+

   349

   350 lemmas trancl_into_rtrancl = tranclp_into_rtranclp [to_set]

   351

   352 lemma rtranclp_into_tranclp1: assumes r: "r^** a b"

   353   shows "!!c. r b c ==> r^++ a c" using r

   354   by induct iprover+

   355

   356 lemmas rtrancl_into_trancl1 = rtranclp_into_tranclp1 [to_set]

   357

   358 lemma rtranclp_into_tranclp2: "[| r a b; r^** b c |] ==> r^++ a c"

   359   -- {* intro rule from @{text r} and @{text rtrancl} *}

   360   apply (erule rtranclp.cases)

   361    apply iprover

   362   apply (rule rtranclp_trans [THEN rtranclp_into_tranclp1])

   363     apply (simp | rule r_into_rtranclp)+

   364   done

   365

   366 lemmas rtrancl_into_trancl2 = rtranclp_into_tranclp2 [to_set]

   367

   368 text {* Nice induction rule for @{text trancl} *}

   369 lemma tranclp_induct [consumes 1, case_names base step, induct pred: tranclp]:

   370   assumes a: "r^++ a b"

   371   and cases: "!!y. r a y ==> P y"

   372     "!!y z. r^++ a y ==> r y z ==> P y ==> P z"

   373   shows "P b" using a

   374   by (induct x\<equiv>a b) (iprover intro: cases)+

   375

   376 lemmas trancl_induct [induct set: trancl] = tranclp_induct [to_set]

   377

   378 lemmas tranclp_induct2 =

   379   tranclp_induct [of _ "(ax,ay)" "(bx,by)", split_rule,

   380     consumes 1, case_names base step]

   381

   382 lemmas trancl_induct2 =

   383   trancl_induct [of "(ax,ay)" "(bx,by)", split_format (complete),

   384     consumes 1, case_names base step]

   385

   386 lemma tranclp_trans_induct:

   387   assumes major: "r^++ x y"

   388     and cases: "!!x y. r x y ==> P x y"

   389       "!!x y z. [| r^++ x y; P x y; r^++ y z; P y z |] ==> P x z"

   390   shows "P x y"

   391   -- {* Another induction rule for trancl, incorporating transitivity *}

   392   by (iprover intro: major [THEN tranclp_induct] cases)

   393

   394 lemmas trancl_trans_induct = tranclp_trans_induct [to_set]

   395

   396 lemma tranclE [cases set: trancl]:

   397   assumes "(a, b) : r^+"

   398   obtains

   399     (base) "(a, b) : r"

   400   | (step) c where "(a, c) : r^+" and "(c, b) : r"

   401   using assms by cases simp_all

   402

   403 lemma trancl_Int_subset: "[| r \<subseteq> s; (r^+ \<inter> s) O r \<subseteq> s|] ==> r^+ \<subseteq> s"

   404   apply (rule subsetI)

   405   apply (rule_tac p = x in PairE)

   406   apply clarify

   407   apply (erule trancl_induct)

   408    apply auto

   409   done

   410

   411 lemma trancl_unfold: "r^+ = r Un r^+ O r"

   412   by (auto intro: trancl_into_trancl elim: tranclE)

   413

   414 text {* Transitivity of @{term "r^+"} *}

   415 lemma trans_trancl [simp]: "trans (r^+)"

   416 proof (rule transI)

   417   fix x y z

   418   assume "(x, y) \<in> r^+"

   419   assume "(y, z) \<in> r^+"

   420   then show "(x, z) \<in> r^+"

   421   proof induct

   422     case (base u)

   423     from (x, y) \<in> r^+ and (y, u) \<in> r

   424     show "(x, u) \<in> r^+" ..

   425   next

   426     case (step u v)

   427     from (x, u) \<in> r^+ and (u, v) \<in> r

   428     show "(x, v) \<in> r^+" ..

   429   qed

   430 qed

   431

   432 lemmas trancl_trans = trans_trancl [THEN transD, standard]

   433

   434 lemma tranclp_trans:

   435   assumes xy: "r^++ x y"

   436   and yz: "r^++ y z"

   437   shows "r^++ x z" using yz xy

   438   by induct iprover+

   439

   440 lemma trancl_id [simp]: "trans r \<Longrightarrow> r^+ = r"

   441   apply auto

   442   apply (erule trancl_induct)

   443    apply assumption

   444   apply (unfold trans_def)

   445   apply blast

   446   done

   447

   448 lemma rtranclp_tranclp_tranclp:

   449   assumes "r^** x y"

   450   shows "!!z. r^++ y z ==> r^++ x z" using assms

   451   by induct (iprover intro: tranclp_trans)+

   452

   453 lemmas rtrancl_trancl_trancl = rtranclp_tranclp_tranclp [to_set]

   454

   455 lemma tranclp_into_tranclp2: "r a b ==> r^++ b c ==> r^++ a c"

   456   by (erule tranclp_trans [OF tranclp.r_into_trancl])

   457

   458 lemmas trancl_into_trancl2 = tranclp_into_tranclp2 [to_set]

   459

   460 lemma trancl_insert:

   461   "(insert (y, x) r)^+ = r^+ \<union> {(a, b). (a, y) \<in> r^* \<and> (x, b) \<in> r^*}"

   462   -- {* primitive recursion for @{text trancl} over finite relations *}

   463   apply (rule equalityI)

   464    apply (rule subsetI)

   465    apply (simp only: split_tupled_all)

   466    apply (erule trancl_induct, blast)

   467    apply (blast intro: rtrancl_into_trancl1 trancl_into_rtrancl trancl_trans)

   468   apply (rule subsetI)

   469   apply (blast intro: trancl_mono rtrancl_mono

   470     [THEN [2] rev_subsetD] rtrancl_trancl_trancl rtrancl_into_trancl2)

   471   done

   472

   473 lemma tranclp_converseI: "(r^++)^--1 x y ==> (r^--1)^++ x y"

   474   apply (drule conversepD)

   475   apply (erule tranclp_induct)

   476   apply (iprover intro: conversepI tranclp_trans)+

   477   done

   478

   479 lemmas trancl_converseI = tranclp_converseI [to_set]

   480

   481 lemma tranclp_converseD: "(r^--1)^++ x y ==> (r^++)^--1 x y"

   482   apply (rule conversepI)

   483   apply (erule tranclp_induct)

   484   apply (iprover dest: conversepD intro: tranclp_trans)+

   485   done

   486

   487 lemmas trancl_converseD = tranclp_converseD [to_set]

   488

   489 lemma tranclp_converse: "(r^--1)^++ = (r^++)^--1"

   490   by (fastsimp simp add: fun_eq_iff

   491     intro!: tranclp_converseI dest!: tranclp_converseD)

   492

   493 lemmas trancl_converse = tranclp_converse [to_set]

   494

   495 lemma sym_trancl: "sym r ==> sym (r^+)"

   496   by (simp only: sym_conv_converse_eq trancl_converse [symmetric])

   497

   498 lemma converse_tranclp_induct [consumes 1, case_names base step]:

   499   assumes major: "r^++ a b"

   500     and cases: "!!y. r y b ==> P(y)"

   501       "!!y z.[| r y z;  r^++ z b;  P(z) |] ==> P(y)"

   502   shows "P a"

   503   apply (rule tranclp_induct [OF tranclp_converseI, OF conversepI, OF major])

   504    apply (rule cases)

   505    apply (erule conversepD)

   506   apply (blast intro: assms dest!: tranclp_converseD)

   507   done

   508

   509 lemmas converse_trancl_induct = converse_tranclp_induct [to_set]

   510

   511 lemma tranclpD: "R^++ x y ==> EX z. R x z \<and> R^** z y"

   512   apply (erule converse_tranclp_induct)

   513    apply auto

   514   apply (blast intro: rtranclp_trans)

   515   done

   516

   517 lemmas tranclD = tranclpD [to_set]

   518

   519 lemma converse_tranclpE:

   520   assumes major: "tranclp r x z"

   521   assumes base: "r x z ==> P"

   522   assumes step: "\<And> y. [| r x y; tranclp r y z |] ==> P"

   523   shows P

   524 proof -

   525   from tranclpD[OF major]

   526   obtain y where "r x y" and "rtranclp r y z" by iprover

   527   from this(2) show P

   528   proof (cases rule: rtranclp.cases)

   529     case rtrancl_refl

   530     with r x y base show P by iprover

   531   next

   532     case rtrancl_into_rtrancl

   533     from this have "tranclp r y z"

   534       by (iprover intro: rtranclp_into_tranclp1)

   535     with r x y step show P by iprover

   536   qed

   537 qed

   538

   539 lemmas converse_tranclE = converse_tranclpE [to_set]

   540

   541 lemma tranclD2:

   542   "(x, y) \<in> R\<^sup>+ \<Longrightarrow> \<exists>z. (x, z) \<in> R\<^sup>* \<and> (z, y) \<in> R"

   543   by (blast elim: tranclE intro: trancl_into_rtrancl)

   544

   545 lemma irrefl_tranclI: "r^-1 \<inter> r^* = {} ==> (x, x) \<notin> r^+"

   546   by (blast elim: tranclE dest: trancl_into_rtrancl)

   547

   548 lemma irrefl_trancl_rD: "!!X. ALL x. (x, x) \<notin> r^+ ==> (x, y) \<in> r ==> x \<noteq> y"

   549   by (blast dest: r_into_trancl)

   550

   551 lemma trancl_subset_Sigma_aux:

   552     "(a, b) \<in> r^* ==> r \<subseteq> A \<times> A ==> a = b \<or> a \<in> A"

   553   by (induct rule: rtrancl_induct) auto

   554

   555 lemma trancl_subset_Sigma: "r \<subseteq> A \<times> A ==> r^+ \<subseteq> A \<times> A"

   556   apply (rule subsetI)

   557   apply (simp only: split_tupled_all)

   558   apply (erule tranclE)

   559    apply (blast dest!: trancl_into_rtrancl trancl_subset_Sigma_aux)+

   560   done

   561

   562 lemma reflcl_tranclp [simp]: "(r^++)^== = r^**"

   563   apply (safe intro!: order_antisym)

   564    apply (erule tranclp_into_rtranclp)

   565   apply (blast elim: rtranclp.cases dest: rtranclp_into_tranclp1)

   566   done

   567

   568 lemmas reflcl_trancl [simp] = reflcl_tranclp [to_set]

   569

   570 lemma trancl_reflcl [simp]: "(r^=)^+ = r^*"

   571   apply safe

   572    apply (drule trancl_into_rtrancl, simp)

   573   apply (erule rtranclE, safe)

   574    apply (rule r_into_trancl, simp)

   575   apply (rule rtrancl_into_trancl1)

   576    apply (erule rtrancl_reflcl [THEN equalityD2, THEN subsetD], fast)

   577   done

   578

   579 lemma trancl_empty [simp]: "{}^+ = {}"

   580   by (auto elim: trancl_induct)

   581

   582 lemma rtrancl_empty [simp]: "{}^* = Id"

   583   by (rule subst [OF reflcl_trancl]) simp

   584

   585 lemma rtranclpD: "R^** a b ==> a = b \<or> a \<noteq> b \<and> R^++ a b"

   586   by (force simp add: reflcl_tranclp [symmetric] simp del: reflcl_tranclp)

   587

   588 lemmas rtranclD = rtranclpD [to_set]

   589

   590 lemma rtrancl_eq_or_trancl:

   591   "(x,y) \<in> R\<^sup>* = (x=y \<or> x\<noteq>y \<and> (x,y) \<in> R\<^sup>+)"

   592   by (fast elim: trancl_into_rtrancl dest: rtranclD)

   593

   594 lemma trancl_unfold_right: "r^+ = r^* O r"

   595 by (auto dest: tranclD2 intro: rtrancl_into_trancl1)

   596

   597 lemma trancl_unfold_left: "r^+ = r O r^*"

   598 by (auto dest: tranclD intro: rtrancl_into_trancl2)

   599

   600

   601 text {* Simplifying nested closures *}

   602

   603 lemma rtrancl_trancl_absorb[simp]: "(R^*)^+ = R^*"

   604 by (simp add: trans_rtrancl)

   605

   606 lemma trancl_rtrancl_absorb[simp]: "(R^+)^* = R^*"

   607 by (subst reflcl_trancl[symmetric]) simp

   608

   609 lemma rtrancl_reflcl_absorb[simp]: "(R^*)^= = R^*"

   610 by auto

   611

   612

   613 text {* @{text Domain} and @{text Range} *}

   614

   615 lemma Domain_rtrancl [simp]: "Domain (R^*) = UNIV"

   616   by blast

   617

   618 lemma Range_rtrancl [simp]: "Range (R^*) = UNIV"

   619   by blast

   620

   621 lemma rtrancl_Un_subset: "(R^* \<union> S^*) \<subseteq> (R Un S)^*"

   622   by (rule rtrancl_Un_rtrancl [THEN subst]) fast

   623

   624 lemma in_rtrancl_UnI: "x \<in> R^* \<or> x \<in> S^* ==> x \<in> (R \<union> S)^*"

   625   by (blast intro: subsetD [OF rtrancl_Un_subset])

   626

   627 lemma trancl_domain [simp]: "Domain (r^+) = Domain r"

   628   by (unfold Domain_def) (blast dest: tranclD)

   629

   630 lemma trancl_range [simp]: "Range (r^+) = Range r"

   631 unfolding Range_def by(simp add: trancl_converse [symmetric])

   632

   633 lemma Not_Domain_rtrancl:

   634     "x ~: Domain R ==> ((x, y) : R^*) = (x = y)"

   635   apply auto

   636   apply (erule rev_mp)

   637   apply (erule rtrancl_induct)

   638    apply auto

   639   done

   640

   641 lemma trancl_subset_Field2: "r^+ <= Field r \<times> Field r"

   642   apply clarify

   643   apply (erule trancl_induct)

   644    apply (auto simp add: Field_def)

   645   done

   646

   647 lemma finite_trancl[simp]: "finite (r^+) = finite r"

   648   apply auto

   649    prefer 2

   650    apply (rule trancl_subset_Field2 [THEN finite_subset])

   651    apply (rule finite_SigmaI)

   652     prefer 3

   653     apply (blast intro: r_into_trancl' finite_subset)

   654    apply (auto simp add: finite_Field)

   655   done

   656

   657 text {* More about converse @{text rtrancl} and @{text trancl}, should

   658   be merged with main body. *}

   659

   660 lemma single_valued_confluent:

   661   "\<lbrakk> single_valued r; (x,y) \<in> r^*; (x,z) \<in> r^* \<rbrakk>

   662   \<Longrightarrow> (y,z) \<in> r^* \<or> (z,y) \<in> r^*"

   663   apply (erule rtrancl_induct)

   664   apply simp

   665   apply (erule disjE)

   666    apply (blast elim:converse_rtranclE dest:single_valuedD)

   667   apply(blast intro:rtrancl_trans)

   668   done

   669

   670 lemma r_r_into_trancl: "(a, b) \<in> R ==> (b, c) \<in> R ==> (a, c) \<in> R^+"

   671   by (fast intro: trancl_trans)

   672

   673 lemma trancl_into_trancl [rule_format]:

   674     "(a, b) \<in> r\<^sup>+ ==> (b, c) \<in> r --> (a,c) \<in> r\<^sup>+"

   675   apply (erule trancl_induct)

   676    apply (fast intro: r_r_into_trancl)

   677   apply (fast intro: r_r_into_trancl trancl_trans)

   678   done

   679

   680 lemma tranclp_rtranclp_tranclp:

   681     "r\<^sup>+\<^sup>+ a b ==> r\<^sup>*\<^sup>* b c ==> r\<^sup>+\<^sup>+ a c"

   682   apply (drule tranclpD)

   683   apply (elim exE conjE)

   684   apply (drule rtranclp_trans, assumption)

   685   apply (drule rtranclp_into_tranclp2, assumption, assumption)

   686   done

   687

   688 lemmas trancl_rtrancl_trancl = tranclp_rtranclp_tranclp [to_set]

   689

   690 lemmas transitive_closure_trans [trans] =

   691   r_r_into_trancl trancl_trans rtrancl_trans

   692   trancl.trancl_into_trancl trancl_into_trancl2

   693   rtrancl.rtrancl_into_rtrancl converse_rtrancl_into_rtrancl

   694   rtrancl_trancl_trancl trancl_rtrancl_trancl

   695

   696 lemmas transitive_closurep_trans' [trans] =

   697   tranclp_trans rtranclp_trans

   698   tranclp.trancl_into_trancl tranclp_into_tranclp2

   699   rtranclp.rtrancl_into_rtrancl converse_rtranclp_into_rtranclp

   700   rtranclp_tranclp_tranclp tranclp_rtranclp_tranclp

   701

   702 declare trancl_into_rtrancl [elim]

   703

   704 subsection {* The power operation on relations *}

   705

   706 text {* @{text "R ^^ n = R O ... O R"}, the n-fold composition of @{text R} *}

   707

   708 overloading

   709   relpow == "compow :: nat \<Rightarrow> ('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set"

   710 begin

   711

   712 primrec relpow :: "nat \<Rightarrow> ('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set" where

   713     "relpow 0 R = Id"

   714   | "relpow (Suc n) R = (R ^^ n) O R"

   715

   716 end

   717

   718 lemma rel_pow_1 [simp]:

   719   fixes R :: "('a \<times> 'a) set"

   720   shows "R ^^ 1 = R"

   721   by simp

   722

   723 lemma rel_pow_0_I:

   724   "(x, x) \<in> R ^^ 0"

   725   by simp

   726

   727 lemma rel_pow_Suc_I:

   728   "(x, y) \<in>  R ^^ n \<Longrightarrow> (y, z) \<in> R \<Longrightarrow> (x, z) \<in> R ^^ Suc n"

   729   by auto

   730

   731 lemma rel_pow_Suc_I2:

   732   "(x, y) \<in> R \<Longrightarrow> (y, z) \<in> R ^^ n \<Longrightarrow> (x, z) \<in> R ^^ Suc n"

   733   by (induct n arbitrary: z) (simp, fastsimp)

   734

   735 lemma rel_pow_0_E:

   736   "(x, y) \<in> R ^^ 0 \<Longrightarrow> (x = y \<Longrightarrow> P) \<Longrightarrow> P"

   737   by simp

   738

   739 lemma rel_pow_Suc_E:

   740   "(x, z) \<in> R ^^ Suc n \<Longrightarrow> (\<And>y. (x, y) \<in> R ^^ n \<Longrightarrow> (y, z) \<in> R \<Longrightarrow> P) \<Longrightarrow> P"

   741   by auto

   742

   743 lemma rel_pow_E:

   744   "(x, z) \<in>  R ^^ n \<Longrightarrow>  (n = 0 \<Longrightarrow> x = z \<Longrightarrow> P)

   745    \<Longrightarrow> (\<And>y m. n = Suc m \<Longrightarrow> (x, y) \<in>  R ^^ m \<Longrightarrow> (y, z) \<in> R \<Longrightarrow> P)

   746    \<Longrightarrow> P"

   747   by (cases n) auto

   748

   749 lemma rel_pow_Suc_D2:

   750   "(x, z) \<in> R ^^ Suc n \<Longrightarrow> (\<exists>y. (x, y) \<in> R \<and> (y, z) \<in> R ^^ n)"

   751   apply (induct n arbitrary: x z)

   752    apply (blast intro: rel_pow_0_I elim: rel_pow_0_E rel_pow_Suc_E)

   753   apply (blast intro: rel_pow_Suc_I elim: rel_pow_0_E rel_pow_Suc_E)

   754   done

   755

   756 lemma rel_pow_Suc_E2:

   757   "(x, z) \<in> R ^^ Suc n \<Longrightarrow> (\<And>y. (x, y) \<in> R \<Longrightarrow> (y, z) \<in> R ^^ n \<Longrightarrow> P) \<Longrightarrow> P"

   758   by (blast dest: rel_pow_Suc_D2)

   759

   760 lemma rel_pow_Suc_D2':

   761   "\<forall>x y z. (x, y) \<in> R ^^ n \<and> (y, z) \<in> R \<longrightarrow> (\<exists>w. (x, w) \<in> R \<and> (w, z) \<in> R ^^ n)"

   762   by (induct n) (simp_all, blast)

   763

   764 lemma rel_pow_E2:

   765   "(x, z) \<in> R ^^ n \<Longrightarrow>  (n = 0 \<Longrightarrow> x = z \<Longrightarrow> P)

   766      \<Longrightarrow> (\<And>y m. n = Suc m \<Longrightarrow> (x, y) \<in> R \<Longrightarrow> (y, z) \<in> R ^^ m \<Longrightarrow> P)

   767    \<Longrightarrow> P"

   768   apply (cases n, simp)

   769   apply (cut_tac n=nat and R=R in rel_pow_Suc_D2', simp, blast)

   770   done

   771

   772 lemma rel_pow_add: "R ^^ (m+n) = R^^m O R^^n"

   773 by(induct n) auto

   774

   775 lemma rel_pow_commute: "R O R ^^ n = R ^^ n O R"

   776 by (induct n) (simp, simp add: O_assoc [symmetric])

   777

   778 lemma rtrancl_imp_UN_rel_pow:

   779   assumes "p \<in> R^*"

   780   shows "p \<in> (\<Union>n. R ^^ n)"

   781 proof (cases p)

   782   case (Pair x y)

   783   with assms have "(x, y) \<in> R^*" by simp

   784   then have "(x, y) \<in> (\<Union>n. R ^^ n)" proof induct

   785     case base show ?case by (blast intro: rel_pow_0_I)

   786   next

   787     case step then show ?case by (blast intro: rel_pow_Suc_I)

   788   qed

   789   with Pair show ?thesis by simp

   790 qed

   791

   792 lemma rel_pow_imp_rtrancl:

   793   assumes "p \<in> R ^^ n"

   794   shows "p \<in> R^*"

   795 proof (cases p)

   796   case (Pair x y)

   797   with assms have "(x, y) \<in> R ^^ n" by simp

   798   then have "(x, y) \<in> R^*" proof (induct n arbitrary: x y)

   799     case 0 then show ?case by simp

   800   next

   801     case Suc then show ?case

   802       by (blast elim: rel_pow_Suc_E intro: rtrancl_into_rtrancl)

   803   qed

   804   with Pair show ?thesis by simp

   805 qed

   806

   807 lemma rtrancl_is_UN_rel_pow:

   808   "R^* = (\<Union>n. R ^^ n)"

   809   by (blast intro: rtrancl_imp_UN_rel_pow rel_pow_imp_rtrancl)

   810

   811 lemma rtrancl_power:

   812   "p \<in> R^* \<longleftrightarrow> (\<exists>n. p \<in> R ^^ n)"

   813   by (simp add: rtrancl_is_UN_rel_pow)

   814

   815 lemma trancl_power:

   816   "p \<in> R^+ \<longleftrightarrow> (\<exists>n > 0. p \<in> R ^^ n)"

   817   apply (cases p)

   818   apply simp

   819   apply (rule iffI)

   820    apply (drule tranclD2)

   821    apply (clarsimp simp: rtrancl_is_UN_rel_pow)

   822    apply (rule_tac x="Suc n" in exI)

   823    apply (clarsimp simp: rel_comp_def)

   824    apply fastsimp

   825   apply clarsimp

   826   apply (case_tac n, simp)

   827   apply clarsimp

   828   apply (drule rel_pow_imp_rtrancl)

   829   apply (drule rtrancl_into_trancl1) apply auto

   830   done

   831

   832 lemma rtrancl_imp_rel_pow:

   833   "p \<in> R^* \<Longrightarrow> \<exists>n. p \<in> R ^^ n"

   834   by (auto dest: rtrancl_imp_UN_rel_pow)

   835

   836 text{* By Sternagel/Thiemann: *}

   837 lemma rel_pow_fun_conv:

   838   "((a,b) \<in> R ^^ n) = (\<exists>f. f 0 = a \<and> f n = b \<and> (\<forall>i<n. (f i, f(Suc i)) \<in> R))"

   839 proof (induct n arbitrary: b)

   840   case 0 show ?case by auto

   841 next

   842   case (Suc n)

   843   show ?case

   844   proof (simp add: rel_comp_def Suc)

   845     show "(\<exists>y. (\<exists>f. f 0 = a \<and> f n = y \<and> (\<forall>i<n. (f i,f(Suc i)) \<in> R)) \<and> (y,b) \<in> R)

   846      = (\<exists>f. f 0 = a \<and> f(Suc n) = b \<and> (\<forall>i<Suc n. (f i, f (Suc i)) \<in> R))"

   847     (is "?l = ?r")

   848     proof

   849       assume ?l

   850       then obtain c f where 1: "f 0 = a"  "f n = c"  "\<And>i. i < n \<Longrightarrow> (f i, f (Suc i)) \<in> R"  "(c,b) \<in> R" by auto

   851       let ?g = "\<lambda> m. if m = Suc n then b else f m"

   852       show ?r by (rule exI[of _ ?g], simp add: 1)

   853     next

   854       assume ?r

   855       then obtain f where 1: "f 0 = a"  "b = f (Suc n)"  "\<And>i. i < Suc n \<Longrightarrow> (f i, f (Suc i)) \<in> R" by auto

   856       show ?l by (rule exI[of _ "f n"], rule conjI, rule exI[of _ f], insert 1, auto)

   857     qed

   858   qed

   859 qed

   860

   861 lemma rel_pow_finite_bounded1:

   862 assumes "finite(R :: ('a*'a)set)" and "k>0"

   863 shows "R^^k \<subseteq> (UN n:{n. 0<n & n <= card R}. R^^n)" (is "_ \<subseteq> ?r")

   864 proof-

   865   { fix a b k

   866     have "(a,b) : R^^(Suc k) \<Longrightarrow> EX n. 0<n & n <= card R & (a,b) : R^^n"

   867     proof(induct k arbitrary: b)

   868       case 0

   869       hence "R \<noteq> {}" by auto

   870       with card_0_eq[OF finite R] have "card R >= Suc 0" by auto

   871       thus ?case using 0 by force

   872     next

   873       case (Suc k)

   874       then obtain a' where "(a,a') : R^^(Suc k)" and "(a',b) : R" by auto

   875       from Suc(1)[OF (a,a') : R^^(Suc k)]

   876       obtain n where "n \<le> card R" and "(a,a') \<in> R ^^ n" by auto

   877       have "(a,b) : R^^(Suc n)" using (a,a') \<in> R^^n and (a',b)\<in> R by auto

   878       { assume "n < card R"

   879         hence ?case using (a,b): R^^(Suc n) Suc_leI[OF n < card R] by blast

   880       } moreover

   881       { assume "n = card R"

   882         from (a,b) \<in> R ^^ (Suc n)[unfolded rel_pow_fun_conv]

   883         obtain f where "f 0 = a" and "f(Suc n) = b"

   884           and steps: "\<And>i. i <= n \<Longrightarrow> (f i, f (Suc i)) \<in> R" by auto

   885         let ?p = "%i. (f i, f(Suc i))"

   886         let ?N = "{i. i \<le> n}"

   887         have "?p  ?N <= R" using steps by auto

   888         from card_mono[OF assms(1) this]

   889         have "card(?p  ?N) <= card R" .

   890         also have "\<dots> < card ?N" using n = card R by simp

   891         finally have "~ inj_on ?p ?N" by(rule pigeonhole)

   892         then obtain i j where i: "i <= n" and j: "j <= n" and ij: "i \<noteq> j" and

   893           pij: "?p i = ?p j" by(auto simp: inj_on_def)

   894         let ?i = "min i j" let ?j = "max i j"

   895         have i: "?i <= n" and j: "?j <= n" and pij: "?p ?i = ?p ?j"

   896           and ij: "?i < ?j"

   897           using i j ij pij unfolding min_def max_def by auto

   898         from i j pij ij obtain i j where i: "i<=n" and j: "j<=n" and ij: "i<j"

   899           and pij: "?p i = ?p j" by blast

   900         let ?g = "\<lambda> l. if l \<le> i then f l else f (l + (j - i))"

   901         let ?n = "Suc(n - (j - i))"

   902         have abl: "(a,b) \<in> R ^^ ?n" unfolding rel_pow_fun_conv

   903         proof (rule exI[of _ ?g], intro conjI impI allI)

   904           show "?g ?n = b" using f(Suc n) = b j ij by auto

   905         next

   906           fix k assume "k < ?n"

   907           show "(?g k, ?g (Suc k)) \<in> R"

   908           proof (cases "k < i")

   909             case True

   910             with i have "k <= n" by auto

   911             from steps[OF this] show ?thesis using True by simp

   912           next

   913             case False

   914             hence "i \<le> k" by auto

   915             show ?thesis

   916             proof (cases "k = i")

   917               case True

   918               thus ?thesis using ij pij steps[OF i] by simp

   919             next

   920               case False

   921               with i \<le> k have "i < k" by auto

   922               hence small: "k + (j - i) <= n" using k<?n by arith

   923               show ?thesis using steps[OF small] i<k by auto

   924             qed

   925           qed

   926         qed (simp add: f 0 = a)

   927         moreover have "?n <= n" using i j ij by arith

   928         ultimately have ?case using n = card R by blast

   929       }

   930       ultimately show ?case using n \<le> card R by force

   931     qed

   932   }

   933   thus ?thesis using gr0_implies_Suc[OF k>0] by auto

   934 qed

   935

   936 lemma rel_pow_finite_bounded:

   937 assumes "finite(R :: ('a*'a)set)"

   938 shows "R^^k \<subseteq> (UN n:{n. n <= card R}. R^^n)"

   939 apply(cases k)

   940  apply force

   941 using rel_pow_finite_bounded1[OF assms, of k] by auto

   942

   943 lemma rtrancl_finite_eq_rel_pow:

   944   "finite R \<Longrightarrow> R^* = (UN n : {n. n <= card R}. R^^n)"

   945 by(fastsimp simp: rtrancl_power dest: rel_pow_finite_bounded)

   946

   947 lemma trancl_finite_eq_rel_pow:

   948   "finite R \<Longrightarrow> R^+ = (UN n : {n. 0 < n & n <= card R}. R^^n)"

   949 apply(auto simp add: trancl_power)

   950 apply(auto dest: rel_pow_finite_bounded1)

   951 done

   952

   953 lemma finite_rel_comp[simp,intro]:

   954 assumes "finite R" and "finite S"

   955 shows "finite(R O S)"

   956 proof-

   957   have "R O S = (UN (x,y) : R. \<Union>((%(u,v). if u=y then {(x,v)} else {})  S))"

   958     by(force simp add: split_def)

   959   thus ?thesis using assms by(clarsimp)

   960 qed

   961

   962 lemma finite_relpow[simp,intro]:

   963   assumes "finite(R :: ('a*'a)set)" shows "n>0 \<Longrightarrow> finite(R^^n)"

   964 apply(induct n)

   965  apply simp

   966 apply(case_tac n)

   967  apply(simp_all add: assms)

   968 done

   969

   970 lemma single_valued_rel_pow:

   971   fixes R :: "('a * 'a) set"

   972   shows "single_valued R \<Longrightarrow> single_valued (R ^^ n)"

   973 apply (induct n arbitrary: R)

   974 apply simp_all

   975 apply (rule single_valuedI)

   976 apply (fast dest: single_valuedD elim: rel_pow_Suc_E)

   977 done

   978

   979 subsection {* Setup of transitivity reasoner *}

   980

   981 ML {*

   982

   983 structure Trancl_Tac = Trancl_Tac

   984 (

   985   val r_into_trancl = @{thm trancl.r_into_trancl};

   986   val trancl_trans  = @{thm trancl_trans};

   987   val rtrancl_refl = @{thm rtrancl.rtrancl_refl};

   988   val r_into_rtrancl = @{thm r_into_rtrancl};

   989   val trancl_into_rtrancl = @{thm trancl_into_rtrancl};

   990   val rtrancl_trancl_trancl = @{thm rtrancl_trancl_trancl};

   991   val trancl_rtrancl_trancl = @{thm trancl_rtrancl_trancl};

   992   val rtrancl_trans = @{thm rtrancl_trans};

   993

   994   fun decomp (@{const Trueprop} $t) =   995 let fun dec (Const (@{const_name Set.member}, _)$ (Const (@{const_name Pair}, _) $a$ b) $rel ) =   996 let fun decr (Const ("Transitive_Closure.rtrancl", _ )$ r) = (r,"r*")

   997               | decr (Const ("Transitive_Closure.trancl", _ ) $r) = (r,"r+")   998 | decr r = (r,"r");   999 val (rel,r) = decr (Envir.beta_eta_contract rel);   1000 in SOME (a,b,rel,r) end   1001 | dec _ = NONE   1002 in dec t end   1003 | decomp _ = NONE;   1004 );   1005   1006 structure Tranclp_Tac = Trancl_Tac   1007 (   1008 val r_into_trancl = @{thm tranclp.r_into_trancl};   1009 val trancl_trans = @{thm tranclp_trans};   1010 val rtrancl_refl = @{thm rtranclp.rtrancl_refl};   1011 val r_into_rtrancl = @{thm r_into_rtranclp};   1012 val trancl_into_rtrancl = @{thm tranclp_into_rtranclp};   1013 val rtrancl_trancl_trancl = @{thm rtranclp_tranclp_tranclp};   1014 val trancl_rtrancl_trancl = @{thm tranclp_rtranclp_tranclp};   1015 val rtrancl_trans = @{thm rtranclp_trans};   1016   1017 fun decomp (@{const Trueprop}$ t) =

  1018     let fun dec (rel $a$ b) =

  1019         let fun decr (Const ("Transitive_Closure.rtranclp", _ ) $r) = (r,"r*")   1020 | decr (Const ("Transitive_Closure.tranclp", _ )$ r)  = (r,"r+")

  1021               | decr r = (r,"r");

  1022             val (rel,r) = decr rel;

  1023         in SOME (a, b, rel, r) end

  1024       | dec _ =  NONE

  1025     in dec t end

  1026     | decomp _ = NONE;

  1027 );

  1028 *}

  1029

  1030 setup {*

  1031   Simplifier.map_simpset_global (fn ss => ss

  1032     addSolver (mk_solver "Trancl" (Trancl_Tac.trancl_tac o Simplifier.the_context))

  1033     addSolver (mk_solver "Rtrancl" (Trancl_Tac.rtrancl_tac o Simplifier.the_context))

  1034     addSolver (mk_solver "Tranclp" (Tranclp_Tac.trancl_tac o Simplifier.the_context))

  1035     addSolver (mk_solver "Rtranclp" (Tranclp_Tac.rtrancl_tac o Simplifier.the_context)))

  1036 *}

  1037

  1038

  1039 text {* Optional methods. *}

  1040

  1041 method_setup trancl =

  1042   {* Scan.succeed (SIMPLE_METHOD' o Trancl_Tac.trancl_tac) *}

  1043   {* simple transitivity reasoner *}

  1044 method_setup rtrancl =

  1045   {* Scan.succeed (SIMPLE_METHOD' o Trancl_Tac.rtrancl_tac) *}

  1046   {* simple transitivity reasoner *}

  1047 method_setup tranclp =

  1048   {* Scan.succeed (SIMPLE_METHOD' o Tranclp_Tac.trancl_tac) *}

  1049   {* simple transitivity reasoner (predicate version) *}

  1050 method_setup rtranclp =

  1051   {* Scan.succeed (SIMPLE_METHOD' o Tranclp_Tac.rtrancl_tac) *}

  1052   {* simple transitivity reasoner (predicate version) *}

  1053

  1054 end
`