Merged
authoreberlm
Tue, 03 Nov 2015 11:20:21 +0100
changeset 61553 933eb9e6a1cc
parent 61533 980dd46a03fb (current diff)
parent 61552 078c9fd2e052 (diff)
child 61554 84901b8aa4f5
child 61609 77b453bd616f
Merged
src/HOL/Isar_Examples/document/style.tex
--- a/Admin/components/components.sha1	Mon Nov 02 16:17:09 2015 +0100
+++ b/Admin/components/components.sha1	Tue Nov 03 11:20:21 2015 +0100
@@ -2,6 +2,7 @@
 2f6417b8e96a0e4e8354fe0f1a253c18fb55d9a7  cvc3-2.4.1.tar.gz
 a5e02b5e990da4275dc5d4480c3b72fc73160c28  cvc4-1.5pre-1.tar.gz
 4d9658fd2688ae8ac78da8fdfcbf85960f871b71  cvc4-1.5pre-2.tar.gz
+b01fdb93f2dc2b8bcfd41c6091d91b37d6e240f9  cvc4-1.5pre-3.tar.gz
 03aec2ec5757301c9df149f115d1f4f1d2cafd9e  cvc4-1.5pre.tar.gz
 842d9526f37b928cf9e22f141884365129990d63  cygwin-20130110.tar.gz
 cb3b0706d208f104b800267697204f6d82f7b48a  cygwin-20130114.tar.gz
--- a/Admin/components/main	Mon Nov 02 16:17:09 2015 +0100
+++ b/Admin/components/main	Tue Nov 03 11:20:21 2015 +0100
@@ -1,6 +1,6 @@
 #main components for everyday use, without big impact on overall build time
 csdp-6.x
-cvc4-1.5pre-2
+cvc4-1.5pre-3
 e-1.8
 exec_process-1.0.3
 Haskabelle-2015
--- a/NEWS	Mon Nov 02 16:17:09 2015 +0100
+++ b/NEWS	Tue Nov 03 11:20:21 2015 +0100
@@ -79,6 +79,9 @@
 standard Isabelle fonts provide glyphs to render important control
 symbols, e.g. "\<^verbatim>", "\<^emph>", "\<^bold>".
 
+* System option "document_symbols" determines completion of Isabelle
+symbols within document source.
+
 * Antiquotation @{cartouche} in Isabelle/Pure is the same as @{text}.
 Consequently, \<open>...\<close> without any decoration prints literal quasi-formal
 text. Command-line tool "isabelle update_cartouches -t" helps to update
@@ -397,6 +400,9 @@
   - New commands "lift_bnf" and "copy_bnf" for lifting (copying) a BNF
     structure on the raw type to an abstract type defined using typedef.
   - Always generate "case_transfer" theorem.
+  - Allow discriminators and selectors with the same name as the type
+    being defined.
+  - Avoid various internal name clashes (e.g., 'datatype f = f').
 
 * Transfer:
   - new methods for interactive debugging of 'transfer' and
--- a/etc/options	Mon Nov 02 16:17:09 2015 +0100
+++ b/etc/options	Tue Nov 03 11:20:21 2015 +0100
@@ -164,3 +164,5 @@
 public option completion_limit : int = 40
   -- "limit for completion within the formal context"
 
+public option document_symbols : bool = false
+  -- "completion of Isabelle symbols within document source"
--- a/src/HOL/BNF_Fixpoint_Base.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/BNF_Fixpoint_Base.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -14,9 +14,6 @@
 imports BNF_Composition Basic_BNFs
 begin
 
-lemma False_imp_eq_True: "(False \<Longrightarrow> Q) \<equiv> Trueprop True"
-  by standard simp_all
-
 lemma conj_imp_eq_imp_imp: "(P \<and> Q \<Longrightarrow> PROP R) \<equiv> (P \<Longrightarrow> Q \<Longrightarrow> PROP R)"
   by standard simp_all
 
--- a/src/HOL/Data_Structures/AList_Upd_Del.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/AList_Upd_Del.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -14,39 +14,39 @@
 hide_const (open) map_of
 
 fun map_of :: "('a*'b)list \<Rightarrow> 'a \<Rightarrow> 'b option" where
-"map_of [] = (\<lambda>a. None)" |
-"map_of ((x,y)#ps) = (\<lambda>a. if x=a then Some y else map_of ps a)"
+"map_of [] = (\<lambda>x. None)" |
+"map_of ((a,b)#ps) = (\<lambda>x. if x=a then Some b else map_of ps x)"
 
 text \<open>Updating an association list:\<close>
 
 fun upd_list :: "'a::linorder \<Rightarrow> 'b \<Rightarrow> ('a*'b) list \<Rightarrow> ('a*'b) list" where
-"upd_list a b [] = [(a,b)]" |
-"upd_list a b ((x,y)#ps) =
-  (if a < x then (a,b)#(x,y)#ps else
-  if a=x then (a,b)#ps else (x,y) # upd_list a b ps)"
+"upd_list x y [] = [(x,y)]" |
+"upd_list x y ((a,b)#ps) =
+  (if x < a then (x,y)#(a,b)#ps else
+  if x = a then (x,y)#ps else (a,b) # upd_list x y ps)"
 
 fun del_list :: "'a::linorder \<Rightarrow> ('a*'b)list \<Rightarrow> ('a*'b)list" where
-"del_list a [] = []" |
-"del_list a ((x,y)#ps) = (if a=x then ps else (x,y) # del_list a ps)"
+"del_list x [] = []" |
+"del_list x ((a,b)#ps) = (if x = a then ps else (a,b) # del_list x ps)"
 
 
 subsection \<open>Lemmas for @{const map_of}\<close>
 
-lemma map_of_ins_list: "map_of (upd_list a b ps) = (map_of ps)(a := Some b)"
+lemma map_of_ins_list: "map_of (upd_list x y ps) = (map_of ps)(x := Some y)"
 by(induction ps) auto
 
-lemma map_of_append: "map_of (ps @ qs) a =
-  (case map_of ps a of None \<Rightarrow> map_of qs a | Some b \<Rightarrow> Some b)"
+lemma map_of_append: "map_of (ps @ qs) x =
+  (case map_of ps x of None \<Rightarrow> map_of qs x | Some y \<Rightarrow> Some y)"
 by(induction ps)(auto)
 
-lemma map_of_None: "sorted (a # map fst ps) \<Longrightarrow> map_of ps a = None"
+lemma map_of_None: "sorted (x # map fst ps) \<Longrightarrow> map_of ps x = None"
 by (induction ps) (auto simp: sorted_lems sorted_Cons_iff)
 
-lemma map_of_None2: "sorted (map fst ps @ [a]) \<Longrightarrow> map_of ps a = None"
+lemma map_of_None2: "sorted (map fst ps @ [x]) \<Longrightarrow> map_of ps x = None"
 by (induction ps) (auto simp: sorted_lems)
 
 lemma map_of_del_list: "sorted1 ps \<Longrightarrow>
-  map_of(del_list a ps) = (map_of ps)(a := None)"
+  map_of(del_list x ps) = (map_of ps)(x := None)"
 by(induction ps) (auto simp: map_of_None sorted_lems fun_eq_iff)
 
 lemma map_of_sorted_Cons: "sorted (a # map fst ps) \<Longrightarrow> x < a \<Longrightarrow>
@@ -63,19 +63,19 @@
 
 subsection \<open>Lemmas for @{const upd_list}\<close>
 
-lemma sorted_upd_list: "sorted1 ps \<Longrightarrow> sorted1 (upd_list a b ps)"
-apply(induction ps) 
+lemma sorted_upd_list: "sorted1 ps \<Longrightarrow> sorted1 (upd_list x y ps)"
+apply(induction ps)
  apply simp
 apply(case_tac ps)
  apply auto
 done
 
-lemma upd_list_sorted1: "\<lbrakk> sorted (map fst ps @ [x]); a < x \<rbrakk> \<Longrightarrow>
-  upd_list a b (ps @ (x,y) # qs) =  upd_list a b ps @ (x,y) # qs"
+lemma upd_list_sorted1: "\<lbrakk> sorted (map fst ps @ [a]); x < a \<rbrakk> \<Longrightarrow>
+  upd_list x y (ps @ (a,b) # qs) =  upd_list x y ps @ (a,b) # qs"
 by(induction ps) (auto simp: sorted_lems)
 
-lemma upd_list_sorted2: "\<lbrakk> sorted (map fst ps @ [x]); x \<le> a \<rbrakk> \<Longrightarrow>
-  upd_list a b (ps @ (x,y) # qs) = ps @ upd_list a b ((x,y)#qs)"
+lemma upd_list_sorted2: "\<lbrakk> sorted (map fst ps @ [a]); a \<le> x \<rbrakk> \<Longrightarrow>
+  upd_list x y (ps @ (a,b) # qs) = ps @ upd_list x y ((a,b) # qs)"
 by(induction ps) (auto simp: sorted_lems)
 
 lemmas upd_list_simps = sorted_lems upd_list_sorted1 upd_list_sorted2
@@ -110,28 +110,28 @@
 lemma del_list_idem: "x \<notin> set(map fst xs) \<Longrightarrow> del_list x xs = xs"
 by (induct xs) auto
 
-lemma del_list_sorted1: "sorted1 (xs @ [(x,y)]) \<Longrightarrow> x \<le> a \<Longrightarrow>
-  del_list a (xs @ (x,y) # ys) = xs @ del_list a ((x,y) # ys)"
+lemma del_list_sorted1: "sorted1 (xs @ [(a,b)]) \<Longrightarrow> a \<le> x \<Longrightarrow>
+  del_list x (xs @ (a,b) # ys) = xs @ del_list x ((a,b) # ys)"
 by (induction xs) (auto simp: sorted_mid_iff2)
 
-lemma del_list_sorted2: "sorted1 (xs @ (x,y) # ys) \<Longrightarrow> a < x \<Longrightarrow>
-  del_list a (xs @ (x,y) # ys) = del_list a xs @ (x,y) # ys"
+lemma del_list_sorted2: "sorted1 (xs @ (a,b) # ys) \<Longrightarrow> x < a \<Longrightarrow>
+  del_list x (xs @ (a,b) # ys) = del_list x xs @ (a,b) # ys"
 by (induction xs) (fastforce simp: sorted_Cons_iff intro!: del_list_idem)+
 
 lemma del_list_sorted3:
-  "sorted1 (xs @ (x,x') # ys @ (y,y') # zs) \<Longrightarrow> a < y \<Longrightarrow>
-  del_list a (xs @ (x,x') # ys @ (y,y') # zs) = del_list a (xs @ (x,x') # ys) @ (y,y') # zs"
+  "sorted1 (xs @ (a,a') # ys @ (b,b') # zs) \<Longrightarrow> x < b \<Longrightarrow>
+  del_list x (xs @ (a,a') # ys @ (b,b') # zs) = del_list x (xs @ (a,a') # ys) @ (b,b') # zs"
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted2 ball_Un)
 
 lemma del_list_sorted4:
-  "sorted1 (xs @ (x,x') # ys @ (y,y') # zs @ (z,z') # us) \<Longrightarrow> a < z \<Longrightarrow>
-  del_list a (xs @ (x,x') # ys @ (y,y') # zs @ (z,z') # us) = del_list a (xs @ (x,x') # ys @ (y,y') # zs) @ (z,z') # us"
+  "sorted1 (xs @ (a,a') # ys @ (b,b') # zs @ (c,c') # us) \<Longrightarrow> x < c \<Longrightarrow>
+  del_list x (xs @ (a,a') # ys @ (b,b') # zs @ (c,c') # us) = del_list x (xs @ (a,a') # ys @ (b,b') # zs) @ (c,c') # us"
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted3)
 
 lemma del_list_sorted5:
-  "sorted1 (xs @ (x,x') # ys @ (y,y') # zs @ (z,z') # us @ (u,u') # vs) \<Longrightarrow> a < u \<Longrightarrow>
-   del_list a (xs @ (x,x') # ys @ (y,y') # zs @ (z,z') # us @ (u,u') # vs) =
-   del_list a (xs @ (x,x') # ys @ (y,y') # zs @ (z,z') # us) @ (u,u') # vs" 
+  "sorted1 (xs @ (a,a') # ys @ (b,b') # zs @ (c,c') # us @ (d,d') # vs) \<Longrightarrow> x < d \<Longrightarrow>
+   del_list x (xs @ (a,a') # ys @ (b,b') # zs @ (c,c') # us @ (d,d') # vs) =
+   del_list x (xs @ (a,a') # ys @ (b,b') # zs @ (c,c') # us) @ (d,d') # vs" 
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted4)
 
 lemmas del_list_sorted =
--- a/src/HOL/Data_Structures/List_Ins_Del.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/List_Ins_Del.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -52,8 +52,8 @@
 
 fun ins_list :: "'a::linorder \<Rightarrow> 'a list \<Rightarrow> 'a list" where
 "ins_list x [] = [x]" |
-"ins_list x (y#zs) =
-  (if x < y then x#y#zs else if x=y then x#zs else y # ins_list x zs)"
+"ins_list x (a#xs) =
+  (if x < a then x#a#xs else if x=a then a#xs else a # ins_list x xs)"
 
 lemma set_ins_list[simp]: "elems (ins_list x xs) = insert x (elems xs)"
 by(induction xs) auto
@@ -66,12 +66,12 @@
 lemma sorted_ins_list: "sorted xs \<Longrightarrow> sorted(ins_list x xs)"
 by(induction xs rule: sorted.induct) auto
 
-lemma ins_list_sorted1: "sorted (xs @ [y]) \<Longrightarrow> y \<le> x \<Longrightarrow>
-  ins_list x (xs @ y # ys) = xs @ ins_list x (y#ys)"
+lemma ins_list_sorted1: "sorted (xs @ [a]) \<Longrightarrow> a \<le> x \<Longrightarrow>
+  ins_list x (xs @ a # ys) = xs @ ins_list x (a#ys)"
 by(induction xs) (auto simp: sorted_lems)
 
-lemma ins_list_sorted2: "sorted (xs @ [y]) \<Longrightarrow> x < y \<Longrightarrow>
-  ins_list x (xs @ y # ys) = ins_list x xs @ (y#ys)"
+lemma ins_list_sorted2: "sorted (xs @ [a]) \<Longrightarrow> x < a \<Longrightarrow>
+  ins_list x (xs @ a # ys) = ins_list x xs @ (a#ys)"
 by(induction xs) (auto simp: sorted_lems)
 
 lemmas ins_list_simps = sorted_lems ins_list_sorted1 ins_list_sorted2
@@ -80,8 +80,8 @@
 subsection \<open>Delete one occurrence of an element from a list:\<close>
 
 fun del_list :: "'a \<Rightarrow> 'a list \<Rightarrow> 'a list" where
-"del_list a [] = []" |
-"del_list a (x#xs) = (if a=x then xs else x # del_list a xs)"
+"del_list x [] = []" |
+"del_list x (a#xs) = (if x=a then xs else a # del_list x xs)"
 
 lemma del_list_idem: "x \<notin> elems xs \<Longrightarrow> del_list x xs = xs"
 by (induct xs) simp_all
@@ -99,28 +99,28 @@
 apply auto
 by (meson order.strict_trans sorted_Cons_iff)
 
-lemma del_list_sorted1: "sorted (xs @ [x]) \<Longrightarrow> x \<le> y \<Longrightarrow>
-  del_list y (xs @ x # ys) = xs @ del_list y (x # ys)"
+lemma del_list_sorted1: "sorted (xs @ [a]) \<Longrightarrow> a \<le> x \<Longrightarrow>
+  del_list x (xs @ a # ys) = xs @ del_list x (a # ys)"
 by (induction xs) (auto simp: sorted_mid_iff2)
 
-lemma del_list_sorted2: "sorted (xs @ x # ys) \<Longrightarrow> y < x \<Longrightarrow>
-  del_list y (xs @ x # ys) = del_list y xs @ x # ys"
+lemma del_list_sorted2: "sorted (xs @ a # ys) \<Longrightarrow> x < a \<Longrightarrow>
+  del_list x (xs @ a # ys) = del_list x xs @ a # ys"
 by (induction xs) (auto simp: sorted_Cons_iff intro!: del_list_idem)
 
 lemma del_list_sorted3:
-  "sorted (xs @ x # ys @ y # zs) \<Longrightarrow> a < y \<Longrightarrow>
-  del_list a (xs @ x # ys @ y # zs) = del_list a (xs @ x # ys) @ y # zs"
+  "sorted (xs @ a # ys @ b # zs) \<Longrightarrow> x < b \<Longrightarrow>
+  del_list x (xs @ a # ys @ b # zs) = del_list x (xs @ a # ys) @ b # zs"
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted2)
 
 lemma del_list_sorted4:
-  "sorted (xs @ x # ys @ y # zs @ z # us) \<Longrightarrow> a < z \<Longrightarrow>
-  del_list a (xs @ x # ys @ y # zs @ z # us) = del_list a (xs @ x # ys @ y # zs) @ z # us"
+  "sorted (xs @ a # ys @ b # zs @ c # us) \<Longrightarrow> x < c \<Longrightarrow>
+  del_list x (xs @ a # ys @ b # zs @ c # us) = del_list x (xs @ a # ys @ b # zs) @ c # us"
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted3)
 
 lemma del_list_sorted5:
-  "sorted (xs @ x # ys @ y # zs @ z # us @ u # vs) \<Longrightarrow> a < u \<Longrightarrow>
-   del_list a (xs @ x # ys @ y # zs @ z # us @ u # vs) =
-   del_list a (xs @ x # ys @ y # zs @ z # us) @ u # vs" 
+  "sorted (xs @ a # ys @ b # zs @ c # us @ d # vs) \<Longrightarrow> x < d \<Longrightarrow>
+   del_list x (xs @ a # ys @ b # zs @ c # us @ d # vs) =
+   del_list x (xs @ a # ys @ b # zs @ c # us) @ d # vs" 
 by (induction xs) (auto simp: sorted_Cons_iff del_list_sorted4)
 
 lemmas del_list_simps = sorted_lems
--- a/src/HOL/Data_Structures/RBT.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/RBT.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -27,23 +27,23 @@
 "red (Node _ l a r) = R l a r"
 
 fun balL :: "'a rbt \<Rightarrow> 'a \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where
-"balL (R t1 x t2) s t3 = R (B t1 x t2) s t3" |
+"balL (R t1 x t2) y t3 = R (B t1 x t2) y t3" |
 "balL bl x (B t1 y t2) = bal bl x (R t1 y t2)" |
 "balL bl x (R (B t1 y t2) z t3) = R (B bl x t1) y (bal t2 z (red t3))" |
 "balL t1 x t2 = R t1 x t2"
 
 fun balR :: "'a rbt \<Rightarrow> 'a \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where
 "balR t1 x (R t2 y t3) = R t1 x (B t2 y t3)" |
-"balR (B t1 x t2) y bl = bal (R t1 x t2) y bl" |
-"balR (R t1 x (B t2 y t3)) z bl = R (bal (red t1) x t2) y (B t3 z bl)" |
+"balR (B t1 x t2) y t3 = bal (R t1 x t2) y t3" |
+"balR (R t1 x (B t2 y t3)) z t4 = R (bal (red t1) x t2) y (B t3 z t4)" |
 "balR t1 x t2 = R t1 x t2"
 
 fun combine :: "'a rbt \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where
 "combine Leaf t = t" |
 "combine t Leaf = t" |
-"combine (R a x b) (R c y d) = (case combine b c of
-    R b2 z c2 \<Rightarrow> (R (R a x b2) z (R c2 y d)) |
-    bc \<Rightarrow> R a x (R bc y d))" |
+"combine (R t1 a t2) (R t3 c t4) = (case combine t2 t3 of
+    R u2 b u3 \<Rightarrow> (R (R t1 a u2) b (R u3 c t4)) |
+    t23 \<Rightarrow> R t1 a (R t23 c t4))" |
 "combine (B t1 a t2) (B t3 c t4) = (case combine t2 t3 of
     R t2' b t3' \<Rightarrow> R (B t1 a t2') b (B t3' c t4) |
     t23 \<Rightarrow> balL t1 a (B t23 c t4))" |
--- a/src/HOL/Data_Structures/Set_by_Ordered.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/Set_by_Ordered.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -13,13 +13,13 @@
 fixes isin :: "'s \<Rightarrow> 'a \<Rightarrow> bool"
 fixes set :: "'s \<Rightarrow> 'a set"
 fixes invar :: "'s \<Rightarrow> bool"
-assumes "set empty = {}"
-assumes "invar s \<Longrightarrow> isin s a = (a \<in> set s)"
-assumes "invar s \<Longrightarrow> set(insert a s) = Set.insert a (set s)"
-assumes "invar s \<Longrightarrow> set(delete a s) = set s - {a}"
-assumes "invar empty"
-assumes "invar s \<Longrightarrow> invar(insert a s)"
-assumes "invar s \<Longrightarrow> invar(delete a s)"
+assumes set_empty:    "set empty = {}"
+assumes set_isin:     "invar s \<Longrightarrow> isin s x = (x \<in> set s)"
+assumes set_insert:   "invar s \<Longrightarrow> set(insert x s) = Set.insert x (set s)"
+assumes set_delete:   "invar s \<Longrightarrow> set(delete x s) = set s - {x}"
+assumes invar_empty:  "invar empty"
+assumes invar_insert: "invar s \<Longrightarrow> invar(insert x s)"
+assumes invar_delete: "invar s \<Longrightarrow> invar(delete x s)"
 
 locale Set_by_Ordered =
 fixes empty :: "'t"
@@ -30,14 +30,14 @@
 fixes wf :: "'t \<Rightarrow> bool"
 assumes empty: "inorder empty = []"
 assumes isin: "wf t \<and> sorted(inorder t) \<Longrightarrow>
-  isin t a = (a \<in> elems (inorder t))"
+  isin t x = (x \<in> elems (inorder t))"
 assumes insert: "wf t \<and> sorted(inorder t) \<Longrightarrow>
-  inorder(insert a t) = ins_list a (inorder t)"
+  inorder(insert x t) = ins_list x (inorder t)"
 assumes delete: "wf t \<and> sorted(inorder t) \<Longrightarrow>
-  inorder(delete a t) = del_list a (inorder t)"
+  inorder(delete x t) = del_list x (inorder t)"
 assumes wf_empty:  "wf empty"
-assumes wf_insert: "wf t \<and> sorted(inorder t) \<Longrightarrow> wf(insert a t)"
-assumes wf_delete: "wf t \<and> sorted(inorder t) \<Longrightarrow> wf(delete a t)"
+assumes wf_insert: "wf t \<and> sorted(inorder t) \<Longrightarrow> wf(insert x t)"
+assumes wf_delete: "wf t \<and> sorted(inorder t) \<Longrightarrow> wf(delete x t)"
 begin
 
 sublocale Set
@@ -49,8 +49,8 @@
 next
   case 3 thus ?case by(simp add: insert)
 next
-  case (4 s a) show ?case
-    using delete[OF 4, of a] 4 by (auto simp: distinct_if_sorted)
+  case (4 s x) show ?case
+    using delete[OF 4, of x] 4 by (auto simp: distinct_if_sorted)
 next
   case 5 thus ?case by(simp add: empty wf_empty)
 next
--- a/src/HOL/Data_Structures/Tree23_Map.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/Tree23_Map.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -21,53 +21,53 @@
    else lookup r x)"
 
 fun upd :: "'a::linorder \<Rightarrow> 'b \<Rightarrow> ('a*'b) tree23 \<Rightarrow> ('a*'b) up\<^sub>i" where
-"upd a b Leaf = Up\<^sub>i Leaf (a,b) Leaf" |
-"upd a b (Node2 l xy r) =
-   (if a < fst xy then
-        (case upd a b l of
-           T\<^sub>i l' => T\<^sub>i (Node2 l' xy r)
-         | Up\<^sub>i l1 q l2 => T\<^sub>i (Node3 l1 q l2 xy r))
-    else if a = fst xy then T\<^sub>i (Node2 l (a,b) r)
+"upd x y Leaf = Up\<^sub>i Leaf (x,y) Leaf" |
+"upd x y (Node2 l ab r) =
+   (if x < fst ab then
+        (case upd x y l of
+           T\<^sub>i l' => T\<^sub>i (Node2 l' ab r)
+         | Up\<^sub>i l1 ab' l2 => T\<^sub>i (Node3 l1 ab' l2 ab r))
+    else if x = fst ab then T\<^sub>i (Node2 l (x,y) r)
     else
-        (case upd a b r of
-           T\<^sub>i r' => T\<^sub>i (Node2 l xy r')
-         | Up\<^sub>i r1 q r2 => T\<^sub>i (Node3 l xy r1 q r2)))" |
-"upd a b (Node3 l xy1 m xy2 r) =
-   (if a < fst xy1 then
-        (case upd a b l of
-           T\<^sub>i l' => T\<^sub>i (Node3 l' xy1 m xy2 r)
-         | Up\<^sub>i l1 q l2 => Up\<^sub>i (Node2 l1 q l2) xy1 (Node2 m xy2 r))
-    else if a = fst xy1 then T\<^sub>i (Node3 l (a,b) m xy2 r)
-    else if a < fst xy2 then
-             (case upd a b m of
-                T\<^sub>i m' => T\<^sub>i (Node3 l xy1 m' xy2 r)
-              | Up\<^sub>i m1 q m2 => Up\<^sub>i (Node2 l xy1 m1) q (Node2 m2 xy2 r))
-         else if a = fst xy2 then T\<^sub>i (Node3 l xy1 m (a,b) r)
+        (case upd x y r of
+           T\<^sub>i r' => T\<^sub>i (Node2 l ab r')
+         | Up\<^sub>i r1 ab' r2 => T\<^sub>i (Node3 l ab r1 ab' r2)))" |
+"upd x y (Node3 l ab1 m ab2 r) =
+   (if x < fst ab1 then
+        (case upd x y l of
+           T\<^sub>i l' => T\<^sub>i (Node3 l' ab1 m ab2 r)
+         | Up\<^sub>i l1 ab' l2 => Up\<^sub>i (Node2 l1 ab' l2) ab1 (Node2 m ab2 r))
+    else if x = fst ab1 then T\<^sub>i (Node3 l (x,y) m ab2 r)
+    else if x < fst ab2 then
+             (case upd x y m of
+                T\<^sub>i m' => T\<^sub>i (Node3 l ab1 m' ab2 r)
+              | Up\<^sub>i m1 ab' m2 => Up\<^sub>i (Node2 l ab1 m1) ab' (Node2 m2 ab2 r))
+         else if x = fst ab2 then T\<^sub>i (Node3 l ab1 m (x,y) r)
          else
-             (case upd a b r of
-                T\<^sub>i r' => T\<^sub>i (Node3 l xy1 m xy2 r')
-              | Up\<^sub>i r1 q r2 => Up\<^sub>i (Node2 l xy1 m) xy2 (Node2 r1 q r2)))"
+             (case upd x y r of
+                T\<^sub>i r' => T\<^sub>i (Node3 l ab1 m ab2 r')
+              | Up\<^sub>i r1 ab' r2 => Up\<^sub>i (Node2 l ab1 m) ab2 (Node2 r1 ab' r2)))"
 
 definition update :: "'a::linorder \<Rightarrow> 'b \<Rightarrow> ('a*'b) tree23 \<Rightarrow> ('a*'b) tree23" where
 "update a b t = tree\<^sub>i(upd a b t)"
 
 fun del :: "'a::linorder \<Rightarrow> ('a*'b) tree23 \<Rightarrow> ('a*'b) up\<^sub>d"
 where
-"del k Leaf = T\<^sub>d Leaf" |
-"del k (Node2 Leaf p Leaf) = (if k=fst p then Up\<^sub>d Leaf else T\<^sub>d(Node2 Leaf p Leaf))" |
-"del k (Node3 Leaf p Leaf q Leaf) = T\<^sub>d(if k=fst p then Node2 Leaf q Leaf
-  else if k=fst q then Node2 Leaf p Leaf else Node3 Leaf p Leaf q Leaf)" |
-"del k (Node2 l a r) = (if k<fst a then node21 (del k l) a r else
-  if k > fst a then node22 l a (del k r) else
-  let (a',t) = del_min r in node22 l a' t)" |
-"del k (Node3 l a m b r) = (if k<fst a then node31 (del k l) a m b r else
-  if k = fst a then let (a',m') = del_min m in node32 l a' m' b r else
-  if k < fst b then node32 l a (del k m) b r else
-  if k = fst b then let (b',r') = del_min r in node33 l a m b' r'
-  else node33 l a m b (del k r))"
+"del x Leaf = T\<^sub>d Leaf" |
+"del x (Node2 Leaf ab1 Leaf) = (if x=fst ab1 then Up\<^sub>d Leaf else T\<^sub>d(Node2 Leaf ab1 Leaf))" |
+"del x (Node3 Leaf ab1 Leaf ab2 Leaf) = T\<^sub>d(if x=fst ab1 then Node2 Leaf ab2 Leaf
+  else if x=fst ab2 then Node2 Leaf ab1 Leaf else Node3 Leaf ab1 Leaf ab2 Leaf)" |
+"del x (Node2 l ab1 r) = (if x<fst ab1 then node21 (del x l) ab1 r else
+  if x > fst ab1 then node22 l ab1 (del x r) else
+  let (ab1',t) = del_min r in node22 l ab1' t)" |
+"del x (Node3 l ab1 m ab2 r) = (if x<fst ab1 then node31 (del x l) ab1 m ab2 r else
+  if x = fst ab1 then let (ab1',m') = del_min m in node32 l ab1' m' ab2 r else
+  if x < fst ab2 then node32 l ab1 (del x m) ab2 r else
+  if x = fst ab2 then let (ab2',r') = del_min r in node33 l ab1 m ab2' r'
+  else node33 l ab1 m ab2 (del x r))"
 
 definition delete :: "'a::linorder \<Rightarrow> ('a*'b) tree23 \<Rightarrow> ('a*'b) tree23" where
-"delete k t = tree\<^sub>d(del k t)"
+"delete x t = tree\<^sub>d(del x t)"
 
 
 subsection \<open>Functional Correctness\<close>
--- a/src/HOL/Data_Structures/Tree23_Set.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/Tree23_Set.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -12,7 +12,7 @@
 "isin Leaf x = False" |
 "isin (Node2 l a r) x = (x < a \<and> isin l x \<or> x=a \<or> isin r x)" |
 "isin (Node3 l a m b r) x =
-  (x < a \<and> isin l x \<or> x = a \<or> (x < b \<and> isin m x \<or> x = b \<or> isin r x))"
+  (x < a \<and> isin l x \<or> x > b \<and> isin r x \<or> x = a \<or> x = b \<or> isin m x)"
 
 datatype 'a up\<^sub>i = T\<^sub>i "'a tree23" | Up\<^sub>i "'a tree23" 'a "'a tree23"
 
@@ -21,37 +21,38 @@
 "tree\<^sub>i (Up\<^sub>i l p r) = Node2 l p r"
 
 fun ins :: "'a::linorder \<Rightarrow> 'a tree23 \<Rightarrow> 'a up\<^sub>i" where
-"ins a Leaf = Up\<^sub>i Leaf a Leaf" |
-"ins a (Node2 l x r) =
-   (if a < x then
-      case ins a l of
-         T\<^sub>i l' => T\<^sub>i (Node2 l' x r)
-       | Up\<^sub>i l1 q l2 => T\<^sub>i (Node3 l1 q l2 x r)
-    else if a=x then T\<^sub>i (Node2 l x r)
+"ins x Leaf = Up\<^sub>i Leaf x Leaf" |
+"ins x (Node2 l a r) =
+   (if x < a then
+      case ins x l of
+         T\<^sub>i l' => T\<^sub>i (Node2 l' a r)
+       | Up\<^sub>i l1 b l2 => T\<^sub>i (Node3 l1 b l2 a r)
+    else if x=a then T\<^sub>i (Node2 l x r)
     else
-      case ins a r of
-        T\<^sub>i r' => T\<^sub>i (Node2 l x r')
-      | Up\<^sub>i r1 q r2 => T\<^sub>i (Node3 l x r1 q r2))" |
-"ins a (Node3 l x1 m x2 r) =
-   (if a < x1 then
-      case ins a l of
-        T\<^sub>i l' => T\<^sub>i (Node3 l' x1 m x2 r)
-      | Up\<^sub>i l1 q l2 => Up\<^sub>i (Node2 l1 q l2) x1 (Node2 m x2 r)
-    else if a=x1 then T\<^sub>i (Node3 l x1 m x2 r)
-    else if a < x2 then
-           case ins a m of
-             T\<^sub>i m' => T\<^sub>i (Node3 l x1 m' x2 r)
-           | Up\<^sub>i m1 q m2 => Up\<^sub>i (Node2 l x1 m1) q (Node2 m2 x2 r)
-         else if a=x2 then T\<^sub>i (Node3 l x1 m x2 r)
-         else
-           case ins a r of
-             T\<^sub>i r' => T\<^sub>i (Node3 l x1 m x2 r')
-           | Up\<^sub>i r1 q r2 => Up\<^sub>i (Node2 l x1 m) x2 (Node2 r1 q r2))"
+      case ins x r of
+        T\<^sub>i r' => T\<^sub>i (Node2 l a r')
+      | Up\<^sub>i r1 b r2 => T\<^sub>i (Node3 l a r1 b r2))" |
+"ins x (Node3 l a m b r) =
+   (if x < a then
+      case ins x l of
+        T\<^sub>i l' => T\<^sub>i (Node3 l' a m b r)
+      | Up\<^sub>i l1 c l2 => Up\<^sub>i (Node2 l1 c l2) a (Node2 m b r)
+    else
+    if x > b then
+      case ins x r of
+        T\<^sub>i r' => T\<^sub>i (Node3 l a m b r')
+      | Up\<^sub>i r1 c r2 => Up\<^sub>i (Node2 l a m) b (Node2 r1 c r2)
+    else
+    if x=a \<or> x = b then T\<^sub>i (Node3 l a m b r)
+    else
+      case ins x m of
+        T\<^sub>i m' => T\<^sub>i (Node3 l a m' b r)
+      | Up\<^sub>i m1 c m2 => Up\<^sub>i (Node2 l a m1) c (Node2 m2 b r))"
 
 hide_const insert
 
 definition insert :: "'a::linorder \<Rightarrow> 'a tree23 \<Rightarrow> 'a tree23" where
-"insert a t = tree\<^sub>i(ins a t)"
+"insert x t = tree\<^sub>i(ins x t)"
 
 datatype 'a up\<^sub>d = T\<^sub>d "'a tree23" | Up\<^sub>d "'a tree23"
 
@@ -94,21 +95,21 @@
 
 fun del :: "'a::linorder \<Rightarrow> 'a tree23 \<Rightarrow> 'a up\<^sub>d"
 where
-"del k Leaf = T\<^sub>d Leaf" |
-"del k (Node2 Leaf p Leaf) = (if k=p then Up\<^sub>d Leaf else T\<^sub>d(Node2 Leaf p Leaf))" |
-"del k (Node3 Leaf p Leaf q Leaf) = T\<^sub>d(if k=p then Node2 Leaf q Leaf
-  else if k=q then Node2 Leaf p Leaf else Node3 Leaf p Leaf q Leaf)" |
-"del k (Node2 l a r) = (if k<a then node21 (del k l) a r else
-  if k > a then node22 l a (del k r) else
+"del x Leaf = T\<^sub>d Leaf" |
+"del x (Node2 Leaf a Leaf) = (if x = a then Up\<^sub>d Leaf else T\<^sub>d(Node2 Leaf a Leaf))" |
+"del x (Node3 Leaf a Leaf b Leaf) = T\<^sub>d(if x = a then Node2 Leaf b Leaf
+  else if x = b then Node2 Leaf a Leaf else Node3 Leaf a Leaf b Leaf)" |
+"del x (Node2 l a r) = (if x<a then node21 (del x l) a r else
+  if x > a then node22 l a (del x r) else
   let (a',t) = del_min r in node22 l a' t)" |
-"del k (Node3 l a m b r) = (if k<a then node31 (del k l) a m b r else
-  if k = a then let (a',m') = del_min m in node32 l a' m' b r else
-  if k < b then node32 l a (del k m) b r else
-  if k = b then let (b',r') = del_min r in node33 l a m b' r'
-  else node33 l a m b (del k r))"
+"del x (Node3 l a m b r) = (if x<a then node31 (del x l) a m b r else
+  if x = a then let (a',m') = del_min m in node32 l a' m' b r else
+  if x < b then node32 l a (del x m) b r else
+  if x = b then let (b',r') = del_min r in node33 l a m b' r'
+  else node33 l a m b (del x r))"
 
 definition delete :: "'a::linorder \<Rightarrow> 'a tree23 \<Rightarrow> 'a tree23" where
-"delete k t = tree\<^sub>d(del k t)"
+"delete x t = tree\<^sub>d(del x t)"
 
 
 subsection "Functional Correctness"
@@ -127,7 +128,7 @@
 
 lemma inorder_ins:
   "sorted(inorder t) \<Longrightarrow> inorder(tree\<^sub>i(ins x t)) = ins_list x (inorder t)"
-by(induction t) (auto simp: ins_list_simps split: up\<^sub>i.splits)
+by(induction t) (auto simp: ins_list_simps split: up\<^sub>i.splits) (* 38 secs in 2015 *)
 
 lemma inorder_insert:
   "sorted(inorder t) \<Longrightarrow> inorder(insert a t) = ins_list a (inorder t)"
@@ -194,7 +195,7 @@
 end
 
 lemma bal_ins: "bal t \<Longrightarrow> bal (tree\<^sub>i(ins a t)) \<and> height(ins a t) = height t"
-by (induct t) (auto split: up\<^sub>i.split) (* 25 secs in 2015 *)
+by (induct t) (auto split: up\<^sub>i.split) (* 87 secs in 2015 *)
 
 text{* Now an alternative proof (by Brian Huffman) that runs faster because
 two properties (balance and height) are combined in one predicate. *}
--- a/src/HOL/Data_Structures/Tree_Map.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/Tree_Map.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -14,16 +14,16 @@
   if x > a then lookup r x else Some b)"
 
 fun update :: "'a::linorder \<Rightarrow> 'b \<Rightarrow> ('a*'b) tree \<Rightarrow> ('a*'b) tree" where
-"update a b Leaf = Node Leaf (a,b) Leaf" |
-"update a b (Node l (x,y) r) =
-   (if a < x then Node (update a b l) (x,y) r
-    else if a=x then Node l (a,b) r
-    else Node l (x,y) (update a b r))"
+"update x y Leaf = Node Leaf (x,y) Leaf" |
+"update x y (Node l (a,b) r) =
+   (if x < a then Node (update x y l) (a,b) r
+    else if x = a then Node l (x,y) r
+    else Node l (a,b) (update x y r))"
 
 fun delete :: "'a::linorder \<Rightarrow> ('a*'b) tree \<Rightarrow> ('a*'b) tree" where
-"delete k Leaf = Leaf" |
-"delete k (Node l (a,b) r) = (if k<a then Node (delete k l) (a,b) r else
-  if k > a then Node l (a,b) (delete k r) else
+"delete x Leaf = Leaf" |
+"delete x (Node l (a,b) r) = (if x < a then Node (delete x l) (a,b) r else
+  if x > a then Node l (a,b) (delete x r) else
   if r = Leaf then l else let (ab',r') = del_min r in Node l ab' r')"
 
 
--- a/src/HOL/Data_Structures/Tree_Set.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Data_Structures/Tree_Set.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -15,20 +15,20 @@
 hide_const (open) insert
 
 fun insert :: "'a::linorder \<Rightarrow> 'a tree \<Rightarrow> 'a tree" where
-"insert a Leaf = Node Leaf a Leaf" |
-"insert a (Node l x r) =
-   (if a < x then Node (insert a l) x r
-    else if a=x then Node l x r
-    else Node l x (insert a r))"
+"insert x Leaf = Node Leaf x Leaf" |
+"insert x (Node l a r) =
+   (if x < a then Node (insert x l) a r else
+    if x = a then Node l a r
+    else Node l a (insert x r))"
 
 fun del_min :: "'a tree \<Rightarrow> 'a * 'a tree" where
 "del_min (Node Leaf a r) = (a, r)" |
 "del_min (Node l a r) = (let (x,l') = del_min l in (x, Node l' a r))"
 
 fun delete :: "'a::linorder \<Rightarrow> 'a tree \<Rightarrow> 'a tree" where
-"delete k Leaf = Leaf" |
-"delete k (Node l a r) = (if k<a then Node (delete k l) a r else
-  if k > a then Node l a (delete k r) else
+"delete x Leaf = Leaf" |
+"delete x (Node l a r) = (if x < a then Node (delete x l) a r else
+  if x > a then Node l a (delete x r) else
   if r = Leaf then l else let (a',r') = del_min r in Node l a' r')"
 
 
--- a/src/HOL/Hahn_Banach/Function_Norm.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Function_Norm.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -11,14 +11,13 @@
 subsection \<open>Continuous linear forms\<close>
 
 text \<open>
-  A linear form @{text f} on a normed vector space @{text "(V, \<parallel>\<cdot>\<parallel>)"}
-  is \<^emph>\<open>continuous\<close>, iff it is bounded, i.e.
+  A linear form \<open>f\<close> on a normed vector space \<open>(V, \<parallel>\<cdot>\<parallel>)\<close> is \<^emph>\<open>continuous\<close>,
+  iff it is bounded, i.e.
   \begin{center}
-  @{text "\<exists>c \<in> R. \<forall>x \<in> V. \<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>"}
+  \<open>\<exists>c \<in> R. \<forall>x \<in> V. \<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>\<close>
   \end{center}
-  In our application no other functions than linear forms are
-  considered, so we can define continuous linear forms as bounded
-  linear forms:
+  In our application no other functions than linear forms are considered, so
+  we can define continuous linear forms as bounded linear forms:
 \<close>
 
 locale continuous = linearform +
@@ -42,34 +41,31 @@
 subsection \<open>The norm of a linear form\<close>
 
 text \<open>
-  The least real number @{text c} for which holds
+  The least real number \<open>c\<close> for which holds
   \begin{center}
-  @{text "\<forall>x \<in> V. \<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>"}
+  \<open>\<forall>x \<in> V. \<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>\<close>
   \end{center}
-  is called the \<^emph>\<open>norm\<close> of @{text f}.
+  is called the \<^emph>\<open>norm\<close> of \<open>f\<close>.
 
-  For non-trivial vector spaces @{text "V \<noteq> {0}"} the norm can be
-  defined as
+  For non-trivial vector spaces \<open>V \<noteq> {0}\<close> the norm can be defined as
   \begin{center}
-  @{text "\<parallel>f\<parallel> = \<sup>x \<noteq> 0. \<bar>f x\<bar> / \<parallel>x\<parallel>"}
+  \<open>\<parallel>f\<parallel> = \<sup>x \<noteq> 0. \<bar>f x\<bar> / \<parallel>x\<parallel>\<close>
   \end{center}
 
-  For the case @{text "V = {0}"} the supremum would be taken from an
-  empty set. Since @{text \<real>} is unbounded, there would be no supremum.
-  To avoid this situation it must be guaranteed that there is an
-  element in this set. This element must be @{text "{} \<ge> 0"} so that
-  @{text fn_norm} has the norm properties. Furthermore it does not
-  have to change the norm in all other cases, so it must be @{text 0},
-  as all other elements are @{text "{} \<ge> 0"}.
+  For the case \<open>V = {0}\<close> the supremum would be taken from an empty set.
+  Since \<open>\<real>\<close> is unbounded, there would be no supremum. To avoid this
+  situation it must be guaranteed that there is an element in this set. This
+  element must be \<open>{} \<ge> 0\<close> so that \<open>fn_norm\<close> has the norm properties.
+  Furthermore it does not have to change the norm in all other cases, so it
+  must be \<open>0\<close>, as all other elements are \<open>{} \<ge> 0\<close>.
 
-  Thus we define the set @{text B} where the supremum is taken from as
-  follows:
+  Thus we define the set \<open>B\<close> where the supremum is taken from as follows:
   \begin{center}
-  @{text "{0} \<union> {\<bar>f x\<bar> / \<parallel>x\<parallel>. x \<noteq> 0 \<and> x \<in> F}"}
+  \<open>{0} \<union> {\<bar>f x\<bar> / \<parallel>x\<parallel>. x \<noteq> 0 \<and> x \<in> F}\<close>
   \end{center}
 
-  @{text fn_norm} is equal to the supremum of @{text B}, if the
-  supremum exists (otherwise it is undefined).
+  \<open>fn_norm\<close> is equal to the supremum of \<open>B\<close>, if the supremum exists
+  (otherwise it is undefined).
 \<close>
 
 locale fn_norm =
@@ -84,8 +80,8 @@
   by (simp add: B_def)
 
 text \<open>
-  The following lemma states that every continuous linear form on a
-  normed space @{text "(V, \<parallel>\<cdot>\<parallel>)"} has a function norm.
+  The following lemma states that every continuous linear form on a normed
+  space \<open>(V, \<parallel>\<cdot>\<parallel>)\<close> has a function norm.
 \<close>
 
 lemma (in normed_vectorspace_with_fn_norm) fn_norm_works:
@@ -98,19 +94,19 @@
     non-empty bounded set of reals has a supremum.\<close>
   have "\<exists>a. lub (B V f) a"
   proof (rule real_complete)
-    txt \<open>First we have to show that @{text B} is non-empty:\<close>
+    txt \<open>First we have to show that \<open>B\<close> is non-empty:\<close>
     have "0 \<in> B V f" ..
     then show "\<exists>x. x \<in> B V f" ..
 
-    txt \<open>Then we have to show that @{text B} is bounded:\<close>
+    txt \<open>Then we have to show that \<open>B\<close> is bounded:\<close>
     show "\<exists>c. \<forall>y \<in> B V f. y \<le> c"
     proof -
-      txt \<open>We know that @{text f} is bounded by some value @{text c}.\<close>
+      txt \<open>We know that \<open>f\<close> is bounded by some value \<open>c\<close>.\<close>
       from bounded obtain c where c: "\<forall>x \<in> V. \<bar>f x\<bar> \<le> c * \<parallel>x\<parallel>" ..
 
-      txt \<open>To prove the thesis, we have to show that there is some
-        @{text b}, such that @{text "y \<le> b"} for all @{text "y \<in>
-        B"}. Due to the definition of @{text B} there are two cases.\<close>
+      txt \<open>To prove the thesis, we have to show that there is some \<open>b\<close>, such
+        that \<open>y \<le> b\<close> for all \<open>y \<in> B\<close>. Due to the definition of \<open>B\<close> there are
+        two cases.\<close>
 
       def b \<equiv> "max c 0"
       have "\<forall>y \<in> B V f. y \<le> b"
@@ -121,8 +117,8 @@
           assume "y = 0"
           then show ?thesis unfolding b_def by arith
         next
-          txt \<open>The second case is @{text "y = \<bar>f x\<bar> / \<parallel>x\<parallel>"} for some
-            @{text "x \<in> V"} with @{text "x \<noteq> 0"}.\<close>
+          txt \<open>The second case is \<open>y = \<bar>f x\<bar> / \<parallel>x\<parallel>\<close> for some
+            \<open>x \<in> V\<close> with \<open>x \<noteq> 0\<close>.\<close>
           assume "y \<noteq> 0"
           with y obtain x where y_rep: "y = \<bar>f x\<bar> * inverse \<parallel>x\<parallel>"
               and x: "x \<in> V" and neq: "x \<noteq> 0"
@@ -130,7 +126,7 @@
           from x neq have gt: "0 < \<parallel>x\<parallel>" ..
 
           txt \<open>The thesis follows by a short calculation using the
-            fact that @{text f} is bounded.\<close>
+            fact that \<open>f\<close> is bounded.\<close>
 
           note y_rep
           also have "\<bar>f x\<bar> * inverse \<parallel>x\<parallel> \<le> (c * \<parallel>x\<parallel>) * inverse \<parallel>x\<parallel>"
@@ -177,16 +173,16 @@
   from this and b show ?thesis ..
 qed
 
-text \<open>The norm of a continuous function is always @{text "\<ge> 0"}.\<close>
+text \<open>The norm of a continuous function is always \<open>\<ge> 0\<close>.\<close>
 
 lemma (in normed_vectorspace_with_fn_norm) fn_norm_ge_zero [iff]:
   assumes "continuous V f norm"
   shows "0 \<le> \<parallel>f\<parallel>\<hyphen>V"
 proof -
   interpret continuous V f norm by fact
-  txt \<open>The function norm is defined as the supremum of @{text B}.
-    So it is @{text "\<ge> 0"} if all elements in @{text B} are @{text "\<ge>
-    0"}, provided the supremum exists and @{text B} is not empty.\<close>
+  txt \<open>The function norm is defined as the supremum of \<open>B\<close>.
+    So it is \<open>\<ge> 0\<close> if all elements in \<open>B\<close> are \<open>\<ge>
+    0\<close>, provided the supremum exists and \<open>B\<close> is not empty.\<close>
   have "lub (B V f) (\<parallel>f\<parallel>\<hyphen>V)"
     using \<open>continuous V f norm\<close> by (rule fn_norm_works)
   moreover have "0 \<in> B V f" ..
@@ -197,7 +193,7 @@
   \<^medskip>
   The fundamental property of function norms is:
   \begin{center}
-  @{text "\<bar>f x\<bar> \<le> \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>"}
+  \<open>\<bar>f x\<bar> \<le> \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>\<close>
   \end{center}
 \<close>
 
@@ -237,10 +233,10 @@
 
 text \<open>
   \<^medskip>
-  The function norm is the least positive real number for
-  which the following inequation holds:
+  The function norm is the least positive real number for which the
+  following inequality holds:
   \begin{center}
-    @{text "\<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>"}
+    \<open>\<bar>f x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>\<close>
   \end{center}
 \<close>
 
--- a/src/HOL/Hahn_Banach/Function_Order.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Function_Order.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -11,10 +11,10 @@
 subsection \<open>The graph of a function\<close>
 
 text \<open>
-  We define the \<^emph>\<open>graph\<close> of a (real) function @{text f} with
-  domain @{text F} as the set
+  We define the \<^emph>\<open>graph\<close> of a (real) function \<open>f\<close> with
+  domain \<open>F\<close> as the set
   \begin{center}
-  @{text "{(x, f x). x \<in> F}"}
+  \<open>{(x, f x). x \<in> F}\<close>
   \end{center}
   So we are modeling partial functions by specifying the domain and
   the mapping function. We use the term ``function'' also for its
@@ -41,8 +41,8 @@
 subsection \<open>Functions ordered by domain extension\<close>
 
 text \<open>
-  A function @{text h'} is an extension of @{text h}, iff the graph of
-  @{text h} is a subset of the graph of @{text h'}.
+  A function \<open>h'\<close> is an extension of \<open>h\<close>, iff the graph of
+  \<open>h\<close> is a subset of the graph of \<open>h'\<close>.
 \<close>
 
 lemma graph_extI:
@@ -60,8 +60,7 @@
 subsection \<open>Domain and function of a graph\<close>
 
 text \<open>
-  The inverse functions to @{text graph} are @{text domain} and @{text
-  funct}.
+  The inverse functions to \<open>graph\<close> are \<open>domain\<close> and \<open>funct\<close>.
 \<close>
 
 definition domain :: "'a graph \<Rightarrow> 'a set"
@@ -71,8 +70,8 @@
   where "funct g = (\<lambda>x. (SOME y. (x, y) \<in> g))"
 
 text \<open>
-  The following lemma states that @{text g} is the graph of a function
-  if the relation induced by @{text g} is unique.
+  The following lemma states that \<open>g\<close> is the graph of a function if the
+  relation induced by \<open>g\<close> is unique.
 \<close>
 
 lemma graph_domain_funct:
@@ -94,10 +93,9 @@
 subsection \<open>Norm-preserving extensions of a function\<close>
 
 text \<open>
-  Given a linear form @{text f} on the space @{text F} and a seminorm
-  @{text p} on @{text E}. The set of all linear extensions of @{text
-  f}, to superspaces @{text H} of @{text F}, which are bounded by
-  @{text p}, is defined as follows.
+  Given a linear form \<open>f\<close> on the space \<open>F\<close> and a seminorm \<open>p\<close> on \<open>E\<close>. The
+  set of all linear extensions of \<open>f\<close>, to superspaces \<open>H\<close> of \<open>F\<close>, which are
+  bounded by \<open>p\<close>, is defined as follows.
 \<close>
 
 definition
--- a/src/HOL/Hahn_Banach/Hahn_Banach.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Hahn_Banach.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,42 +9,39 @@
 begin
 
 text \<open>
-  We present the proof of two different versions of the Hahn-Banach
-  Theorem, closely following @{cite \<open>\S36\<close> "Heuser:1986"}.
+  We present the proof of two different versions of the Hahn-Banach Theorem,
+  closely following @{cite \<open>\S36\<close> "Heuser:1986"}.
 \<close>
 
+
 subsection \<open>The Hahn-Banach Theorem for vector spaces\<close>
 
 paragraph \<open>Hahn-Banach Theorem.\<close>
 text \<open>
-  Let @{text F} be a subspace of a real vector space @{text E}, let @{text
-  p} be a semi-norm on @{text E}, and @{text f} be a linear form defined on
-  @{text F} such that @{text f} is bounded by @{text p}, i.e. @{text "\<forall>x \<in>
-  F. f x \<le> p x"}. Then @{text f} can be extended to a linear form @{text h}
-  on @{text E} such that @{text h} is norm-preserving, i.e. @{text h} is
-  also bounded by @{text p}.
+  Let \<open>F\<close> be a subspace of a real vector space \<open>E\<close>, let \<open>p\<close> be a semi-norm
+  on \<open>E\<close>, and \<open>f\<close> be a linear form defined on \<open>F\<close> such that \<open>f\<close> is bounded
+  by \<open>p\<close>, i.e. \<open>\<forall>x \<in> F. f x \<le> p x\<close>. Then \<open>f\<close> can be extended to a linear
+  form \<open>h\<close> on \<open>E\<close> such that \<open>h\<close> is norm-preserving, i.e. \<open>h\<close> is also bounded
+  by \<open>p\<close>.
 \<close>
 
 paragraph \<open>Proof Sketch.\<close>
 text \<open>
-  \<^enum> Define @{text M} as the set of norm-preserving extensions of
-  @{text f} to subspaces of @{text E}. The linear forms in @{text M}
-  are ordered by domain extension.
+  \<^enum> Define \<open>M\<close> as the set of norm-preserving extensions of \<open>f\<close> to subspaces
+  of \<open>E\<close>. The linear forms in \<open>M\<close> are ordered by domain extension.
 
-  \<^enum> We show that every non-empty chain in @{text M} has an upper
-  bound in @{text M}.
+  \<^enum> We show that every non-empty chain in \<open>M\<close> has an upper bound in \<open>M\<close>.
+
+  \<^enum> With Zorn's Lemma we conclude that there is a maximal function \<open>g\<close> in
+  \<open>M\<close>.
 
-  \<^enum> With Zorn's Lemma we conclude that there is a maximal function
-  @{text g} in @{text M}.
-
-  \<^enum> The domain @{text H} of @{text g} is the whole space @{text
-  E}, as shown by classical contradiction:
+  \<^enum> The domain \<open>H\<close> of \<open>g\<close> is the whole space \<open>E\<close>, as shown by classical
+  contradiction:
 
-    \<^item> Assuming @{text g} is not defined on whole @{text E}, it can
-    still be extended in a norm-preserving way to a super-space @{text
-    H'} of @{text H}.
+    \<^item> Assuming \<open>g\<close> is not defined on whole \<open>E\<close>, it can still be extended in
+    a norm-preserving way to a super-space \<open>H'\<close> of \<open>H\<close>.
 
-    \<^item> Thus @{text g} can not be maximal. Contradiction!
+    \<^item> Thus \<open>g\<close> can not be maximal. Contradiction!
 \<close>
 
 theorem Hahn_Banach:
@@ -52,9 +49,9 @@
     and "seminorm E p" and "linearform F f"
   assumes fp: "\<forall>x \<in> F. f x \<le> p x"
   shows "\<exists>h. linearform E h \<and> (\<forall>x \<in> F. h x = f x) \<and> (\<forall>x \<in> E. h x \<le> p x)"
-    -- \<open>Let @{text E} be a vector space, @{text F} a subspace of @{text E}, @{text p} a seminorm on @{text E},\<close>
-    -- \<open>and @{text f} a linear form on @{text F} such that @{text f} is bounded by @{text p},\<close>
-    -- \<open>then @{text f} can be extended to a linear form @{text h} on @{text E} in a norm-preserving way. \<^smallskip>\<close>
+    -- \<open>Let \<open>E\<close> be a vector space, \<open>F\<close> a subspace of \<open>E\<close>, \<open>p\<close> a seminorm on \<open>E\<close>,\<close>
+    -- \<open>and \<open>f\<close> a linear form on \<open>F\<close> such that \<open>f\<close> is bounded by \<open>p\<close>,\<close>
+    -- \<open>then \<open>f\<close> can be extended to a linear form \<open>h\<close> on \<open>E\<close> in a norm-preserving way. \<^smallskip>\<close>
 proof -
   interpret vectorspace E by fact
   interpret subspace F E by fact
@@ -67,8 +64,8 @@
   {
     fix c assume cM: "c \<in> chains M" and ex: "\<exists>x. x \<in> c"
     have "\<Union>c \<in> M"
-      -- \<open>Show that every non-empty chain @{text c} of @{text M} has an upper bound in @{text M}:\<close>
-      -- \<open>@{text "\<Union>c"} is greater than any element of the chain @{text c}, so it suffices to show @{text "\<Union>c \<in> M"}.\<close>
+      -- \<open>Show that every non-empty chain \<open>c\<close> of \<open>M\<close> has an upper bound in \<open>M\<close>:\<close>
+      -- \<open>\<open>\<Union>c\<close> is greater than any element of the chain \<open>c\<close>, so it suffices to show \<open>\<Union>c \<in> M\<close>.\<close>
       unfolding M_def
     proof (rule norm_pres_extensionI)
       let ?H = "domain (\<Union>c)"
@@ -98,9 +95,9 @@
     qed
   }
   then have "\<exists>g \<in> M. \<forall>x \<in> M. g \<subseteq> x \<longrightarrow> x = g"
-  -- \<open>With Zorn's Lemma we can conclude that there is a maximal element in @{text M}. \<^smallskip>\<close>
+  -- \<open>With Zorn's Lemma we can conclude that there is a maximal element in \<open>M\<close>. \<^smallskip>\<close>
   proof (rule Zorn's_Lemma)
-      -- \<open>We show that @{text M} is non-empty:\<close>
+      -- \<open>We show that \<open>M\<close> is non-empty:\<close>
     show "graph F f \<in> M"
       unfolding M_def
     proof (rule norm_pres_extensionI2)
@@ -119,18 +116,18 @@
     and HE: "H \<unlhd> E" and FH: "F \<unlhd> H"
     and graphs: "graph F f \<subseteq> graph H h"
     and hp: "\<forall>x \<in> H. h x \<le> p x" unfolding M_def ..
-      -- \<open>@{text g} is a norm-preserving extension of @{text f}, in other words:\<close>
-      -- \<open>@{text g} is the graph of some linear form @{text h} defined on a subspace @{text H} of @{text E},\<close>
-      -- \<open>and @{text h} is an extension of @{text f} that is again bounded by @{text p}. \<^smallskip>\<close>
+      -- \<open>\<open>g\<close> is a norm-preserving extension of \<open>f\<close>, in other words:\<close>
+      -- \<open>\<open>g\<close> is the graph of some linear form \<open>h\<close> defined on a subspace \<open>H\<close> of \<open>E\<close>,\<close>
+      -- \<open>and \<open>h\<close> is an extension of \<open>f\<close> that is again bounded by \<open>p\<close>. \<^smallskip>\<close>
   from HE E have H: "vectorspace H"
     by (rule subspace.vectorspace)
 
   have HE_eq: "H = E"
-    -- \<open>We show that @{text h} is defined on whole @{text E} by classical contradiction. \<^smallskip>\<close>
+    -- \<open>We show that \<open>h\<close> is defined on whole \<open>E\<close> by classical contradiction. \<^smallskip>\<close>
   proof (rule classical)
     assume neq: "H \<noteq> E"
-      -- \<open>Assume @{text h} is not defined on whole @{text E}. Then show that @{text h} can be extended\<close>
-      -- \<open>in a norm-preserving way to a function @{text h'} with the graph @{text g'}. \<^smallskip>\<close>
+      -- \<open>Assume \<open>h\<close> is not defined on whole \<open>E\<close>. Then show that \<open>h\<close> can be extended\<close>
+      -- \<open>in a norm-preserving way to a function \<open>h'\<close> with the graph \<open>g'\<close>. \<^smallskip>\<close>
     have "\<exists>g' \<in> M. g \<subseteq> g' \<and> g \<noteq> g'"
     proof -
       from HE have "H \<subseteq> E" ..
@@ -146,7 +143,7 @@
       qed
 
       def H' \<equiv> "H + lin x'"
-        -- \<open>Define @{text H'} as the direct sum of @{text H} and the linear closure of @{text x'}. \<^smallskip>\<close>
+        -- \<open>Define \<open>H'\<close> as the direct sum of \<open>H\<close> and the linear closure of \<open>x'\<close>. \<^smallskip>\<close>
       have HH': "H \<unlhd> H'"
       proof (unfold H'_def)
         from x'E have "vectorspace (lin x')" ..
@@ -156,8 +153,8 @@
       obtain xi where
         xi: "\<forall>y \<in> H. - p (y + x') - h y \<le> xi
           \<and> xi \<le> p (y + x') - h y"
-        -- \<open>Pick a real number @{text \<xi>} that fulfills certain inequations; this will\<close>
-        -- \<open>be used to establish that @{text h'} is a norm-preserving extension of @{text h}.
+        -- \<open>Pick a real number \<open>\<xi>\<close> that fulfills certain inequality; this will\<close>
+        -- \<open>be used to establish that \<open>h'\<close> is a norm-preserving extension of \<open>h\<close>.
            \label{ex-xi-use}\<^smallskip>\<close>
       proof -
         from H have "\<exists>xi. \<forall>y \<in> H. - p (y + x') - h y \<le> xi
@@ -185,10 +182,10 @@
 
       def h' \<equiv> "\<lambda>x. let (y, a) =
           SOME (y, a). x = y + a \<cdot> x' \<and> y \<in> H in h y + a * xi"
-        -- \<open>Define the extension @{text h'} of @{text h} to @{text H'} using @{text \<xi>}. \<^smallskip>\<close>
+        -- \<open>Define the extension \<open>h'\<close> of \<open>h\<close> to \<open>H'\<close> using \<open>\<xi>\<close>. \<^smallskip>\<close>
 
       have "g \<subseteq> graph H' h' \<and> g \<noteq> graph H' h'"
-        -- \<open>@{text h'} is an extension of @{text h} \dots \<^smallskip>\<close>
+        -- \<open>\<open>h'\<close> is an extension of \<open>h\<close> \dots \<^smallskip>\<close>
       proof
         show "g \<subseteq> graph H' h'"
         proof -
@@ -225,7 +222,7 @@
         qed
       qed
       moreover have "graph H' h' \<in> M"
-        -- \<open>and @{text h'} is norm-preserving. \<^smallskip>\<close>
+        -- \<open>and \<open>h'\<close> is norm-preserving. \<^smallskip>\<close>
       proof (unfold M_def)
         show "graph H' h' \<in> norm_pres_extensions E p F f"
         proof (rule norm_pres_extensionI2)
@@ -273,7 +270,7 @@
       ultimately show ?thesis ..
     qed
     then have "\<not> (\<forall>x \<in> M. g \<subseteq> x \<longrightarrow> g = x)" by simp
-      -- \<open>So the graph @{text g} of @{text h} cannot be maximal. Contradiction! \<^smallskip>\<close>
+      -- \<open>So the graph \<open>g\<close> of \<open>h\<close> cannot be maximal. Contradiction! \<^smallskip>\<close>
     with gx show "H = E" by contradiction
   qed
 
@@ -295,14 +292,14 @@
 
 text \<open>
   The following alternative formulation of the Hahn-Banach
-  Theorem\label{abs-Hahn-Banach} uses the fact that for a real linear
-  form @{text f} and a seminorm @{text p} the following inequations
-  are equivalent:\footnote{This was shown in lemma @{thm [source]
-  abs_ineq_iff} (see page \pageref{abs-ineq-iff}).}
+  Theorem\label{abs-Hahn-Banach} uses the fact that for a real linear form
+  \<open>f\<close> and a seminorm \<open>p\<close> the following inequality are
+  equivalent:\footnote{This was shown in lemma @{thm [source] abs_ineq_iff}
+  (see page \pageref{abs-ineq-iff}).}
   \begin{center}
   \begin{tabular}{lll}
-  @{text "\<forall>x \<in> H. \<bar>h x\<bar> \<le> p x"} & and &
-  @{text "\<forall>x \<in> H. h x \<le> p x"} \\
+  \<open>\<forall>x \<in> H. \<bar>h x\<bar> \<le> p x\<close> & and &
+  \<open>\<forall>x \<in> H. h x \<le> p x\<close> \\
   \end{tabular}
   \end{center}
 \<close>
@@ -339,9 +336,9 @@
 subsection \<open>The Hahn-Banach Theorem for normed spaces\<close>
 
 text \<open>
-  Every continuous linear form @{text f} on a subspace @{text F} of a
-  norm space @{text E}, can be extended to a continuous linear form
-  @{text g} on @{text E} such that @{text "\<parallel>f\<parallel> = \<parallel>g\<parallel>"}.
+  Every continuous linear form \<open>f\<close> on a subspace \<open>F\<close> of a norm space \<open>E\<close>,
+  can be extended to a continuous linear form \<open>g\<close> on \<open>E\<close> such that \<open>\<parallel>f\<parallel> =
+  \<parallel>g\<parallel>\<close>.
 \<close>
 
 theorem norm_Hahn_Banach:
@@ -370,22 +367,22 @@
     by (rule normed_vectorspace_with_fn_norm.fn_norm_ge_zero
       [OF normed_vectorspace_with_fn_norm.intro,
        OF F_norm \<open>continuous F f norm\<close> , folded B_def fn_norm_def])
-  txt \<open>We define a function @{text p} on @{text E} as follows:
-    @{text "p x = \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>"}\<close>
+  txt \<open>We define a function \<open>p\<close> on \<open>E\<close> as follows:
+    \<open>p x = \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>\<close>\<close>
   def p \<equiv> "\<lambda>x. \<parallel>f\<parallel>\<hyphen>F * \<parallel>x\<parallel>"
 
-  txt \<open>@{text p} is a seminorm on @{text E}:\<close>
+  txt \<open>\<open>p\<close> is a seminorm on \<open>E\<close>:\<close>
   have q: "seminorm E p"
   proof
     fix x y a assume x: "x \<in> E" and y: "y \<in> E"
     
-    txt \<open>@{text p} is positive definite:\<close>
+    txt \<open>\<open>p\<close> is positive definite:\<close>
     have "0 \<le> \<parallel>f\<parallel>\<hyphen>F" by (rule ge_zero)
     moreover from x have "0 \<le> \<parallel>x\<parallel>" ..
     ultimately show "0 \<le> p x"  
       by (simp add: p_def zero_le_mult_iff)
 
-    txt \<open>@{text p} is absolutely homogeneous:\<close>
+    txt \<open>\<open>p\<close> is absolutely homogeneous:\<close>
 
     show "p (a \<cdot> x) = \<bar>a\<bar> * p x"
     proof -
@@ -396,7 +393,7 @@
       finally show ?thesis .
     qed
 
-    txt \<open>Furthermore, @{text p} is subadditive:\<close>
+    txt \<open>Furthermore, \<open>p\<close> is subadditive:\<close>
 
     show "p (x + y) \<le> p x + p y"
     proof -
@@ -411,7 +408,7 @@
     qed
   qed
 
-  txt \<open>@{text f} is bounded by @{text p}.\<close>
+  txt \<open>\<open>f\<close> is bounded by \<open>p\<close>.\<close>
 
   have "\<forall>x \<in> F. \<bar>f x\<bar> \<le> p x"
   proof
@@ -423,10 +420,10 @@
          OF F_norm, folded B_def fn_norm_def])
   qed
 
-  txt \<open>Using the fact that @{text p} is a seminorm and @{text f} is bounded
-    by @{text p} we can apply the Hahn-Banach Theorem for real vector
-    spaces. So @{text f} can be extended in a norm-preserving way to
-    some function @{text g} on the whole vector space @{text E}.\<close>
+  txt \<open>Using the fact that \<open>p\<close> is a seminorm and \<open>f\<close> is bounded by \<open>p\<close> we
+    can apply the Hahn-Banach Theorem for real vector spaces. So \<open>f\<close> can be
+    extended in a norm-preserving way to some function \<open>g\<close> on the whole
+    vector space \<open>E\<close>.\<close>
 
   with E FE linearform q obtain g where
       linearformE: "linearform E g"
@@ -434,7 +431,7 @@
     and b: "\<forall>x \<in> E. \<bar>g x\<bar> \<le> p x"
     by (rule abs_Hahn_Banach [elim_format]) iprover
 
-  txt \<open>We furthermore have to show that @{text g} is also continuous:\<close>
+  txt \<open>We furthermore have to show that \<open>g\<close> is also continuous:\<close>
 
   have g_cont: "continuous E g norm" using linearformE
   proof
@@ -443,25 +440,25 @@
       by (simp only: p_def)
   qed
 
-  txt \<open>To complete the proof, we show that @{text "\<parallel>g\<parallel> = \<parallel>f\<parallel>"}.\<close>
+  txt \<open>To complete the proof, we show that \<open>\<parallel>g\<parallel> = \<parallel>f\<parallel>\<close>.\<close>
 
   have "\<parallel>g\<parallel>\<hyphen>E = \<parallel>f\<parallel>\<hyphen>F"
   proof (rule order_antisym)
     txt \<open>
-      First we show @{text "\<parallel>g\<parallel> \<le> \<parallel>f\<parallel>"}.  The function norm @{text
-      "\<parallel>g\<parallel>"} is defined as the smallest @{text "c \<in> \<real>"} such that
+      First we show \<open>\<parallel>g\<parallel> \<le> \<parallel>f\<parallel>\<close>. The function norm \<open>\<parallel>g\<parallel>\<close> is defined as the
+      smallest \<open>c \<in> \<real>\<close> such that
       \begin{center}
       \begin{tabular}{l}
-      @{text "\<forall>x \<in> E. \<bar>g x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>"}
+      \<open>\<forall>x \<in> E. \<bar>g x\<bar> \<le> c \<cdot> \<parallel>x\<parallel>\<close>
       \end{tabular}
       \end{center}
-      \noindent Furthermore holds
+      \<^noindent> Furthermore holds
       \begin{center}
       \begin{tabular}{l}
-      @{text "\<forall>x \<in> E. \<bar>g x\<bar> \<le> \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>"}
+      \<open>\<forall>x \<in> E. \<bar>g x\<bar> \<le> \<parallel>f\<parallel> \<cdot> \<parallel>x\<parallel>\<close>
       \end{tabular}
       \end{center}
-\<close>
+    \<close>
 
     from g_cont _ ge_zero
     show "\<parallel>g\<parallel>\<hyphen>E \<le> \<parallel>f\<parallel>\<hyphen>F"
--- a/src/HOL/Hahn_Banach/Hahn_Banach_Ext_Lemmas.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Hahn_Banach_Ext_Lemmas.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,34 +9,30 @@
 begin
 
 text \<open>
-  In this section the following context is presumed.  Let @{text E} be
-  a real vector space with a seminorm @{text q} on @{text E}. @{text
-  F} is a subspace of @{text E} and @{text f} a linear function on
-  @{text F}. We consider a subspace @{text H} of @{text E} that is a
-  superspace of @{text F} and a linear form @{text h} on @{text
-  H}. @{text H} is a not equal to @{text E} and @{text "x\<^sub>0"} is
-  an element in @{text "E - H"}.  @{text H} is extended to the direct
-  sum @{text "H' = H + lin x\<^sub>0"}, so for any @{text "x \<in> H'"}
-  the decomposition of @{text "x = y + a \<cdot> x"} with @{text "y \<in> H"} is
-  unique. @{text h'} is defined on @{text H'} by @{text "h' x = h y +
-  a \<cdot> \<xi>"} for a certain @{text \<xi>}.
+  In this section the following context is presumed. Let \<open>E\<close> be a real
+  vector space with a seminorm \<open>q\<close> on \<open>E\<close>. \<open>F\<close> is a subspace of \<open>E\<close> and \<open>f\<close>
+  a linear function on \<open>F\<close>. We consider a subspace \<open>H\<close> of \<open>E\<close> that is a
+  superspace of \<open>F\<close> and a linear form \<open>h\<close> on \<open>H\<close>. \<open>H\<close> is a not equal to \<open>E\<close>
+  and \<open>x\<^sub>0\<close> is an element in \<open>E - H\<close>. \<open>H\<close> is extended to the direct sum \<open>H'
+  = H + lin x\<^sub>0\<close>, so for any \<open>x \<in> H'\<close> the decomposition of \<open>x = y + a \<cdot> x\<close>
+  with \<open>y \<in> H\<close> is unique. \<open>h'\<close> is defined on \<open>H'\<close> by \<open>h' x = h y + a \<cdot> \<xi>\<close>
+  for a certain \<open>\<xi>\<close>.
 
-  Subsequently we show some properties of this extension @{text h'} of
-  @{text h}.
+  Subsequently we show some properties of this extension \<open>h'\<close> of \<open>h\<close>.
 
   \<^medskip>
-  This lemma will be used to show the existence of a linear
-  extension of @{text f} (see page \pageref{ex-xi-use}). It is a
-  consequence of the completeness of @{text \<real>}. To show
+  This lemma will be used to show the existence of a linear extension of \<open>f\<close>
+  (see page \pageref{ex-xi-use}). It is a consequence of the completeness of
+  \<open>\<real>\<close>. To show
   \begin{center}
   \begin{tabular}{l}
-  @{text "\<exists>\<xi>. \<forall>y \<in> F. a y \<le> \<xi> \<and> \<xi> \<le> b y"}
+  \<open>\<exists>\<xi>. \<forall>y \<in> F. a y \<le> \<xi> \<and> \<xi> \<le> b y\<close>
   \end{tabular}
   \end{center}
-  \noindent it suffices to show that
+  \<^noindent> it suffices to show that
   \begin{center}
   \begin{tabular}{l}
-  @{text "\<forall>u \<in> F. \<forall>v \<in> F. a u \<le> b v"}
+  \<open>\<forall>u \<in> F. \<forall>v \<in> F. a u \<le> b v\<close>
   \end{tabular}
   \end{center}
 \<close>
@@ -48,7 +44,7 @@
 proof -
   interpret vectorspace F by fact
   txt \<open>From the completeness of the reals follows:
-    The set @{text "S = {a u. u \<in> F}"} has a supremum, if it is
+    The set \<open>S = {a u. u \<in> F}\<close> has a supremum, if it is
     non-empty and has an upper bound.\<close>
 
   let ?S = "{a u | u. u \<in> F}"
@@ -86,9 +82,8 @@
 
 text \<open>
   \<^medskip>
-  The function @{text h'} is defined as a @{text "h' x = h y
-  + a \<cdot> \<xi>"} where @{text "x = y + a \<cdot> \<xi>"} is a linear extension of
-  @{text h} to @{text H'}.
+  The function \<open>h'\<close> is defined as a \<open>h' x = h y + a \<cdot> \<xi>\<close> where
+  \<open>x = y + a \<cdot> \<xi>\<close> is a linear extension of \<open>h\<close> to \<open>H'\<close>.
 \<close>
 
 lemma h'_lf:
@@ -194,8 +189,8 @@
 
 text \<open>
   \<^medskip>
-  The linear extension @{text h'} of @{text h}
-  is bounded by the seminorm @{text p}.\<close>
+  The linear extension \<open>h'\<close> of \<open>h\<close> is bounded by the seminorm \<open>p\<close>.
+\<close>
 
 lemma h'_norm_pres:
   assumes h'_def: "h' \<equiv> \<lambda>x. let (y, a) =
@@ -235,8 +230,8 @@
         also from x0 y' z have "p y = p (y + a \<cdot> x0)" by simp
         finally show ?thesis .
       next
-        txt \<open>In the case @{text "a < 0"}, we use @{text "a\<^sub>1"}
-          with @{text ya} taken as @{text "y / a"}:\<close>
+        txt \<open>In the case \<open>a < 0\<close>, we use \<open>a\<^sub>1\<close>
+          with \<open>ya\<close> taken as \<open>y / a\<close>:\<close>
         assume lz: "a < 0" then have nz: "a \<noteq> 0" by simp
         from a1 ay
         have "- p (inverse a \<cdot> y + x0) - h (inverse a \<cdot> y) \<le> xi" ..
@@ -257,8 +252,8 @@
         finally have "a * xi \<le> p (y + a \<cdot> x0) - h y" .
         then show ?thesis by simp
       next
-        txt \<open>In the case @{text "a > 0"}, we use @{text "a\<^sub>2"}
-          with @{text ya} taken as @{text "y / a"}:\<close>
+        txt \<open>In the case \<open>a > 0\<close>, we use \<open>a\<^sub>2\<close>
+          with \<open>ya\<close> taken as \<open>y / a\<close>:\<close>
         assume gz: "0 < a" then have nz: "a \<noteq> 0" by simp
         from a2 ay
         have "xi \<le> p (inverse a \<cdot> y + x0) - h (inverse a \<cdot> y)" ..
--- a/src/HOL/Hahn_Banach/Hahn_Banach_Sup_Lemmas.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Hahn_Banach_Sup_Lemmas.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -2,27 +2,25 @@
     Author:     Gertrud Bauer, TU Munich
 *)
 
-section \<open>The supremum w.r.t.~the function order\<close>
+section \<open>The supremum wrt.\ the function order\<close>
 
 theory Hahn_Banach_Sup_Lemmas
 imports Function_Norm Zorn_Lemma
 begin
 
 text \<open>
-  This section contains some lemmas that will be used in the proof of
-  the Hahn-Banach Theorem.  In this section the following context is
-  presumed.  Let @{text E} be a real vector space with a seminorm
-  @{text p} on @{text E}.  @{text F} is a subspace of @{text E} and
-  @{text f} a linear form on @{text F}. We consider a chain @{text c}
-  of norm-preserving extensions of @{text f}, such that @{text "\<Union>c =
-  graph H h"}.  We will show some properties about the limit function
-  @{text h}, i.e.\ the supremum of the chain @{text c}.
+  This section contains some lemmas that will be used in the proof of the
+  Hahn-Banach Theorem. In this section the following context is presumed.
+  Let \<open>E\<close> be a real vector space with a seminorm \<open>p\<close> on \<open>E\<close>. \<open>F\<close> is a
+  subspace of \<open>E\<close> and \<open>f\<close> a linear form on \<open>F\<close>. We consider a chain \<open>c\<close> of
+  norm-preserving extensions of \<open>f\<close>, such that \<open>\<Union>c = graph H h\<close>. We will
+  show some properties about the limit function \<open>h\<close>, i.e.\ the supremum of
+  the chain \<open>c\<close>.
 
   \<^medskip>
-  Let @{text c} be a chain of norm-preserving extensions of
-  the function @{text f} and let @{text "graph H h"} be the supremum
-  of @{text c}.  Every element in @{text H} is member of one of the
-  elements of the chain.
+  Let \<open>c\<close> be a chain of norm-preserving extensions of the function \<open>f\<close> and
+  let \<open>graph H h\<close> be the supremum of \<open>c\<close>. Every element in \<open>H\<close> is member of
+  one of the elements of the chain.
 \<close>
 
 lemmas [dest?] = chainsD
@@ -57,11 +55,10 @@
 
 text \<open>
   \<^medskip>
-  Let @{text c} be a chain of norm-preserving extensions of
-  the function @{text f} and let @{text "graph H h"} be the supremum
-  of @{text c}.  Every element in the domain @{text H} of the supremum
-  function is member of the domain @{text H'} of some function @{text
-  h'}, such that @{text h} extends @{text h'}.
+  Let \<open>c\<close> be a chain of norm-preserving extensions of the function \<open>f\<close> and
+  let \<open>graph H h\<close> be the supremum of \<open>c\<close>. Every element in the domain \<open>H\<close> of
+  the supremum function is member of the domain \<open>H'\<close> of some function \<open>h'\<close>,
+  such that \<open>h\<close> extends \<open>h'\<close>.
 \<close>
 
 lemma some_H'h':
@@ -86,10 +83,9 @@
 
 text \<open>
   \<^medskip>
-  Any two elements @{text x} and @{text y} in the domain
-  @{text H} of the supremum function @{text h} are both in the domain
-  @{text H'} of some function @{text h'}, such that @{text h} extends
-  @{text h'}.
+  Any two elements \<open>x\<close> and \<open>y\<close> in the domain \<open>H\<close> of the supremum function
+  \<open>h\<close> are both in the domain \<open>H'\<close> of some function \<open>h'\<close>, such that \<open>h\<close>
+  extends \<open>h'\<close>.
 \<close>
 
 lemma some_H'h'2:
@@ -103,8 +99,8 @@
     \<and> linearform H' h' \<and> H' \<unlhd> E \<and> F \<unlhd> H'
     \<and> graph F f \<subseteq> graph H' h' \<and> (\<forall>x \<in> H'. h' x \<le> p x)"
 proof -
-  txt \<open>@{text y} is in the domain @{text H''} of some function @{text h''},
-  such that @{text h} extends @{text h''}.\<close>
+  txt \<open>\<open>y\<close> is in the domain \<open>H''\<close> of some function \<open>h''\<close>,
+  such that \<open>h\<close> extends \<open>h''\<close>.\<close>
 
   from M cM u and y obtain H' h' where
       y_hy: "(y, h y) \<in> graph H' h'"
@@ -114,8 +110,8 @@
       "graph F f \<subseteq> graph H' h'"  "\<forall>x \<in> H'. h' x \<le> p x"
     by (rule some_H'h't [elim_format]) blast
 
-  txt \<open>@{text x} is in the domain @{text H'} of some function @{text h'},
-    such that @{text h} extends @{text h'}.\<close>
+  txt \<open>\<open>x\<close> is in the domain \<open>H'\<close> of some function \<open>h'\<close>,
+    such that \<open>h\<close> extends \<open>h'\<close>.\<close>
 
   from M cM u and x obtain H'' h'' where
       x_hx: "(x, h x) \<in> graph H'' h''"
@@ -125,9 +121,9 @@
       "graph F f \<subseteq> graph H'' h''"  "\<forall>x \<in> H''. h'' x \<le> p x"
     by (rule some_H'h't [elim_format]) blast
 
-  txt \<open>Since both @{text h'} and @{text h''} are elements of the chain,
-    @{text h''} is an extension of @{text h'} or vice versa. Thus both
-    @{text x} and @{text y} are contained in the greater
+  txt \<open>Since both \<open>h'\<close> and \<open>h''\<close> are elements of the chain,
+    \<open>h''\<close> is an extension of \<open>h'\<close> or vice versa. Thus both
+    \<open>x\<close> and \<open>y\<close> are contained in the greater
     one. \label{cases1}\<close>
 
   from cM c'' c' consider "graph H'' h'' \<subseteq> graph H' h'" | "graph H' h' \<subseteq> graph H'' h''"
@@ -159,8 +155,8 @@
 
 text \<open>
   \<^medskip>
-  The relation induced by the graph of the supremum of a
-  chain @{text c} is definite, i.~e.~t is the graph of a function.
+  The relation induced by the graph of the supremum of a chain \<open>c\<close> is
+  definite, i.e.\ it is the graph of a function.
 \<close>
 
 lemma sup_definite:
@@ -182,9 +178,8 @@
   then obtain H2 h2 where G2_rep: "G2 = graph H2 h2"
     unfolding M_def by blast
 
-  txt \<open>@{text "G\<^sub>1"} is contained in @{text "G\<^sub>2"}
-    or vice versa, since both @{text "G\<^sub>1"} and @{text
-    "G\<^sub>2"} are members of @{text c}. \label{cases2}\<close>
+  txt \<open>\<open>G\<^sub>1\<close> is contained in \<open>G\<^sub>2\<close> or vice versa, since both \<open>G\<^sub>1\<close> and \<open>G\<^sub>2\<close>
+    are members of \<open>c\<close>. \label{cases2}\<close>
 
   from cM G1 G2 consider "G1 \<subseteq> G2" | "G2 \<subseteq> G1"
     by (blast dest: chainsD)
@@ -210,12 +205,11 @@
 
 text \<open>
   \<^medskip>
-  The limit function @{text h} is linear. Every element
-  @{text x} in the domain of @{text h} is in the domain of a function
-  @{text h'} in the chain of norm preserving extensions.  Furthermore,
-  @{text h} is an extension of @{text h'} so the function values of
-  @{text x} are identical for @{text h'} and @{text h}.  Finally, the
-  function @{text h'} is linear by construction of @{text M}.
+  The limit function \<open>h\<close> is linear. Every element \<open>x\<close> in the domain of \<open>h\<close>
+  is in the domain of a function \<open>h'\<close> in the chain of norm preserving
+  extensions. Furthermore, \<open>h\<close> is an extension of \<open>h'\<close> so the function
+  values of \<open>x\<close> are identical for \<open>h'\<close> and \<open>h\<close>. Finally, the function \<open>h'\<close>
+  is linear by construction of \<open>M\<close>.
 \<close>
 
 lemma sup_lf:
@@ -266,10 +260,9 @@
 
 text \<open>
   \<^medskip>
-  The limit of a non-empty chain of norm preserving
-  extensions of @{text f} is an extension of @{text f}, since every
-  element of the chain is an extension of @{text f} and the supremum
-  is an extension for every element of the chain.
+  The limit of a non-empty chain of norm preserving extensions of \<open>f\<close> is an
+  extension of \<open>f\<close>, since every element of the chain is an extension of \<open>f\<close>
+  and the supremum is an extension for every element of the chain.
 \<close>
 
 lemma sup_ext:
@@ -293,10 +286,9 @@
 
 text \<open>
   \<^medskip>
-  The domain @{text H} of the limit function is a superspace
-  of @{text F}, since @{text F} is a subset of @{text H}. The
-  existence of the @{text 0} element in @{text F} and the closure
-  properties follow from the fact that @{text F} is a vector space.
+  The domain \<open>H\<close> of the limit function is a superspace of \<open>F\<close>, since \<open>F\<close> is
+  a subset of \<open>H\<close>. The existence of the \<open>0\<close> element in \<open>F\<close> and the closure
+  properties follow from the fact that \<open>F\<close> is a vector space.
 \<close>
 
 lemma sup_supF:
@@ -319,8 +311,7 @@
 
 text \<open>
   \<^medskip>
-  The domain @{text H} of the limit function is a subspace of
-  @{text E}.
+  The domain \<open>H\<close> of the limit function is a subspace of \<open>E\<close>.
 \<close>
 
 lemma sup_subE:
@@ -376,8 +367,8 @@
 
 text \<open>
   \<^medskip>
-  The limit function is bounded by the norm @{text p} as
-  well, since all elements in the chain are bounded by @{text p}.
+  The limit function is bounded by the norm \<open>p\<close> as well, since all elements
+  in the chain are bounded by \<open>p\<close>.
 \<close>
 
 lemma sup_norm_pres:
@@ -398,14 +389,14 @@
 
 text \<open>
   \<^medskip>
-  The following lemma is a property of linear forms on real
-  vector spaces. It will be used for the lemma @{text abs_Hahn_Banach}
-  (see page \pageref{abs-Hahn_Banach}). \label{abs-ineq-iff} For real
-  vector spaces the following inequations are equivalent:
+  The following lemma is a property of linear forms on real vector spaces.
+  It will be used for the lemma \<open>abs_Hahn_Banach\<close> (see page
+  \pageref{abs-Hahn-Banach}). \label{abs-ineq-iff} For real vector spaces
+  the following inequality are equivalent:
   \begin{center}
   \begin{tabular}{lll}
-  @{text "\<forall>x \<in> H. \<bar>h x\<bar> \<le> p x"} & and &
-  @{text "\<forall>x \<in> H. h x \<le> p x"} \\
+  \<open>\<forall>x \<in> H. \<bar>h x\<bar> \<le> p x\<close> & and &
+  \<open>\<forall>x \<in> H. h x \<le> p x\<close> \\
   \end{tabular}
   \end{center}
 \<close>
--- a/src/HOL/Hahn_Banach/Linearform.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Linearform.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,8 +9,8 @@
 begin
 
 text \<open>
-  A \<^emph>\<open>linear form\<close> is a function on a vector space into the reals
-  that is additive and multiplicative.
+  A \<^emph>\<open>linear form\<close> is a function on a vector space into the reals that is
+  additive and multiplicative.
 \<close>
 
 locale linearform =
@@ -44,7 +44,7 @@
   finally show ?thesis by simp
 qed
 
-text \<open>Every linear form yields @{text 0} for the @{text 0} vector.\<close>
+text \<open>Every linear form yields \<open>0\<close> for the \<open>0\<close> vector.\<close>
 
 lemma (in linearform) zero [iff]:
   assumes "vectorspace V"
--- a/src/HOL/Hahn_Banach/Normed_Space.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Normed_Space.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -11,9 +11,9 @@
 subsection \<open>Quasinorms\<close>
 
 text \<open>
-  A \<^emph>\<open>seminorm\<close> @{text "\<parallel>\<cdot>\<parallel>"} is a function on a real vector space
-  into the reals that has the following properties: it is positive
-  definite, absolute homogeneous and subadditive.
+  A \<^emph>\<open>seminorm\<close> \<open>\<parallel>\<cdot>\<parallel>\<close> is a function on a real vector space into the reals
+  that has the following properties: it is positive definite, absolute
+  homogeneous and subadditive.
 \<close>
 
 locale seminorm =
@@ -57,8 +57,8 @@
 subsection \<open>Norms\<close>
 
 text \<open>
-  A \<^emph>\<open>norm\<close> @{text "\<parallel>\<cdot>\<parallel>"} is a seminorm that maps only the
-  @{text 0} vector to @{text 0}.
+  A \<^emph>\<open>norm\<close> \<open>\<parallel>\<cdot>\<parallel>\<close> is a seminorm that maps only the
+  \<open>0\<close> vector to \<open>0\<close>.
 \<close>
 
 locale norm = seminorm +
--- a/src/HOL/Hahn_Banach/Subspace.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Subspace.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -11,9 +11,8 @@
 subsection \<open>Definition\<close>
 
 text \<open>
-  A non-empty subset @{text U} of a vector space @{text V} is a
-  \<^emph>\<open>subspace\<close> of @{text V}, iff @{text U} is closed under addition
-  and scalar multiplication.
+  A non-empty subset \<open>U\<close> of a vector space \<open>V\<close> is a \<^emph>\<open>subspace\<close> of \<open>V\<close>, iff
+  \<open>U\<close> is closed under addition and scalar multiplication.
 \<close>
 
 locale subspace =
@@ -51,9 +50,9 @@
 
 text \<open>
   \<^medskip>
-  Similar as for linear spaces, the existence of the zero
-  element in every subspace follows from the non-emptiness of the
-  carrier set and by vector space laws.
+  Similar as for linear spaces, the existence of the zero element in every
+  subspace follows from the non-emptiness of the carrier set and by vector
+  space laws.
 \<close>
 
 lemma (in subspace) zero [intro]:
@@ -140,8 +139,8 @@
 subsection \<open>Linear closure\<close>
 
 text \<open>
-  The \<^emph>\<open>linear closure\<close> of a vector @{text x} is the set of all
-  scalar multiples of @{text x}.
+  The \<^emph>\<open>linear closure\<close> of a vector \<open>x\<close> is the set of all scalar multiples
+  of \<open>x\<close>.
 \<close>
 
 definition lin :: "('a::{minus,plus,zero}) \<Rightarrow> 'a set"
@@ -227,8 +226,8 @@
 subsection \<open>Sum of two vectorspaces\<close>
 
 text \<open>
-  The \<^emph>\<open>sum\<close> of two vectorspaces @{text U} and @{text V} is the
-  set of all sums of elements from @{text U} and @{text V}.
+  The \<^emph>\<open>sum\<close> of two vectorspaces \<open>U\<close> and \<open>V\<close> is the set of all sums of
+  elements from \<open>U\<close> and \<open>V\<close>.
 \<close>
 
 lemma sum_def: "U + V = {u + v | u v. u \<in> U \<and> v \<in> V}"
@@ -246,7 +245,7 @@
     "u \<in> U \<Longrightarrow> v \<in> V \<Longrightarrow> u + v \<in> U + V"
   unfolding sum_def by blast
 
-text \<open>@{text U} is a subspace of @{text "U + V"}.\<close>
+text \<open>\<open>U\<close> is a subspace of \<open>U + V\<close>.\<close>
 
 lemma subspace_sum1 [iff]:
   assumes "vectorspace U" "vectorspace V"
@@ -329,11 +328,10 @@
 subsection \<open>Direct sums\<close>
 
 text \<open>
-  The sum of @{text U} and @{text V} is called \<^emph>\<open>direct\<close>, iff the
-  zero element is the only common element of @{text U} and @{text
-  V}. For every element @{text x} of the direct sum of @{text U} and
-  @{text V} the decomposition in @{text "x = u + v"} with
-  @{text "u \<in> U"} and @{text "v \<in> V"} is unique.
+  The sum of \<open>U\<close> and \<open>V\<close> is called \<^emph>\<open>direct\<close>, iff the zero element is the
+  only common element of \<open>U\<close> and \<open>V\<close>. For every element \<open>x\<close> of the direct
+  sum of \<open>U\<close> and \<open>V\<close> the decomposition in \<open>x = u + v\<close> with \<open>u \<in> U\<close> and
+  \<open>v \<in> V\<close> is unique.
 \<close>
 
 lemma decomp:
@@ -378,12 +376,10 @@
 qed
 
 text \<open>
-  An application of the previous lemma will be used in the proof of
-  the Hahn-Banach Theorem (see page \pageref{decomp-H-use}): for any
-  element @{text "y + a \<cdot> x\<^sub>0"} of the direct sum of a
-  vectorspace @{text H} and the linear closure of @{text "x\<^sub>0"}
-  the components @{text "y \<in> H"} and @{text a} are uniquely
-  determined.
+  An application of the previous lemma will be used in the proof of the
+  Hahn-Banach Theorem (see page \pageref{decomp-H-use}): for any element
+  \<open>y + a \<cdot> x\<^sub>0\<close> of the direct sum of a vectorspace \<open>H\<close> and the linear closure
+  of \<open>x\<^sub>0\<close> the components \<open>y \<in> H\<close> and \<open>a\<close> are uniquely determined.
 \<close>
 
 lemma decomp_H':
@@ -437,10 +433,9 @@
 qed
 
 text \<open>
-  Since for any element @{text "y + a \<cdot> x'"} of the direct sum of a
-  vectorspace @{text H} and the linear closure of @{text x'} the
-  components @{text "y \<in> H"} and @{text a} are unique, it follows from
-  @{text "y \<in> H"} that @{text "a = 0"}.
+  Since for any element \<open>y + a \<cdot> x'\<close> of the direct sum of a vectorspace \<open>H\<close>
+  and the linear closure of \<open>x'\<close> the components \<open>y \<in> H\<close> and \<open>a\<close> are unique,
+  it follows from \<open>y \<in> H\<close> that \<open>a = 0\<close>.
 \<close>
 
 lemma decomp_H'_H:
@@ -465,9 +460,8 @@
 qed
 
 text \<open>
-  The components @{text "y \<in> H"} and @{text a} in @{text "y + a \<cdot> x'"}
-  are unique, so the function @{text h'} defined by
-  @{text "h' (y + a \<cdot> x') = h y + a \<cdot> \<xi>"} is definite.
+  The components \<open>y \<in> H\<close> and \<open>a\<close> in \<open>y + a \<cdot> x'\<close> are unique, so the function
+  \<open>h'\<close> defined by \<open>h' (y + a \<cdot> x') = h y + a \<cdot> \<xi>\<close> is definite.
 \<close>
 
 lemma h'_definite:
--- a/src/HOL/Hahn_Banach/Vector_Space.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Vector_Space.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -11,9 +11,9 @@
 subsection \<open>Signature\<close>
 
 text \<open>
-  For the definition of real vector spaces a type @{typ 'a} of the
-  sort @{text "{plus, minus, zero}"} is considered, on which a real
-  scalar multiplication @{text \<cdot>} is declared.
+  For the definition of real vector spaces a type @{typ 'a} of the sort
+  \<open>{plus, minus, zero}\<close> is considered, on which a real scalar multiplication
+  \<open>\<cdot>\<close> is declared.
 \<close>
 
 consts
@@ -23,14 +23,13 @@
 subsection \<open>Vector space laws\<close>
 
 text \<open>
-  A \<^emph>\<open>vector space\<close> is a non-empty set @{text V} of elements from
-  @{typ 'a} with the following vector space laws: The set @{text V} is
-  closed under addition and scalar multiplication, addition is
-  associative and commutative; @{text "- x"} is the inverse of @{text
-  x} w.~r.~t.~addition and @{text 0} is the neutral element of
-  addition.  Addition and multiplication are distributive; scalar
-  multiplication is associative and the real number @{text "1"} is
-  the neutral element of scalar multiplication.
+  A \<^emph>\<open>vector space\<close> is a non-empty set \<open>V\<close> of elements from @{typ 'a} with
+  the following vector space laws: The set \<open>V\<close> is closed under addition and
+  scalar multiplication, addition is associative and commutative; \<open>- x\<close> is
+  the inverse of \<open>x\<close> wrt.\ addition and \<open>0\<close> is the neutral element of
+  addition. Addition and multiplication are distributive; scalar
+  multiplication is associative and the real number \<open>1\<close> is the neutral
+  element of scalar multiplication.
 \<close>
 
 locale vectorspace =
@@ -65,7 +64,8 @@
 lemma neg_closed [iff]: "x \<in> V \<Longrightarrow> - x \<in> V"
   by (simp add: negate_eq1)
 
-lemma add_left_commute: "x \<in> V \<Longrightarrow> y \<in> V \<Longrightarrow> z \<in> V \<Longrightarrow> x + (y + z) = y + (x + z)"
+lemma add_left_commute:
+  "x \<in> V \<Longrightarrow> y \<in> V \<Longrightarrow> z \<in> V \<Longrightarrow> x + (y + z) = y + (x + z)"
 proof -
   assume xyz: "x \<in> V"  "y \<in> V"  "z \<in> V"
   then have "x + (y + z) = (x + y) + z"
@@ -78,8 +78,8 @@
 lemmas add_ac = add_assoc add_commute add_left_commute
 
 
-text \<open>The existence of the zero element of a vector space
-  follows from the non-emptiness of carrier set.\<close>
+text \<open>The existence of the zero element of a vector space follows from the
+  non-emptiness of carrier set.\<close>
 
 lemma zero [iff]: "0 \<in> V"
 proof -
@@ -214,7 +214,8 @@
   then show "x + y = x + z" by (simp only:)
 qed
 
-lemma add_right_cancel: "x \<in> V \<Longrightarrow> y \<in> V \<Longrightarrow> z \<in> V \<Longrightarrow> (y + x = z + x) = (y = z)"
+lemma add_right_cancel:
+    "x \<in> V \<Longrightarrow> y \<in> V \<Longrightarrow> z \<in> V \<Longrightarrow> (y + x = z + x) = (y = z)"
   by (simp only: add_commute add_left_cancel)
 
 lemma add_assoc_cong:
@@ -372,4 +373,3 @@
 end
 
 end
-
--- a/src/HOL/Hahn_Banach/Zorn_Lemma.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/Zorn_Lemma.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -10,13 +10,12 @@
 
 text \<open>
   Zorn's Lemmas states: if every linear ordered subset of an ordered
-  set @{text S} has an upper bound in @{text S}, then there exists a
-  maximal element in @{text S}.  In our application, @{text S} is a
+  set \<open>S\<close> has an upper bound in \<open>S\<close>, then there exists a
+  maximal element in \<open>S\<close>.  In our application, \<open>S\<close> is a
   set of sets ordered by set inclusion. Since the union of a chain of
   sets is an upper bound for all elements of the chain, the conditions
-  of Zorn's lemma can be modified: if @{text S} is non-empty, it
-  suffices to show that for every non-empty chain @{text c} in @{text
-  S} the union of @{text c} also lies in @{text S}.
+  of Zorn's lemma can be modified: if \<open>S\<close> is non-empty, it
+  suffices to show that for every non-empty chain \<open>c\<close> in \<open>S\<close> the union of \<open>c\<close> also lies in \<open>S\<close>.
 \<close>
 
 theorem Zorn's_Lemma:
@@ -30,14 +29,14 @@
     show "\<exists>y \<in> S. \<forall>z \<in> c. z \<subseteq> y"
     proof cases
 
-      txt \<open>If @{text c} is an empty chain, then every element in
-        @{text S} is an upper bound of @{text c}.\<close>
+      txt \<open>If \<open>c\<close> is an empty chain, then every element in
+        \<open>S\<close> is an upper bound of \<open>c\<close>.\<close>
 
       assume "c = {}"
       with aS show ?thesis by fast
 
-      txt \<open>If @{text c} is non-empty, then @{text "\<Union>c"} is an upper
-        bound of @{text c}, lying in @{text S}.\<close>
+      txt \<open>If \<open>c\<close> is non-empty, then \<open>\<Union>c\<close> is an upper
+        bound of \<open>c\<close>, lying in \<open>S\<close>.\<close>
 
     next
       assume "c \<noteq> {}"
--- a/src/HOL/Hahn_Banach/document/root.tex	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Hahn_Banach/document/root.tex	Tue Nov 03 11:20:21 2015 +0100
@@ -16,7 +16,7 @@
 \pagenumbering{arabic}
 
 \title{The Hahn-Banach Theorem \\ for Real Vector Spaces}
-\author{Gertrud Bauer \\ \url{http://www.in.tum.de/~bauerg/}}
+\author{Gertrud Bauer}
 \maketitle
 
 \begin{abstract}
--- a/src/HOL/Isar_Examples/Basic_Logic.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Basic_Logic.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -13,10 +13,9 @@
 
 subsection \<open>Pure backward reasoning\<close>
 
-text \<open>In order to get a first idea of how Isabelle/Isar proof
-  documents may look like, we consider the propositions @{text I},
-  @{text K}, and @{text S}.  The following (rather explicit) proofs
-  should require little extra explanations.\<close>
+text \<open>In order to get a first idea of how Isabelle/Isar proof documents may
+  look like, we consider the propositions \<open>I\<close>, \<open>K\<close>, and \<open>S\<close>. The following
+  (rather explicit) proofs should require little extra explanations.\<close>
 
 lemma I: "A \<longrightarrow> A"
 proof
@@ -51,14 +50,12 @@
   qed
 qed
 
-text \<open>Isar provides several ways to fine-tune the reasoning,
-  avoiding excessive detail.  Several abbreviated language elements
-  are available, enabling the writer to express proofs in a more
-  concise way, even without referring to any automated proof tools
-  yet.
+text \<open>Isar provides several ways to fine-tune the reasoning, avoiding
+  excessive detail. Several abbreviated language elements are available,
+  enabling the writer to express proofs in a more concise way, even without
+  referring to any automated proof tools yet.
 
-  First of all, proof by assumption may be abbreviated as a single
-  dot.\<close>
+  First of all, proof by assumption may be abbreviated as a single dot.\<close>
 
 lemma "A \<longrightarrow> A"
 proof
@@ -66,21 +63,21 @@
   show A by fact+
 qed
 
-text \<open>In fact, concluding any (sub-)proof already involves solving
-  any remaining goals by assumption\footnote{This is not a completely
-  trivial operation, as proof by assumption may involve full
-  higher-order unification.}.  Thus we may skip the rather vacuous
-  body of the above proof as well.\<close>
+text \<open>In fact, concluding any (sub-)proof already involves solving any
+  remaining goals by assumption\footnote{This is not a completely trivial
+  operation, as proof by assumption may involve full higher-order
+  unification.}. Thus we may skip the rather vacuous body of the above proof
+  as well.\<close>
 
 lemma "A \<longrightarrow> A"
 proof
 qed
 
-text \<open>Note that the \isacommand{proof} command refers to the @{text
-  rule} method (without arguments) by default.  Thus it implicitly
-  applies a single rule, as determined from the syntactic form of the
-  statements involved.  The \isacommand{by} command abbreviates any
-  proof with empty body, so the proof may be further pruned.\<close>
+text \<open>Note that the \isacommand{proof} command refers to the \<open>rule\<close> method
+  (without arguments) by default. Thus it implicitly applies a single rule,
+  as determined from the syntactic form of the statements involved. The
+  \isacommand{by} command abbreviates any proof with empty body, so the
+  proof may be further pruned.\<close>
 
 lemma "A \<longrightarrow> A"
   by rule
@@ -89,19 +86,18 @@
 
 lemma "A \<longrightarrow> A" ..
 
-text \<open>Thus we have arrived at an adequate representation of the
-  proof of a tautology that holds by a single standard
-  rule.\footnote{Apparently, the rule here is implication
-  introduction.}\<close>
+text \<open>Thus we have arrived at an adequate representation of the proof of a
+  tautology that holds by a single standard rule.\footnote{Apparently, the
+  rule here is implication introduction.}
 
-text \<open>Let us also reconsider @{text K}.  Its statement is composed
-  of iterated connectives.  Basic decomposition is by a single rule at
-  a time, which is why our first version above was by nesting two
-  proofs.
+  \<^medskip>
+  Let us also reconsider \<open>K\<close>. Its statement is composed of iterated
+  connectives. Basic decomposition is by a single rule at a time, which is
+  why our first version above was by nesting two proofs.
 
-  The @{text intro} proof method repeatedly decomposes a goal's
-  conclusion.\footnote{The dual method is @{text elim}, acting on a
-  goal's premises.}\<close>
+  The \<open>intro\<close> proof method repeatedly decomposes a goal's
+  conclusion.\footnote{The dual method is \<open>elim\<close>, acting on a goal's
+  premises.}\<close>
 
 lemma "A \<longrightarrow> B \<longrightarrow> A"
 proof (intro impI)
@@ -114,29 +110,27 @@
 lemma "A \<longrightarrow> B \<longrightarrow> A"
   by (intro impI)
 
-text \<open>Just like @{text rule}, the @{text intro} and @{text elim}
-  proof methods pick standard structural rules, in case no explicit
-  arguments are given.  While implicit rules are usually just fine for
-  single rule application, this may go too far with iteration.  Thus
-  in practice, @{text intro} and @{text elim} would be typically
-  restricted to certain structures by giving a few rules only, e.g.\
-  \isacommand{proof}~@{text "(intro impI allI)"} to strip implications
-  and universal quantifiers.
+text \<open>Just like \<open>rule\<close>, the \<open>intro\<close> and \<open>elim\<close> proof methods pick standard
+  structural rules, in case no explicit arguments are given. While implicit
+  rules are usually just fine for single rule application, this may go too
+  far with iteration. Thus in practice, \<open>intro\<close> and \<open>elim\<close> would be
+  typically restricted to certain structures by giving a few rules only,
+  e.g.\ \isacommand{proof}~\<open>(intro impI allI)\<close> to strip implications and
+  universal quantifiers.
 
-  Such well-tuned iterated decomposition of certain structures is the
-  prime application of @{text intro} and @{text elim}.  In contrast,
-  terminal steps that solve a goal completely are usually performed by
-  actual automated proof methods (such as \isacommand{by}~@{text
-  blast}.\<close>
+  Such well-tuned iterated decomposition of certain structures is the prime
+  application of \<open>intro\<close> and \<open>elim\<close>. In contrast, terminal steps that solve
+  a goal completely are usually performed by actual automated proof methods
+  (such as \isacommand{by}~\<open>blast\<close>.\<close>
 
 
 subsection \<open>Variations of backward vs.\ forward reasoning\<close>
 
-text \<open>Certainly, any proof may be performed in backward-style only.
-  On the other hand, small steps of reasoning are often more naturally
-  expressed in forward-style.  Isar supports both backward and forward
-  reasoning as a first-class concept.  In order to demonstrate the
-  difference, we consider several proofs of @{text "A \<and> B \<longrightarrow> B \<and> A"}.
+text \<open>Certainly, any proof may be performed in backward-style only. On the
+  other hand, small steps of reasoning are often more naturally expressed in
+  forward-style. Isar supports both backward and forward reasoning as a
+  first-class concept. In order to demonstrate the difference, we consider
+  several proofs of \<open>A \<and> B \<longrightarrow> B \<and> A\<close>.
 
   The first version is purely backward.\<close>
 
@@ -150,13 +144,12 @@
   qed
 qed
 
-text \<open>Above, the @{text "conjunct_1/2"} projection rules had to be
-  named explicitly, since the goals @{text B} and @{text A} did not
-  provide any structural clue.  This may be avoided using
-  \isacommand{from} to focus on the @{text "A \<and> B"} assumption as the
-  current facts, enabling the use of double-dot proofs.  Note that
-  \isacommand{from} already does forward-chaining, involving the
-  @{text conjE} rule here.\<close>
+text \<open>Above, the projection rules \<open>conjunct1\<close> / \<open>conjunct2\<close> had to be named
+  explicitly, since the goals \<open>B\<close> and \<open>A\<close> did not provide any structural
+  clue. This may be avoided using \isacommand{from} to focus on the \<open>A \<and> B\<close>
+  assumption as the current facts, enabling the use of double-dot proofs.
+  Note that \isacommand{from} already does forward-chaining, involving the
+  \<open>conjE\<close> rule here.\<close>
 
 lemma "A \<and> B \<longrightarrow> B \<and> A"
 proof
@@ -168,27 +161,26 @@
   qed
 qed
 
-text \<open>In the next version, we move the forward step one level
-  upwards.  Forward-chaining from the most recent facts is indicated
-  by the \isacommand{then} command.  Thus the proof of @{text "B \<and> A"}
-  from @{text "A \<and> B"} actually becomes an elimination, rather than an
-  introduction.  The resulting proof structure directly corresponds to
-  that of the @{text conjE} rule, including the repeated goal
-  proposition that is abbreviated as @{text ?thesis} below.\<close>
+text \<open>In the next version, we move the forward step one level upwards.
+  Forward-chaining from the most recent facts is indicated by the
+  \isacommand{then} command. Thus the proof of \<open>B \<and> A\<close> from \<open>A \<and> B\<close> actually
+  becomes an elimination, rather than an introduction. The resulting proof
+  structure directly corresponds to that of the \<open>conjE\<close> rule, including the
+  repeated goal proposition that is abbreviated as \<open>?thesis\<close> below.\<close>
 
 lemma "A \<and> B \<longrightarrow> B \<and> A"
 proof
   assume "A \<and> B"
   then show "B \<and> A"
-  proof                    -- \<open>rule @{text conjE} of @{text "A \<and> B"}\<close>
+  proof                    -- \<open>rule \<open>conjE\<close> of \<open>A \<and> B\<close>\<close>
     assume B A
-    then show ?thesis ..   -- \<open>rule @{text conjI} of @{text "B \<and> A"}\<close>
+    then show ?thesis ..   -- \<open>rule \<open>conjI\<close> of \<open>B \<and> A\<close>\<close>
   qed
 qed
 
-text \<open>In the subsequent version we flatten the structure of the main
-  body by doing forward reasoning all the time.  Only the outermost
-  decomposition step is left as backward.\<close>
+text \<open>In the subsequent version we flatten the structure of the main body by
+  doing forward reasoning all the time. Only the outermost decomposition
+  step is left as backward.\<close>
 
 lemma "A \<and> B \<longrightarrow> B \<and> A"
 proof
@@ -198,9 +190,9 @@
   from \<open>B\<close> \<open>A\<close> show "B \<and> A" ..
 qed
 
-text \<open>We can still push forward-reasoning a bit further, even at the
-  risk of getting ridiculous.  Note that we force the initial proof
-  step to do nothing here, by referring to the ``-'' proof method.\<close>
+text \<open>We can still push forward-reasoning a bit further, even at the risk of
+  getting ridiculous. Note that we force the initial proof step to do
+  nothing here, by referring to the \<open>-\<close> proof method.\<close>
 
 lemma "A \<and> B \<longrightarrow> B \<and> A"
 proof -
@@ -210,27 +202,28 @@
     from \<open>A \<and> B\<close> have B ..
     from \<open>B\<close> \<open>A\<close> have "B \<and> A" ..
   }
-  then show ?thesis ..         -- \<open>rule @{text impI}\<close>
+  then show ?thesis ..         -- \<open>rule \<open>impI\<close>\<close>
 qed
 
-text \<open>\medskip With these examples we have shifted through a whole
-  range from purely backward to purely forward reasoning.  Apparently,
-  in the extreme ends we get slightly ill-structured proofs, which
-  also require much explicit naming of either rules (backward) or
-  local facts (forward).
+text \<open>
+  \<^medskip>
+  With these examples we have shifted through a whole range from purely
+  backward to purely forward reasoning. Apparently, in the extreme ends we
+  get slightly ill-structured proofs, which also require much explicit
+  naming of either rules (backward) or local facts (forward).
 
-  The general lesson learned here is that good proof style would
-  achieve just the \emph{right} balance of top-down backward
-  decomposition, and bottom-up forward composition.  In general, there
-  is no single best way to arrange some pieces of formal reasoning, of
-  course.  Depending on the actual applications, the intended audience
-  etc., rules (and methods) on the one hand vs.\ facts on the other
-  hand have to be emphasized in an appropriate way.  This requires the
-  proof writer to develop good taste, and some practice, of course.\<close>
+  The general lesson learned here is that good proof style would achieve
+  just the \<^emph>\<open>right\<close> balance of top-down backward decomposition, and
+  bottom-up forward composition. In general, there is no single best way to
+  arrange some pieces of formal reasoning, of course. Depending on the
+  actual applications, the intended audience etc., rules (and methods) on
+  the one hand vs.\ facts on the other hand have to be emphasized in an
+  appropriate way. This requires the proof writer to develop good taste, and
+  some practice, of course.
 
-text \<open>For our example the most appropriate way of reasoning is
-  probably the middle one, with conjunction introduction done after
-  elimination.\<close>
+  \<^medskip>
+  For our example the most appropriate way of reasoning is probably the
+  middle one, with conjunction introduction done after elimination.\<close>
 
 lemma "A \<and> B \<longrightarrow> B \<and> A"
 proof
@@ -246,50 +239,48 @@
 
 subsection \<open>A few examples from ``Introduction to Isabelle''\<close>
 
-text \<open>We rephrase some of the basic reasoning examples of
-  @{cite "isabelle-intro"}, using HOL rather than FOL.\<close>
+text \<open>We rephrase some of the basic reasoning examples of @{cite
+  "isabelle-intro"}, using HOL rather than FOL.\<close>
 
 
 subsubsection \<open>A propositional proof\<close>
 
-text \<open>We consider the proposition @{text "P \<or> P \<longrightarrow> P"}.  The proof
-  below involves forward-chaining from @{text "P \<or> P"}, followed by an
-  explicit case-analysis on the two \emph{identical} cases.\<close>
+text \<open>We consider the proposition \<open>P \<or> P \<longrightarrow> P\<close>. The proof below involves
+  forward-chaining from \<open>P \<or> P\<close>, followed by an explicit case-analysis on
+  the two \<^emph>\<open>identical\<close> cases.\<close>
 
 lemma "P \<or> P \<longrightarrow> P"
 proof
   assume "P \<or> P"
   then show P
-  proof                    -- \<open>
-    rule @{text disjE}: \smash{$\infer{C}{A \disj B & \infer*{C}{[A]} & \infer*{C}{[B]}}$}
-\<close>
+  proof                    -- \<open>rule \<open>disjE\<close>: \smash{$\infer{\<open>C\<close>}{\<open>A \<or> B\<close> & \infer*{\<open>C\<close>}{[\<open>A\<close>]} & \infer*{\<open>C\<close>}{[\<open>B\<close>]}}$}\<close>
     assume P show P by fact
   next
     assume P show P by fact
   qed
 qed
 
-text \<open>Case splits are \emph{not} hardwired into the Isar language as
-  a special feature.  The \isacommand{next} command used to separate
-  the cases above is just a short form of managing block structure.
+text \<open>Case splits are \<^emph>\<open>not\<close> hardwired into the Isar language as a
+  special feature. The \isacommand{next} command used to separate the cases
+  above is just a short form of managing block structure.
 
-  \medskip In general, applying proof methods may split up a goal into
-  separate ``cases'', i.e.\ new subgoals with individual local
-  assumptions.  The corresponding proof text typically mimics this by
-  establishing results in appropriate contexts, separated by blocks.
+  \<^medskip>
+  In general, applying proof methods may split up a goal into separate
+  ``cases'', i.e.\ new subgoals with individual local assumptions. The
+  corresponding proof text typically mimics this by establishing results in
+  appropriate contexts, separated by blocks.
 
   In order to avoid too much explicit parentheses, the Isar system
   implicitly opens an additional block for any new goal, the
-  \isacommand{next} statement then closes one block level, opening a
-  new one.  The resulting behavior is what one would expect from
-  separating cases, only that it is more flexible.  E.g.\ an induction
-  base case (which does not introduce local assumptions) would
-  \emph{not} require \isacommand{next} to separate the subsequent step
-  case.
+  \isacommand{next} statement then closes one block level, opening a new
+  one. The resulting behaviour is what one would expect from separating
+  cases, only that it is more flexible. E.g.\ an induction base case (which
+  does not introduce local assumptions) would \<^emph>\<open>not\<close> require
+  \isacommand{next} to separate the subsequent step case.
 
-  \medskip In our example the situation is even simpler, since the two
-  cases actually coincide.  Consequently the proof may be rephrased as
-  follows.\<close>
+  \<^medskip>
+  In our example the situation is even simpler, since the two cases actually
+  coincide. Consequently the proof may be rephrased as follows.\<close>
 
 lemma "P \<or> P \<longrightarrow> P"
 proof
@@ -316,37 +307,33 @@
 
 subsubsection \<open>A quantifier proof\<close>
 
-text \<open>To illustrate quantifier reasoning, let us prove @{text
-  "(\<exists>x. P (f x)) \<longrightarrow> (\<exists>y. P y)"}.  Informally, this holds because any
-  @{text a} with @{text "P (f a)"} may be taken as a witness for the
-  second existential statement.
+text \<open>To illustrate quantifier reasoning, let us prove
+  \<open>(\<exists>x. P (f x)) \<longrightarrow> (\<exists>y. P y)\<close>. Informally, this holds because any \<open>a\<close> with
+  \<open>P (f a)\<close> may be taken as a witness for the second existential statement.
 
-  The first proof is rather verbose, exhibiting quite a lot of
-  (redundant) detail.  It gives explicit rules, even with some
-  instantiation.  Furthermore, we encounter two new language elements:
-  the \isacommand{fix} command augments the context by some new
-  ``arbitrary, but fixed'' element; the \isacommand{is} annotation
-  binds term abbreviations by higher-order pattern matching.\<close>
+  The first proof is rather verbose, exhibiting quite a lot of (redundant)
+  detail. It gives explicit rules, even with some instantiation.
+  Furthermore, we encounter two new language elements: the \isacommand{fix}
+  command augments the context by some new ``arbitrary, but fixed'' element;
+  the \isacommand{is} annotation binds term abbreviations by higher-order
+  pattern matching.\<close>
 
 lemma "(\<exists>x. P (f x)) \<longrightarrow> (\<exists>y. P y)"
 proof
   assume "\<exists>x. P (f x)"
   then show "\<exists>y. P y"
-  proof (rule exE)             -- \<open>
-    rule @{text exE}: \smash{$\infer{B}{\ex x A(x) & \infer*{B}{[A(x)]_x}}$}
-\<close>
+  proof (rule exE)             -- \<open>rule \<open>exE\<close>: \smash{$\infer{\<open>B\<close>}{\<open>\<exists>x. A(x)\<close> & \infer*{\<open>B\<close>}{[\<open>A(x)\<close>]_x}}$}\<close>
     fix a
     assume "P (f a)" (is "P ?witness")
     then show ?thesis by (rule exI [of P ?witness])
   qed
 qed
 
-text \<open>While explicit rule instantiation may occasionally improve
-  readability of certain aspects of reasoning, it is usually quite
-  redundant.  Above, the basic proof outline gives already enough
-  structural clues for the system to infer both the rules and their
-  instances (by higher-order unification).  Thus we may as well prune
-  the text as follows.\<close>
+text \<open>While explicit rule instantiation may occasionally improve readability
+  of certain aspects of reasoning, it is usually quite redundant. Above, the
+  basic proof outline gives already enough structural clues for the system
+  to infer both the rules and their instances (by higher-order unification).
+  Thus we may as well prune the text as follows.\<close>
 
 lemma "(\<exists>x. P (f x)) \<longrightarrow> (\<exists>y. P y)"
 proof
@@ -359,10 +346,9 @@
   qed
 qed
 
-text \<open>Explicit @{text \<exists>}-elimination as seen above can become quite
-  cumbersome in practice.  The derived Isar language element
-  ``\isakeyword{obtain}'' provides a more handsome way to do
-  generalized existence reasoning.\<close>
+text \<open>Explicit \<open>\<exists>\<close>-elimination as seen above can become quite cumbersome in
+  practice. The derived Isar language element ``\isakeyword{obtain}''
+  provides a more handsome way to do generalized existence reasoning.\<close>
 
 lemma "(\<exists>x. P (f x)) \<longrightarrow> (\<exists>y. P y)"
 proof
@@ -371,21 +357,19 @@
   then show "\<exists>y. P y" ..
 qed
 
-text \<open>Technically, \isakeyword{obtain} is similar to
-  \isakeyword{fix} and \isakeyword{assume} together with a soundness
-  proof of the elimination involved.  Thus it behaves similar to any
-  other forward proof element.  Also note that due to the nature of
-  general existence reasoning involved here, any result exported from
-  the context of an \isakeyword{obtain} statement may \emph{not} refer
-  to the parameters introduced there.\<close>
+text \<open>Technically, \isakeyword{obtain} is similar to \isakeyword{fix} and
+  \isakeyword{assume} together with a soundness proof of the elimination
+  involved. Thus it behaves similar to any other forward proof element. Also
+  note that due to the nature of general existence reasoning involved here,
+  any result exported from the context of an \isakeyword{obtain} statement
+  may \<^emph>\<open>not\<close> refer to the parameters introduced there.\<close>
 
 
 subsubsection \<open>Deriving rules in Isabelle\<close>
 
-text \<open>We derive the conjunction elimination rule from the
-  corresponding projections.  The proof is quite straight-forward,
-  since Isabelle/Isar supports non-atomic goals and assumptions fully
-  transparently.\<close>
+text \<open>We derive the conjunction elimination rule from the corresponding
+  projections. The proof is quite straight-forward, since Isabelle/Isar
+  supports non-atomic goals and assumptions fully transparently.\<close>
 
 theorem conjE: "A \<and> B \<Longrightarrow> (A \<Longrightarrow> B \<Longrightarrow> C) \<Longrightarrow> C"
 proof -
--- a/src/HOL/Isar_Examples/Cantor.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Cantor.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -12,17 +12,17 @@
   the Isabelle/HOL manual @{cite "isabelle-HOL"}.}\<close>
 
 text \<open>Cantor's Theorem states that every set has more subsets than
-  it has elements.  It has become a favorite basic example in pure
-  higher-order logic since it is so easily expressed: \[\all{f::\alpha
-  \To \alpha \To \idt{bool}} \ex{S::\alpha \To \idt{bool}}
-  \all{x::\alpha} f \ap x \not= S\]
+  it has elements.  It has become a favourite basic example in pure
+  higher-order logic since it is so easily expressed:
+
+  @{text [display]
+  \<open>\<forall>f::\<alpha> \<Rightarrow> \<alpha> \<Rightarrow> bool. \<exists>S::\<alpha> \<Rightarrow> bool. \<forall>x::\<alpha>. f x \<noteq> S\<close>}
 
-  Viewing types as sets, $\alpha \To \idt{bool}$ represents the
-  powerset of $\alpha$.  This version of the theorem states that for
-  every function from $\alpha$ to its powerset, some subset is outside
-  its range.  The Isabelle/Isar proofs below uses HOL's set theory,
-  with the type $\alpha \ap \idt{set}$ and the operator
-  $\idt{range}::(\alpha \To \beta) \To \beta \ap \idt{set}$.\<close>
+  Viewing types as sets, \<open>\<alpha> \<Rightarrow> bool\<close> represents the powerset of \<open>\<alpha>\<close>. This
+  version of the theorem states that for every function from \<open>\<alpha>\<close> to its
+  powerset, some subset is outside its range. The Isabelle/Isar proofs below
+  uses HOL's set theory, with the type \<open>\<alpha> set\<close> and the operator
+  \<open>range :: (\<alpha> \<Rightarrow> \<beta>) \<Rightarrow> \<beta> set\<close>.\<close>
 
 theorem "\<exists>S. S \<notin> range (f :: 'a \<Rightarrow> 'a set)"
 proof
@@ -46,20 +46,19 @@
   qed
 qed
 
-text \<open>How much creativity is required?  As it happens, Isabelle can
-  prove this theorem automatically using best-first search.
-  Depth-first search would diverge, but best-first search successfully
-  navigates through the large search space.  The context of Isabelle's
-  classical prover contains rules for the relevant constructs of HOL's
-  set theory.\<close>
+text \<open>How much creativity is required? As it happens, Isabelle can prove
+  this theorem automatically using best-first search. Depth-first search
+  would diverge, but best-first search successfully navigates through the
+  large search space. The context of Isabelle's classical prover contains
+  rules for the relevant constructs of HOL's set theory.\<close>
 
 theorem "\<exists>S. S \<notin> range (f :: 'a \<Rightarrow> 'a set)"
   by best
 
-text \<open>While this establishes the same theorem internally, we do not
-  get any idea of how the proof actually works.  There is currently no
-  way to transform internal system-level representations of Isabelle
-  proofs back into Isar text.  Writing intelligible proof documents
-  really is a creative process, after all.\<close>
+text \<open>While this establishes the same theorem internally, we do not get any
+  idea of how the proof actually works. There is currently no way to
+  transform internal system-level representations of Isabelle proofs back
+  into Isar text. Writing intelligible proof documents really is a creative
+  process, after all.\<close>
 
 end
--- a/src/HOL/Isar_Examples/Drinker.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Drinker.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,8 +9,8 @@
 begin
 
 text \<open>Here is another example of classical reasoning: the Drinker's
-  Principle says that for some person, if he is drunk, everybody else
-  is drunk!
+  Principle says that for some person, if he is drunk, everybody else is
+  drunk!
 
   We first prove a classical part of de-Morgan's law.\<close>
 
--- a/src/HOL/Isar_Examples/Expr_Compiler.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Expr_Compiler.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -10,17 +10,16 @@
 imports Main
 begin
 
-text \<open>This is a (rather trivial) example of program verification.
-  We model a compiler for translating expressions to stack machine
-  instructions, and prove its correctness wrt.\ some evaluation
-  semantics.\<close>
+text \<open>This is a (rather trivial) example of program verification. We model a
+  compiler for translating expressions to stack machine instructions, and
+  prove its correctness wrt.\ some evaluation semantics.\<close>
 
 
 subsection \<open>Binary operations\<close>
 
-text \<open>Binary operations are just functions over some type of values.
-  This is both for abstract syntax and semantics, i.e.\ we use a
-  ``shallow embedding'' here.\<close>
+text \<open>Binary operations are just functions over some type of values. This is
+  both for abstract syntax and semantics, i.e.\ we use a ``shallow
+  embedding'' here.\<close>
 
 type_synonym 'val binop = "'val \<Rightarrow> 'val \<Rightarrow> 'val"
 
@@ -28,16 +27,15 @@
 subsection \<open>Expressions\<close>
 
 text \<open>The language of expressions is defined as an inductive type,
-  consisting of variables, constants, and binary operations on
-  expressions.\<close>
+  consisting of variables, constants, and binary operations on expressions.\<close>
 
 datatype (dead 'adr, dead 'val) expr =
     Variable 'adr
   | Constant 'val
   | Binop "'val binop" "('adr, 'val) expr" "('adr, 'val) expr"
 
-text \<open>Evaluation (wrt.\ some environment of variable assignments) is
-  defined by primitive recursion over the structure of expressions.\<close>
+text \<open>Evaluation (wrt.\ some environment of variable assignments) is defined
+  by primitive recursion over the structure of expressions.\<close>
 
 primrec eval :: "('adr, 'val) expr \<Rightarrow> ('adr \<Rightarrow> 'val) \<Rightarrow> 'val"
 where
@@ -48,16 +46,15 @@
 
 subsection \<open>Machine\<close>
 
-text \<open>Next we model a simple stack machine, with three
-  instructions.\<close>
+text \<open>Next we model a simple stack machine, with three instructions.\<close>
 
 datatype (dead 'adr, dead 'val) instr =
     Const 'val
   | Load 'adr
   | Apply "'val binop"
 
-text \<open>Execution of a list of stack machine instructions is easily
-  defined as follows.\<close>
+text \<open>Execution of a list of stack machine instructions is easily defined as
+  follows.\<close>
 
 primrec exec :: "(('adr, 'val) instr) list \<Rightarrow> 'val list \<Rightarrow> ('adr \<Rightarrow> 'val) \<Rightarrow> 'val list"
 where
@@ -75,8 +72,8 @@
 
 subsection \<open>Compiler\<close>
 
-text \<open>We are ready to define the compilation function of expressions
-  to lists of stack machine instructions.\<close>
+text \<open>We are ready to define the compilation function of expressions to
+  lists of stack machine instructions.\<close>
 
 primrec compile :: "('adr, 'val) expr \<Rightarrow> (('adr, 'val) instr) list"
 where
@@ -85,9 +82,8 @@
 | "compile (Binop f e1 e2) = compile e2 @ compile e1 @ [Apply f]"
 
 
-text \<open>The main result of this development is the correctness theorem
-  for @{text compile}.  We first establish a lemma about @{text exec}
-  and list append.\<close>
+text \<open>The main result of this development is the correctness theorem for
+  \<open>compile\<close>. We first establish a lemma about \<open>exec\<close> and list append.\<close>
 
 lemma exec_append:
   "exec (xs @ ys) stack env =
@@ -127,11 +123,14 @@
 qed
 
 
-text \<open>\bigskip In the proofs above, the @{text simp} method does
-  quite a lot of work behind the scenes (mostly ``functional program
-  execution'').  Subsequently, the same reasoning is elaborated in
-  detail --- at most one recursive function definition is used at a
-  time.  Thus we get a better idea of what is actually going on.\<close>
+text \<open>
+  \<^bigskip>
+  In the proofs above, the \<open>simp\<close> method does quite a lot of work behind the
+  scenes (mostly ``functional program execution''). Subsequently, the same
+  reasoning is elaborated in detail --- at most one recursive function
+  definition is used at a time. Thus we get a better idea of what is
+  actually going on.
+\<close>
 
 lemma exec_append':
   "exec (xs @ ys) stack env = exec ys (exec xs stack env) env"
--- a/src/HOL/Isar_Examples/Group.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Group.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -10,18 +10,17 @@
 
 subsection \<open>Groups and calculational reasoning\<close> 
 
-text \<open>Groups over signature $({\times} :: \alpha \To \alpha \To
-  \alpha, \idt{one} :: \alpha, \idt{inverse} :: \alpha \To \alpha)$
-  are defined as an axiomatic type class as follows.  Note that the
-  parent class $\idt{times}$ is provided by the basic HOL theory.\<close>
+text \<open>Groups over signature \<open>(\<times> :: \<alpha> \<Rightarrow> \<alpha> \<Rightarrow> \<alpha>, one :: \<alpha>, inverse :: \<alpha> \<Rightarrow> \<alpha>)\<close>
+  are defined as an axiomatic type class as follows. Note that the parent
+  class \<open>\<times>\<close> is provided by the basic HOL theory.\<close>
 
 class group = times + one + inverse +
   assumes group_assoc: "(x * y) * z = x * (y * z)"
     and group_left_one: "1 * x = x"
     and group_left_inverse: "inverse x * x = 1"
 
-text \<open>The group axioms only state the properties of left one and
-  inverse, the right versions may be derived as follows.\<close>
+text \<open>The group axioms only state the properties of left one and inverse,
+  the right versions may be derived as follows.\<close>
 
 theorem (in group) group_right_inverse: "x * inverse x = 1"
 proof -
@@ -44,9 +43,8 @@
   finally show ?thesis .
 qed
 
-text \<open>With \name{group-right-inverse} already available,
-  \name{group-right-one}\label{thm:group-right-one} is now established
-  much easier.\<close>
+text \<open>With \<open>group_right_inverse\<close> already available, \<open>group_right_one\<close>
+  \label{thm:group-right-one} is now established much easier.\<close>
 
 theorem (in group) group_right_one: "x * 1 = x"
 proof -
@@ -61,27 +59,27 @@
   finally show ?thesis .
 qed
 
-text \<open>\medskip The calculational proof style above follows typical
-  presentations given in any introductory course on algebra.  The
-  basic technique is to form a transitive chain of equations, which in
-  turn are established by simplifying with appropriate rules.  The
-  low-level logical details of equational reasoning are left implicit.
+text \<open>
+  \<^medskip>
+  The calculational proof style above follows typical presentations given in
+  any introductory course on algebra. The basic technique is to form a
+  transitive chain of equations, which in turn are established by
+  simplifying with appropriate rules. The low-level logical details of
+  equational reasoning are left implicit.
 
-  Note that ``$\dots$'' is just a special term variable that is bound
-  automatically to the argument\footnote{The argument of a curried
-  infix expression happens to be its right-hand side.} of the last
-  fact achieved by any local assumption or proven statement.  In
-  contrast to $\var{thesis}$, the ``$\dots$'' variable is bound
-  \emph{after} the proof is finished, though.
+  Note that ``\<open>\<dots>\<close>'' is just a special term variable that is bound
+  automatically to the argument\footnote{The argument of a curried infix
+  expression happens to be its right-hand side.} of the last fact achieved
+  by any local assumption or proven statement. In contrast to \<open>?thesis\<close>, the
+  ``\<open>\<dots>\<close>'' variable is bound \<^emph>\<open>after\<close> the proof is finished.
 
   There are only two separate Isar language elements for calculational
-  proofs: ``\isakeyword{also}'' for initial or intermediate
-  calculational steps, and ``\isakeyword{finally}'' for exhibiting the
-  result of a calculation.  These constructs are not hardwired into
-  Isabelle/Isar, but defined on top of the basic Isar/VM interpreter.
-  Expanding the \isakeyword{also} and \isakeyword{finally} derived
-  language elements, calculations may be simulated by hand as
-  demonstrated below.\<close>
+  proofs: ``\isakeyword{also}'' for initial or intermediate calculational
+  steps, and ``\isakeyword{finally}'' for exhibiting the result of a
+  calculation. These constructs are not hardwired into Isabelle/Isar, but
+  defined on top of the basic Isar/VM interpreter. Expanding the
+  \isakeyword{also} and \isakeyword{finally} derived language elements,
+  calculations may be simulated by hand as demonstrated below.\<close>
 
 theorem (in group) "x * 1 = x"
 proof -
@@ -114,51 +112,49 @@
   show ?thesis .
 qed
 
-text \<open>Note that this scheme of calculations is not restricted to
-  plain transitivity.  Rules like anti-symmetry, or even forward and
-  backward substitution work as well.  For the actual implementation
-  of \isacommand{also} and \isacommand{finally}, Isabelle/Isar
-  maintains separate context information of ``transitivity'' rules.
-  Rule selection takes place automatically by higher-order
-  unification.\<close>
+text \<open>Note that this scheme of calculations is not restricted to plain
+  transitivity. Rules like anti-symmetry, or even forward and backward
+  substitution work as well. For the actual implementation of
+  \isacommand{also} and \isacommand{finally}, Isabelle/Isar maintains
+  separate context information of ``transitivity'' rules. Rule selection
+  takes place automatically by higher-order unification.\<close>
 
 
 subsection \<open>Groups as monoids\<close>
 
-text \<open>Monoids over signature $({\times} :: \alpha \To \alpha \To
-  \alpha, \idt{one} :: \alpha)$ are defined like this.\<close>
+text \<open>Monoids over signature \<open>(\<times> :: \<alpha> \<Rightarrow> \<alpha> \<Rightarrow> \<alpha>, one :: \<alpha>)\<close> are defined like
+  this.\<close>
 
 class monoid = times + one +
   assumes monoid_assoc: "(x * y) * z = x * (y * z)"
     and monoid_left_one: "1 * x = x"
     and monoid_right_one: "x * 1 = x"
 
-text \<open>Groups are \emph{not} yet monoids directly from the
-  definition.  For monoids, \name{right-one} had to be included as an
-  axiom, but for groups both \name{right-one} and \name{right-inverse}
-  are derivable from the other axioms.  With \name{group-right-one}
-  derived as a theorem of group theory (see
+text \<open>Groups are \<^emph>\<open>not\<close> yet monoids directly from the definition. For
+  monoids, \<open>right_one\<close> had to be included as an axiom, but for groups both
+  \<open>right_one\<close> and \<open>right_inverse\<close> are derivable from the other axioms. With
+  \<open>group_right_one\<close> derived as a theorem of group theory (see
   page~\pageref{thm:group-right-one}), we may still instantiate
-  $\idt{group} \subseteq \idt{monoid}$ properly as follows.\<close>
+  \<open>group \<subseteq> monoid\<close> properly as follows.\<close>
 
-instance group < monoid
+instance group \<subseteq> monoid
   by intro_classes
     (rule group_assoc,
       rule group_left_one,
       rule group_right_one)
 
 text \<open>The \isacommand{instance} command actually is a version of
-  \isacommand{theorem}, setting up a goal that reflects the intended
-  class relation (or type constructor arity).  Thus any Isar proof
-  language element may be involved to establish this statement.  When
-  concluding the proof, the result is transformed into the intended
-  type signature extension behind the scenes.\<close>
+  \isacommand{theorem}, setting up a goal that reflects the intended class
+  relation (or type constructor arity). Thus any Isar proof language element
+  may be involved to establish this statement. When concluding the proof,
+  the result is transformed into the intended type signature extension
+  behind the scenes.\<close>
 
 
 subsection \<open>More theorems of group theory\<close>
 
 text \<open>The one element is already uniquely determined by preserving
-  an \emph{arbitrary} group element.\<close>
+  an \<^emph>\<open>arbitrary\<close> group element.\<close>
 
 theorem (in group) group_one_equality:
   assumes eq: "e * x = x"
--- a/src/HOL/Isar_Examples/Hoare.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Hoare.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -12,11 +12,10 @@
 
 subsection \<open>Abstract syntax and semantics\<close>
 
-text \<open>The following abstract syntax and semantics of Hoare Logic
-  over \texttt{WHILE} programs closely follows the existing tradition
-  in Isabelle/HOL of formalizing the presentation given in
-  @{cite \<open>\S6\<close> "Winskel:1993"}.  See also @{file "~~/src/HOL/Hoare"} and
-  @{cite "Nipkow:1998:Winskel"}.\<close>
+text \<open>The following abstract syntax and semantics of Hoare Logic over
+  \<^verbatim>\<open>WHILE\<close> programs closely follows the existing tradition in Isabelle/HOL
+  of formalizing the presentation given in @{cite \<open>\S6\<close> "Winskel:1993"}. See
+  also @{file "~~/src/HOL/Hoare"} and @{cite "Nipkow:1998:Winskel"}.\<close>
 
 type_synonym 'a bexp = "'a set"
 type_synonym 'a assn = "'a set"
@@ -60,14 +59,15 @@
 
 subsection \<open>Primitive Hoare rules\<close>
 
-text \<open>From the semantics defined above, we derive the standard set
-  of primitive Hoare rules; e.g.\ see @{cite \<open>\S6\<close> "Winskel:1993"}.
-  Usually, variant forms of these rules are applied in actual proof,
-  see also \S\ref{sec:hoare-isar} and \S\ref{sec:hoare-vcg}.
+text \<open>From the semantics defined above, we derive the standard set of
+  primitive Hoare rules; e.g.\ see @{cite \<open>\S6\<close> "Winskel:1993"}. Usually,
+  variant forms of these rules are applied in actual proof, see also
+  \S\ref{sec:hoare-isar} and \S\ref{sec:hoare-vcg}.
 
-  \medskip The \name{basic} rule represents any kind of atomic access
-  to the state space.  This subsumes the common rules of \name{skip}
-  and \name{assign}, as formulated in \S\ref{sec:hoare-isar}.\<close>
+  \<^medskip>
+  The \<open>basic\<close> rule represents any kind of atomic access to the state space.
+  This subsumes the common rules of \<open>skip\<close> and \<open>assign\<close>, as formulated in
+  \S\ref{sec:hoare-isar}.\<close>
 
 theorem basic: "\<turnstile> {s. f s \<in> P} (Basic f) P"
 proof
@@ -79,7 +79,7 @@
 qed
 
 text \<open>The rules for sequential commands and semantic consequences are
- established in a straight forward manner as follows.\<close>
+  established in a straight forward manner as follows.\<close>
 
 theorem seq: "\<turnstile> P c1 Q \<Longrightarrow> \<turnstile> Q c2 R \<Longrightarrow> \<turnstile> P (c1; c2) R"
 proof
@@ -105,8 +105,8 @@
 qed
 
 text \<open>The rule for conditional commands is directly reflected by the
-  corresponding semantics; in the proof we just have to look closely
-  which cases apply.\<close>
+  corresponding semantics; in the proof we just have to look closely which
+  cases apply.\<close>
 
 theorem cond:
   assumes case_b: "\<turnstile> (P \<inter> b) c1 Q"
@@ -134,12 +134,11 @@
   qed
 qed
 
-text \<open>The @{text while} rule is slightly less trivial --- it is the
-  only one based on recursion, which is expressed in the semantics by
-  a Kleene-style least fixed-point construction.  The auxiliary
-  statement below, which is by induction on the number of iterations
-  is the main point to be proven; the rest is by routine application
-  of the semantics of \texttt{WHILE}.\<close>
+text \<open>The \<open>while\<close> rule is slightly less trivial --- it is the only one based
+  on recursion, which is expressed in the semantics by a Kleene-style least
+  fixed-point construction. The auxiliary statement below, which is by
+  induction on the number of iterations is the main point to be proven; the
+  rest is by routine application of the semantics of \<^verbatim>\<open>WHILE\<close>.\<close>
 
 theorem while:
   assumes body: "\<turnstile> (P \<inter> b) c P"
@@ -167,24 +166,23 @@
 
 text \<open>We now introduce concrete syntax for describing commands (with
   embedded expressions) and assertions. The basic technique is that of
-  semantic ``quote-antiquote''.  A \emph{quotation} is a syntactic
-  entity delimited by an implicit abstraction, say over the state
-  space.  An \emph{antiquotation} is a marked expression within a
-  quotation that refers the implicit argument; a typical antiquotation
-  would select (or even update) components from the state.
+  semantic ``quote-antiquote''. A \<^emph>\<open>quotation\<close> is a syntactic entity
+  delimited by an implicit abstraction, say over the state space. An
+  \<^emph>\<open>antiquotation\<close> is a marked expression within a quotation that refers the
+  implicit argument; a typical antiquotation would select (or even update)
+  components from the state.
 
-  We will see some examples later in the concrete rules and
-  applications.\<close>
+  We will see some examples later in the concrete rules and applications.
 
-text \<open>The following specification of syntax and translations is for
-  Isabelle experts only; feel free to ignore it.
+  \<^medskip>
+  The following specification of syntax and translations is for Isabelle
+  experts only; feel free to ignore it.
 
-  While the first part is still a somewhat intelligible specification
-  of the concrete syntactic representation of our Hoare language, the
-  actual ``ML drivers'' is quite involved.  Just note that the we
-  re-use the basic quote/antiquote translations as already defined in
-  Isabelle/Pure (see @{ML Syntax_Trans.quote_tr}, and
-  @{ML Syntax_Trans.quote_tr'},).\<close>
+  While the first part is still a somewhat intelligible specification of the
+  concrete syntactic representation of our Hoare language, the actual ``ML
+  drivers'' is quite involved. Just note that the we re-use the basic
+  quote/antiquote translations as already defined in Isabelle/Pure (see @{ML
+  Syntax_Trans.quote_tr}, and @{ML Syntax_Trans.quote_tr'},).\<close>
 
 syntax
   "_quote" :: "'b \<Rightarrow> ('a \<Rightarrow> 'b)"
@@ -213,10 +211,9 @@
   in [(@{syntax_const "_quote"}, K quote_tr)] end
 \<close>
 
-text \<open>As usual in Isabelle syntax translations, the part for
-  printing is more complicated --- we cannot express parts as macro
-  rules as above.  Don't look here, unless you have to do similar
-  things for yourself.\<close>
+text \<open>As usual in Isabelle syntax translations, the part for printing is
+  more complicated --- we cannot express parts as macro rules as above.
+  Don't look here, unless you have to do similar things for yourself.\<close>
 
 print_translation \<open>
   let
@@ -245,13 +242,14 @@
 
 subsection \<open>Rules for single-step proof \label{sec:hoare-isar}\<close>
 
-text \<open>We are now ready to introduce a set of Hoare rules to be used
-  in single-step structured proofs in Isabelle/Isar.  We refer to the
-  concrete syntax introduce above.
+text \<open>We are now ready to introduce a set of Hoare rules to be used in
+  single-step structured proofs in Isabelle/Isar. We refer to the concrete
+  syntax introduce above.
 
-  \medskip Assertions of Hoare Logic may be manipulated in
-  calculational proofs, with the inclusion expressed in terms of sets
-  or predicates.  Reversed order is supported as well.\<close>
+  \<^medskip>
+  Assertions of Hoare Logic may be manipulated in calculational proofs, with
+  the inclusion expressed in terms of sets or predicates. Reversed order is
+  supported as well.\<close>
 
 lemma [trans]: "\<turnstile> P c Q \<Longrightarrow> P' \<subseteq> P \<Longrightarrow> \<turnstile> P' c Q"
   by (unfold Valid_def) blast
@@ -278,10 +276,10 @@
   by (simp add: Valid_def)
 
 
-text \<open>Identity and basic assignments.\footnote{The $\idt{hoare}$
-  method introduced in \S\ref{sec:hoare-vcg} is able to provide proper
-  instances for any number of basic assignments, without producing
-  additional verification conditions.}\<close>
+text \<open>Identity and basic assignments.\footnote{The \<open>hoare\<close> method introduced
+  in \S\ref{sec:hoare-vcg} is able to provide proper instances for any
+  number of basic assignments, without producing additional verification
+  conditions.}\<close>
 
 lemma skip [intro?]: "\<turnstile> P SKIP P"
 proof -
@@ -293,19 +291,19 @@
   by (rule basic)
 
 text \<open>Note that above formulation of assignment corresponds to our
-  preferred way to model state spaces, using (extensible) record types
-  in HOL @{cite "Naraschewski-Wenzel:1998:HOOL"}.  For any record field
-  $x$, Isabelle/HOL provides a functions $x$ (selector) and
-  $\idt{x{\dsh}update}$ (update).  Above, there is only a place-holder
-  appearing for the latter kind of function: due to concrete syntax
-  \isa{\'x := \'a} also contains \isa{x\_update}.\footnote{Note that
-  due to the external nature of HOL record fields, we could not even
-  state a general theorem relating selector and update functions (if
-  this were required here); this would only work for any particular
-  instance of record fields introduced so far.}\<close>
+  preferred way to model state spaces, using (extensible) record types in
+  HOL @{cite "Naraschewski-Wenzel:1998:HOOL"}. For any record field \<open>x\<close>,
+  Isabelle/HOL provides a functions \<open>x\<close> (selector) and \<open>x_update\<close> (update).
+  Above, there is only a place-holder appearing for the latter kind of
+  function: due to concrete syntax \<open>\<acute>x := \<acute>a\<close> also contains
+  \<open>x_update\<close>.\footnote{Note that due to the external nature of HOL record
+  fields, we could not even state a general theorem relating selector and
+  update functions (if this were required here); this would only work for
+  any particular instance of record fields introduced so far.}
 
-text \<open>Sequential composition --- normalizing with associativity
-  achieves proper of chunks of code verified separately.\<close>
+  \<^medskip>
+  Sequential composition --- normalizing with associativity achieves proper
+  of chunks of code verified separately.\<close>
 
 lemmas [trans, intro?] = seq
 
@@ -344,16 +342,15 @@
 
 subsection \<open>Verification conditions \label{sec:hoare-vcg}\<close>
 
-text \<open>We now load the \emph{original} ML file for proof scripts and
-  tactic definition for the Hoare Verification Condition Generator
-  (see @{file "~~/src/HOL/Hoare/"}).  As far as we
-  are concerned here, the result is a proof method \name{hoare}, which
-  may be applied to a Hoare Logic assertion to extract purely logical
-  verification conditions.  It is important to note that the method
-  requires \texttt{WHILE} loops to be fully annotated with invariants
-  beforehand.  Furthermore, only \emph{concrete} pieces of code are
-  handled --- the underlying tactic fails ungracefully if supplied
-  with meta-variables or parameters, for example.\<close>
+text \<open>We now load the \<^emph>\<open>original\<close> ML file for proof scripts and tactic
+  definition for the Hoare Verification Condition Generator (see @{file
+  "~~/src/HOL/Hoare/"}). As far as we are concerned here, the result is a
+  proof method \<open>hoare\<close>, which may be applied to a Hoare Logic assertion to
+  extract purely logical verification conditions. It is important to note
+  that the method requires \<^verbatim>\<open>WHILE\<close> loops to be fully annotated with
+  invariants beforehand. Furthermore, only \<^emph>\<open>concrete\<close> pieces of code are
+  handled --- the underlying tactic fails ungracefully if supplied with
+  meta-variables or parameters, for example.\<close>
 
 lemma SkipRule: "p \<subseteq> q \<Longrightarrow> Valid p (Basic id) q"
   by (auto simp add: Valid_def)
--- a/src/HOL/Isar_Examples/Hoare_Ex.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Hoare_Ex.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -6,9 +6,9 @@
 
 subsection \<open>State spaces\<close>
 
-text \<open>First of all we provide a store of program variables that
-  occur in any of the programs considered later.  Slightly unexpected
-  things may happen when attempting to work with undeclared variables.\<close>
+text \<open>First of all we provide a store of program variables that occur in any
+  of the programs considered later. Slightly unexpected things may happen
+  when attempting to work with undeclared variables.\<close>
 
 record vars =
   I :: nat
@@ -16,29 +16,28 @@
   N :: nat
   S :: nat
 
-text \<open>While all of our variables happen to have the same type,
-  nothing would prevent us from working with many-sorted programs as
-  well, or even polymorphic ones.  Also note that Isabelle/HOL's
-  extensible record types even provides simple means to extend the
-  state space later.\<close>
+text \<open>While all of our variables happen to have the same type, nothing would
+  prevent us from working with many-sorted programs as well, or even
+  polymorphic ones. Also note that Isabelle/HOL's extensible record types
+  even provides simple means to extend the state space later.\<close>
 
 
 subsection \<open>Basic examples\<close>
 
-text \<open>We look at few trivialities involving assignment and
-  sequential composition, in order to get an idea of how to work with
-  our formulation of Hoare Logic.\<close>
+text \<open>We look at few trivialities involving assignment and sequential
+  composition, in order to get an idea of how to work with our formulation
+  of Hoare Logic.\<close>
 
-text \<open>Using the basic @{text assign} rule directly is a bit
+text \<open>Using the basic \<open>assign\<close> rule directly is a bit
   cumbersome.\<close>
 
 lemma "\<turnstile> \<lbrace>\<acute>(N_update (\<lambda>_. (2 * \<acute>N))) \<in> \<lbrace>\<acute>N = 10\<rbrace>\<rbrace> \<acute>N := 2 * \<acute>N \<lbrace>\<acute>N = 10\<rbrace>"
   by (rule assign)
 
-text \<open>Certainly we want the state modification already done, e.g.\
-  by simplification.  The \name{hoare} method performs the basic state
-  update for us; we may apply the Simplifier afterwards to achieve
-  ``obvious'' consequences as well.\<close>
+text \<open>Certainly we want the state modification already done, e.g.\ by
+  simplification. The \<open>hoare\<close> method performs the basic state update for us;
+  we may apply the Simplifier afterwards to achieve ``obvious'' consequences
+  as well.\<close>
 
 lemma "\<turnstile> \<lbrace>True\<rbrace> \<acute>N := 10 \<lbrace>\<acute>N = 10\<rbrace>"
   by hoare
@@ -67,8 +66,8 @@
       \<lbrace>\<acute>M = b \<and> \<acute>N = a\<rbrace>"
   by hoare simp
 
-text \<open>It is important to note that statements like the following one
-  can only be proven for each individual program variable.  Due to the
+text \<open>It is important to note that statements like the following one can
+  only be proven for each individual program variable. Due to the
   extra-logical nature of record fields, we cannot formulate a theorem
   relating record selectors and updates schematically.\<close>
 
@@ -84,9 +83,9 @@
   oops
 
 
-text \<open>In the following assignments we make use of the consequence
-  rule in order to achieve the intended precondition.  Certainly, the
-  \name{hoare} method is able to handle this case, too.\<close>
+text \<open>In the following assignments we make use of the consequence rule in
+  order to achieve the intended precondition. Certainly, the \<open>hoare\<close> method
+  is able to handle this case, too.\<close>
 
 lemma "\<turnstile> \<lbrace>\<acute>M = \<acute>N\<rbrace> \<acute>M := \<acute>M + 1 \<lbrace>\<acute>M \<noteq> \<acute>N\<rbrace>"
 proof -
@@ -114,10 +113,10 @@
 
 subsection \<open>Multiplication by addition\<close>
 
-text \<open>We now do some basic examples of actual \texttt{WHILE}
-  programs.  This one is a loop for calculating the product of two
-  natural numbers, by iterated addition.  We first give detailed
-  structured proof based on single-step Hoare rules.\<close>
+text \<open>We now do some basic examples of actual \<^verbatim>\<open>WHILE\<close> programs. This one is
+  a loop for calculating the product of two natural numbers, by iterated
+  addition. We first give detailed structured proof based on single-step
+  Hoare rules.\<close>
 
 lemma
   "\<turnstile> \<lbrace>\<acute>M = 0 \<and> \<acute>S = 0\<rbrace>
@@ -141,10 +140,10 @@
   finally show ?thesis .
 qed
 
-text \<open>The subsequent version of the proof applies the @{text hoare}
-  method to reduce the Hoare statement to a purely logical problem
-  that can be solved fully automatically.  Note that we have to
-  specify the \texttt{WHILE} loop invariant in the original statement.\<close>
+text \<open>The subsequent version of the proof applies the \<open>hoare\<close> method to
+  reduce the Hoare statement to a purely logical problem that can be solved
+  fully automatically. Note that we have to specify the \<^verbatim>\<open>WHILE\<close> loop
+  invariant in the original statement.\<close>
 
 lemma
   "\<turnstile> \<lbrace>\<acute>M = 0 \<and> \<acute>S = 0\<rbrace>
@@ -157,15 +156,15 @@
 
 subsection \<open>Summing natural numbers\<close>
 
-text \<open>We verify an imperative program to sum natural numbers up to a
-  given limit.  First some functional definition for proper
-  specification of the problem.\<close>
+text \<open>We verify an imperative program to sum natural numbers up to a given
+  limit. First some functional definition for proper specification of the
+  problem.
 
-text \<open>The following proof is quite explicit in the individual steps
-  taken, with the \name{hoare} method only applied locally to take
-  care of assignment and sequential composition.  Note that we express
-  intermediate proof obligation in pure logic, without referring to
-  the state space.\<close>
+  \<^medskip>
+  The following proof is quite explicit in the individual steps taken, with
+  the \<open>hoare\<close> method only applied locally to take care of assignment and
+  sequential composition. Note that we express intermediate proof obligation
+  in pure logic, without referring to the state space.\<close>
 
 theorem
   "\<turnstile> \<lbrace>True\<rbrace>
@@ -203,9 +202,8 @@
   finally show ?thesis .
 qed
 
-text \<open>The next version uses the @{text hoare} method, while still
-  explaining the resulting proof obligations in an abstract,
-  structured manner.\<close>
+text \<open>The next version uses the \<open>hoare\<close> method, while still explaining the
+  resulting proof obligations in an abstract, structured manner.\<close>
 
 theorem
   "\<turnstile> \<lbrace>True\<rbrace>
@@ -230,8 +228,8 @@
   qed
 qed
 
-text \<open>Certainly, this proof may be done fully automatic as well,
-  provided that the invariant is given beforehand.\<close>
+text \<open>Certainly, this proof may be done fully automatic as well, provided
+  that the invariant is given beforehand.\<close>
 
 theorem
   "\<turnstile> \<lbrace>True\<rbrace>
@@ -248,8 +246,8 @@
 
 subsection \<open>Time\<close>
 
-text \<open>A simple embedding of time in Hoare logic: function @{text
-  timeit} inserts an extra variable to keep track of the elapsed time.\<close>
+text \<open>A simple embedding of time in Hoare logic: function \<open>timeit\<close> inserts
+  an extra variable to keep track of the elapsed time.\<close>
 
 record tstate = time :: nat
 
--- a/src/HOL/Isar_Examples/Knaster_Tarski.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Knaster_Tarski.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -14,30 +14,27 @@
 subsection \<open>Prose version\<close>
 
 text \<open>According to the textbook @{cite \<open>pages 93--94\<close> "davey-priestley"},
-  the Knaster-Tarski fixpoint theorem is as
-  follows.\footnote{We have dualized the argument, and tuned the
-  notation a little bit.}
-
-  \textbf{The Knaster-Tarski Fixpoint Theorem.}  Let @{text L} be a
-  complete lattice and @{text "f: L \<rightarrow> L"} an order-preserving map.
-  Then @{text "\<Sqinter>{x \<in> L | f(x) \<le> x}"} is a fixpoint of @{text f}.
+  the Knaster-Tarski fixpoint theorem is as follows.\footnote{We have
+  dualized the argument, and tuned the notation a little bit.}
 
-  \textbf{Proof.} Let @{text "H = {x \<in> L | f(x) \<le> x}"} and @{text "a =
-  \<Sqinter>H"}.  For all @{text "x \<in> H"} we have @{text "a \<le> x"}, so @{text
-  "f(a) \<le> f(x) \<le> x"}.  Thus @{text "f(a)"} is a lower bound of @{text
-  H}, whence @{text "f(a) \<le> a"}.  We now use this inequality to prove
-  the reverse one (!) and thereby complete the proof that @{text a} is
-  a fixpoint.  Since @{text f} is order-preserving, @{text "f(f(a)) \<le>
-  f(a)"}.  This says @{text "f(a) \<in> H"}, so @{text "a \<le> f(a)"}.\<close>
+  \<^bold>\<open>The Knaster-Tarski Fixpoint Theorem.\<close> Let \<open>L\<close> be a complete lattice and
+  \<open>f: L \<rightarrow> L\<close> an order-preserving map. Then \<open>\<Sqinter>{x \<in> L | f(x) \<le> x}\<close> is a
+  fixpoint of \<open>f\<close>.
+
+  \<^bold>\<open>Proof.\<close> Let \<open>H = {x \<in> L | f(x) \<le> x}\<close> and \<open>a = \<Sqinter>H\<close>. For all \<open>x \<in> H\<close> we
+  have \<open>a \<le> x\<close>, so \<open>f(a) \<le> f(x) \<le> x\<close>. Thus \<open>f(a)\<close> is a lower bound of \<open>H\<close>,
+  whence \<open>f(a) \<le> a\<close>. We now use this inequality to prove the reverse one (!)
+  and thereby complete the proof that \<open>a\<close> is a fixpoint. Since \<open>f\<close> is
+  order-preserving, \<open>f(f(a)) \<le> f(a)\<close>. This says \<open>f(a) \<in> H\<close>, so \<open>a \<le> f(a)\<close>.\<close>
 
 
 subsection \<open>Formal versions\<close>
 
-text \<open>The Isar proof below closely follows the original
-  presentation.  Virtually all of the prose narration has been
-  rephrased in terms of formal Isar language elements.  Just as many
-  textbook-style proofs, there is a strong bias towards forward proof,
-  and several bends in the course of reasoning.\<close>
+text \<open>The Isar proof below closely follows the original presentation.
+  Virtually all of the prose narration has been rephrased in terms of formal
+  Isar language elements. Just as many textbook-style proofs, there is a
+  strong bias towards forward proof, and several bends in the course of
+  reasoning.\<close>
 
 theorem Knaster_Tarski:
   fixes f :: "'a::complete_lattice \<Rightarrow> 'a"
@@ -67,15 +64,15 @@
   qed
 qed
 
-text \<open>Above we have used several advanced Isar language elements,
-  such as explicit block structure and weak assumptions.  Thus we have
-  mimicked the particular way of reasoning of the original text.
+text \<open>Above we have used several advanced Isar language elements, such as
+  explicit block structure and weak assumptions. Thus we have mimicked the
+  particular way of reasoning of the original text.
 
-  In the subsequent version the order of reasoning is changed to
-  achieve structured top-down decomposition of the problem at the
-  outer level, while only the inner steps of reasoning are done in a
-  forward manner.  We are certainly more at ease here, requiring only
-  the most basic features of the Isar language.\<close>
+  In the subsequent version the order of reasoning is changed to achieve
+  structured top-down decomposition of the problem at the outer level, while
+  only the inner steps of reasoning are done in a forward manner. We are
+  certainly more at ease here, requiring only the most basic features of the
+  Isar language.\<close>
 
 theorem Knaster_Tarski':
   fixes f :: "'a::complete_lattice \<Rightarrow> 'a"
--- a/src/HOL/Isar_Examples/Mutilated_Checkerboard.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Mutilated_Checkerboard.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,8 +9,8 @@
 imports Main
 begin
 
-text \<open>The Mutilated Checker Board Problem, formalized inductively.
-  See @{cite "paulson-mutilated-board"} for the original tactic script version.\<close>
+text \<open>The Mutilated Checker Board Problem, formalized inductively. See @{cite
+  "paulson-mutilated-board"} for the original tactic script version.\<close>
 
 subsection \<open>Tilings\<close>
 
--- a/src/HOL/Isar_Examples/Nested_Datatype.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Nested_Datatype.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -20,7 +20,7 @@
 
 lemmas subst_simps = subst_term.simps subst_term_list.simps
 
-text \<open>\medskip A simple lemma about composition of substitutions.\<close>
+text \<open>\<^medskip> A simple lemma about composition of substitutions.\<close>
 
 lemma
   "subst_term (subst_term f1 \<circ> f2) t =
--- a/src/HOL/Isar_Examples/Peirce.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Peirce.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -8,16 +8,15 @@
 imports Main
 begin
 
-text \<open>We consider Peirce's Law: $((A \impl B) \impl A) \impl A$.
-  This is an inherently non-intuitionistic statement, so its proof
-  will certainly involve some form of classical contradiction.
+text \<open>We consider Peirce's Law: \<open>((A \<longrightarrow> B) \<longrightarrow> A) \<longrightarrow> A\<close>. This is an inherently
+  non-intuitionistic statement, so its proof will certainly involve some
+  form of classical contradiction.
 
-  The first proof is again a well-balanced combination of plain
-  backward and forward reasoning.  The actual classical step is where
-  the negated goal may be introduced as additional assumption.  This
-  eventually leads to a contradiction.\footnote{The rule involved
-  there is negation elimination; it holds in intuitionistic logic as
-  well.}\<close>
+  The first proof is again a well-balanced combination of plain backward and
+  forward reasoning. The actual classical step is where the negated goal may
+  be introduced as additional assumption. This eventually leads to a
+  contradiction.\footnote{The rule involved there is negation elimination;
+  it holds in intuitionistic logic as well.}\<close>
 
 theorem "((A \<longrightarrow> B) \<longrightarrow> A) \<longrightarrow> A"
 proof
@@ -34,19 +33,17 @@
   qed
 qed
 
-text \<open>In the subsequent version the reasoning is rearranged by means
-  of ``weak assumptions'' (as introduced by \isacommand{presume}).
-  Before assuming the negated goal $\neg A$, its intended consequence
-  $A \impl B$ is put into place in order to solve the main problem.
-  Nevertheless, we do not get anything for free, but have to establish
-  $A \impl B$ later on.  The overall effect is that of a logical
-  \emph{cut}.
+text \<open>In the subsequent version the reasoning is rearranged by means of
+  ``weak assumptions'' (as introduced by \isacommand{presume}). Before
+  assuming the negated goal \<open>\<not> A\<close>, its intended consequence \<open>A \<longrightarrow> B\<close> is put
+  into place in order to solve the main problem. Nevertheless, we do not get
+  anything for free, but have to establish \<open>A \<longrightarrow> B\<close> later on. The overall
+  effect is that of a logical \<^emph>\<open>cut\<close>.
 
-  Technically speaking, whenever some goal is solved by
-  \isacommand{show} in the context of weak assumptions then the latter
-  give rise to new subgoals, which may be established separately.  In
-  contrast, strong assumptions (as introduced by \isacommand{assume})
-  are solved immediately.\<close>
+  Technically speaking, whenever some goal is solved by \isacommand{show} in
+  the context of weak assumptions then the latter give rise to new subgoals,
+  which may be established separately. In contrast, strong assumptions (as
+  introduced by \isacommand{assume}) are solved immediately.\<close>
 
 theorem "((A \<longrightarrow> B) \<longrightarrow> A) \<longrightarrow> A"
 proof
@@ -65,21 +62,20 @@
   qed
 qed
 
-text \<open>Note that the goals stemming from weak assumptions may be even
-  left until qed time, where they get eventually solved ``by
-  assumption'' as well.  In that case there is really no fundamental
-  difference between the two kinds of assumptions, apart from the
-  order of reducing the individual parts of the proof configuration.
+text \<open>Note that the goals stemming from weak assumptions may be even left
+  until qed time, where they get eventually solved ``by assumption'' as
+  well. In that case there is really no fundamental difference between the
+  two kinds of assumptions, apart from the order of reducing the individual
+  parts of the proof configuration.
 
-  Nevertheless, the ``strong'' mode of plain assumptions is quite
-  important in practice to achieve robustness of proof text
-  interpretation.  By forcing both the conclusion \emph{and} the
-  assumptions to unify with the pending goal to be solved, goal
-  selection becomes quite deterministic.  For example, decomposition
-  with rules of the ``case-analysis'' type usually gives rise to
-  several goals that only differ in there local contexts.  With strong
-  assumptions these may be still solved in any order in a predictable
-  way, while weak ones would quickly lead to great confusion,
-  eventually demanding even some backtracking.\<close>
+  Nevertheless, the ``strong'' mode of plain assumptions is quite important
+  in practice to achieve robustness of proof text interpretation. By forcing
+  both the conclusion \<^emph>\<open>and\<close> the assumptions to unify with the pending goal
+  to be solved, goal selection becomes quite deterministic. For example,
+  decomposition with rules of the ``case-analysis'' type usually gives rise
+  to several goals that only differ in there local contexts. With strong
+  assumptions these may be still solved in any order in a predictable way,
+  while weak ones would quickly lead to great confusion, eventually
+  demanding even some backtracking.\<close>
 
 end
--- a/src/HOL/Isar_Examples/Puzzle.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Puzzle.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -8,9 +8,8 @@
   Original pen-and-paper proof due to Herbert Ehler; Isabelle tactic
   script by Tobias Nipkow.}\<close>
 
-text \<open>\textbf{Problem.}  Given some function $f\colon \Nat \to \Nat$
-  such that $f \ap (f \ap n) < f \ap (\idt{Suc} \ap n)$ for all $n$.
-  Demonstrate that $f$ is the identity.\<close>
+text \<open>\<^bold>\<open>Problem.\<close> Given some function \<open>f: \<nat> \<rightarrow> \<nat>\<close> such that
+  \<open>f (f n) < f (Suc n)\<close> for all \<open>n\<close>. Demonstrate that \<open>f\<close> is the identity.\<close>
 
 theorem
   assumes f_ax: "\<And>n. f (f n) < f (Suc n)"
--- a/src/HOL/Isar_Examples/Summation.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/Summation.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -9,16 +9,16 @@
 begin
 
 text \<open>Subsequently, we prove some summation laws of natural numbers
-  (including odds, squares, and cubes).  These examples demonstrate
-  how plain natural deduction (including induction) may be combined
-  with calculational proof.\<close>
+  (including odds, squares, and cubes). These examples demonstrate how plain
+  natural deduction (including induction) may be combined with calculational
+  proof.\<close>
 
 
 subsection \<open>Summation laws\<close>
 
-text \<open>The sum of natural numbers $0 + \cdots + n$ equals $n \times
-  (n + 1)/2$.  Avoiding formal reasoning about division we prove this
-  equation multiplied by $2$.\<close>
+text \<open>The sum of natural numbers \<open>0 + \<cdots> + n\<close> equals \<open>n \<times> (n + 1)/2\<close>.
+  Avoiding formal reasoning about division we prove this equation multiplied
+  by \<open>2\<close>.\<close>
 
 theorem sum_of_naturals:
   "2 * (\<Sum>i::nat=0..n. i) = n * (n + 1)"
@@ -35,47 +35,39 @@
     by simp
 qed
 
-text \<open>The above proof is a typical instance of mathematical
-  induction.  The main statement is viewed as some $\var{P} \ap n$
-  that is split by the induction method into base case $\var{P} \ap
-  0$, and step case $\var{P} \ap n \Impl \var{P} \ap (\idt{Suc} \ap
-  n)$ for arbitrary $n$.
+text \<open>The above proof is a typical instance of mathematical induction. The
+  main statement is viewed as some \<open>?P n\<close> that is split by the induction
+  method into base case \<open>?P 0\<close>, and step case \<open>?P n \<Longrightarrow> ?P (Suc n)\<close> for
+  arbitrary \<open>n\<close>.
 
-  The step case is established by a short calculation in forward
-  manner.  Starting from the left-hand side $\var{S} \ap (n + 1)$ of
-  the thesis, the final result is achieved by transformations
-  involving basic arithmetic reasoning (using the Simplifier).  The
-  main point is where the induction hypothesis $\var{S} \ap n = n
-  \times (n + 1)$ is introduced in order to replace a certain subterm.
-  So the ``transitivity'' rule involved here is actual
-  \emph{substitution}.  Also note how the occurrence of ``\dots'' in
-  the subsequent step documents the position where the right-hand side
-  of the hypothesis got filled in.
+  The step case is established by a short calculation in forward manner.
+  Starting from the left-hand side \<open>?S (n + 1)\<close> of the thesis, the final
+  result is achieved by transformations involving basic arithmetic reasoning
+  (using the Simplifier). The main point is where the induction hypothesis
+  \<open>?S n = n \<times> (n + 1)\<close> is introduced in order to replace a certain subterm.
+  So the ``transitivity'' rule involved here is actual \<^emph>\<open>substitution\<close>. Also
+  note how the occurrence of ``\dots'' in the subsequent step documents the
+  position where the right-hand side of the hypothesis got filled in.
 
-  \medskip A further notable point here is integration of calculations
-  with plain natural deduction.  This works so well in Isar for two
-  reasons.
-  \begin{enumerate}
-
-  \item Facts involved in \isakeyword{also}~/ \isakeyword{finally}
-  calculational chains may be just anything.  There is nothing special
-  about \isakeyword{have}, so the natural deduction element
-  \isakeyword{assume} works just as well.
+  \<^medskip>
+  A further notable point here is integration of calculations with plain
+  natural deduction. This works so well in Isar for two reasons.
 
-  \item There are two \emph{separate} primitives for building natural
-  deduction contexts: \isakeyword{fix}~$x$ and
-  \isakeyword{assume}~$A$.  Thus it is possible to start reasoning
-  with some new ``arbitrary, but fixed'' elements before bringing in
-  the actual assumption.  In contrast, natural deduction is
-  occasionally formalized with basic context elements of the form
-  $x:A$ instead.
+    \<^enum> Facts involved in \isakeyword{also}~/ \isakeyword{finally}
+    calculational chains may be just anything. There is nothing special
+    about \isakeyword{have}, so the natural deduction element
+    \isakeyword{assume} works just as well.
+  
+    \<^enum> There are two \<^emph>\<open>separate\<close> primitives for building natural deduction
+    contexts: \isakeyword{fix}~\<open>x\<close> and \isakeyword{assume}~\<open>A\<close>. Thus it is
+    possible to start reasoning with some new ``arbitrary, but fixed''
+    elements before bringing in the actual assumption. In contrast, natural
+    deduction is occasionally formalized with basic context elements of the
+    form \<open>x:A\<close> instead.
 
-  \end{enumerate}
-\<close>
-
-text \<open>\medskip We derive further summation laws for odds, squares,
-  and cubes as follows.  The basic technique of induction plus
-  calculation is the same as before.\<close>
+  \<^medskip>
+  We derive further summation laws for odds, squares, and cubes as follows.
+  The basic technique of induction plus calculation is the same as before.\<close>
 
 theorem sum_of_odds:
   "(\<Sum>i::nat=0..<n. 2 * i + 1) = n^Suc (Suc 0)"
@@ -93,9 +85,8 @@
     by simp
 qed
 
-text \<open>Subsequently we require some additional tweaking of Isabelle
-  built-in arithmetic simplifications, such as bringing in
-  distributivity by hand.\<close>
+text \<open>Subsequently we require some additional tweaking of Isabelle built-in
+  arithmetic simplifications, such as bringing in distributivity by hand.\<close>
 
 lemmas distrib = add_mult_distrib add_mult_distrib2
 
@@ -134,15 +125,13 @@
 
 text \<open>Note that in contrast to older traditions of tactical proof
   scripts, the structured proof applies induction on the original,
-  unsimplified statement.  This allows to state the induction cases
-  robustly and conveniently.  Simplification (or other automated)
-  methods are then applied in terminal position to solve certain
-  sub-problems completely.
+  unsimplified statement. This allows to state the induction cases robustly
+  and conveniently. Simplification (or other automated) methods are then
+  applied in terminal position to solve certain sub-problems completely.
 
-  As a general rule of good proof style, automatic methods such as
-  $\idt{simp}$ or $\idt{auto}$ should normally be never used as
-  initial proof methods with a nested sub-proof to address the
-  automatically produced situation, but only as terminal ones to solve
-  sub-problems.\<close>
+  As a general rule of good proof style, automatic methods such as \<open>simp\<close> or
+  \<open>auto\<close> should normally be never used as initial proof methods with a
+  nested sub-proof to address the automatically produced situation, but only
+  as terminal ones to solve sub-problems.\<close>
 
 end
--- a/src/HOL/Isar_Examples/document/root.tex	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Isar_Examples/document/root.tex	Tue Nov 03 11:20:21 2015 +0100
@@ -1,11 +1,22 @@
-\input{style}
+\documentclass[11pt,a4paper]{article}
+\usepackage[only,bigsqcap]{stmaryrd}
+\usepackage{ifthen,proof,amssymb,isabelle,isabellesym}
+\isabellestyle{it}
+\usepackage{pdfsetup}\urlstyle{rm}
+
+\renewcommand{\isacommand}[1]
+{\ifthenelse{\equal{sorry}{#1}}{$\;$\dummyproof}
+  {\ifthenelse{\equal{oops}{#1}}{$\vdots$}{\isakeyword{#1}}}}
+
+\newcommand{\DUMMYPROOF}{{\langle\mathit{proof}\rangle}}
+\newcommand{\dummyproof}{$\DUMMYPROOF$}
 
 \hyphenation{Isabelle}
 
 \begin{document}
 
 \title{Miscellaneous Isabelle/Isar examples for Higher-Order Logic}
-\author{Markus Wenzel \\ \url{http://www.in.tum.de/~wenzelm/} \\[2ex]
+\author{Markus Wenzel \\[2ex]
   With contributions by Gertrud Bauer and Tobias Nipkow}
 \maketitle
 
--- a/src/HOL/Isar_Examples/document/style.tex	Mon Nov 02 16:17:09 2015 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-\documentclass[11pt,a4paper]{article}
-\usepackage[only,bigsqcap]{stmaryrd}
-\usepackage{ifthen,proof,amssymb,isabelle,isabellesym}
-\isabellestyle{it}
-\usepackage{pdfsetup}\urlstyle{rm}
-
-\renewcommand{\isacommand}[1]
-{\ifthenelse{\equal{sorry}{#1}}{$\;$\dummyproof}
-  {\ifthenelse{\equal{oops}{#1}}{$\vdots$}{\isakeyword{#1}}}}
-
-\newcommand{\DUMMYPROOF}{{\langle\idt{proof}\rangle}}
-\newcommand{\dummyproof}{$\DUMMYPROOF$}
-
-\newcommand{\name}[1]{\textsl{#1}}
-
-\newcommand{\idt}[1]{{\mathord{\mathit{#1}}}}
-\newcommand{\var}[1]{{?\!\idt{#1}}}
-\DeclareMathSymbol{\dshsym}{\mathalpha}{letters}{"2D}
-\newcommand{\dsh}{\dshsym}
-
-\newcommand{\To}{\to}
-\newcommand{\dt}{{\mathpunct.}}
-\newcommand{\ap}{\mathbin{\!}}
-\newcommand{\lam}[1]{\mathop{\lambda} #1\dt\;}
-\newcommand{\all}[1]{\forall #1\dt\;}
-\newcommand{\ex}[1]{\exists #1\dt\;}
-\newcommand{\impl}{\to}
-\newcommand{\conj}{\land}
-\newcommand{\disj}{\lor}
-\newcommand{\Impl}{\Longrightarrow}
-
-\newcommand{\Nat}{\mathord{\mathrm{I}\mkern-3.8mu\mathrm{N}}}
-
-
-%%% Local Variables: 
-%%% mode: latex
-%%% TeX-master: "root"
-%%% End: 
--- a/src/HOL/Library/Lattice_Algebras.thy	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Library/Lattice_Algebras.thy	Tue Nov 03 11:20:21 2015 +0100
@@ -1,4 +1,4 @@
-(* Author: Steven Obua, TU Muenchen *)
+(*  Author:     Steven Obua, TU Muenchen *)
 
 section \<open>Various algebraic structures combined with a lattice\<close>
 
@@ -224,7 +224,7 @@
   proof -
     from that have a: "inf (a + a) 0 = 0"
       by (simp add: inf_commute inf_absorb1)
-    have "inf a 0 + inf a 0 = inf (inf (a + a) 0) a"  (is "?l=_")
+    have "inf a 0 + inf a 0 = inf (inf (a + a) 0) a"  (is "?l = _")
       by (simp add: add_sup_inf_distribs inf_aci)
     then have "?l = 0 + inf a 0"
       by (simp add: a, simp add: inf_commute)
@@ -619,4 +619,3 @@
 qed
 
 end
-
--- a/src/HOL/ROOT	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/ROOT	Tue Nov 03 11:20:21 2015 +0100
@@ -647,7 +647,6 @@
   document_files
     "root.bib"
     "root.tex"
-    "style.tex"
 
 session "HOL-Eisbach" in Eisbach = HOL +
   description {*
--- a/src/HOL/Tools/ATP/atp_problem.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Tools/ATP/atp_problem.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -397,15 +397,20 @@
     val dfg = (case format of DFG _ => true | _ => false)
     fun str _ (AType ((s, _), [])) =
         if dfg andalso s = tptp_individual_type then dfg_individual_type else s
-      | str _ (AType ((s, _), tys)) =
-        let val ss = tys |> map (str false) in
-          if s = tptp_product_type then
-            ss |> space_implode
-                      (if dfg then ", " else " " ^ tptp_product_type ^ " ")
-               |> (not dfg andalso length ss > 1) ? parens
-          else
-            tptp_string_of_app format s ss
-        end
+      | str rhs (AType ((s, _), tys)) =
+        if s = tptp_fun_type then
+          let val [ty1, ty2] = tys in
+            str rhs (AFun (ty1, ty2))
+          end
+        else
+          let val ss = tys |> map (str false) in
+            if s = tptp_product_type then
+              ss |> space_implode
+                        (if dfg then ", " else " " ^ tptp_product_type ^ " ")
+                 |> (not dfg andalso length ss > 1) ? parens
+            else
+              tptp_string_of_app format s ss
+          end
       | str rhs (AFun (ty1, ty2)) =
         (str false ty1 |> dfg ? parens) ^ " " ^
         (if dfg then "" else tptp_fun_type ^ " ") ^ str true ty2
--- a/src/HOL/Tools/BNF/bnf_fp_def_sugar.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Tools/BNF/bnf_fp_def_sugar.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -105,14 +105,13 @@
   val morph_gfp_sugar_thms: morphism -> gfp_sugar_thms -> gfp_sugar_thms
   val transfer_gfp_sugar_thms: theory -> gfp_sugar_thms -> gfp_sugar_thms
 
-  val mk_co_recs_prelims: BNF_Util.fp_kind -> typ list list list -> typ list -> typ list ->
-     typ list -> typ list -> int list -> int list list -> term list -> Proof.context ->
-     (term list
-      * (typ list list * typ list list list list * term list list * term list list list list) option
-      * (string * term list * term list list
-         * (((term list list * term list list * term list list list list * term list list list list)
-             * term list list list) * typ list)) option)
-     * Proof.context
+  val mk_co_recs_prelims: Proof.context -> BNF_Util.fp_kind -> typ list list list -> typ list ->
+     typ list -> typ list -> typ list -> int list -> int list list -> term list ->
+     term list
+     * (typ list list * typ list list list list * term list list * term list list list list) option
+     * (string * term list * term list list
+        * (((term list list * term list list * term list list list list * term list list list list)
+            * term list list list) * typ list)) option
   val repair_nullary_single_ctr: typ list list -> typ list list
   val mk_corec_p_pred_types: typ list -> int list -> typ list list
   val mk_corec_fun_arg_types: typ list list list -> typ list -> typ list -> typ list -> int list ->
@@ -1176,7 +1175,7 @@
   | unzip_recT _ (Type (@{type_name prod}, Ts as [_, TFree _])) = Ts
   | unzip_recT _ T = [T];
 
-fun mk_recs_args_types ctr_Tsss Cs absTs repTs ns mss ctor_rec_fun_Ts lthy =
+fun mk_recs_args_types ctxt ctr_Tsss Cs absTs repTs ns mss ctor_rec_fun_Ts =
   let
     val Css = map2 replicate ns Cs;
     val x_Tssss =
@@ -1188,11 +1187,11 @@
     val x_Tsss' = map (map flat_rec_arg_args) x_Tssss;
     val f_Tss = map2 (map2 (curry (op --->))) x_Tsss' Css;
 
-    val ((fss, xssss), lthy) = lthy
+    val ((fss, xssss), _) = ctxt
       |> mk_Freess "f" f_Tss
       ||>> mk_Freessss "x" x_Tssss;
   in
-    ((f_Tss, x_Tssss, fss, xssss), lthy)
+    (f_Tss, x_Tssss, fss, xssss)
   end;
 
 fun unzip_corecT (Type (@{type_name sum}, _)) T = [T]
@@ -1222,14 +1221,14 @@
    mk_corec_fun_arg_types0 ctr_Tsss Cs absTs repTs ns mss
      (binder_fun_types (fastype_of dtor_corec)));
 
-fun mk_corecs_args_types ctr_Tsss Cs absTs repTs ns mss dtor_corec_fun_Ts lthy =
+fun mk_corecs_args_types ctxt ctr_Tsss Cs absTs repTs ns mss dtor_corec_fun_Ts =
   let
     val p_Tss = mk_corec_p_pred_types Cs ns;
 
     val (q_Tssss, g_Tsss, g_Tssss, corec_types) =
       mk_corec_fun_arg_types0 ctr_Tsss Cs absTs repTs ns mss dtor_corec_fun_Ts;
 
-    val (((((Free (x, _), cs), pss), qssss), gssss), lthy) = lthy
+    val (((((Free (x, _), cs), pss), qssss), gssss), _) = ctxt
       |> yield_singleton (mk_Frees "x") dummyT
       ||>> mk_Frees "a" Cs
       ||>> mk_Freess "p" p_Tss
@@ -1238,7 +1237,7 @@
 
     val cpss = map2 (map o rapp) cs pss;
 
-    fun build_sum_inj mk_inj = build_map lthy [] (uncurry mk_inj o dest_sumT o snd);
+    fun build_sum_inj mk_inj = build_map ctxt [] (uncurry mk_inj o dest_sumT o snd);
 
     fun build_dtor_corec_arg _ [] [cg] = cg
       | build_dtor_corec_arg T [cq] [cg, cg'] =
@@ -1250,25 +1249,25 @@
     val cgssss = map2 (map o map o map o rapp) cs gssss;
     val cqgsss = @{map 3} (@{map 3} (@{map 3} build_dtor_corec_arg)) g_Tsss cqssss cgssss;
   in
-    ((x, cs, cpss, (((pgss, pss, qssss, gssss), cqgsss), corec_types)), lthy)
+    (x, cs, cpss, (((pgss, pss, qssss, gssss), cqgsss), corec_types))
   end;
 
-fun mk_co_recs_prelims fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0 lthy =
+fun mk_co_recs_prelims ctxt fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0 =
   let
-    val thy = Proof_Context.theory_of lthy;
+    val thy = Proof_Context.theory_of ctxt;
 
     val (xtor_co_rec_fun_Ts, xtor_co_recs) =
       mk_xtor_co_recs thy fp fpTs Cs xtor_co_recs0 |> `(binder_fun_types o fastype_of o hd);
 
-    val ((recs_args_types, corecs_args_types), lthy') =
+    val (recs_args_types, corecs_args_types) =
       if fp = Least_FP then
-        mk_recs_args_types ctr_Tsss Cs absTs repTs ns mss xtor_co_rec_fun_Ts lthy
-        |>> (rpair NONE o SOME)
+        mk_recs_args_types ctxt ctr_Tsss Cs absTs repTs ns mss xtor_co_rec_fun_Ts
+        |> (rpair NONE o SOME)
       else
-        mk_corecs_args_types ctr_Tsss Cs absTs repTs ns mss xtor_co_rec_fun_Ts lthy
-        |>> (pair NONE o SOME);
+        mk_corecs_args_types ctxt ctr_Tsss Cs absTs repTs ns mss xtor_co_rec_fun_Ts
+        |> (pair NONE o SOME);
   in
-    ((xtor_co_recs, recs_args_types, corecs_args_types), lthy')
+    (xtor_co_recs, recs_args_types, corecs_args_types)
   end;
 
 fun mk_preds_getterss_join c cps absT abs cqgss =
@@ -2175,8 +2174,9 @@
     val kss = map (fn n => 1 upto n) ns;
     val mss = map (map length) ctr_Tsss;
 
-    val ((xtor_co_recs, recs_args_types, corecs_args_types), lthy') =
-      mk_co_recs_prelims fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0 lthy;
+    val (xtor_co_recs, recs_args_types, corecs_args_types) =
+      mk_co_recs_prelims lthy fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0;
+    val lthy' = lthy;
 
     fun define_ctrs_dtrs_for_type fp_bnf fp_b fpT C E ctor dtor xtor_co_rec ctor_dtor dtor_ctor
         ctor_inject pre_map_def pre_set_defs pre_rel_def fp_map_thm fp_set_thms fp_rel_thm n ks ms
--- a/src/HOL/Tools/BNF/bnf_fp_n2m_sugar.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Tools/BNF/bnf_fp_n2m_sugar.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -255,8 +255,8 @@
         val fp_nesting_bnfs = nesting_bnfs lthy ctrXs_Tsss Xs;
         val live_nesting_bnfs = nesting_bnfs lthy ctrXs_Tsss As;
 
-        val ((xtor_co_recs, recs_args_types, corecs_args_types), _) =
-          mk_co_recs_prelims fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0 lthy;
+        val (xtor_co_recs, recs_args_types, corecs_args_types) =
+          mk_co_recs_prelims lthy fp ctr_Tsss fpTs Cs absTs repTs ns mss xtor_co_recs0;
 
         fun mk_binding b pre = Binding.prefix_name (pre ^ "_") b;
 
--- a/src/HOL/Tools/Ctr_Sugar/ctr_sugar.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/HOL/Tools/Ctr_Sugar/ctr_sugar.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -462,16 +462,22 @@
           else
             sel)) (1 upto m) o pad_list Binding.empty m) ctrs0 ms raw_sel_bindingss;
 
+    val add_bindings =
+      Variable.add_fixes (distinct (op =) (filter Symbol_Pos.is_identifier
+        (map Binding.name_of (disc_bindings @ flat sel_bindingss))))
+      #> snd;
+
     val case_Ts = map (fn Ts => Ts ---> B) ctr_Tss;
 
-    val ((((((((exh_y, xss), yss), fs), gs), u), w), (p, p'))) =
+    val ((((((((u, exh_y), xss), yss), fs), gs), w), (p, p'))) =
       no_defs_lthy
-      |> yield_singleton (mk_Frees "y") fcT (* for compatibility with "datatype_realizer.ML" *)
+      |> add_bindings
+      |> yield_singleton (mk_Frees fc_b_name) fcT
+      ||>> yield_singleton (mk_Frees "y") fcT (* for compatibility with "datatype_realizer.ML" *)
       ||>> mk_Freess "x" ctr_Tss
       ||>> mk_Freess "y" ctr_Tss
       ||>> mk_Frees "f" case_Ts
       ||>> mk_Frees "g" case_Ts
-      ||>> yield_singleton (mk_Frees fc_b_name) fcT
       ||>> yield_singleton (mk_Frees "z") B
       ||>> yield_singleton (apfst (op ~~) oo mk_Frees' "P") HOLogic.boolT
       |> fst;
@@ -673,13 +679,14 @@
 
     fun after_qed ([exhaust_thm] :: thmss) lthy =
       let
-        val ((((((((xss, xss'), fs), gs), h), (u, u')), v), p), _) =
+        val ((((((((u, u'), (xss, xss')), fs), gs), h), v), p), _) =
           lthy
-          |> mk_Freess' "x" ctr_Tss
+          |> add_bindings
+          |> yield_singleton (apfst (op ~~) oo mk_Frees' fc_b_name) fcT
+          ||>> mk_Freess' "x" ctr_Tss
           ||>> mk_Frees "f" case_Ts
           ||>> mk_Frees "g" case_Ts
           ||>> yield_singleton (mk_Frees "h") (B --> C)
-          ||>> yield_singleton (apfst (op ~~) oo mk_Frees' fc_b_name) fcT
           ||>> yield_singleton (mk_Frees (fc_b_name ^ "'")) fcT
           ||>> yield_singleton (mk_Frees "P") HOLogic.boolT;
 
@@ -687,18 +694,18 @@
         val xgs = map2 (curry Term.list_comb) gs xss;
 
         val fcase = Term.list_comb (casex, fs);
-    
+
         val ufcase = fcase $ u;
         val vfcase = fcase $ v;
-    
+
         val eta_fcase = Term.list_comb (casex, eta_fs);
         val eta_gcase = Term.list_comb (casex, eta_gs);
-    
+
         val eta_ufcase = eta_fcase $ u;
         val eta_vgcase = eta_gcase $ v;
 
         fun mk_uu_eq () = HOLogic.mk_eq (u, u);
-    
+
         val uv_eq = mk_Trueprop_eq (u, v);
 
         val ((inject_thms, inject_thmss), half_distinct_thmss) = chop n thmss |>> `flat;
--- a/src/Pure/PIDE/markup.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Pure/PIDE/markup.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -36,7 +36,7 @@
   val language_prop: bool -> T
   val language_ML: bool -> T
   val language_SML: bool -> T
-  val language_document: bool -> T
+  val language_document: {symbols: bool, delimited: bool} -> T
   val language_antiquotation: T
   val language_text: bool -> T
   val language_rail: T
@@ -310,7 +310,8 @@
 val language_prop = language' {name = "prop", symbols = true, antiquotes = false};
 val language_ML = language' {name = "ML", symbols = false, antiquotes = true};
 val language_SML = language' {name = "SML", symbols = false, antiquotes = false};
-val language_document = language' {name = "document", symbols = false, antiquotes = true};
+fun language_document {symbols, delimited} =
+  language' {name = "document", symbols = symbols, antiquotes = true} delimited;
 val language_antiquotation =
   language {name = "antiquotation", symbols = true, antiquotes = false, delimited = true};
 val language_text = language' {name = "text", symbols = true, antiquotes = false};
--- a/src/Pure/PIDE/query_operation.scala	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Pure/PIDE/query_operation.scala	Tue Nov 03 11:20:21 2015 +0100
@@ -16,6 +16,26 @@
     val RUNNING = Value("running")
     val FINISHED = Value("finished")
   }
+
+  object State
+  {
+    val empty: State = State()
+
+    def make(command: Command, query: List[String]): State =
+      State(instance = Document_ID.make().toString,
+        location = Some(command),
+        query = query,
+        status = Status.WAITING)
+  }
+
+  sealed case class State(
+    instance: String = Document_ID.none.toString,
+    location: Option[Command] = None,
+    query: List[String] = Nil,
+    update_pending: Boolean = false,
+    output: List[XML.Tree] = Nil,
+    status: Status.Value = Status.FINISHED,
+    exec_id: Document_ID.Exec = Document_ID.none)
 }
 
 class Query_Operation[Editor_Context](
@@ -26,37 +46,19 @@
   consume_output: (Document.Snapshot, Command.Results, XML.Body) => Unit)
 {
   private val print_function = operation_name + "_query"
-  private val instance = Document_ID.make().toString
 
 
   /* implicit state -- owned by GUI thread */
 
-  @volatile private var current_location: Option[Command] = None
-  @volatile private var current_query: List[String] = Nil
-  @volatile private var current_update_pending = false
-  @volatile private var current_output: List[XML.Tree] = Nil
-  @volatile private var current_status = Query_Operation.Status.FINISHED
-  @volatile private var current_exec_id = Document_ID.none
-
-  def get_location: Option[Command] = current_location
+  private val current_state = Synchronized(Query_Operation.State.empty)
 
-  private def reset_state()
-  {
-    current_location = None
-    current_query = Nil
-    current_update_pending = false
-    current_output = Nil
-    current_status = Query_Operation.Status.FINISHED
-    current_exec_id = Document_ID.none
-  }
+  def get_location: Option[Command] = current_state.value.location
 
   private def remove_overlay()
   {
-    current_location match {
-      case None =>
-      case Some(command) =>
-        editor.remove_overlay(command, print_function, instance :: current_query)
-        editor.flush()
+    val state = current_state.value
+    for (command <- state.location) {
+      editor.remove_overlay(command, print_function, state.instance :: state.query)
     }
   }
 
@@ -70,29 +72,31 @@
 
     /* snapshot */
 
-    val (snapshot, command_results, removed) =
-      current_location match {
+    val state0 = current_state.value
+
+    val (snapshot, command_results, results, removed) =
+      state0.location match {
         case Some(cmd) =>
           val snapshot = editor.node_snapshot(cmd.node_name)
           val command_results = snapshot.state.command_results(snapshot.version, cmd)
+          val results =
+            (for {
+              (_, elem @ XML.Elem(Markup(Markup.RESULT, props), _)) <- command_results.iterator
+              if props.contains((Markup.INSTANCE, state0.instance))
+            } yield elem).toList
           val removed = !snapshot.version.nodes(cmd.node_name).commands.contains(cmd)
-          (snapshot, command_results, removed)
+          (snapshot, command_results, results, removed)
         case None =>
-          (Document.Snapshot.init, Command.Results.empty, true)
+          (Document.Snapshot.init, Command.Results.empty, Nil, true)
       }
 
-    val results =
-      (for {
-        (_, elem @ XML.Elem(Markup(Markup.RESULT, props), _)) <- command_results.iterator
-        if props.contains((Markup.INSTANCE, instance))
-      } yield elem).toList
 
 
     /* resolve sendback: static command id */
 
     def resolve_sendback(body: XML.Body): XML.Body =
     {
-      current_location match {
+      state0.location match {
         case None => body
         case Some(command) =>
           def resolve(body: XML.Body): XML.Body =
@@ -101,7 +105,7 @@
               case XML.Elem(Markup(Markup.SENDBACK, props), b) =>
                 val props1 =
                   props.map({
-                    case (Markup.ID, Properties.Value.Long(id)) if id == current_exec_id =>
+                    case (Markup.ID, Properties.Value.Long(id)) if id == state0.exec_id =>
                       (Markup.ID, Properties.Value.Long(command.id))
                     case p => p
                   })
@@ -137,27 +141,27 @@
         get_status(Markup.RUNNING, Query_Operation.Status.RUNNING) getOrElse
         Query_Operation.Status.WAITING
 
+
+    /* state update */
+
     if (new_status == Query_Operation.Status.RUNNING)
       results.collectFirst(
       {
         case XML.Elem(Markup(_, Position.Id(id)), List(elem: XML.Elem))
         if elem.name == Markup.RUNNING => id
-      }).foreach(id => current_exec_id = id)
-
-
-    /* state update */
+      }).foreach(id => current_state.change(_.copy(exec_id = id)))
 
-    if (current_output != new_output || current_status != new_status) {
+    if (state0.output != new_output || state0.status != new_status) {
       if (snapshot.is_outdated)
-        current_update_pending = true
+        current_state.change(_.copy(update_pending = true))
       else {
-        current_update_pending = false
-        if (current_output != new_output && !removed) {
-          current_output = new_output
+        current_state.change(_.copy(update_pending = false))
+        if (state0.output != new_output && !removed) {
+          current_state.change(_.copy(output = new_output))
           consume_output(snapshot, command_results, new_output)
         }
-        if (current_status != new_status) {
-          current_status = new_status
+        if (state0.status != new_status) {
+          current_state.change(_.copy(status = new_status))
           consume_status(new_status)
           if (new_status == Query_Operation.Status.FINISHED)
             remove_overlay()
@@ -170,7 +174,7 @@
   /* query operations */
 
   def cancel_query(): Unit =
-    GUI_Thread.require { editor.session.cancel_exec(current_exec_id) }
+    GUI_Thread.require { editor.session.cancel_exec(current_state.value.exec_id) }
 
   def apply_query(query: List[String])
   {
@@ -179,19 +183,18 @@
     editor.current_node_snapshot(editor_context) match {
       case Some(snapshot) =>
         remove_overlay()
-        reset_state()
+        current_state.change(_ => Query_Operation.State.empty)
         consume_output(Document.Snapshot.init, Command.Results.empty, Nil)
         if (!snapshot.is_outdated) {
           editor.current_command(editor_context, snapshot) match {
             case Some(command) =>
-              current_location = Some(command)
-              current_query = query
-              current_status = Query_Operation.Status.WAITING
-              editor.insert_overlay(command, print_function, instance :: query)
+              val state = Query_Operation.State.make(command, query)
+              current_state.change(_ => state)
+              editor.insert_overlay(command, print_function, state.instance :: query)
             case None =>
           }
         }
-        consume_status(current_status)
+        consume_status(current_state.value.status)
         editor.flush()
       case None =>
     }
@@ -201,8 +204,9 @@
   {
     GUI_Thread.require {}
 
+    val state = current_state.value
     for {
-      command <- current_location
+      command <- state.location
       snapshot = editor.node_snapshot(command.node_name)
       link <- editor.hyperlink_command(true, snapshot, command)
     } link.follow(editor_context)
@@ -214,10 +218,11 @@
   private val main =
     Session.Consumer[Session.Commands_Changed](getClass.getName) {
       case changed =>
-        current_location match {
+        val state = current_state.value
+        state.location match {
           case Some(command)
-          if current_update_pending ||
-            (current_status != Query_Operation.Status.FINISHED &&
+          if state.update_pending ||
+            (state.status != Query_Operation.Status.FINISHED &&
               changed.commands.contains(command)) =>
             GUI_Thread.later { content_update() }
           case _ =>
@@ -231,8 +236,8 @@
   def deactivate() {
     editor.session.commands_changed -= main
     remove_overlay()
-    reset_state()
+    current_state.change(_ => Query_Operation.State.empty)
     consume_output(Document.Snapshot.init, Command.Results.empty, Nil)
-    consume_status(current_status)
+    consume_status(Query_Operation.Status.FINISHED)
   }
 }
--- a/src/Pure/Thy/thy_info.scala	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Pure/Thy/thy_info.scala	Tue Nov 03 11:20:21 2015 +0100
@@ -35,23 +35,25 @@
 
   object Dependencies
   {
-    val empty = new Dependencies(Nil, Nil, Multi_Map.empty, Multi_Map.empty)
+    val empty = new Dependencies(Nil, Nil, Set.empty, Multi_Map.empty, Multi_Map.empty)
   }
 
   final class Dependencies private(
     rev_deps: List[Thy_Info.Dep],
     val keywords: Thy_Header.Keywords,
+    val seen: Set[Document.Node.Name],
     val seen_names: Multi_Map[String, Document.Node.Name],
     val seen_positions: Multi_Map[String, Position.T])
   {
     def :: (dep: Thy_Info.Dep): Dependencies =
       new Dependencies(dep :: rev_deps, dep.header.keywords ::: keywords,
-        seen_names, seen_positions)
+        seen, seen_names, seen_positions)
 
     def + (thy: (Document.Node.Name, Position.T)): Dependencies =
     {
       val (name, pos) = thy
       new Dependencies(rev_deps, keywords,
+        seen + name,
         seen_names + (name.theory -> name),
         seen_positions + (name.theory -> pos))
     }
@@ -102,15 +104,13 @@
       required: Dependencies, thy: (Document.Node.Name, Position.T)): Dependencies =
   {
     val (name, require_pos) = thy
-    val theory = name.theory
 
     def message: String =
-      "The error(s) above occurred for theory " + quote(theory) +
+      "The error(s) above occurred for theory " + quote(name.theory) +
         required_by(initiators) + Position.here(require_pos)
 
     val required1 = required + thy
-    if (required.seen_names.isDefinedAt(theory) || resources.loaded_theories(theory))
-      required1
+    if (required.seen(name) || resources.loaded_theories(name.theory)) required1
     else {
       try {
         if (initiators.contains(name)) error(cycle_msg(initiators))
--- a/src/Pure/Thy/thy_output.ML	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Pure/Thy/thy_output.ML	Tue Nov 03 11:20:21 2015 +0100
@@ -196,7 +196,10 @@
 fun output_text state {markdown} source =
   let
     val pos = Input.pos_of source;
-    val _ = Position.report pos (Markup.language_document (Input.is_delimited source));
+    val _ =
+      Position.report pos
+        (Markup.language_document
+          {symbols = Options.default_bool "document_symbols", delimited = Input.is_delimited source});
     val syms = Input.source_explode source;
 
     val output_antiquote = eval_antiquote state #> Symbol.explode #> Latex.output_ctrl_symbols;
--- a/src/Tools/jEdit/src/document_model.scala	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Tools/jEdit/src/document_model.scala	Tue Nov 03 11:20:21 2015 +0100
@@ -255,6 +255,9 @@
       reset_blob()
       reset_bibtex()
 
+      for (doc_view <- PIDE.document_views(buffer))
+        doc_view.rich_text_area.active_reset()
+
       if (clear) {
         pending_clear = true
         pending.clear
--- a/src/Tools/jEdit/src/jedit_editor.scala	Mon Nov 02 16:17:09 2015 +0100
+++ b/src/Tools/jEdit/src/jedit_editor.scala	Tue Nov 03 11:20:21 2015 +0100
@@ -41,7 +41,7 @@
         name => (name, Document.Node.no_perspective_text))
 
     val edits = models.flatMap(_.flushed_edits(doc_blobs)) ::: removed_perspective
-    if (edits.nonEmpty) session.update(doc_blobs, edits)
+    session.update(doc_blobs, edits)
   }
 
   private val delay_flush =