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 proof -

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

   159   using assms

   160   proof(induct i rule:less_induct)

   161     case (less t)

   162     show ?case

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

   164       case True

   165       with less (2) show ?thesis by blast

   166     next

   167       case False

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

   169       from less(1)[OF this]

   170       show ?thesis .

   171     qed

   172   qed 

   173   with that show ?thesis by metis

   174 qed

   175 

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

   177 

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

   179 

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

   181 

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

   183 

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

   185 

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

   187   by (unfold rel_of_def rtranclp_rtrancl_eq, auto)

   188 

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

   190 proof -

   191   { fix x y

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

   193     by (unfold pred_of_def rtranclp_rtrancl_eq, auto)

   194   } thus ?thesis by auto

   195 qed

   196 

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

   198   by (simp add: pred_of_def)

   199 

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

   201 

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

   203 

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

   205   assumes "rpath r x1 x2 x3"

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

   207     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"

   208   shows "P x1 x2 x3"

   209   using assms[unfolded rpath_def]

   210   by (induct, auto simp:pred_of_def rpath_def)

   211 

   212 lemma rpathE: 

   213   assumes "rpath r x xs y"

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

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

   216   using assms

   217   by (induct, auto)

   218 

   219 text {* Introduction rule for empty path *}

   220 lemma rbaseI [intro!]: 

   221   assumes "x = y"

   222   shows "rpath r x [] y"

   223   by  (unfold rpath_def assms, 

   224          rule Transitive_Closure_Table.rtrancl_path.base)

   225 

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

   227 lemma rstepI [intro!]: 

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

   229     and "rpath r y ys z"

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

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

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

   233 next

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

   235   by (auto simp:pred_of_def rpath_def)

   236 qed

   237 

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

   239 lemma rpath_appendI [intro]: 

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

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

   242   using assms 

   243   by (unfold rpath_def, auto intro:rtrancl_path_trans)

   244 

   245 text {* Elimination rule for empty path *}

   246 

   247 lemma rpath_cases [cases pred:rpath]:

   248   assumes "rpath r a1 a2 a3"

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

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

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

   252   using assms [unfolded rpath_def]

   253   by (cases, auto simp:rpath_def pred_of_def)

   254 

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

   256   assumes "rpath r x [] y"

   257   obtains "y = x"

   258   using assms[unfolded rpath_def] by auto

   259 

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

   261 lemma rpath_nnl_last:

   262   assumes "rtrancl_path r x xs y"

   263   and "xs \<noteq> []"

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

   265 proof -

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

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

   268   with assms(1)

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

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

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

   272   from that[OF this] show ?thesis .

   273 qed

   274 

   275 text {*

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

   277 *}

   278 

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

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

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

   282   using assms[unfolded rpath_def]

   283   by (cases, auto simp:rpath_def pred_of_def)

   284 

   285 text {*

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

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

   288 *}

   289 lemma rpath_nnl_lastE: 

   290   assumes "rpath r x xs y"

   291   and "xs \<noteq> []"

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

   293   using assms[unfolded rpath_def]

   294   by (rule rpath_nnl_last, auto)

   295 

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

   297 

   298 lemma rpath_appendE:

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

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

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

   302   by auto

   303 

   304 lemma rpath_subE: 

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

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

   307   using assms

   308  by (elim rpath_appendE, auto)

   309 

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

   311 lemma rpath_dest_eq:

   312   assumes "rpath r x xs x1"

   313   and "rpath r x xs x2"

   314   shows "x1 = x2"

   315   using assms

   316   by (induct, auto)

   317 

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

   319 

   320 lemma edges_on_unfold:

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

   322 proof -

   323   { fix c d

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

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

   326         by (auto simp:edges_on_def)

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

   328     proof(cases "l1")

   329       case Nil

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

   331       thus ?thesis by auto

   332     next

   333       case (Cons e es)

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

   335       thus ?thesis by (auto simp:edges_on_def)

   336     qed

   337   } moreover

   338   { fix c d

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

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

   341     proof -

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

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

   344       thus ?thesis by (unfold edges_on_def, simp)

   345     qed

   346     moreover {

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

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

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

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

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

   352     }

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

   354   } ultimately show ?thesis by auto

   355 qed

   356 

   357 lemma edges_on_len:

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

   359   shows "length l \<ge> 2"

   360   using assms

   361   by (unfold edges_on_def, auto)

   362 

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

   364 

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

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

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

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

   369 proof -

   370   from assms obtain l1 l2 

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

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

   373   proof(cases "l1")

   374     case Nil with h 

   375     show ?thesis by auto

   376   next

   377     case (Cons e el)

   378     from h[unfolded this] 

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

   380     thus ?thesis 

   381       by (unfold edges_on_def, auto)

   382   qed

   383   thus ?thesis 

   384   proof

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

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

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

   388   next

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

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

   391   qed

   392 qed

   393 

   394 text {*

   395   Every edges on the path is a graph edges:

   396 *}

   397 lemma rpath_edges_on:

   398   assumes "rpath r x xs y"

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

   400   using assms

   401 proof(induct arbitrary:y)

   402   case (rbase x)

   403   thus ?case by (unfold edges_on_def, auto)

   404 next

   405   case (rstep x y ys z)

   406   show ?case

   407   proof -

   408     { fix a b

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

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

   411     } thus ?thesis by auto

   412   qed

   413 qed

   414 

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

   416 lemma edges_on_Cons_mono:

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

   418 proof -

   419   { fix a b

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

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

   422       by (auto simp:edges_on_def)

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

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

   425       by (unfold edges_on_def, blast)

   426   } thus ?thesis by auto

   427 qed

   428 

   429 text {*

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

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

   432   with the change of graph.

   433 

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

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

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

   437 *}

   438 

   439 lemma rpath_transfer:

   440   assumes "rpath r1 x xs y"

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

   442   shows "rpath r2 x xs y"

   443   using assms

   444 proof(induct)

   445   case (rstep x y ys z)

   446   show ?case 

   447   proof(rule rstepI)

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

   449     proof -

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

   451           by (unfold edges_on_def, auto)

   452      with rstep(4) show ?thesis by auto

   453     qed

   454   next

   455     show "rpath r2 y ys z" 

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

   457   qed

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

   459 

   460 lemma edges_on_rpathI:

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

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

   463   using assms

   464 proof(induct xs arbitrary: a b)

   465   case Nil

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

   467       by (unfold edges_on_def, auto)

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

   469   thus ?case by auto

   470 next

   471   case (Cons x xs a b)

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

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

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

   475   ultimately show ?case by (auto)

   476 qed

   477 

   478 text {*

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

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

   481 *}

   482 lemma star_rpath:

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

   484   obtains xs where "rpath r x xs y"

   485 proof -

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

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

   488     from assms

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

   490       apply (fold pred_of_star)

   491       by (auto simp:pred_of_def)

   492   qed

   493   from that and this show ?thesis by blast

   494 qed

   495 

   496 text {*

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

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

   499 *}

   500 lemma rpath_star: 

   501   assumes "rpath r x xs y"

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

   503 proof -

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

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

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

   507 qed  

   508 

   509 lemma subtree_transfer:

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

   511   and "r1 \<subseteq> r2"

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

   513 proof -

   514   from assms(1)[unfolded subtree_def] 

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

   516   from star_rpath[OF this]

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

   518   hence "rpath r2 a xs a'"

   519   proof(rule rpath_transfer)

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

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

   522   qed

   523   from rpath_star[OF this]

   524   show ?thesis by (auto simp:subtree_def)

   525 qed

   526 

   527 lemma subtree_rev_transfer:

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

   529   and "r1 \<subseteq> r2"

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

   531   using assms and subtree_transfer by metis

   532 

   533 text {*

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

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

   536 *}

   537 lemma rpath_plus: 

   538   assumes "rpath r x xs y"

   539   and "xs \<noteq> []"

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

   541 proof -

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

   543   from assms(1)[unfolded this]

   544   show ?thesis

   545   proof(cases)

   546     case rstep

   547     show ?thesis

   548     proof -

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

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

   551     qed

   552   qed

   553 qed

   554 

   555 lemma plus_rpath: 

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

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

   558 proof -

   559   from assms

   560   show ?thesis

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

   562     case 1

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

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

   565   next

   566     case (2 z)

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

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

   569     from rstepI[OF 2(1) this]

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

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

   572   qed

   573 qed

   574 

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

   576 

   577 lemma ancestors_subtreeI:

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

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

   580   using assms by (auto simp:subtree_def ancestors_def)

   581 

   582 lemma ancestors_Field:

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

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

   585   using assms 

   586   apply (unfold ancestors_def, simp)

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

   588 

   589 lemma subtreeE:

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

   591   obtains "a = b"

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

   593 proof -

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

   595   from rtranclD[OF this]

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

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

   598 qed

   599 

   600 lemma subtree_Field:

   601   assumes "a \<in> Field r"

   602   shows "subtree r a \<subseteq> Field r"

   603 by (metis Field_def UnI1 ancestors_Field assms subsetI subtreeE)

   604 

   605 lemma subtree_Field:

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

   607 proof

   608   fix y

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

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

   611   proof(cases rule:subtreeE)

   612     case 1

   613     thus ?thesis by auto

   614   next

   615     case 2

   616     thus ?thesis apply (auto simp:ancestors_def)

   617     using Field_def tranclD by fastforce 

   618   qed

   619 qed

   620 

   621 lemma subtree_ancestorsI:

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

   623   and "a \<noteq> b"

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

   625   using assms

   626   by (auto elim!:subtreeE)

   627 

   628 text {*

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

   630 *}

   631 lemma subtree_mono:

   632   assumes "r1 \<subseteq> r2"

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

   634 proof

   635   fix c

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

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

   638   from star_rpath[OF this] obtain xs 

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

   640   hence "rpath r2 c xs x"

   641   proof(rule rpath_transfer)

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

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

   644   qed

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

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

   647 qed

   648 

   649 text {*

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

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

   652 

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

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

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

   656 *}

   657 lemma subtree_del_outside: (* ddd *)

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

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

   660 proof -

   661   { fix c

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

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

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

   665     proof(rule star_rpath)

   666       fix xs

   667       assume rp: "rpath r c xs x"

   668       show ?thesis

   669       proof -

   670         from rp

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

   672         proof(rule rpath_transfer)

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

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

   675           proof

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

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

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

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

   680             from rp[unfolded this]

   681             show False

   682             proof(rule rpath_appendE)

   683               assume "rpath r b l2 x"

   684               thus ?thesis

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

   686             qed

   687           qed

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

   689         qed

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

   691       qed

   692     qed

   693   } moreover {

   694     fix c

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

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

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

   698   } ultimately show ?thesis by auto

   699 qed

   700 

   701 (* ddd *)

   702 lemma subset_del_subtree_outside: (* ddd *)

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

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

   705 proof -

   706   { fix c

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

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

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

   710     proof(rule star_rpath)

   711       fix xs

   712       assume rp: "rpath r c xs x"

   713       show ?thesis

   714       proof -

   715         from rp

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

   717         proof(rule rpath_transfer)

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

   719           moreover {

   720               fix a b

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

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

   723               proof

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

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

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

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

   728                 from rp[unfolded this]

   729                 show False

   730                 proof(rule rpath_appendE)

   731                   assume "rpath r b l2 x"

   732                   from rpath_star[OF this]

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

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

   735                 qed

   736              qed

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

   738         qed

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

   740       qed

   741     qed

   742   } moreover {

   743     fix c

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

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

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

   747   } ultimately show ?thesis by auto

   748 qed

   749 

   750 lemma subtree_insert_ext:

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

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

   753     using assms by (auto simp:subtree_def rtrancl_insert)

   754 

   755 lemma subtree_insert_next:

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

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

   758     using assms

   759     by (auto simp:subtree_def rtrancl_insert)

   760 

   761 lemma set_add_rootI:

   762   assumes "root r a"

   763   and "a \<notin> Domain r1"

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

   765 proof -

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

   767   { fix a'

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

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

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

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

   772     proof

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

   774       with assms(1) show False 

   775         by (auto simp:root_def ancestors_def)

   776     qed

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

   778     with assms(2) 

   779     have False by (auto)

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

   781 qed

   782 

   783 lemma ancestors_mono:

   784   assumes "r1 \<subseteq> r2"

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

   786 proof

   787  fix a

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

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

   790  from plus_rpath[OF this] obtain xs where 

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

   792  have "rpath r2 x xs a"

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

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

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

   796  qed

   797  from rpath_plus[OF this h(2)]

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

   799 qed

   800 

   801 lemma subtree_refute:

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

   803   and "x \<noteq> y"

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

   805 proof

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

   807    thus False

   808      by(elim subtreeE, insert assms, auto)

   809 qed

   810 

   811 subsubsection {* Properties about relational trees *}

   812 

   813 context rtree 

   814 begin

   815 

   816 lemma ancestors_headE:

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

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

   819   obtains "b = c"

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

   821 proof -

   822   from assms(1) 

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

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

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

   826     case 1

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

   828     thus ?thesis by auto

   829   next

   830     case (2 y)

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

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

   833     thus ?thesis by auto

   834   qed

   835   with that show ?thesis by metis

   836 qed

   837 

   838 lemma ancestors_accum:

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

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

   841 proof -

   842   { fix c

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

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

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

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

   847       case 1

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

   849       thus ?thesis by auto

   850     next

   851       case (2 c')

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

   853       from 2(2)[unfolded this]

   854       show ?thesis by (auto simp:ancestors_def)

   855     qed

   856   } moreover {

   857     fix c

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

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

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

   861     proof

   862       assume "c = b"

   863       from assms[folded this] 

   864       show ?thesis by (auto simp:ancestors_def)

   865     next

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

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

   868     qed

   869   } ultimately show ?thesis by auto

   870 qed

   871 

   872 lemma rootI:

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

   874   and "r' \<subseteq> r"

   875   shows "root r' x"

   876 proof -

   877   from acyclic_subset[OF acl assms(2)]

   878   have acl': "acyclic r'" .

   879   { fix x'

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

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

   882     have "x' \<noteq> x"

   883     proof

   884       assume eq_x: "x' = x"

   885       from h1[unfolded this] and acl'

   886       show False by (auto simp:acyclic_def)

   887     qed

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

   889     ultimately have False using h by auto

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

   891 qed

   892 

   893 lemma rpath_overlap_oneside: (* ddd *)

   894   assumes "rpath r x xs1 x1"

   895   and "rpath r x xs2 x2"

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

   897   obtains xs3 where "xs2 = xs1 @ xs3"

   898 proof(cases "xs1 = []")

   899   case True

   900   with that show ?thesis by auto

   901 next

   902   case False

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

   904   proof -

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

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

   907        from this(1) have "False"

   908        proof(rule index_minimize)

   909           fix j

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

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

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

   913           let ?idx = "j - 1"

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

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

   916             by (metis Suc_diff_1 le_neq_implies_less length_greater_0_conv lessI less_imp_diff_less)

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

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

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

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

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

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

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

   924             using id_take_nth_drop[OF lt_i] .

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

   926               using id_take_nth_drop[OF lt_i'] .

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

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

   929           proof -

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

   931                 using eq_xs1 Suc_diff_1 lt_i lt_j take_Suc_conv_app_nth by fastforce 

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

   933                 using Suc_diff_1 lt_i' lt_j take_Suc_conv_app_nth by fastforce 

   934             ultimately show ?thesis using eq_take h1 by auto

   935           qed

   936           show ?thesis

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

   938             case True

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

   940             proof -

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

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

   943                 from this[unfolded rpath_def]

   944                 show ?thesis by (auto simp:pred_of_def)

   945             qed

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

   947             proof -

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

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

   950               from this[unfolded rpath_def]

   951               show ?thesis by (auto simp:pred_of_def)

   952             qed

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

   954         next

   955            case False

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

   957             using rev_exhaust by blast 

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

   959            proof -

   960             from eq_xs1[unfolded eq_es] 

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

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

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

   964             show ?thesis by auto

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

   966            proof -

   967             from eq_xs2[folded eq_take, unfolded eq_es]

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

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

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

   971             show ?thesis by auto

   972            qed

   973            ultimately show ?thesis 

   974               using sgv[unfolded single_valued_def] neq_idx by metis

   975         qed

   976        qed

   977      } thus ?thesis by auto

   978   qed

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

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

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

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

   983   from that[OF this] show ?thesis .

   984 qed

   985 

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

   987   assumes "rpath r x xs1 x1"

   988   and "rpath r x xs2 x2"

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

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

   991 proof -

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

   993   with assms rpath_overlap_oneside that show ?thesis by metis

   994 qed

   995 

   996 text {*

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

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

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

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

  1001   the one side version first.

  1002 *}

  1003 

  1004 lemma rpath_unique_oneside:

  1005   assumes "rpath r x xs1 y"

  1006     and "rpath r x xs2 y"

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

  1008   shows "xs1 = xs2"

  1009 proof -

  1010   from rpath_overlap_oneside[OF assms] 

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

  1012   show ?thesis

  1013   proof(cases "xs3 = []") 

  1014     case True

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

  1016   next

  1017     case False

  1018     note FalseH = this

  1019     show ?thesis

  1020     proof(cases "xs1 = []")

  1021       case True

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

  1023       proof(rule rpath_plus)

  1024         from assms(1)[unfolded True] 

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

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

  1027       next

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

  1029       qed

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

  1031     next 

  1032       case False

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

  1034       from assms(2)[unfolded less_1 this]

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

  1036       thus ?thesis

  1037       proof(cases rule:rpath_appendE)

  1038         case 1

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

  1040         have "e = y" .

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

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

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

  1044       qed

  1045     qed

  1046   qed

  1047 qed

  1048 

  1049 text {*

  1050   The following is the full version of path uniqueness.

  1051 *}

  1052 lemma rpath_unique:

  1053   assumes "rpath r x xs1 y"

  1054     and "rpath r x xs2 y"

  1055   shows "xs1 = xs2"

  1056 proof(cases "length xs1 \<le> length xs2")

  1057    case True

  1058    from rpath_unique_oneside[OF assms this] show ?thesis .

  1059 next

  1060   case False

  1061   hence "length xs2 \<le> length xs1" by simp

  1062   from rpath_unique_oneside[OF assms(2,1) this]

  1063   show ?thesis by simp

  1064 qed

  1065 

  1066 text {*

  1067   The following lemma shows that the `independence` relation is symmetric.

  1068   It is an obvious auxiliary lemma which will be used later. 

  1069 *}

  1070 lemma sym_indep: "indep r x y \<Longrightarrow> indep r y x"

  1071   by (unfold indep_def, auto)

  1072 

  1073 text {*

  1074   This is another `obvious` lemma about trees, which says trees rooted at 

  1075   independent nodes are disjoint.

  1076 *}

  1077 lemma subtree_disjoint:

  1078   assumes "indep r x y"

  1079   shows "subtree r x \<inter> subtree r y = {}"

  1080 proof -

  1081   { fix z x y xs1 xs2 xs3

  1082       assume ind: "indep r x y"

  1083       and rp1: "rpath r z xs1 x"

  1084       and rp2: "rpath r z xs2 y"

  1085       and h: "xs2 = xs1 @ xs3"

  1086       have False

  1087       proof(cases "xs1 = []")

  1088         case True

  1089         from rp1[unfolded this] have "x = z" by auto

  1090         from rp2[folded this] rpath_star ind[unfolded indep_def]

  1091         show ?thesis by metis

  1092       next

  1093         case False

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

  1095         from rp2[unfolded h this]

  1096         have "rpath r z (es @ [e] @ xs3) y" by simp

  1097         thus ?thesis

  1098         proof(cases rule:rpath_appendE)

  1099           case 1

  1100           have "e = x" using 1(1)[folded eq_xs1] rp1 rpath_dest_eq by metis

  1101           from rpath_star[OF 1(2)[unfolded this]] ind[unfolded indep_def]

  1102           show ?thesis by auto

  1103         qed

  1104       qed

  1105   } note my_rule = this

  1106   { fix z

  1107     assume h: "z \<in> subtree r x" "z \<in> subtree r y"

  1108     from h(1) have "(z, x) \<in> r^*" by (unfold subtree_def, auto)

  1109     then obtain xs1 where rp1: "rpath r z xs1 x" using star_rpath by metis

  1110     from h(2) have "(z, y) \<in> r^*" by (unfold subtree_def, auto)

  1111     then obtain xs2 where rp2: "rpath r z xs2 y" using star_rpath by metis

  1112     from rp1 rp2

  1113     have False

  1114     by (cases, insert my_rule[OF sym_indep[OF assms(1)] rp2 rp1] 

  1115                   my_rule[OF assms(1) rp1 rp2], auto)

  1116   } thus ?thesis by auto

  1117 qed

  1118 

  1119 text {*

  1120   The following lemma @{text "subtree_del"} characterizes the change of sub-tree of 

  1121   @{text "x"} with the removal of an inside edge @{text "(a, b)"}. 

  1122   Note that, the case for the removal of an outside edge has already been dealt with

  1123   in lemma @{text "subtree_del_outside"}). 

  1124 

  1125   This lemma is underpinned by the following two `obvious` facts:

  1126   \begin{enumearte}

  1127   \item

  1128   In graph @{text "r"}, for an inside edge @{text "(a,b) \<in> edges_in r x"},  

  1129   every node @{text "c"} in the sub-tree of @{text "a"} has a path

  1130   which goes first from @{text "c"} to @{text "a"}, then through edge @{text "(a, b)"}, and 

  1131   finally reaches @{text "x"}. By the uniqueness of path in a tree,

  1132   all paths from sub-tree of @{text "a"} to @{text "x"} are such constructed, therefore 

  1133   must go through @{text "(a, b)"}. The consequence is: with the removal of @{text "(a,b)"},

  1134   all such paths will be broken. 

  1135