src/HOL/Transitive_Closure.thy
 author bulwahn Fri Oct 21 11:17:14 2011 +0200 (2011-10-21) changeset 45231 d85a2fdc586c parent 45153 93e290c11b0f child 45607 16b4f5774621 permissions -rw-r--r--
replacing code_inline by code_unfold, removing obsolete code_unfold, code_inline del now that the ancient code generator is removed
     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^== \<equiv> sup r op ="

    48

    49 abbreviation

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

    51   "r^= \<equiv> 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

   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 (fastforce 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 rtrancl_trancl_reflcl [code]: "r^* = (r^+)^="

   580   by simp

   581

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

   583   by (auto elim: trancl_induct)

   584

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

   586   by (rule subst [OF reflcl_trancl]) simp

   587

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

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

   590

   591 lemmas rtranclD = rtranclpD [to_set]

   592

   593 lemma rtrancl_eq_or_trancl:

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

   595   by (fast elim: trancl_into_rtrancl dest: rtranclD)

   596

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

   598 by (auto dest: tranclD2 intro: rtrancl_into_trancl1)

   599

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

   601 by (auto dest: tranclD intro: rtrancl_into_trancl2)

   602

   603

   604 text {* Simplifying nested closures *}

   605

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

   607 by (simp add: trans_rtrancl)

   608

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

   610 by (subst reflcl_trancl[symmetric]) simp

   611

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

   613 by auto

   614

   615

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

   617

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

   619   by blast

   620

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

   622   by blast

   623

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

   625   by (rule rtrancl_Un_rtrancl [THEN subst]) fast

   626

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

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

   629

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

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

   632

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

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

   635

   636 lemma Not_Domain_rtrancl:

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

   638   apply auto

   639   apply (erule rev_mp)

   640   apply (erule rtrancl_induct)

   641    apply auto

   642   done

   643

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

   645   apply clarify

   646   apply (erule trancl_induct)

   647    apply (auto simp add: Field_def)

   648   done

   649

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

   651   apply auto

   652    prefer 2

   653    apply (rule trancl_subset_Field2 [THEN finite_subset])

   654    apply (rule finite_SigmaI)

   655     prefer 3

   656     apply (blast intro: r_into_trancl' finite_subset)

   657    apply (auto simp add: finite_Field)

   658   done

   659

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

   661   be merged with main body. *}

   662

   663 lemma single_valued_confluent:

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

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

   666   apply (erule rtrancl_induct)

   667   apply simp

   668   apply (erule disjE)

   669    apply (blast elim:converse_rtranclE dest:single_valuedD)

   670   apply(blast intro:rtrancl_trans)

   671   done

   672

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

   674   by (fast intro: trancl_trans)

   675

   676 lemma trancl_into_trancl [rule_format]:

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

   678   apply (erule trancl_induct)

   679    apply (fast intro: r_r_into_trancl)

   680   apply (fast intro: r_r_into_trancl trancl_trans)

   681   done

   682

   683 lemma tranclp_rtranclp_tranclp:

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

   685   apply (drule tranclpD)

   686   apply (elim exE conjE)

   687   apply (drule rtranclp_trans, assumption)

   688   apply (drule rtranclp_into_tranclp2, assumption, assumption)

   689   done

   690

   691 lemmas trancl_rtrancl_trancl = tranclp_rtranclp_tranclp [to_set]

   692

   693 lemmas transitive_closure_trans [trans] =

   694   r_r_into_trancl trancl_trans rtrancl_trans

   695   trancl.trancl_into_trancl trancl_into_trancl2

   696   rtrancl.rtrancl_into_rtrancl converse_rtrancl_into_rtrancl

   697   rtrancl_trancl_trancl trancl_rtrancl_trancl

   698

   699 lemmas transitive_closurep_trans' [trans] =

   700   tranclp_trans rtranclp_trans

   701   tranclp.trancl_into_trancl tranclp_into_tranclp2

   702   rtranclp.rtrancl_into_rtrancl converse_rtranclp_into_rtranclp

   703   rtranclp_tranclp_tranclp tranclp_rtranclp_tranclp

   704

   705 declare trancl_into_rtrancl [elim]

   706

   707 subsection {* The power operation on relations *}

   708

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

   710

   711 overloading

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

   713 begin

   714

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

   716     "relpow 0 R = Id"

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

   718

   719 end

   720

   721 lemma rel_pow_1 [simp]:

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

   723   shows "R ^^ 1 = R"

   724   by simp

   725

   726 lemma rel_pow_0_I:

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

   728   by simp

   729

   730 lemma rel_pow_Suc_I:

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

   732   by auto

   733

   734 lemma rel_pow_Suc_I2:

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

   736   by (induct n arbitrary: z) (simp, fastforce)

   737

   738 lemma rel_pow_0_E:

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

   740   by simp

   741

   742 lemma rel_pow_Suc_E:

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

   744   by auto

   745

   746 lemma rel_pow_E:

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

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

   749    \<Longrightarrow> P"

   750   by (cases n) auto

   751

   752 lemma rel_pow_Suc_D2:

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

   754   apply (induct n arbitrary: x z)

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

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

   757   done

   758

   759 lemma rel_pow_Suc_E2:

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

   761   by (blast dest: rel_pow_Suc_D2)

   762

   763 lemma rel_pow_Suc_D2':

   764   "\<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)"

   765   by (induct n) (simp_all, blast)

   766

   767 lemma rel_pow_E2:

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

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

   770    \<Longrightarrow> P"

   771   apply (cases n, simp)

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

   773   done

   774

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

   776 by(induct n) auto

   777

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

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

   780

   781 lemma rel_pow_empty:

   782   "0 < n \<Longrightarrow> ({} :: ('a \<times> 'a) set) ^^ n = {}"

   783   by (cases n) auto

   784

   785 lemma rtrancl_imp_UN_rel_pow:

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

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

   788 proof (cases p)

   789   case (Pair x y)

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

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

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

   793   next

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

   795   qed

   796   with Pair show ?thesis by simp

   797 qed

   798

   799 lemma rel_pow_imp_rtrancl:

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

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

   802 proof (cases p)

   803   case (Pair x y)

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

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

   806     case 0 then show ?case by simp

   807   next

   808     case Suc then show ?case

   809       by (blast elim: rel_pow_Suc_E intro: rtrancl_into_rtrancl)

   810   qed

   811   with Pair show ?thesis by simp

   812 qed

   813

   814 lemma rtrancl_is_UN_rel_pow:

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

   816   by (blast intro: rtrancl_imp_UN_rel_pow rel_pow_imp_rtrancl)

   817

   818 lemma rtrancl_power:

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

   820   by (simp add: rtrancl_is_UN_rel_pow)

   821

   822 lemma trancl_power:

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

   824   apply (cases p)

   825   apply simp

   826   apply (rule iffI)

   827    apply (drule tranclD2)

   828    apply (clarsimp simp: rtrancl_is_UN_rel_pow)

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

   830    apply (clarsimp simp: rel_comp_def)

   831    apply fastforce

   832   apply clarsimp

   833   apply (case_tac n, simp)

   834   apply clarsimp

   835   apply (drule rel_pow_imp_rtrancl)

   836   apply (drule rtrancl_into_trancl1) apply auto

   837   done

   838

   839 lemma rtrancl_imp_rel_pow:

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

   841   by (auto dest: rtrancl_imp_UN_rel_pow)

   842

   843 text{* By Sternagel/Thiemann: *}

   844 lemma rel_pow_fun_conv:

   845   "((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))"

   846 proof (induct n arbitrary: b)

   847   case 0 show ?case by auto

   848 next

   849   case (Suc n)

   850   show ?case

   851   proof (simp add: rel_comp_def Suc)

   852     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)

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

   854     (is "?l = ?r")

   855     proof

   856       assume ?l

   857       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

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

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

   860     next

   861       assume ?r

   862       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

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

   864     qed

   865   qed

   866 qed

   867

   868 lemma rel_pow_finite_bounded1:

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

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

   871 proof-

   872   { fix a b k

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

   874     proof(induct k arbitrary: b)

   875       case 0

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

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

   878       thus ?case using 0 by force

   879     next

   880       case (Suc k)

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

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

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

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

   885       { assume "n < card R"

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

   887       } moreover

   888       { assume "n = card R"

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

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

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

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

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

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

   895         from card_mono[OF assms(1) this]

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

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

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

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

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

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

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

   903           and ij: "?i < ?j"

   904           using i j ij pij unfolding min_def max_def by auto

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

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

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

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

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

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

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

   912         next

   913           fix k assume "k < ?n"

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

   915           proof (cases "k < i")

   916             case True

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

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

   919           next

   920             case False

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

   922             show ?thesis

   923             proof (cases "k = i")

   924               case True

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

   926             next

   927               case False

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

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

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

   931             qed

   932           qed

   933         qed (simp add: f 0 = a)

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

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

   936       }

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

   938     qed

   939   }

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

   941 qed

   942

   943 lemma rel_pow_finite_bounded:

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

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

   946 apply(cases k)

   947  apply force

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

   949

   950 lemma rtrancl_finite_eq_rel_pow:

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

   952 by(fastforce simp: rtrancl_power dest: rel_pow_finite_bounded)

   953

   954 lemma trancl_finite_eq_rel_pow:

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

   956 apply(auto simp add: trancl_power)

   957 apply(auto dest: rel_pow_finite_bounded1)

   958 done

   959

   960 lemma finite_rel_comp[simp,intro]:

   961 assumes "finite R" and "finite S"

   962 shows "finite(R O S)"

   963 proof-

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

   965     by(force simp add: split_def)

   966   thus ?thesis using assms by(clarsimp)

   967 qed

   968

   969 lemma finite_relpow[simp,intro]:

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

   971 apply(induct n)

   972  apply simp

   973 apply(case_tac n)

   974  apply(simp_all add: assms)

   975 done

   976

   977 lemma single_valued_rel_pow:

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

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

   980 apply (induct n arbitrary: R)

   981 apply simp_all

   982 apply (rule single_valuedI)

   983 apply (fast dest: single_valuedD elim: rel_pow_Suc_E)

   984 done

   985

   986

   987 subsection {* Bounded transitive closure *}

   988

   989 definition ntrancl :: "nat \<Rightarrow> ('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set"

   990 where

   991   "ntrancl n R = (\<Union>i\<in>{i. 0 < i \<and> i \<le> Suc n}. R ^^ i)"

   992

   993 lemma ntrancl_Zero [simp, code]:

   994   "ntrancl 0 R = R"

   995 proof

   996   show "R \<subseteq> ntrancl 0 R"

   997     unfolding ntrancl_def by fastforce

   998 next

   999   {

  1000     fix i have "0 < i \<and> i \<le> Suc 0 \<longleftrightarrow> i = 1" by auto

  1001   }

  1002   from this show "ntrancl 0 R \<le> R"

  1003     unfolding ntrancl_def by auto

  1004 qed

  1005

  1006 lemma ntrancl_Suc [simp, code]:

  1007   "ntrancl (Suc n) R = ntrancl n R O (Id \<union> R)"

  1008 proof

  1009   {

  1010     fix a b

  1011     assume "(a, b) \<in> ntrancl (Suc n) R"

  1012     from this obtain i where "0 < i" "i \<le> Suc (Suc n)" "(a, b) \<in> R ^^ i"

  1013       unfolding ntrancl_def by auto

  1014     have "(a, b) \<in> ntrancl n R O (Id \<union> R)"

  1015     proof (cases "i = 1")

  1016       case True

  1017       from this (a, b) \<in> R ^^ i show ?thesis

  1018         unfolding ntrancl_def by auto

  1019     next

  1020       case False

  1021       from this 0 < i obtain j where j: "i = Suc j" "0 < j"

  1022         by (cases i) auto

  1023       from this (a, b) \<in> R ^^ i obtain c where c1: "(a, c) \<in> R ^^ j" and c2:"(c, b) \<in> R"

  1024         by auto

  1025       from c1 j i \<le> Suc (Suc n) have "(a, c) \<in> ntrancl n R"

  1026         unfolding ntrancl_def by fastforce

  1027       from this c2 show ?thesis by fastforce

  1028     qed

  1029   }

  1030   from this show "ntrancl (Suc n) R \<subseteq> ntrancl n R O (Id \<union> R)"

  1031     by auto

  1032 next

  1033   show "ntrancl n R O (Id \<union> R) \<subseteq> ntrancl (Suc n) R"

  1034     unfolding ntrancl_def by fastforce

  1035 qed

  1036

  1037 lemma finite_trancl_ntranl:

  1038   "finite R \<Longrightarrow> trancl R = ntrancl (card R - 1) R"

  1039   by (cases "card R") (auto simp add: trancl_finite_eq_rel_pow rel_pow_empty ntrancl_def)

  1040

  1041

  1042 subsection {* Acyclic relations *}

  1043

  1044 definition acyclic :: "('a * 'a) set => bool" where

  1045   "acyclic r \<longleftrightarrow> (!x. (x,x) ~: r^+)"

  1046

  1047 abbreviation acyclicP :: "('a => 'a => bool) => bool" where

  1048   "acyclicP r \<equiv> acyclic {(x, y). r x y}"

  1049

  1050 lemma acyclic_irrefl:

  1051   "acyclic r \<longleftrightarrow> irrefl (r^+)"

  1052   by (simp add: acyclic_def irrefl_def)

  1053

  1054 lemma acyclicI: "ALL x. (x, x) ~: r^+ ==> acyclic r"

  1055   by (simp add: acyclic_def)

  1056

  1057 lemma acyclic_insert [iff]:

  1058      "acyclic(insert (y,x) r) = (acyclic r & (x,y) ~: r^*)"

  1059 apply (simp add: acyclic_def trancl_insert)

  1060 apply (blast intro: rtrancl_trans)

  1061 done

  1062

  1063 lemma acyclic_converse [iff]: "acyclic(r^-1) = acyclic r"

  1064 by (simp add: acyclic_def trancl_converse)

  1065

  1066 lemmas acyclicP_converse [iff] = acyclic_converse [to_pred]

  1067

  1068 lemma acyclic_impl_antisym_rtrancl: "acyclic r ==> antisym(r^*)"

  1069 apply (simp add: acyclic_def antisym_def)

  1070 apply (blast elim: rtranclE intro: rtrancl_into_trancl1 rtrancl_trancl_trancl)

  1071 done

  1072

  1073 (* Other direction:

  1074 acyclic = no loops

  1075 antisym = only self loops

  1076 Goalw [acyclic_def,antisym_def] "antisym( r^* ) ==> acyclic(r - Id)

  1077 ==> antisym( r^* ) = acyclic(r - Id)";

  1078 *)

  1079

  1080 lemma acyclic_subset: "[| acyclic s; r <= s |] ==> acyclic r"

  1081 apply (simp add: acyclic_def)

  1082 apply (blast intro: trancl_mono)

  1083 done

  1084

  1085

  1086 subsection {* Setup of transitivity reasoner *}

  1087

  1088 ML {*

  1089

  1090 structure Trancl_Tac = Trancl_Tac

  1091 (

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

  1093   val trancl_trans  = @{thm trancl_trans};

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

  1095   val r_into_rtrancl = @{thm r_into_rtrancl};

  1096   val trancl_into_rtrancl = @{thm trancl_into_rtrancl};

  1097   val rtrancl_trancl_trancl = @{thm rtrancl_trancl_trancl};

  1098   val trancl_rtrancl_trancl = @{thm trancl_rtrancl_trancl};

  1099   val rtrancl_trans = @{thm rtrancl_trans};

  1100

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

  1104               | decr (Const ("Transitive_Closure.trancl", _ ) $r) = (r,"r+")   1105 | decr r = (r,"r");   1106 val (rel,r) = decr (Envir.beta_eta_contract rel);   1107 in SOME (a,b,rel,r) end   1108 | dec _ = NONE   1109 in dec t end   1110 | decomp _ = NONE;   1111 );   1112   1113 structure Tranclp_Tac = Trancl_Tac   1114 (   1115 val r_into_trancl = @{thm tranclp.r_into_trancl};   1116 val trancl_trans = @{thm tranclp_trans};   1117 val rtrancl_refl = @{thm rtranclp.rtrancl_refl};   1118 val r_into_rtrancl = @{thm r_into_rtranclp};   1119 val trancl_into_rtrancl = @{thm tranclp_into_rtranclp};   1120 val rtrancl_trancl_trancl = @{thm rtranclp_tranclp_tranclp};   1121 val trancl_rtrancl_trancl = @{thm tranclp_rtranclp_tranclp};   1122 val rtrancl_trans = @{thm rtranclp_trans};   1123   1124 fun decomp (@{const Trueprop}$ t) =

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

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

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

  1129             val (rel,r) = decr rel;

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

  1131       | dec _ =  NONE

  1132     in dec t end

  1133     | decomp _ = NONE;

  1134 );

  1135 *}

  1136

  1137 setup {*

  1138   Simplifier.map_simpset_global (fn ss => ss

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

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

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

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

  1143 *}

  1144

  1145

  1146 text {* Optional methods. *}

  1147

  1148 method_setup trancl =

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

  1150   {* simple transitivity reasoner *}

  1151 method_setup rtrancl =

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

  1153   {* simple transitivity reasoner *}

  1154 method_setup tranclp =

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

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

  1157 method_setup rtranclp =

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

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

  1160

  1161 end
`