1 theory RTree

     2 imports "~~/src/HOL/Library/Transitive_Closure_Table" Max

     3 begin

     4 

     5 section {* A theory of relational trees *}

     6 

     7 inductive_cases path_nilE [elim!]: "rtrancl_path r x [] y"

     8 inductive_cases path_consE [elim!]: "rtrancl_path r x (z#zs) y"

     9 

    10 subsection {* Definitions *}

    11 

    12 text {*

    13   In this theory, we are going to give a notion of of `Relational Graph` and

    14   its derived notion `Relational Tree`. Given a binary relation @{text "r"},

    15   the `Relational Graph of @{text "r"}` is the graph, the edges of which

    16   are those in @{text "r"}. In this way, any binary relation can be viewed

    17   as a `Relational Graph`. Note, this notion of graph includes infinite graphs. 

    18 

    19   A `Relation Graph` @{text "r"} is said to be a `Relational Tree` if it is both

    20   {\em single valued} and {\em acyclic}. 

    21 *}

    22 

    23 text {*

    24   The following @{text "sgv"} specifies that relation @{text "r"} is {\em single valued}.

    25 *}

    26 locale sgv = 

    27   fixes r

    28   assumes sgv: "single_valued r"

    29 

    30 text {*

    31   The following @{text "rtree"} specifies that @{text "r"} is a 

    32   {\em Relational Tree}.

    33 *}

    34 locale rtree = sgv + 

    35   assumes acl: "acyclic r"

    36 

    37 text {* 

    38   The following two auxiliary functions @{text "rel_of"} and @{text "pred_of"} 

    39   transfer between the predicate and set representation of binary relations.

    40 *}

    41 

    42 definition "rel_of r = {(x, y) | x y. r x y}"

    43 

    44 definition "pred_of r = (\<lambda> x y. (x, y) \<in> r)"

    45 

    46 text {*

    47   To reason about {\em Relational Graph}, a notion of path is 

    48   needed, which is given by the following @{text "rpath"} (short 

    49   for `relational path`). 

    50   The path @{text "xs"} in proposition @{text "rpath r x xs y"} is 

    51   a path leading from @{text "x"} to @{text "y"}, which serves as a 

    52   witness of the fact @{text "(x, y) \<in> r^*"}. 

    53 

    54   @{text "rpath"}

    55   is simply a wrapper of the @{text "rtrancl_path"} defined in the imported 

    56   theory @{text "Transitive_Closure_Table"}, which defines 

    57   a notion of path for the predicate form of binary relations. 

    58 *}

    59 definition "rpath r x xs y = rtrancl_path (pred_of r) x xs y"

    60 

    61 text {*

    62   Given a path @{text "ps"}, @{text "edges_on ps"} is the 

    63   set of edges along the path, which is defined as follows:

    64 *}

    65 

    66 definition "edges_on ps = {(a,b) | a b. \<exists> xs ys. ps = xs@[a,b]@ys}"

    67 

    68 text {*

    69    The following @{text "indep"} defines a notion of independence. 

    70    Two nodes @{text "x"} and @{text "y"} are said to be independent

    71    (expressed as @{text "indep x y"}),  if neither one is reachable 

    72    from the other in relational graph @{text "r"}.

    73 *}

    74 definition "indep r x y = (((x, y) \<notin> r^*) \<and> ((y, x) \<notin> r^*))"

    75 

    76 text {*

    77   In relational tree @{text "r"}, the sub tree of node @{text "x"} is written

    78   @{text "subtree r x"}, which is defined to be the set of nodes (including itself) 

    79   which can reach @{text "x"} by following some path in @{text "r"}:

    80 *}

    81 

    82 definition "subtree r x = {y . (y, x) \<in> r^*}"

    83 

    84 definition "ancestors r x = {y. (x, y) \<in> r^+}"

    85 

    86 definition "root r x = (ancestors r x = {})"

    87 

    88 text {*

    89   The following @{text "edge_in r x"} is the set of edges

    90   contained in the sub-tree of @{text "x"}, with @{text "r"} as the underlying graph.

    91 *}

    92 

    93 definition "edges_in r x = {(a, b) | a b. (a, b) \<in> r \<and> b \<in> subtree r x}"

    94 

    95 text {*

    96   The following lemma @{text "edges_in_meaning"} shows the intuitive meaning 

    97   of `an edge @{text "(a, b)"} is in the sub-tree of @{text "x"}`, 

    98   i.e., both @{text "a"} and @{text "b"} are in the sub-tree.

    99 *}

   100 lemma edges_in_meaning: 

   101   "edges_in r x = {(a, b) | a b. (a, b) \<in> r \<and> a \<in> subtree r x \<and> b \<in> subtree r x}"

   102 proof -

   103   { fix a b

   104     assume h: "(a, b) \<in> r" "b \<in> subtree r x"

   105     moreover have "a \<in> subtree r x"

   106     proof -

   107       from h(2)[unfolded subtree_def] have "(b, x) \<in> r^*" by simp

   108       with h(1) have "(a, x) \<in> r^*" by auto

   109       thus ?thesis by (auto simp:subtree_def)

   110     qed

   111     ultimately have "((a, b) \<in> r \<and> a \<in> subtree r x \<and> b \<in> subtree r x)" 

   112       by (auto)

   113   } thus ?thesis by (auto simp:edges_in_def)

   114 qed

   115 

   116 text {*

   117   The following lemma shows the meaning of @{term "edges_in"} from the other side, 

   118   which says: for the edge @{text "(a,b)"} to be outside of the sub-tree of @{text "x"}, 

   119   it is sufficient to show that @{text "b"} is.

   120 *}

   121 lemma edges_in_refutation:

   122   assumes "b \<notin> subtree r x"

   123   shows "(a, b) \<notin> edges_in r x"

   124   using assms by (unfold edges_in_def subtree_def, auto)

   125 

   126 definition "children r x = {y. (y, x) \<in> r}"

   127 

   128 locale fbranch =

   129   fixes r

   130   assumes fb: "\<forall> x \<in> Range r . finite (children r x)"

   131 begin

   132 

   133 lemma finite_children: "finite (children r x)"

   134 proof(cases "children r x = {}")

   135   case True

   136   thus ?thesis by auto

   137 next

   138   case False

   139   then obtain y where "(y, x) \<in> r" by (auto simp:children_def)

   140   hence "x \<in> Range r" by auto

   141   from fb[rule_format, OF this]

   142   show ?thesis .

   143 qed

   144 

   145 end

   146 

   147 locale fsubtree = fbranch + 

   148    assumes wf: "wf r"

   149 

   150 (* ccc *)

   151 

   152 subsection {* Auxiliary lemmas *}

   153 

   154 lemma index_minimize:

   155   assumes "P (i::nat)"

   156   obtains j where "P j" and "\<forall> k < j. \<not> P k" 

   157 using assms

   158 proof -

   159   have "\<exists> j. P j \<and> (\<forall> k < j. \<not> P k)"

   160   using assms

   161   proof(induct i rule:less_induct)

   162     case (less t)

   163     show ?case

   164     proof(cases "\<forall> j < t. \<not> P j")

   165       case True

   166       with less (2) show ?thesis by blast

   167     next

   168       case False

   169       then obtain j where "j < t" "P j" by auto

   170       from less(1)[OF this]

   171       show ?thesis .

   172     qed

   173   qed 

   174   with that show ?thesis by metis

   175 qed

   176 

   177 subsection {* Properties of Relational Graphs and Relational Trees *}

   178 

   179 subsubsection {* Properties of @{text "rel_of"} and @{text "pred_of"} *}

   180 

   181 text {* The following lemmas establish bijectivity of the two functions *}

   182 

   183 lemma pred_rel_eq: "pred_of (rel_of r) = r" by (auto simp:rel_of_def pred_of_def)

   184 

   185 lemma rel_pred_eq: "rel_of (pred_of r) = r" by (auto simp:rel_of_def pred_of_def)

   186 

   187 lemma rel_of_star: "rel_of (r^**) = (rel_of r)^*"

   188   by (unfold rel_of_def rtranclp_rtrancl_eq, auto)

   189 

   190 lemma pred_of_star: "pred_of (r^*) = (pred_of r)^**"

   191 proof -

   192   { fix x y

   193     have "pred_of (r^*) x y = (pred_of r)^** x y"

   194     by (unfold pred_of_def rtranclp_rtrancl_eq, auto)

   195   } thus ?thesis by auto

   196 qed

   197 

   198 lemma star_2_pstar: "(x, y) \<in> r^* = (pred_of (r^*)) x y"

   199   by (simp add: pred_of_def)

   200 

   201 subsubsection {* Properties of @{text "rpath"} *}

   202 

   203 text {* Induction rule for @{text "rpath"}: *}

   204 

   205 lemma rpath_induct [consumes 1, case_names rbase rstep, induct pred: rpath]:

   206   assumes "rpath r x1 x2 x3"

   207     and "\<And>x. P x [] x"

   208     and "\<And>x y ys z. (x, y) \<in> r \<Longrightarrow> rpath r y ys z \<Longrightarrow> P y ys z \<Longrightarrow> P x (y # ys) z"

   209   shows "P x1 x2 x3"

   210   using assms[unfolded rpath_def]

   211   by (induct, auto simp:pred_of_def rpath_def)

   212 

   213 lemma rpathE: 

   214   assumes "rpath r x xs y"

   215   obtains (base) "y = x" "xs = []"

   216      | (step) z zs where "(x, z) \<in> r" "rpath r z zs y" "xs = z#zs"

   217   using assms

   218   by (induct, auto)

   219 

   220 text {* Introduction rule for empty path *}

   221 lemma rbaseI [intro!]: 

   222   assumes "x = y"

   223   shows "rpath r x [] y"

   224   by  (unfold rpath_def assms, 

   225          rule Transitive_Closure_Table.rtrancl_path.base)

   226 

   227 text {* Introduction rule for non-empty path *}

   228 lemma rstepI [intro!]: 

   229   assumes "(x, y) \<in> r"

   230     and "rpath r y ys z"

   231   shows "rpath r x (y#ys) z" 

   232 proof(unfold rpath_def, rule Transitive_Closure_Table.rtrancl_path.step)

   233   from assms(1) show "pred_of r x y" by (auto simp:pred_of_def)

   234 next

   235   from assms(2) show "rtrancl_path (pred_of r) y ys z"  

   236   by (auto simp:pred_of_def rpath_def)

   237 qed

   238 

   239 text {* Introduction rule for @{text "@"}-path *}

   240 lemma rpath_appendI [intro]: 

   241   assumes "rpath r x xs a" and "rpath r a ys y"

   242   shows "rpath r x (xs @ ys) y"

   243   using assms 

   244   by (unfold rpath_def, auto intro:rtrancl_path_trans)

   245 

   246 text {* Elimination rule for empty path *}

   247 

   248 lemma rpath_cases [cases pred:rpath]:

   249   assumes "rpath r a1 a2 a3"

   250   obtains (rbase)  "a1 = a3" and "a2 = []"

   251     | (rstep)  y :: "'a" and ys :: "'a list"  

   252          where "(a1, y) \<in> r" and "a2 = y # ys" and "rpath r y ys a3"

   253   using assms [unfolded rpath_def]

   254   by (cases, auto simp:rpath_def pred_of_def)

   255 

   256 lemma rpath_nilE [elim!, cases pred:rpath]: 

   257   assumes "rpath r x [] y"

   258   obtains "y = x"

   259   using assms[unfolded rpath_def] by auto

   260 

   261 -- {* This is a auxiliary lemmas used only in the proof of @{text "rpath_nnl_lastE"} *}

   262 lemma rpath_nnl_last:

   263   assumes "rtrancl_path r x xs y"

   264   and "xs \<noteq> []"

   265   obtains xs' where "xs = xs'@[y]"

   266 proof -

   267   from append_butlast_last_id[OF `xs \<noteq> []`, symmetric] 

   268   obtain xs' y' where eq_xs: "xs = (xs' @ y' # [])" by simp

   269   with assms(1)

   270   have "rtrancl_path r x ... y" by simp

   271   hence "y = y'" by (rule rtrancl_path_appendE, auto)

   272   with eq_xs have "xs = xs'@[y]" by simp

   273   from that[OF this] show ?thesis .

   274 qed

   275 

   276 text {*

   277   Elimination rule for non-empty paths constructed with @{text "#"}.

   278 *}

   279 

   280 lemma rpath_ConsE [elim!, cases pred:rpath]:

   281   assumes "rpath r x (y # ys) x2"

   282   obtains (rstep) "(x, y) \<in> r" and "rpath r y ys x2"

   283   using assms[unfolded rpath_def]

   284   by (cases, auto simp:rpath_def pred_of_def)

   285 

   286 text {*

   287   Elimination rule for non-empty path, where the destination node 

   288   @{text "y"} is shown to be at the end of the path.

   289 *}

   290 lemma rpath_nnl_lastE: 

   291   assumes "rpath r x xs y"

   292   and "xs \<noteq> []"

   293   obtains xs' where "xs = xs'@[y]"

   294   using assms[unfolded rpath_def]

   295   by (rule rpath_nnl_last, auto)

   296 

   297 text {* Other elimination rules of @{text "rpath"} *}

   298 

   299 lemma rpath_appendE:

   300   assumes "rpath r x (xs @ [a] @ ys) y"

   301   obtains "rpath r x (xs @ [a]) a" and "rpath r a ys y"

   302   using rtrancl_path_appendE[OF assms[unfolded rpath_def, simplified], folded rpath_def]

   303   by auto

   304 

   305 lemma rpath_subE: 

   306   assumes "rpath r x (xs @ [a] @ ys @ [b] @ zs) y"

   307   obtains "rpath r x (xs @ [a]) a" and "rpath r a (ys @ [b]) b" and "rpath r b zs y" 

   308   using assms

   309  by (elim rpath_appendE, auto)

   310 

   311 text {* Every path has a unique end point. *}

   312 lemma rpath_dest_eq:

   313   assumes "rpath r x xs x1"

   314   and "rpath r x xs x2"

   315   shows "x1 = x2"

   316   using assms

   317   by (induct, auto)

   318 

   319 subsubsection {* Properites of @{text "edges_on"} *}

   320 

   321 lemma edges_on_unfold:

   322   "edges_on (a # b # xs) = {(a, b)} \<union> edges_on (b # xs)" (is "?L = ?R")

   323 proof -

   324   { fix c d

   325     assume "(c, d) \<in> ?L"

   326     then obtain l1 l2 where h: "(a # b # xs) = l1 @ [c, d] @ l2" 

   327         by (auto simp:edges_on_def)

   328     have "(c, d) \<in> ?R"

   329     proof(cases "l1")

   330       case Nil

   331       with h have "(c, d) = (a, b)" by auto

   332       thus ?thesis by auto

   333     next

   334       case (Cons e es)

   335       from h[unfolded this] have "b#xs = es@[c, d]@l2" by auto

   336       thus ?thesis by (auto simp:edges_on_def)

   337     qed

   338   } moreover

   339   { fix c d

   340     assume "(c, d) \<in> ?R"

   341     moreover have "(a, b) \<in> ?L" 

   342     proof -

   343       have "(a # b # xs) = []@[a,b]@xs" by simp

   344       hence "\<exists> l1 l2. (a # b # xs) = l1@[a,b]@l2" by auto

   345       thus ?thesis by (unfold edges_on_def, simp)

   346     qed

   347     moreover {

   348         assume "(c, d) \<in> edges_on (b#xs)"

   349         then obtain l1 l2 where "b#xs = l1@[c, d]@l2" by (unfold edges_on_def, auto)

   350         hence "a#b#xs = (a#l1)@[c,d]@l2" by simp

   351         hence "\<exists> l1 l2. (a # b # xs) = l1@[c,d]@l2" by metis

   352         hence "(c,d) \<in> ?L" by (unfold edges_on_def, simp)

   353     }

   354     ultimately have "(c, d) \<in> ?L" by auto

   355   } ultimately show ?thesis by auto

   356 qed

   357 

   358 lemma edges_on_len:

   359   assumes "(a,b) \<in> edges_on l"

   360   shows "length l \<ge> 2"

   361   using assms

   362   by (unfold edges_on_def, auto)

   363 

   364 text {* Elimination of @{text "edges_on"} for non-empty path *}

   365 

   366 lemma edges_on_consE [elim, cases set:edges_on]:

   367   assumes "(a,b) \<in> edges_on (x#xs)"

   368   obtains (head)  xs' where "x = a" and "xs = b#xs'"

   369       |  (tail)  "(a,b) \<in> edges_on xs"

   370 proof -

   371   from assms obtain l1 l2 

   372   where h: "(x#xs) = l1 @ [a,b] @ l2" by (unfold edges_on_def, blast)

   373   have "(\<exists> xs'. x = a \<and> xs = b#xs') \<or> ((a,b) \<in> edges_on xs)"

   374   proof(cases "l1")

   375     case Nil with h 

   376     show ?thesis by auto

   377   next

   378     case (Cons e el)

   379     from h[unfolded this] 

   380     have "xs = el @ [a,b] @ l2" by auto

   381     thus ?thesis 

   382       by (unfold edges_on_def, auto)

   383   qed

   384   thus ?thesis 

   385   proof

   386     assume "(\<exists>xs'. x = a \<and> xs = b # xs')"

   387     then obtain xs' where "x = a" "xs = b#xs'" by blast

   388     from that(1)[OF this] show ?thesis .

   389   next

   390     assume "(a, b) \<in> edges_on xs"

   391     from that(2)[OF this] show ?thesis .

   392   qed

   393 qed

   394 

   395 text {*

   396   Every edges on the path is a graph edges:

   397 *}

   398 lemma rpath_edges_on:

   399   assumes "rpath r x xs y"

   400   shows "(edges_on (x#xs)) \<subseteq> r"

   401   using assms

   402 proof(induct arbitrary:y)

   403   case (rbase x)

   404   thus ?case by (unfold edges_on_def, auto)

   405 next

   406   case (rstep x y ys z)

   407   show ?case

   408   proof -

   409     { fix a b

   410       assume "(a, b) \<in> edges_on (x # y # ys)"

   411       hence "(a, b) \<in> r" by (cases, insert rstep, auto)

   412     } thus ?thesis by auto

   413   qed

   414 qed

   415 

   416 text {* @{text "edges_on"} is mono with respect to @{text "#"}-operation: *}

   417 lemma edges_on_Cons_mono:

   418    shows "edges_on xs \<subseteq> edges_on (x#xs)"

   419 proof -

   420   { fix a b

   421     assume "(a, b) \<in> edges_on xs"

   422     then obtain l1 l2 where "xs = l1 @ [a,b] @ l2" 

   423       by (auto simp:edges_on_def)

   424     hence "x # xs = (x#l1) @ [a, b] @ l2" by auto

   425     hence "(a, b) \<in> edges_on (x#xs)" 

   426       by (unfold edges_on_def, blast)

   427   } thus ?thesis by auto

   428 qed

   429 

   430 text {*

   431   The following rule @{text "rpath_transfer"} is used to show 

   432   that one path is intact as long as all the edges on it are intact

   433   with the change of graph.

   434 

   435   If @{text "x#xs"} is path in graph @{text "r1"} and 

   436   every edges along the path is also in @{text "r2"}, 

   437   then @{text "x#xs"} is also a edge in graph @{text "r2"}:

   438 *}

   439 

   440 lemma rpath_transfer:

   441   assumes "rpath r1 x xs y"

   442   and "edges_on (x#xs) \<subseteq> r2"

   443   shows "rpath r2 x xs y"

   444   using assms

   445 proof(induct)

   446   case (rstep x y ys z)

   447   show ?case 

   448   proof(rule rstepI)

   449     show "(x, y) \<in> r2"

   450     proof -

   451       have "(x, y) \<in> edges_on  (x # y # ys)"

   452           by (unfold edges_on_def, auto)

   453      with rstep(4) show ?thesis by auto

   454     qed

   455   next

   456     show "rpath r2 y ys z" 

   457      using rstep edges_on_Cons_mono[of "y#ys" "x"] by (auto)

   458   qed

   459 qed (unfold rpath_def, auto intro!:Transitive_Closure_Table.rtrancl_path.base)

   460 

   461 lemma edges_on_rpathI:

   462   assumes "edges_on (a#xs@[b]) \<subseteq> r"

   463   shows "rpath r a (xs@[b]) b"

   464   using assms

   465 proof(induct xs arbitrary: a b)

   466   case Nil

   467   moreover have "(a, b) \<in> edges_on (a # [] @ [b])"

   468       by (unfold edges_on_def, auto)

   469   ultimately have "(a, b) \<in> r" by auto

   470   thus ?case by auto

   471 next

   472   case (Cons x xs a b)

   473   from this(2) have "edges_on (x # xs @ [b]) \<subseteq> r" by (simp add:edges_on_unfold)

   474   from Cons(1)[OF this] have " rpath r x (xs @ [b]) b" .

   475   moreover from Cons(2) have "(a, x) \<in> r" by (auto simp:edges_on_unfold)

   476   ultimately show ?case by (auto)

   477 qed

   478 

   479 text {*

   480   The following lemma extracts the path from @{text "x"} to @{text "y"}

   481   from proposition @{text "(x, y) \<in> r^*"}

   482 *}

   483 lemma star_rpath:

   484   assumes "(x, y) \<in> r^*"

   485   obtains xs where "rpath r x xs y"

   486 proof -

   487   have "\<exists> xs. rpath r x xs y"

   488   proof(unfold rpath_def, rule iffD1[OF rtranclp_eq_rtrancl_path])

   489     from assms

   490     show "(pred_of r)\<^sup>*\<^sup>* x y"

   491       apply (fold pred_of_star)

   492       by (auto simp:pred_of_def)

   493   qed

   494   from that and this show ?thesis by blast

   495 qed

   496 

   497 text {*

   498   The following lemma uses the path @{text "xs"} from @{text "x"} to @{text "y"}

   499   as a witness to show @{text "(x, y) \<in> r^*"}.

   500 *}

   501 lemma rpath_star: 

   502   assumes "rpath r x xs y"

   503   shows "(x, y) \<in> r^*"

   504 proof -

   505   from iffD2[OF rtranclp_eq_rtrancl_path] and assms[unfolded rpath_def]

   506   have "(pred_of r)\<^sup>*\<^sup>* x y" by metis

   507   thus ?thesis by (simp add: pred_of_star star_2_pstar)

   508 qed  

   509 

   510 lemma subtree_transfer:

   511   assumes "a \<in> subtree r1 a'"

   512   and "r1 \<subseteq> r2"

   513   shows "a \<in> subtree r2 a'"

   514 proof -

   515   from assms(1)[unfolded subtree_def] 

   516   have "(a, a') \<in> r1^*" by auto

   517   from star_rpath[OF this]

   518   obtain xs where rp: "rpath r1 a xs a'" by blast

   519   hence "rpath r2 a xs a'"

   520   proof(rule rpath_transfer)

   521     from rpath_edges_on[OF rp] and assms(2)

   522     show "edges_on (a # xs) \<subseteq> r2" by simp

   523   qed

   524   from rpath_star[OF this]

   525   show ?thesis by (auto simp:subtree_def)

   526 qed

   527 

   528 lemma subtree_rev_transfer:

   529   assumes "a \<notin> subtree r2 a'"

   530   and "r1 \<subseteq> r2"

   531   shows "a \<notin> subtree r1 a'"

   532   using assms and subtree_transfer by metis

   533 

   534 text {*

   535   The following lemmas establishes a relation from paths in @{text "r"}

   536   to @{text "r^+"} relation.

   537 *}

   538 lemma rpath_plus: 

   539   assumes "rpath r x xs y"

   540   and "xs \<noteq> []"

   541   shows "(x, y) \<in> r^+"

   542 proof -

   543   from assms(2) obtain e es where "xs = e#es" by (cases xs, auto)

   544   from assms(1)[unfolded this]

   545   show ?thesis

   546   proof(cases)

   547     case rstep

   548     show ?thesis

   549     proof -

   550       from rpath_star[OF rstep(2)] have "(e, y) \<in> r\<^sup>*" .

   551       with rstep(1) show "(x, y) \<in> r^+" by auto

   552     qed

   553   qed

   554 qed

   555 

   556 lemma plus_rpath: 

   557   assumes "(x, y) \<in> r^+"

   558   obtains xs where "rpath r x xs y" and "xs \<noteq> []"

   559 proof -

   560   from assms

   561   show ?thesis

   562   proof(cases rule:converse_tranclE[consumes 1])

   563     case 1

   564     hence "rpath r x [y] y" by auto

   565     from that[OF this] show ?thesis by auto

   566   next

   567     case (2 z)

   568     from 2(2) have "(z, y) \<in> r^*" by auto

   569     from star_rpath[OF this] obtain xs where "rpath r z xs y" by auto

   570     from rstepI[OF 2(1) this]

   571     have "rpath r x (z # xs) y" .

   572     from that[OF this] show ?thesis by auto

   573   qed

   574 qed

   575 

   576 subsubsection {* Properties of @{text "subtree"} and @{term "ancestors"}*}

   577 

   578 lemma ancestors_subtreeI:

   579   assumes "b \<in> ancestors r a"

   580   shows "a \<in> subtree r b"

   581   using assms by (auto simp:subtree_def ancestors_def)

   582 

   583 lemma ancestors_Field:

   584   assumes "b \<in> ancestors r a"

   585   obtains "a \<in> Domain r" "b \<in> Range r"

   586   using assms 

   587   apply (unfold ancestors_def, simp)

   588   by (metis Domain.DomainI Range.intros trancl_domain trancl_range)

   589 

   590 lemma subtreeE:

   591   assumes "a \<in> subtree r b"

   592   obtains "a = b"

   593       | "a \<noteq> b" and "b \<in> ancestors r a"

   594 proof -

   595   from assms have "(a, b) \<in> r^*" by (auto simp:subtree_def)

   596   from rtranclD[OF this]

   597   have " a = b \<or> a \<noteq> b \<and> (a, b) \<in> r\<^sup>+" .

   598   with that[unfolded ancestors_def] show ?thesis by auto

   599 qed

   600 

   601 

   602 lemma subtree_Field:

   603   "subtree r x \<subseteq> Field r \<union> {x}"

   604 proof

   605   fix y

   606   assume "y \<in> subtree r x"

   607   thus "y \<in> Field r \<union> {x}"

   608   proof(cases rule:subtreeE)

   609     case 1

   610     thus ?thesis by auto

   611   next

   612     case 2

   613     thus ?thesis apply (auto simp:ancestors_def)

   614     using Field_def tranclD by fastforce 

   615   qed

   616 qed

   617 

   618 lemma subtree_ancestorsI:

   619   assumes "a \<in> subtree r b"

   620   and "a \<noteq> b"

   621   shows "b \<in> ancestors r a"

   622   using assms

   623   by (auto elim!:subtreeE)

   624 

   625 text {*

   626   @{text "subtree"} is mono with respect to the underlying graph.

   627 *}

   628 lemma subtree_mono:

   629   assumes "r1 \<subseteq> r2"

   630   shows "subtree r1 x \<subseteq> subtree r2 x"

   631 proof

   632   fix c

   633   assume "c \<in> subtree r1 x"

   634   hence "(c, x) \<in> r1^*" by (auto simp:subtree_def)

   635   from star_rpath[OF this] obtain xs 

   636   where rp:"rpath r1 c xs x" by metis

   637   hence "rpath r2 c xs x"

   638   proof(rule rpath_transfer)

   639     from rpath_edges_on[OF rp] have "edges_on (c # xs) \<subseteq> r1" .

   640     with assms show "edges_on (c # xs) \<subseteq> r2" by auto

   641   qed

   642   thus "c \<in> subtree r2 x"

   643     by (rule rpath_star[elim_format], auto simp:subtree_def)

   644 qed

   645 

   646 text {*

   647   The following lemma characterizes the change of sub-tree of @{text "x"}

   648   with the removal of an outside edge @{text "(a,b)"}. 

   649 

   650   Note that, according to lemma @{thm edges_in_refutation}, the assumption

   651   @{term "b \<notin> subtree r x"} amounts to saying @{text "(a, b)"} 

   652   is outside the sub-tree of @{text "x"}.

   653 *}

   654 lemma subtree_del_outside: (* ddd *)

   655     assumes "b \<notin> subtree r x" 

   656     shows "subtree (r - {(a, b)}) x = (subtree r x)" 

   657 proof -

   658   { fix c

   659     assume "c \<in> (subtree r x)"

   660     hence "(c, x) \<in> r^*" by (auto simp:subtree_def)

   661     hence "c \<in> subtree (r - {(a, b)}) x"

   662     proof(rule star_rpath)

   663       fix xs

   664       assume rp: "rpath r c xs x"

   665       show ?thesis

   666       proof -

   667         from rp

   668         have "rpath  (r - {(a, b)}) c xs x"

   669         proof(rule rpath_transfer)

   670           from rpath_edges_on[OF rp] have "edges_on (c # xs) \<subseteq> r" .

   671           moreover have "(a, b) \<notin> edges_on (c#xs)"

   672           proof

   673             assume "(a, b) \<in> edges_on (c # xs)"

   674             then obtain l1 l2 where h: "c#xs = l1@[a,b]@l2" by (auto simp:edges_on_def)

   675             hence "tl (c#xs) = tl (l1@[a,b]@l2)" by simp

   676             then obtain l1' where eq_xs_b: "xs = l1'@[b]@l2" by (cases l1, auto)

   677             from rp[unfolded this]

   678             show False

   679             proof(rule rpath_appendE)

   680               assume "rpath r b l2 x"

   681               thus ?thesis

   682               by(rule rpath_star[elim_format], insert assms(1), auto simp:subtree_def)

   683             qed

   684           qed

   685           ultimately show "edges_on (c # xs) \<subseteq> r - {(a,b)}" by auto

   686         qed

   687         thus ?thesis by (rule rpath_star[elim_format], auto simp:subtree_def)

   688       qed

   689     qed

   690   } moreover {

   691     fix c

   692     assume "c \<in> subtree (r - {(a, b)}) x"

   693     moreover have "... \<subseteq> (subtree r x)" by (rule subtree_mono, auto)

   694     ultimately have "c \<in> (subtree r x)" by auto

   695   } ultimately show ?thesis by auto

   696 qed

   697 

   698 (* ddd *)

   699 lemma subset_del_subtree_outside: (* ddd *)

   700     assumes "Range r' \<inter> subtree r x = {}" 

   701     shows "subtree (r - r') x = (subtree r x)" 

   702 proof -

   703   { fix c

   704     assume "c \<in> (subtree r x)"

   705     hence "(c, x) \<in> r^*" by (auto simp:subtree_def)

   706     hence "c \<in> subtree (r - r') x"

   707     proof(rule star_rpath)

   708       fix xs

   709       assume rp: "rpath r c xs x"

   710       show ?thesis

   711       proof -

   712         from rp

   713         have "rpath  (r - r') c xs x"

   714         proof(rule rpath_transfer)

   715           from rpath_edges_on[OF rp] have "edges_on (c # xs) \<subseteq> r" .

   716           moreover {

   717               fix a b

   718               assume h: "(a, b) \<in> r'"

   719               have "(a, b) \<notin> edges_on (c#xs)"

   720               proof

   721                 assume "(a, b) \<in> edges_on (c # xs)"

   722                 then obtain l1 l2 where "c#xs = (l1@[a])@[b]@l2" by (auto simp:edges_on_def)

   723                 hence "tl (c#xs) = tl (l1@[a,b]@l2)" by simp

   724                 then obtain l1' where eq_xs_b: "xs = l1'@[b]@l2" by (cases l1, auto)

   725                 from rp[unfolded this]

   726                 show False

   727                 proof(rule rpath_appendE)

   728                   assume "rpath r b l2 x"

   729                   from rpath_star[OF this]

   730                   have "b \<in> subtree r x" by (auto simp:subtree_def)

   731                   with assms (1) and h show ?thesis by (auto)

   732                 qed

   733              qed

   734          } ultimately show "edges_on (c # xs) \<subseteq> r - r'" by auto

   735         qed

   736         thus ?thesis by (rule rpath_star[elim_format], auto simp:subtree_def)

   737       qed

   738     qed

   739   } moreover {

   740     fix c

   741     assume "c \<in> subtree (r - r') x"

   742     moreover have "... \<subseteq> (subtree r x)" by (rule subtree_mono, auto)

   743     ultimately have "c \<in> (subtree r x)" by auto

   744   } ultimately show ?thesis by auto

   745 qed

   746 

   747 lemma subtree_insert_ext:

   748     assumes "b \<in> subtree r x"

   749     shows "subtree (r \<union> {(a, b)}) x = (subtree r x) \<union> (subtree r a)" 

   750     using assms by (auto simp:subtree_def rtrancl_insert)

   751 

   752 lemma subtree_insert_next:

   753     assumes "b \<notin> subtree r x"

   754     shows "subtree (r \<union> {(a, b)}) x = (subtree r x)" 

   755     using assms

   756     by (auto simp:subtree_def rtrancl_insert)

   757 

   758 lemma set_add_rootI:

   759   assumes "root r a"

   760   and "a \<notin> Domain r1"

   761   shows "root (r \<union> r1) a"

   762 proof -

   763   let ?r = "r \<union> r1"

   764   { fix a'

   765     assume "a' \<in> ancestors ?r a"

   766     hence "(a, a') \<in> ?r^+" by (auto simp:ancestors_def)

   767     from tranclD[OF this] obtain z where "(a, z) \<in> ?r" by auto

   768     moreover have "(a, z) \<notin> r"

   769     proof

   770       assume "(a, z) \<in> r"

   771       with assms(1) show False 

   772         by (auto simp:root_def ancestors_def)

   773     qed

   774     ultimately have "(a, z) \<in> r1" by auto

   775     with assms(2) 

   776     have False by (auto)

   777   } thus ?thesis by (auto simp:root_def)

   778 qed

   779 

   780 lemma ancestors_mono:

   781   assumes "r1 \<subseteq> r2"

   782   shows "ancestors r1 x \<subseteq> ancestors r2 x"

   783 proof

   784  fix a

   785  assume "a \<in> ancestors r1 x"

   786  hence "(x, a) \<in> r1^+" by (auto simp:ancestors_def)

   787  from plus_rpath[OF this] obtain xs where 

   788     h: "rpath r1 x xs a" "xs \<noteq> []" .

   789  have "rpath r2 x xs a"

   790  proof(rule rpath_transfer[OF h(1)])

   791   from rpath_edges_on[OF h(1)] and assms

   792   show "edges_on (x # xs) \<subseteq> r2" by auto

   793  qed

   794  from rpath_plus[OF this h(2)]

   795  show "a \<in> ancestors r2 x" by (auto simp:ancestors_def)

   796 qed

   797 

   798 lemma subtree_refute:

   799   assumes "x \<notin> ancestors r y"

   800   and "x \<noteq> y"

   801   shows "y \<notin> subtree r x"

   802 proof

   803    assume "y \<in> subtree r x"

   804    thus False

   805      by(elim subtreeE, insert assms, auto)

   806 qed

   807 

   808 subsubsection {* Properties about relational trees *}

   809 

   810 context rtree 

   811 begin

   812 

   813 lemma ancestors_headE:

   814   assumes "c \<in> ancestors r a"

   815   assumes "(a, b) \<in> r"

   816   obtains "b = c"

   817      |   "c \<in> ancestors r b"

   818 proof -

   819   from assms(1) 

   820   have "(a, c) \<in> r^+" by (auto simp:ancestors_def)

   821   hence "b = c \<or> c \<in> ancestors r b"

   822   proof(cases rule:converse_tranclE[consumes 1])

   823     case 1

   824     with assms(2) and sgv have "b = c" by (auto simp:single_valued_def)

   825     thus ?thesis by auto

   826   next

   827     case (2 y)

   828     from 2(1) and assms(2) and sgv have "y = b" by (auto simp:single_valued_def)

   829     from 2(2)[unfolded this] have "c \<in> ancestors r b" by (auto simp:ancestors_def)

   830     thus ?thesis by auto

   831   qed

   832   with that show ?thesis by metis

   833 qed

   834 

   835 lemma ancestors_accum:

   836   assumes "(a, b) \<in> r"

   837   shows "ancestors r a = ancestors r b \<union> {b}"

   838 proof -

   839   { fix c

   840     assume "c \<in> ancestors r a"

   841     hence "(a, c) \<in> r^+" by (auto simp:ancestors_def)

   842     hence "c \<in> ancestors r b \<union> {b}"

   843     proof(cases rule:converse_tranclE[consumes 1])

   844       case 1

   845       with sgv assms have "c = b" by (unfold single_valued_def, auto)

   846       thus ?thesis by auto

   847     next

   848       case (2 c')

   849       with sgv assms have "c' = b" by (unfold single_valued_def, auto)

   850       from 2(2)[unfolded this]

   851       show ?thesis by (auto simp:ancestors_def)

   852     qed

   853   } moreover {

   854     fix c

   855     assume "c \<in> ancestors r b \<union> {b}"

   856     hence "c = b \<or> c \<in> ancestors r b" by auto

   857     hence "c \<in> ancestors r a"

   858     proof

   859       assume "c = b"

   860       from assms[folded this] 

   861       show ?thesis by (auto simp:ancestors_def)

   862     next

   863       assume "c \<in> ancestors r b"

   864       with assms show ?thesis by (auto simp:ancestors_def)

   865     qed

   866   } ultimately show ?thesis by auto

   867 qed

   868 

   869 lemma rootI:

   870   assumes h: "\<And> x'. x' \<noteq> x \<Longrightarrow> x \<notin> subtree r' x'"

   871   and "r' \<subseteq> r"

   872   shows "root r' x"

   873 proof -

   874   from acyclic_subset[OF acl assms(2)]

   875   have acl': "acyclic r'" .

   876   { fix x'

   877     assume "x' \<in> ancestors r' x"

   878     hence h1: "(x, x') \<in> r'^+" by (auto simp:ancestors_def)

   879     have "x' \<noteq> x"

   880     proof

   881       assume eq_x: "x' = x"

   882       from h1[unfolded this] and acl'

   883       show False by (auto simp:acyclic_def)

   884     qed

   885     moreover from h1 have "x \<in> subtree r' x'" by (auto simp:subtree_def)

   886     ultimately have False using h by auto

   887   } thus ?thesis by (auto simp:root_def)

   888 qed

   889 

   890 lemma rpath_overlap_oneside: (* ddd *)

   891   assumes "rpath r x xs1 x1" (* ccc *)

   892   and "rpath r x xs2 x2"

   893   and "length xs1 \<le> length xs2"

   894   obtains xs3 where 

   895     "xs2 = xs1 @ xs3" "rpath r x xs1 x1" "rpath r x1 xs3 x2"

   896 proof(cases "xs1 = []")

   897   case True

   898   with that show ?thesis by auto

   899 next

   900   case False

   901   have "\<forall> i \<le> length xs1. take i xs1 = take i xs2"

   902   proof -

   903      { assume "\<not> (\<forall> i \<le> length xs1. take i xs1 = take i xs2)"

   904        then obtain i where "i \<le> length xs1 \<and> take i xs1 \<noteq> take i xs2" by auto

   905        from this(1) have "False"

   906        proof(rule index_minimize)

   907           fix j

   908           assume h1: "j \<le> length xs1 \<and> take j xs1 \<noteq> take j xs2"

   909           and h2: " \<forall>k<j. \<not> (k \<le> length xs1 \<and> take k xs1 \<noteq> take k xs2)"

   910           -- {* @{text "j - 1"} is the branch point between @{text "xs1"} and @{text "xs2"} *}

   911           let ?idx = "j - 1"

   912           -- {* A number of inequalities concerning @{text "j - 1"} are derived first *}

   913           have lt_i: "?idx < length xs1" using False h1 

   914             by (metis Suc_diff_1 le_neq_implies_less length_greater_0_conv lessI less_imp_diff_less)

   915           have lt_i': "?idx < length xs2" using lt_i and assms(3) by auto

   916           have lt_j: "?idx < j" using h1 by (cases j, auto)

   917           -- {* From thesis inequalities, a number of equations concerning @{text "xs1"}

   918                  and @{text "xs2"} are derived *}

   919           have eq_take: "take ?idx xs1 = take ?idx xs2"

   920             using h2[rule_format, OF lt_j] and h1 by auto

   921           have eq_xs1: " xs1 = take ?idx xs1 @ xs1 ! (?idx) # drop (Suc (?idx)) xs1" 

   922             using id_take_nth_drop[OF lt_i] .

   923           have eq_xs2: "xs2 = take ?idx xs2 @ xs2 ! (?idx) # drop (Suc (?idx)) xs2" 

   924               using id_take_nth_drop[OF lt_i'] .

   925           -- {* The branch point along the path is finally pinpointed *}

   926           have neq_idx: "xs1!?idx \<noteq> xs2!?idx" 

   927           proof -

   928             have "take j xs1 = take ?idx xs1 @ [xs1 ! ?idx]"

   929                 using eq_xs1 Suc_diff_1 lt_i lt_j take_Suc_conv_app_nth by fastforce 

   930             moreover have eq_tk2: "take j xs2 = take ?idx xs2 @ [xs2 ! ?idx]"

   931                 using Suc_diff_1 lt_i' lt_j take_Suc_conv_app_nth by fastforce 

   932             ultimately show ?thesis using eq_take h1 by auto

   933           qed

   934           show ?thesis

   935           proof(cases " take (j - 1) xs1 = []")

   936             case True

   937             have "(x, xs1!?idx) \<in> r"

   938             proof -

   939                 from eq_xs1[unfolded True, simplified, symmetric] assms(1) 

   940                 have "rpath r x ( xs1 ! ?idx # drop (Suc ?idx) xs1) x1" by simp

   941                 from this[unfolded rpath_def]

   942                 show ?thesis by (auto simp:pred_of_def)

   943             qed

   944             moreover have "(x, xs2!?idx) \<in> r"

   945             proof -

   946               from eq_xs2[folded eq_take, unfolded True, simplified, symmetric] assms(2)

   947               have "rpath r x ( xs2 ! ?idx # drop (Suc ?idx) xs2) x2" by simp

   948               from this[unfolded rpath_def]

   949               show ?thesis by (auto simp:pred_of_def)

   950             qed

   951             ultimately show ?thesis using neq_idx sgv[unfolded single_valued_def] by metis

   952         next

   953            case False

   954            then obtain e es where eq_es: "take ?idx xs1 = es@[e]" 

   955             using rev_exhaust by blast 

   956            have "(e, xs1!?idx) \<in> r"

   957            proof -

   958             from eq_xs1[unfolded eq_es] 

   959             have "xs1 = es@[e, xs1!?idx]@drop (Suc ?idx) xs1" by simp

   960             hence "(e, xs1!?idx) \<in> edges_on xs1" by (simp add:edges_on_def, metis)

   961             with rpath_edges_on[OF assms(1)] edges_on_Cons_mono[of xs1 x]

   962             show ?thesis by auto

   963            qed moreover have "(e, xs2!?idx) \<in> r"

   964            proof -

   965             from eq_xs2[folded eq_take, unfolded eq_es]

   966             have "xs2 = es@[e, xs2!?idx]@drop (Suc ?idx) xs2" by simp

   967             hence "(e, xs2!?idx) \<in> edges_on xs2" by (simp add:edges_on_def, metis)

   968             with rpath_edges_on[OF assms(2)] edges_on_Cons_mono[of xs2 x]

   969             show ?thesis by auto

   970            qed

   971            ultimately show ?thesis 

   972               using sgv[unfolded single_valued_def] neq_idx by metis

   973         qed

   974        qed

   975      } thus ?thesis by auto

   976   qed

   977   from this[rule_format, of "length xs1"]

   978   have "take (length xs1) xs1 = take (length xs1) xs2" by simp

   979   moreover have "xs2 = take (length xs1) xs2 @ drop (length xs1) xs2" by simp

   980   ultimately have "xs2 = xs1 @ drop (length xs1) xs2" by auto

   981   from that[OF this] show ?thesis .

   982 qed

   983 

   984 lemma rpath_overlap_oneside: (* ddd *)

   985   assumes "rpath r x xs1 x1"

   986   and "rpath r x xs2 x2"

   987   and "length xs1 \<le> length xs2"

   988   obtains xs3 where "xs2 = xs1 @ xs3"

   989 proof(cases "xs1 = []")

   990   case True

   991   with that show ?thesis by auto

   992 next

   993   case False

   994   have "\<forall> i \<le> length xs1. take i xs1 = take i xs2"

   995   proof -

   996      { assume "\<not> (\<forall> i \<le> length xs1. take i xs1 = take i xs2)"

   997        then obtain i where "i \<le> length xs1 \<and> take i xs1 \<noteq> take i xs2" by auto

   998        from this(1) have "False"

   999        proof(rule index_minimize)

  1000           fix j

  1001           assume h1: "j \<le> length xs1 \<and> take j xs1 \<noteq> take j xs2"

  1002           and h2: " \<forall>k<j. \<not> (k \<le> length xs1 \<and> take k xs1 \<noteq> take k xs2)"

  1003           -- {* @{text "j - 1"} is the branch point between @{text "xs1"} and @{text "xs2"} *}

  1004           let ?idx = "j - 1"

  1005           -- {* A number of inequalities concerning @{text "j - 1"} are derived first *}

  1006           have lt_i: "?idx < length xs1" using False h1 

  1007             by (metis Suc_diff_1 le_neq_implies_less length_greater_0_conv lessI less_imp_diff_less)

  1008           have lt_i': "?idx < length xs2" using lt_i and assms(3) by auto

  1009           have lt_j: "?idx < j" using h1 by (cases j, auto)

  1010           -- {* From thesis inequalities, a number of equations concerning @{text "xs1"}

  1011                  and @{text "xs2"} are derived *}

  1012           have eq_take: "take ?idx xs1 = take ?idx xs2"

  1013             using h2[rule_format, OF lt_j] and h1 by auto

  1014           have eq_xs1: " xs1 = take ?idx xs1 @ xs1 ! (?idx) # drop (Suc (?idx)) xs1" 

  1015             using id_take_nth_drop[OF lt_i] .

  1016           have eq_xs2: "xs2 = take ?idx xs2 @ xs2 ! (?idx) # drop (Suc (?idx)) xs2" 

  1017               using id_take_nth_drop[OF lt_i'] .

  1018           -- {* The branch point along the path is finally pinpointed *}

  1019           have neq_idx: "xs1!?idx \<noteq> xs2!?idx" 

  1020           proof -

  1021             have "take j xs1 = take ?idx xs1 @ [xs1 ! ?idx]"

  1022                 using eq_xs1 Suc_diff_1 lt_i lt_j take_Suc_conv_app_nth by fastforce 

  1023             moreover have eq_tk2: "take j xs2 = take ?idx xs2 @ [xs2 ! ?idx]"

  1024                 using Suc_diff_1 lt_i' lt_j take_Suc_conv_app_nth by fastforce 

  1025             ultimately show ?thesis using eq_take h1 by auto

  1026           qed

  1027           show ?thesis

  1028           proof(cases " take (j - 1) xs1 = []")

  1029             case True

  1030             have "(x, xs1!?idx) \<in> r"

  1031             proof -

  1032                 from eq_xs1[unfolded True, simplified, symmetric] assms(1) 

  1033                 have "rpath r x ( xs1 ! ?idx # drop (Suc ?idx) xs1) x1" by simp

  1034                 from this[unfolded rpath_def]

  1035                 show ?thesis by (auto simp:pred_of_def)

  1036             qed

  1037             moreover have "(x, xs2!?idx) \<in> r"

  1038             proof -

  1039               from eq_xs2[folded eq_take, unfolded True, simplified, symmetric] assms(2)

  1040               have "rpath r x ( xs2 ! ?idx # drop (Suc ?idx) xs2) x2" by simp

  1041               from this[unfolded rpath_def]

  1042               show ?thesis by (auto simp:pred_of_def)

  1043             qed

  1044             ultimately show ?thesis using neq_idx sgv[unfolded single_valued_def] by metis

  1045         next

  1046            case False

  1047            then obtain e es where eq_es: "take ?idx xs1 = es@[e]" 

  1048             using rev_exhaust by blast 

  1049            have "(e, xs1!?idx) \<in> r"

  1050            proof -

  1051             from eq_xs1[unfolded eq_es] 

  1052             have "xs1 = es@[e, xs1!?idx]@drop (Suc ?idx) xs1" by simp

  1053             hence "(e, xs1!?idx) \<in> edges_on xs1" by (simp add:edges_on_def, metis)

  1054             with rpath_edges_on[OF assms(1)] edges_on_Cons_mono[of xs1 x]

  1055             show ?thesis by auto

  1056            qed moreover have "(e, xs2!?idx) \<in> r"

  1057            proof -

  1058             from eq_xs2[folded eq_take, unfolded eq_es]

  1059             have "xs2 = es@[e, xs2!?idx]@drop (Suc ?idx) xs2" by simp

  1060             hence "(e, xs2!?idx) \<in> edges_on xs2" by (simp add:edges_on_def, metis)

  1061             with rpath_edges_on[OF assms(2)] edges_on_Cons_mono[of xs2 x]

  1062             show ?thesis by auto

  1063            qed

  1064            ultimately show ?thesis 

  1065               using sgv[unfolded single_valued_def] neq_idx by metis

  1066         qed

  1067        qed

  1068      } thus ?thesis by auto

  1069   qed

  1070   from this[rule_format, of "length xs1"]

  1071   have "take (length xs1) xs1 = take (length xs1) xs2" by simp

  1072   moreover have "xs2 = take (length xs1) xs2 @ drop (length xs1) xs2" by simp

  1073   ultimately have "xs2 = xs1 @ drop (length xs1) xs2" by auto

  1074   from that[OF this] show ?thesis .

  1075 qed

  1076 

  1077 lemma rpath_overlap [consumes 2, cases pred:rpath]:

  1078   assumes "rpath r x xs1 x1"

  1079   and "rpath r x xs2 x2"

  1080   obtains (less_1) xs3 where "xs2 = xs1 @ xs3"

  1081      |    (less_2) xs3 where "xs1 = xs2 @ xs3"

  1082 proof -

  1083   have "length xs1 \<le> length xs2 \<or> length xs2 \<le> length xs1" by auto

  1084   with assms rpath_overlap_oneside that show ?thesis by metis

  1085 qed

  1086 

  1087 text {*

  1088   As a corollary of @{thm "rpath_overlap_oneside"}, 

  1089   the following two lemmas gives one important property of relation tree, 

  1090   i.e. there is at most one path between any two nodes.

  1091   Similar to the proof of @{thm rpath_overlap}, we starts with

  1092   the one side version first.

  1093 *}

  1094 

  1095 lemma rpath_unique_oneside:

  1096   assumes "rpath r x xs1 y"

  1097     and "rpath r x xs2 y"

  1098     and "length xs1 \<le> length xs2"

  1099   shows "xs1 = xs2"

  1100 proof -

  1101   from rpath_overlap_oneside[OF assms] 

  1102   obtain xs3 where less_1: "xs2 = xs1 @ xs3" by blast

  1103   show ?thesis

  1104   proof(cases "xs3 = []") 

  1105     case True

  1106     from less_1[unfolded this] show ?thesis by simp

  1107   next

  1108     case False

  1109     note FalseH = this

  1110     show ?thesis

  1111     proof(cases "xs1 = []")

  1112       case True

  1113       have "(x, x) \<in> r^+"

  1114       proof(rule rpath_plus)

  1115         from assms(1)[unfolded True] 

  1116         have "y = x" by (cases rule:rpath_nilE, simp)

  1117         from assms(2)[unfolded this] show "rpath r x xs2 x" .

  1118       next

  1119         from less_1 and False show "xs2 \<noteq> []" by simp

  1120       qed

  1121       with acl show ?thesis by (unfold acyclic_def, auto)

  1122     next 

  1123       case False

  1124       then obtain e es where eq_xs1: "xs1 = es@[e]" using rev_exhaust by auto

  1125       from assms(2)[unfolded less_1 this]

  1126       have "rpath r x (es @ [e] @ xs3) y" by simp

  1127       thus ?thesis

  1128       proof(cases rule:rpath_appendE)

  1129         case 1

  1130         from rpath_dest_eq [OF 1(1)[folded eq_xs1] assms(1)]

  1131         have "e = y" .

  1132         from rpath_plus [OF 1(2)[unfolded this] FalseH]

  1133         have "(y, y) \<in> r^+" .

  1134         with acl show ?thesis by (unfold acyclic_def, auto)

  1135       qed